ABOUT ME

Today
Yesterday
Total
  • [python/pandas/sklearn] 준이의 메모장
    카테고리 없음 2024. 1. 14. 16:14

    python/pandas/sklearn import를 통해 라이브러리를 불러오고, matplotlib을 이용하여 데이터를 시각화한다.

     

    만약 y가 [1.0, 1.66, 3.50 ..] 처럼 연속형 변수(키, 몸무게 등)라면 회귀, y가 [female, male, male, ..]처럼 범주형이면 분류

     

     

    별칭을 사용하여 import하는 구문

    #scikit-learn
    import sklearn as sk
    
    #pandas
    import pandas as pd
    
    #numpy
    import numpy as np
    
    #matplotlib
    !pip install matplotlib
    import matplotlib.pyplot as plt
    
    #seaborn
    !pip install seaborn
    import seaborn as sns

     

     

    데이터 프레임 변수명 : df

    데이터 불러오기

    df = pd.read_csv('파일명.csv')
    df = pd.read_json('파일명.json')
    
    #불러온 데이터의 모든 컬럼에 대한 데이터 분포 수 확인
    [df[c].value_counts() for c in df]

     

     

    불러온 데이터 시각화

    <histogram>
    # matplotlib
    plt.hist(df['컬럼명'])
    df['컬럼명'].plot(kind = 'hist')
    
    # seaborn
    sns.histplot(x='컬럼명', data=df)
    
    <heatmap>
    sns.heatmap(df.corr(), annot = True)
    
    <countplot>
    sns.countplot(x = '컬럼명', hue = '컬럼명', data = df)   # hue = 색깔구분
    
    <lmplot>
    sns.lmplot(x ='컬럼명', y = '컬럼명', data = df, hue = '컬럼명', height = 12)	# hue = 색깔구분
    
    <jointplot>
    sns.jointplot(data = df, x = '컬럼명', y = '컬럼명')
    
    <barplot>
    # matplotlib
    # df의 특정 컬럼을 바플롯을 통해 시각화하라 >> value_counts()사용해야함
    # value_counts할 때, normalize=True라면 비율대로 나와서 볼 수 있음
    df['컬럼명'].value_counts().plot(kind='bar')
    
    바플롯(=막대그래프)제외 나머지
    df['컬럼명'].plot(kind='others')
    
    # seaborn
    sns.barplot(x='컬럼명', y='컬럼명', data=df)
    
    출력된 그래프에서 특정 컬럼에 대한 평균값을 출력
    df.groupby([조건])['특정컬럼명'].mean()
    
    <치수 설정하기>
    plt.figure(figsize(10, 10))

     

     

    상관관계 함수

    # 상관관계를 heatmap 그래프로 시각화, corr()함수 사용
    corr = df.corr()
    sns.heatmap(corr, annot=True)
    
    #상관계수가 가장 높은 것 = 1 제외 가장 1에 가까운 것 (밝은 색일수록 강한 것)

     

    컬럼 타입 변경

    # 컬럼 타입 확인
    df['컬럼명'].dtypes
    
    # obfect타입 컬럼을 int타입으로 변경
    df['컬럼명'] = df['컬럼명'].astype(int)

     

     

    결측치 처리 관련 코드

    # 결측치 확인 코드
    df.isnull().sum()
    
    # 조건에 의한 결측지 처리 (결측치3000개 이상 컬럼 삭제, float타입 결측치 0으로 변환)
    df.drop('3000개 초과 컬럼', axis = 1, inplace = True)
    df['결측치컬럼'].fillna(0, inplace = True)
    
    # df에 결측치 존재하는 모든 행 삭제, df_na에 저장
    df_na = df.dropna()
    
    # 결측값을 앞쪽 행의 값으로 채우기
    df.fillna(method = 'ffill', inplace=True)
    
    # 결측값을 뒤쪽 행의 값으로 채우기
    df.fillna(method = 'backfill', inplace=True)
    
    # 결측값을 0으로 채우기
    df['컬럼명'].fillna(0, inplace=True)

     

     

    조건에 의한 데이터 처리

    # 조건에 의한 특정 행 삭제 후 df_temp에 저장
    idx = df[df['Speed_Per_Hour']>=300].index     # 특정 열 내 데이터 값이 300이상인 인덱스번호
    df_temp = df.drop(idx)
    
    # 조건에 의한 특정 열 삭제
    df = df.drop(['열1', '열2'], axis = 1)
    
    # df의 컬럼 'A', 'B', 'C'만 df_a로 할당하라
    df_a = df[['A', 'B', 'C']] 
    
    # object타입 컬럼의 결측값을 공백으로 변환
    df['object타입 컬럼'].replace(np.nan, ' ', inplace = True)
    
    #replace 함수를 이용, 해당 컬럼값 a를 b로 변경
    df['컬럼명'].replace('a', 'b', inplace=True)
    
    #최빈값 : age_cd 컬럼데이터 중 a를 age_cd의 최빈값으로 변경
    most_freq_town = df['age_cd'].value_counts().mode()
    df['age_cd'].replace('a', most_freq_town, inplace=True)
    
    df["English"].fillna(df["English"].mode()[0])
    
    #평균값 : mean() /#중간값 : median() /#최댓값 : max() /#최솟값 : min()
    
    #'index'열의 6번 행의 값을 NaN으로 바꾸기
    df.loc[6,'index'] = np.NaN

     

     

    데이터 전처리

     

    1. Label Encoder

    from sklearn.preprocessing import LabelEncoder
    
    le = LabelEncoder()
    >>>수치형 데이터로 변환할때 fit_transform을 사용
    df['컬럼명'] = le.fit_transform(df['컬럼명'])
    
    # 라벨 인코딩 전처리 대상이 많을경우
    df['컬럼1'] = le.fit_transform(df['컬럼1'])
    df['컬럼2'] = le.fit_transform(df['컬럼2'])
    df['컬럼3'] = le.fit_transform(df['컬럼3'])
    df2 = pd.DataFrame()
    
    for key in df:
    	df2[key] = df[key]
        
    df2 	#확인
    
    #혹은
    
    df2 = df.drop(['컬럼1','컬럼2','컬럼3'], axis=1)
    df2['컬럼1'] = le.fit_transform(df['컬럼1'])
    df2['컬럼2'] = le.fit_transform(df['컬럼2'])
    df2['컬럼3'] = le.fit_transform(df['컬럼3'])
    
    
    #특정 타입 데이터만 라벨인코딩
    cat_cols = df1.select_dtypes(include='object')	#object타입의 데이터만 라벨인코딩하겠다
    cat_cols['컬럼명'] = le.fit_transform(cat_cols['컬럼명'])

     

    2. One-Hot-Encoder

    <원-핫-인코딩 pandas의 get_dummies 사용>
    df = pd.get_dummies(data = df, columns = ['컬럼명'], drop_first = True)
    # 첫 가변수 1개를 삭제하라고 하였을 때 drop_first=True 입력 !!
    
    (pandas 사용하지 않을때)
    from sklearn.preprocessing import OneHotEncoder
    ohe = OneHotEncoder()
    
    #to_categorical
    y_train_ohe = to_categorical(y_train)
    y_test_ohe = to_categorical(y_test)
    
    위처럼 했을 시, history = model.fit(X_train, y_train.ohe, ... validation_daata=(X_test, y_test_ohe)..)

     

     

    트레인셋 / 테스트셋 분할

    < 'A'컬럼을 Label(y)로, 나머지 컬럼을 Label(X)로 할당한후 데이터셋 분리하라 >
    from sklearn.model_selection import train_test_split
    
    y = df['A'].values
    X = df.drop(['A'], axis = 1).values
    
    # 훈련셋 : 검증셋 = 7 : 3, 전체에서 검증셋 비율 => test_size = 0.3
    # y데이터를 원래 데이터 분포와 유사하게 추출되도록.(=stratify)
    X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size = 0.3, random_state=58, stratify = y)
    
    # location의 park와 beach가 골고루 분배되도록 stratify하게 분할한다.
    >>>> stratify = df['location']
    
    # 딥러닝 전 입력, 출력값 확인 
    X_train.shape # 입력
    y.unique() # 출력값

     

     

    데이터 정규화 / 표준화

    from sklearn.preprocessing import StandardScaler
    std = StandardScaler()
    X_train = std.fit_transform(X_train)
    X_valid = std.transform(X_valid)
    
    # MinMaxScaler
    from sklearn.preprocessing import MinMaxScaler
    mms = MinMaxScaler()
    X_train = mms.fit_transform(X_train)
    X_valid = mms.transform(X_valid)
    
    # RobustScaler
    from sklearn.preprocessing import RobustScaler
    rbs = RobustScaler()
    X_train = rbs.fit_transform(X_train)
    X_valid = rbs.transform(X_valid)

     

    머신러닝

     

    1. 로지스틱 회귀

    from sklearn.metrics import accuracy_score
    from sklearn.linear_model import LogisticRegression
    
    LR = LogisticRegression(C=1.0, Max_iter = 2000)
    
    LR.fit(X_train, y_train)
    y_pred = LR.predict(X_valid)
    LR.score(y_test, y_pred)

     

    2. 랜덤 포레스트

    from sklearn.ensemble import RandomForestClassifier
    
    rfc = RandomForestClassifier(n_estimators = 100, max_features = 9, max_depth = 15, random_state = 42)
    rfc.fit(X_train, y_train)
    
    # 모델의 성능 점수
    rfc.score(X_valid, y_valid)

     

    3.  랜덤 포레스트 회귀

    from sklearn.ensemble import RandomForestRegressor
    
    rfr = RandomForestRegressor(n_estimators = 100, max_features = 9, max_depth = 15, random_state = 42)
    rfr.fit(X_train, y_train)
    rfr.score(X_valid, y_valid)

     

    4. 결정트리 회귀

    from sklearn.tree import DecisionTreeRegressor
    
    dt = DecisionTreeRegressor(max_depth = 5, min_samples_split = 3, random_state = 120)
    dt.fit(X_train, y_train)

     

    5. 결정트리 분류

    from sklearn.ensemble import DecisionTreeClassifier
    
    dt = DecisionTreeClassifier(max_depth = 5, min_samples_split = 3, random_state = 120)
    dt.fit(X_train, y_train)

     

    6. 엑스트라 트리 분류

    from sklearn.ensemble import ExtraTreesClassifier
    
    extra_tree = ExtraTreeClassifier(random_state=42, max_depth=8, min_samples_split=2)
    extra_tree.fit(X_train, y_train)

     

    7. 엑스트라 트리 회귀

    from sklearn.ensemble import ExtraTreesRegressor
    
    extra_tree = ExtraTreesRegressor(random_state=42, max_depth=5, min_samples_split=2)
    extra_tree.fit(X_train, y_train)

     

    8. XGBoost

    !pip install xgboost
    
    from xgboost import XGBRegressor as xgb
    from sklearn.metrics import roc_auc_score, accuraty_score, mean_squared_error, r2_score
    
    model = xgb(n_estimators=100, gamma=1, eta=0.1, max_depth=5, reg_lambda=5, reg_alpha=5)
    model.fit(X_train, y_train)
    
    y_pred = xgb_model.predict(X_test)
    print(confusion_matrix(y_test, y_pred))
    model.score(X_test, y_test)

     

    9. LightGBM

    !pip install lightgbm
    from lightgbm import LGBMClassifier
    
    lgbm_model = LGBMClassifier(n_estimators=3)
    lgbm_model.fit(X_train, y_train)
    
    y_pred = lgbm_model.predict(X_test)
    print(confusion_matrix(y_test, y_pred))
    lgbm_model.score(X_test, y_test)

     

    10. 선형회귀

    from sklearn.linear_model import LinearRegression as lr
    from sklearn.metrics import roc_auc_score, accuracy_score, mean_squared_error, r2_score
    
    model = lr()
    model.fit(X_train, y_train)
    
    print("모델의 회귀계수는 : ", model.coef_, "이고 모델의 절편은 : ", model.intercept_)
    
    y_pred = model.predict(X_test)
    print("RMSE on Test set : {0:, 5f}".format(mean_squared_error(y_test, y_pred)**0.5))
    print("R-squared Score on Est set : {0:, 5f}".format(r2_score(y_test, y_pred)))

     

    회귀_ MAE, MSE 를 출력하라

    # decisionTree 회귀 MAE + 출력
    from sklearn.metrics import mean_absolute_error
    
    y_pred = dt.predict(X_valid)
    dt_mae = mean_absolute_error(y_valid, y_pred)
    print(mean_absolute_error(y_valid,y_pred))
    
    # RandomForest 회귀 MAE, MSE + 출력
    from sklearn.metrics import mean_absolute_error, mean_squared_error
    
    y_pred = rfc.predict(X_valid)
    rfc_mae = mean_absolute_error(y_valid, y_pred)
    rfc_mse = mean_squared_error(y_valid, y_pred)
    print(mean_absolute_error(y_valid,y_pred))
    print(mean_squared_error(y_valid,y_pred))
    문제따라 mae.mse 사용

     

     

    Confusion Matrix 구하고 heatmap그리기

    from sklearn.metrics import confusion_matrix
    from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
    from sklearn.metrics import classification_report
    
    y_pred = rfc.predict(X_valid)
    cm = confusion_matrix(y_valid, y_pred)
    
    sns.heatmap(cm, annot = True)
    print(classification_report(y_valid, y_pred))
    
    # classification report 를 report 변수에 저장
    report = classification_report(y_valid, y_pred)

     

     

    *activation - 마지막 출력층 label 열이 하나고 0,1로 구분된다면 sigmoid, label의 열이 두개 이상이면 softmax

     

    딥러닝

     

    1. 콜백 & 체크포인트 없는 회귀

    import tensorflow as tf
    from tensorflow.keras.models import Sequential, load_model
    from tensorflow.keras.layers import Dense, Dropout, Activation
    from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
    from sklearn.preprocessing import MinMaxScaler
    
    model = Sequential()
    model.add(Dense(128, input_shape=(X_train.shape[1],), activation = 'relu'))
    # x_train.shape = [행 수, 열 수] 나오는데 [1] -> 1번째 값인 열의 개수가 입력됨 
    model.add(Dropout(0.2))
    model.add(Dense(64, activation = 'relu'))
    model.add(Dense(1))
    
    model.compile(optimizer = 'adam', loss = 'mse', metrics = ['mse']) >>> loss랑 metrics값은 14번 보고 판단
    
    histroy = model.fit(X_train, y_train, epochs = 30, batch_size = 16, validation_data = (X_valid, y_valid)

     

     

    2. 콜백 & 체크포인트 있는 회귀

    import tensorflow as tf
    from tensorflow.keras.models import Sequential
    from tensorflow.keras.layers import Dense, Dropout, Activation
    from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
    from sklearn.preprocessing import MinMaxScaler
    
    model = Sequential()
    model.add(Dense(128, activation = 'relu', input_shape=(X_train.shape[1],)))
    model.add(Dropout(0.2))
    model.add(Dense(64, activation = 'relu'))
    model.add(Dropout(0.2))
    model.add(Dense(1))
    
    model.compile(optimizer = 'adam', loss = 'mse', metrics = ['mae', 'mse'])
    
    checkpoint_path = "best_model.h5"
    modelcheck = ModelCheckpoint(filepath = checkpoint_path, save_weights_only = True, save_best_only = True,
    						monitor = 'val_loss', verbose = 1)
    
    earlystop = EarlyStopping(monitor = 'val_loss', patience = 4, mode = 'min', verbose = 1)
    
    histroy = model.fit(X_train, y_train, epochs = 10, validation_data = (X_valid, y_valid),
    					 callbacks = [modelcheck, earlystop])

     

     

    3. 콜백 & 체크포인트 있는 분류 ( 단일 )

    **문제에서 주는 모니터링 지표에 따라 monitor = ' ' 값 바꿔주어야 함

    ** modelcheckpoint객체는 modelcheck변수에 저장, earlystopping 객체는 earlystop 변수에 저장

    import tensorflow as tf
    from tensorflow.keras.models import Sequential
    from tensorflow.keras.layers import Dense, Dropout, Activation
    from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
    from tensorflow.keras.utils import to_categorical
    from sklearn.preprocessing import MinMaxScaler
    
    model = Sequential()
    model.add(Dense(128, activation = 'relu', input_shape=(X_train.shape[1],)))
    model.add(Dropout(0.2))
    model.add(Dense(64, activation = 'relu'))
    model.add(Dropout(0.2))
    model.add(Dense(32, activation = 'relu'))
    model.add(Dropout(0.2))
    model.add(Dense(1, activation='sigmoid'))>>>> dense=1 : sigmoid / 나머지 dense: softmax
    출력값 dense를 판단하는 기준 : y에 대한 출력값 >> y.unique()
    
    model.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['acc'])
    
    checkpoint_path = "best_model.h5"
    modelcheck = ModelCheckpoint(filepath = checkpoint_path, monitor = 'val_loss', save_weights_only = True, 
    						save_best_only=True, verbose = 1)
    
    earlystop = EarlyStopping(monitor = 'val_loss', patience = 4, mode = 'min', verbose = 1)
    # es = EarlyStopping(monitor = 'val_acc', patience = 4, mode = 'max', verbose = 1)
    # patienc=4 > monitor가 4번동안 가장 작을때(클때) 멈춰라
    
    histroy = model.fit(X_train, y_train, epochs = 10, batch_size = 10,
    					validation_data = (X_valid, y_valid), callbacks = [modelcheck, earlystop])

     

     

    4. 콜백 & 체크포인트 있는 분류 ( 다중 )

    **문제에서 주는 모니터링 지표에 따라 monitor = ' ' 값 바꿔주어야 함

    ** modelcheckpoint객체는 modelcheck변수에 저장, earlystopping 객체는 earlystop 변수에 저장

    import tensorflow as tf
    from tensorflow.keras.models import Sequential, load_model
    from tensorflow.keras.layers import Dense, Dropout, Activation
    from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
    from tensorflow.keras.utils import to_categorical
    from sklearn.preprocessing import MinMaxScaler
    
    model = Sequential()         # 히든레이어 3개 이상
    model.add(Dense(128, activation = 'relu', input_shape=(X_train.shape[1],)))
    model.add(Dropout(0.2))
    model.add(Dense(64, activation = 'relu'))
    model.add(Dropout(0.2))
    model.add(Dense(32, activation = 'relu'))
    model.add(Dropout(0.2))
    model.add(Dense(3, activation='softmax'))
    
    model.compile(optimizer = 'adam', loss = 'categorical_crossentropy', metrics = ['acc'])
    # y가 원핫인코딩 되지 않았으면 아래 코드 적용
    # model.compile(optimizer = 'adam', loss = 'sparse_categorical_crossentropy', metrics = ['acc'])
    
    checkpoint_path = "best_model.h5"
    modelcheck = ModelCheckpoint(filepath = checkpoint_path, monitor = 'val_loss', save_weights_only = True,
    						save_best_only=True, verbose = 1)
    
    earlystop = EarlyStopping(monitor = 'val_loss', patience = 4, mode = 'min', verbose = 1)
    # earlystop = EarlyStopping(monitor = 'val_acc', patience = 4, mode = 'max', verbose = 1)
    
    histroy = model.fit(X_train, y_train, epochs = 10, batch_size = 10,
    					validation_data = (X_valid, y_valid), callbacks = [modelcheck, earlystop])

     

     

    최종 성능 평가 그래프 보이기

    import matplotlib.pyplot import plt
    
    # 표시하라
    plt.plot(history.history['loss'])
    plt.plot(history.history['val_loss'])
    plt.plot(history.history['acc'])
    plt.plot(history.history['val_acc'])
    
    plt.title('Accuracy')	# 제목
    plt.xlabel('Epochs')	# x축
    plt.ylabel('Acc')	# y축
    plt.legend(['loss', 'val_loss', 'acc', 'val_acc'])	# 범례
    plt.show()
    
    
    #plt.legend(['Trian', 'Validation'], loc='lower right')
    plt.plot(history.history['loss'], 'b', label='Train Loss')

     

     

    그 외

    #'Name'컬럼에서 호칭을 따로 분리해서 'Title'컬럼을 새로 만들어라.
    df['Title'] = df['Name'].str.extract(' [a-zA-Z]+\.')
    
    #'Title'컬럼의 데이터 분포를 확인하고 고유값 개수가 전체 10%미만인 값을 'Others'로 바꿔라
    df.loc[df['Title'].isin(['Mr','Miss','Mrs'])==False, ['Title']]='Others'
    
    #'Age'컬럼을 'Title'컬럼을 기준으로 하여 그룹 별 나이의 중앙값으로 채워라
    df.groupby('Title')['Age'].median()
    df_simple['Age'] = df['Age'].fillna(df.groupby('Title')['Age'].transform(median())
    
    #데이터 프레임 형태로 보기
    df['Age'].mode()[0]
    
    #첫번째 열을 제외한 데이터
    df.iloc[:, 1:]
    
    #feature_importance
    rf_importances_values = model.feature_importances_
    rf_importances = pd.Series(rf_importances_vvalues, index = X_train.columns)
    rf_top10 = rf_importances.sorf_values(ascending=False)[:10]
    
    #pivot_table, 서비스 수에 따른 요금 평균변화를 그래프로 나타내기위해 데이터 가져옴
    df2 = pd.pivot_table(df, index = ['service'])
    
    #다차원 배열을 1차원으로 평평하게 만들어주기
    y_train = np.ravel(y_train, order='C')

     

Designed by Tistory.