R, Python 분석과 프로그래밍의 친구 (by R Friend)

  (1) YAML 파일을 파싱해서 Python 객체로 읽어오기: yaml.load()

import yaml

with open('vegetables.yml') as f:

    vegetables = yaml.load(f, Loader=yaml.FullLoader)

    print(vegetables)

{'Vegetables': ['Pepper', 'Tomato', 'Garlic']}

import yaml

with open('deployment-definition.yml') as f:

    deployment_def = yaml.load(f, Loader=yaml.FullLoader)

deployment_def

{'apiVersion': 'apps/v1',
 'kind': 'Deployment',
 'metadata': {'name': 'frontend',
  'labels': {'app': 'mywebsite', 'tier': 'frontend'}},
 'spec': {'replicas': 3,
  'template': {'metadata': {'name': 'myapp-pod', 'labels': {'app': 'myapp'}},
   'spec': {'containers': [{'name': 'nginx', 'image': 'nginx'}]}},
  'selector': {'matchLabels': {'app': 'myapp'}}}}

  (2) 여러개의 YAML 문서들을 파싱하여 읽어오기 : yaml.load_all()

import yaml

with open('fruit-vegetable.yml') as f:

    fruits_vegetables = yaml.load_all(f, Loader=yaml.FullLoader)

    for fruit_vegetable in fruits_vegetables:

        print(fruit_vegetable)

{'Fruits': ['Blueberry', 'Apple', 'Orange']}
{'Vegetables': ['Pepper', 'Tomato', 'Garlic']}

  (3) 읽어온 YAML 파일을 정렬하기

import yaml

with open('cars.yml') as f:

    cars_original = yaml.load(f, Loader=yaml.FullLoader)

    print(cars_original)

    print("---------------------")

    # sorting by Key

    cars_sorted = yaml.dump(cars_original, sort_keys=True)

    print(cars_sorted)

{'hyundai': 45000, 'tesla': 65000, 'chevrolet': 42000, 'audi': 51000, 'mercedesbenz': 80000}
---------------------
audi: 51000
chevrolet: 42000
hyundai: 45000
mercedesbenz: 80000
tesla: 65000

import yaml

with open('cars.yml') as f:

    cars_original = yaml.load(f, Loader=yaml.FullLoader)

    print(cars_original)

    print("---------------------")

    # sort by key in ascending order

    for key, value in sorted(cars_original.items()):

        print(key, ':', value

{'hyundai': 45000, 'tesla': 65000, 'chevrolet': 42000, 'audi': 51000, 'mercedesbenz': 80000}
---------------------
audi : 51000
chevrolet : 42000
hyundai : 45000
mercedesbenz : 80000
tesla : 65000

import yaml

with open('cars.yml') as f:

    cars_original = yaml.load(f, Loader=yaml.FullLoader)

    print(cars_original)

    print("---------------------")

    # sorting by key in reverse order

    for key, value in sorted(cars_original.items(), reverse=True):

        print(key, ':', value)

tesla : 65000
mercedesbenz : 80000
hyundai : 45000
chevrolet : 42000
audi : 51000

import yaml

with open('cars.yml') as f:

    cars_original = yaml.load(f, Loader=yaml.FullLoader)

    print(cars_original)

    print("---------------------")

    # sorting by value in ascending order

    for key, value in sorted(cars_original.items(), key = lambda item: item[1]):

        print(key, ':', value)

{'hyundai': 45000, 'tesla': 65000, 'chevrolet': 42000, 'audi': 51000, 'mercedesbenz': 80000}
---------------------
chevrolet : 42000
hyundai : 45000
audi : 51000
tesla : 65000
mercedesbenz : 80000

  (4) Python 객체를 YAML stream으로 직렬화 하기: yaml.dump()

import yaml

fruits = {'fruits': ['blueberry', 'apple', 'orange']}

# serialize a Python object into YAML stream

fruits_serialized_yaml = yaml.dump(fruits)

print(fruits_serialized_yaml)

fruits:
- blueberry
- apple
- orange

  (5) Python 객체를 YAML 파일로 쓰기: with open('w') as f: yaml.dump()

import yaml

fruits = {'fruits': ['blueberry', 'apple', 'orange']}

with open('fruits.yaml', 'w') as f:

    yaml.dump(fruits, f)

import pandas as pd

tr = pd.DataFrame({

    'ts': ['2020-06-01', '2020-06-02', '2020-06-03', '2020-06-01', '2020-06-03'], 

    'id': [1, 1, 1, 2, 3], 

    'amt': [100, 300, 50, 200, 150]})

tr

date_id_idx = pd.MultiIndex.from_product((set(tr.ts), set(tr.id)))

date_id_idx

MultiIndex([('2020-06-01', 1),
            ('2020-06-01', 2),
            ('2020-06-01', 3),
            ('2020-06-02', 1),
            ('2020-06-02', 2),
            ('2020-06-02', 3),
            ('2020-06-03', 1),
            ('2020-06-03', 2),
            ('2020-06-03', 3)],
           )

tr_tsformat = tr.set_index(['ts', 'id']).reindex(date_id_idx)

tr_tsformat

tr_tsformat = tr.set_index(['ts', 'id']).reindex(date_id_idx, fill_value=0)

tr_tsformat

tr_tsformat.reset_index(inplace=True)

tr_tsformat

tr_tsformat.columns = ['ts', 'id', 'amt']

tr_tsformat

  (1) 날짜/시간 포맷 지정 없이 pd.read_csv() 로 날짜/시간 데이터 읽어올 경우

import pandas as pd

df = pd.read_csv('date_sample', sep=",", names=['date', 'id', 'val']) # no datetime parsing

df

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 6 entries, 0 to 5
Data columns (total 3 columns):
date    6 non-null object <-- not datetime format
id      6 non-null int64
val     6 non-null int64
dtypes: int64(2), object(1)
memory usage: 272.0+ bytes

  (2) parse_dates=['date'] 칼럼에 대해 

      dayfirst=True 일이 월보다 먼저 위치하는 것으로 

      infer_datetime_format=True 날짜시간 포맷 추정해서 파싱하기

import pandas as pd

df_date = pd.read_csv("date_sample", 

                      sep=",", 

                      names=['date', 'id', 'val'], 

                      parse_dates=['date'], 

                      dayfirst=True, # May 1st

                      infer_datetime_format=True)

df_date  # May 1st, 2020

  (3) dayfirst=False 일(day)이 월(month)보다 뒤에 있는 파일 날짜/시간 파싱하기

df_date_dayfirstF = pd.read_csv("date_sample", 

                                sep=",", 

                                names=['date', 'id', 'val'], 

                                parse_dates=['date'], 

                                dayfirst=False, # January 5th, default setting

                                infer_datetime_format=True)

df_date_dayfirstF  # January 5th, 2020

  (4) date_parser=Parser 함수를 사용해서 데이터 읽어올 때 날짜/시간 파싱하기

# parsing datetime string using lambda Function at date_parser

# Reference: converting string to DataTime: https://rfriend.tistory.com/498

import pandas as pd

from datetime import datetime

dt_parser = lambda x: datetime.strptime(x, "%d/%m/%Y %H:%M:%S")

df_date2 = pd.read_csv("date_sample", 

                       sep=",", 

                       names=['date', 'id', 'val'], 

                       parse_dates=['date'], # column name

                       date_parser=dt_parser)

df_date2

# parse_dates=[column_position]

import pandas as pd

from datetime import datetime

dt_parser = lambda x: datetime.strptime(x, "%d/%m/%Y %H:%M:%S")

df_date3 = pd.read_csv("date_sample", 

                       sep=",", 

                       names=['date', 'id', 'val'], 

                       parse_dates=[0], # position index

                       date_parser=dt_parser)

df_date3

  (5) index_col 로 날짜-시간 데이터를 DataFrame index로 불러오기

# use datetime as an index

import pandas as pd

df_date_idx = pd.read_csv("date_sample", 

                          sep=",", 

                          names=['date', 'id', 'val'], 

                          index_col=['date'], # or index_col=0 

                          parse_dates=True, 

                          dayfirst=True,

                          infer_datetime_format=True)

df_date_idx

# python build-in function int(x, base=10)

int('101', base=2)

[Out]: 5

int('101', base=5)

[Out]: 26

# create a basetwo() function using functools.partial() and int() function

from functools import partial

basetwo = partial(int, base=2)  # freeze base=2

basetwo('101')

[Out]: 5

# add __doc__ attribute

basetwo.__doc__ = 'Convert base 2 string to an int.'

basetwo.__doc__

[Out]: 'Convert base 2 string to an int.'

basetwo.func

[Out]: int

basetwo.args

[Out]: ()

basetwo.keywords

[Out]: {'base': 2}

 구분

 Binary File on disk

Bytes object on memory 

 직렬화

(serialization)

 with open("file.txt", "wb") as MyFile:

     pickle.dump(MyObject, MyFile)

 pickle.dumps(MyObject, MyBytes)

 역직렬화

(deserialization)

 with open("file.txt", "rb") as MyFile:

     MyObj2 = pickle.load(MyFile)

 MyObj2 = pickle.loads(MyBytes)

MyObject = {'id': [1, 2, 3, 4], 

           'name': ['KIM', 'CHOI', 'LEE', 'PARK'], 

           'score': [90.5, 85.7, 98.9, 62.4], 

           'pass_yn': [True, True, True, False]}

 (1-1) 파이썬 객체를 직렬화하여 이진 파일(binary file)에 저장하기 : pickle.dump()

import pickle

with open("serialized_file.txt", "wb") as MyFile:

    pickle.dump(MyObject, MyFile, protocol=3)

 (1-2) 직렬화되어 있는 이진 파일로 부터 파이썬 객체로 역직렬화: pickle.load()

import pickle

with open("serialized_file.txt", "rb") as MyFile:

    UnpickledObject = pickle.load(MyFile)

UnpickledObject

[Out]:

{'id': [1, 2, 3, 4],
 'name': ['KIM', 'CHOI', 'LEE', 'PARK'],
 'score': [90.5, 85.7, 98.9, 62.4],
 'pass_yn': [True, True, True, False]}

 (2-1) 파이썬 객체를 직렬화하여 메모리에 Bytes object로 저장하기: pickle.dumps()

import pickle 

MyBytes = pickle.dumps(MyObject, protocol=3)

# unreadable bytes object

MyBytes

[Out]:
b'\x80\x03}q\x00(X\x02\x00\x00\x00idq\x01]q\x02(K\x01K\x02K\x03K\x04eX\x04\x00\x00\x00nameq\x03]q\x04(X\x03\x00\x00\x00KIMq\x05X\x04\x00\x00\x00CHOIq\x06X\x03\x00\x00\x00LEEq\x07X\x04\x00\x00\x00PARKq\x08eX\x05\x00\x00\x00scoreq\t]q\n(G@V\xa0\x00\x00\x00\x00\x00G@Ul\xcc\xcc\xcc\xcc\xcdG@X\xb9\x99\x99\x99\x99\x9aG@O333333eX\x07\x00\x00\x00pass_ynq\x0b]q\x0c(\x88\x88\x88\x89eu.'

 (2-2) 직렬화되어 있는 바이트 객체를 파이썬 객체로 역직렬화: pickle.loads()

import pickle

MyObj2 = pickle.loads(MyBytes)

MyObj2

[Out]:

{'id': [1, 2, 3, 4],
 'name': ['KIM', 'CHOI', 'LEE', 'PARK'],
 'score': [90.5, 85.7, 98.9, 62.4],
 'pass_yn': [True, True, True, False]}

 (1-1) 문자열로 이루어진 리스트를 한 줄씩 텍스트 파일에 쓰기 : write() 메소드

matrix_quotes = ["The Matrix is the world that has been pulled over your eyes to blind you from the truth.\n", 

                 "You have to let it all go, Neo. Fear, doubt, and disblief. Free your mind.\n", 

                 "There is a difference between knowing the path and walking the path.\n", 

                 "Welcom to the desert of the real!\n"]

with open('matrix_quotes.txt', 'w') as f:

    for line in matrix_quotes:

        f.write(line)

 (1-2) 문자열로 이루어진 리스트의 모든 줄을 텍스트 파일에 쓰기: writelines() 메소드 

matrix_quotes = ["The Matrix is the world that has been pulled over your eyes to blind you from the truth.\n", 

                 "You have to let it all go, Neo. Fear, doubt, and disblief. Free your mind.\n", 

                 "There is a difference between knowing the path and walking the path.\n", 

                 "Welcom to the desert of the real!\n"]

with open('maxtix_quotes_2.txt', 'w') as f:

    f.writelines(matrix_quotes)

  (2-1) 텍스트 파일을 한 줄씩 읽어오기 : readline() 메소드

matrix_quotes_list

[Out]: 

['The Matrix is the world that has been pulled over your eyes to blind you from the truth.\n',  'You have to let it all go, Neo. Fear, doubt, and disblief. Free your mind.\n',  'There is a difference between knowing the path and walking the path.\n',  'Welcom to the desert of the real!\n',  '']

  (2-2) 텍스트 파일을 모두 한꺼번에 읽어오기 : readlines() 메소드

with open('matrix_quotes.txt', 'r') as text_file:

    matrix_quotes_list_2 = text_file.readlines()

matrix_quotes_list_2

[Out]: 

['The Matrix is the world that has been pulled over your eyes to blind you from the truth.\n',  'You have to let it all go, Neo. Fear, doubt, and disblief. Free your mind.\n',  'There is a difference between knowing the path and walking the path.\n',  'Welcom to the desert of the real!\n']

open(

  file,                 # 필수 매개변수, 파일의 경로

  mode = 'r',       # 선택적 매개변수, 'rt' (읽기용, text mode)가 기본값

  buffering = -1,   # 선택적 매개변수, 버퍼링 정책 (0 : binary mode 시 버퍼링 미수행, 

                        # 1: 텍스트 모드 시 개행문자(\n)을 만날 때까지 버퍼링)

  encoding = None, # 선택적 매개변수, 문자 인코딩 방식 (예: 'utf-8', 'cp949', 'latin' 등)

  errors = None,   # 선택적 매개변수, 텍스트 모드 시 에러 처리 (예: 'ignore' 에러 무시)

  newline = None, # 선택적 매개변수, 줄바꿈 처리 (None, '\n', '\r', '\r\n')

  closefd = True,   # 선택적 매개변수, False 입력 시 파일 닫더라도 파일 기술자 계속 열어둠

  opener = None) # 선택적 매개변수, 파일을 여는 함수를 직저 구현 시 사용

  (1) 파일을 열고 --> 파일에 데이터를 쓰고 --> 파일을 닫기

# Open and Write

MyFile = open('myfile.txt', 'w')

MyFile.write('Open, read, write and close a file using Python')

MyFile.close()

# encoding = 'cp949' for Windows10 OS

MyFile

[Out] <_io.TextIOWrapper name='myfile.txt' mode='w' encoding='cp949'>

import os

os.listdir(os.getcwd())

[Out]:
['myfile.txt',
 'Python_read_write_file.ipynb']

  (2) 파일을 열고 --> 파일의 데이터를 읽고 --> 파일을 닫기

# Open and Read

MyFile = open('myfile.txt', 'r')

# equivalent to the above

#MyFile = open('myfile.txt', 'rt')

#MyFile = open('myfile.txt', 't')

#MyFile = open('myfile.txt')

MyString = MyFile.read()

print(MyString)

[Out]: Open, read, write and close a file using Python

# close the 'MyFile' file

MyFile.close()

  (3) with open(파일 이름) as 파일 객체: 를 사용해서 파일 열기

# Using the with statement the file is automatically closed

with open('myfile.txt', 'r') as MyFile:

    MyString = MyFile.read()

    print(MyString)

    # no need for MyFile.close()

[Out]: Open, read, write and close a file using Python

  (4) 텍스트 모드에서 인코딩, 디코딩 에러 발생 시 처리 : errors

errors 매개변수 

error 처리 방법 

 'strict'

 인코딩 에러 발생 시 ValueError 예외

 'ignore'

 에러 무시

 'replace'

 대체 기호 삽입 (예: "?")

 'surrogateescape'

 U+DC80~U+DCFF 사이의 유니코드 사용자 자유 영역의 잘못된 바이트를 code points 로 나타냄

 'xmlcharrefreplace'

 파일을 쓸 때 파일에 기록하려는 텍스트 안의 지정된 인코딩에서 지원되지 않는 문자를 &#NNN; 의 XML 문자 참조로 바꿔서 기록

 'backslashreplace'

 파일을 쓸 때 현재 인코딩에서 지원되지 않는 문자를 역슬래시(back slash, \)로 시작되는 escape sequence로 바꿔서 기록

 구분

 np.digitize(X, bins)

pd.cut(X, bins, labels) 

 bins=[start, end]

 [포함, 미포함)

 (미포함, 포함)

 bin 구간 대비 

 작거나 큰 수

 bin 첫 구간 보다 작으면 [-inf, start)

 --> 자동으로 '1'로 digitize 

 bin 마지막 구간 보다 크면 [end, inf)

 --> 자동으로 bin 순서에 따라 digitize

 bin 첫번째 구간보다 작으면 --> NaN

 bin 마지막 구간보다 크면 --> Nan

 label

 0, 1, 2, ... 순서의 양의 정수 자동 설정

 사용자 지정 가능 (labels option)

 반환 (return)

 numpy array

 a list of categories with labels

  (1) np.digitize(X, bins) 를 이용한 연속형 변수의 여러개 구간별 범주화

import pandas as pd

import numpy as np

df = pd.DataFrame({'col': np.arange(10)})

df

bins=[0, 5, 8]

# returns numpy array

np.digitize(df['col'], bins)

[Out]: array([1, 1, 1, 1, 1, 2, 2, 2, 3, 3])

df['grp_digitize'] = np.digitize(df['col'], bins)

df

[Out]:

  (2) pd.cut(X, bins, labels) 를 이용한 연속형 변수의 여러개 구간별 범주화 

import pandas as pd

import numpy as np

df = pd.DataFrame({'col': np.arange(10)})

# pd.cut(미포함, 포함]

bins=[0, 5, 8]

# returns a list of catogiries with labels

pd.cut(df["col"], bins=bins)

[Out]:
0           NaN
1    (0.0, 5.0]
2    (0.0, 5.0]
3    (0.0, 5.0]
4    (0.0, 5.0]
5    (0.0, 5.0]
6    (5.0, 8.0]
7    (5.0, 8.0]
8    (5.0, 8.0]
9           NaN
Name: col, dtype: category
Categories (2, interval[int64]): [(0, 5] < (5, 8]]

df['grp_cut'] = pd.cut(df["col"], bins=bins, labels=['a', 'b'])

df

[Out]:

df.groupby('grp_cut')['col'].sum()

[Out]:

grp_cut
a    15
b    21
Name: col, dtype: int64

# UDF of summary statistics

def my_summary(x):

    result = {

        'sum': x.sum(), 

        'count': x.count(), 

        'mean': x.mean(), 

        'variance': x.var()

    }

    return result

df.groupby('grp_cut')['col'].apply(my_summary).unstack()

[Out]:

  (1) sklearn.model_selection.train_test_split 함수를 이용한 Train, Test set 분할

      (층을 고려한 X_train, X_test, y_train, y_test 반환)

import numpy as np

X = np.arange(30).reshape(15, 2)

X

[Out]:
array([[ 0,  1],
       [ 2,  3],
       [ 4,  5],
       [ 6,  7],
       [ 8,  9],
       [10, 11],
       [12, 13],
       [14, 15],
       [16, 17],
       [18, 19],
       [20, 21],
       [22, 23],
       [24, 25],
       [26, 27],
       [28, 29]])

y = np.arange(15)

y

[Out]: 
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])

# stratum (group)

grp = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

grp

[Out]:

[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

# returns X_train, X_test, y_train, y_test dataset

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, 

                                                    y, 

                                                    test_size=0.2, 

                                                    shuffle=True,

                                                    stratify=grp, 

                                                    random_state=1004)

print('X_train shape:', X_train.shape)

print('X_test shape:', X_test.shape)

print('y_train shape:', y_train.shape)

print('y_test shape:', y_test.shape)

[Out]:

X_train shape: (12, 2)
X_test shape: (3, 2)
y_train shape: (12,)
y_test shape: (3,)

X_train

[Out]:

array([[12, 13],
       [ 8,  9],
       [28, 29],
       [ 0,  1],
       [10, 11],
       [ 6,  7],
       [ 2,  3],
       [18, 19],
       [20, 21],
       [22, 23],
       [26, 27],
       [14, 15]])

y_train

[Out]: 

array([ 6,  4, 14,  0,  5,  3,  1,  9, 10, 11, 13,  7])

X_test

[Out]:

array([[16, 17],
       [ 4,  5],
       [24, 25]])

y_test

[Out]: array([ 8,  2, 12])

  (2) sklearn.model_selection.StratifiedShuffleSplit 함수를 이용한 Train, Test set 분할

       (층을 고려한 train/test indices 반환 --> Train, Test set indexing)

i# Stratified ShuffleSplit cross-validator 

# provides train/test indices to split data in train/test sets.

from sklearn.model_selection import StratifiedShuffleSplit

split = StratifiedShuffleSplit(n_splits=1, test_size=0.2, random_state=1004)

for train_idx, test_idx in split.split(X, grp):

    X_train = X[train_idx]

    X_test = X[test_idx]

    y_train = y[train_idx]

    y_test = y[test_idx]

X_train

[Out]:
array([[12, 13],
       [ 8,  9],
       [28, 29],
       [ 0,  1],
       [10, 11],
       [ 6,  7],
       [ 2,  3],
       [18, 19],
       [20, 21],
       [22, 23],
       [26, 27],
       [14, 15]])

y_train

[Out]: array([ 6,  4, 14,  0,  5,  3,  1,  9, 10, 11, 13,  7])

X_test

[Out]:

array([[16, 17],
       [ 4,  5],
       [24, 25]])

y_test

[Out]: array([ 8,  2, 12])

import pandas as pd

import numpy as np

X = np.arange(30).reshape(15, 2)

y = np.arange(15)

df = pd.DataFrame(np.column_stack((X, y)), columns=['X1','X2', 'y'])

df

df['grp'] = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

df

from sklearn.model_selection import StratifiedShuffleSplit

split = StratifiedShuffleSplit(n_splits=1, test_size=0.2, random_state=1004)

for train_idx, test_idx in split.split(df, df["grp"]):

    df_strat_train = df.loc[train_idx]

    df_strat_test = df.loc[test_idx]

df_strat_train

df_strat_test

df["grp"].value_counts() / len(df)

[Out]:
1    0.666667
0    0.333333
Name: grp, dtype: float64

df_strat_train["grp"].value_counts() / len(df_strat_train)

[Out]:

1    0.666667
0    0.333333
Name: grp, dtype: float64

df_strat_test["grp"].value_counts() / len(df_strat_test)

[Out]:

1    0.666667
0    0.333333
Name: grp, dtype: float64

  (1) scikit-learn.model_selection의 train_test_split 함수로 train, test set 분할하기

     (split train and test set using sklearn.model_selection train_test_split())

import numpy as np

X = np.arange(20).reshape(10, 2)

X

[Out]:

array([[ 0,  1],
       [ 2,  3],
       [ 4,  5],
       [ 6,  7],
       [ 8,  9],
       [10, 11],
       [12, 13],
       [14, 15],
       [16, 17],
       [18, 19]])

y = np.arange(10)

y

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

from sklearn.model_selection import train_test_split

# shuffle = False

X_train, X_test, y_train, y_test = train_test_split(X, 

                                                    y, 

                                                    test_size=0.4, 

                                                    shuffle=False, 

                                                    random_state=1004)

print('X_train shape:', X_train.shape)

print('X_test shape:', X_test.shape)

print('y_train shape:', y_train.shape)

print('y_test shape:', y_test.shape)

[Out]:

X_train shape: (6, 2)
X_test shape: (4, 2)
y_train shape: (6,)
y_test shape: (4,)

X_train

[Out]: 

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

y_train

[Out]: array([0, 1, 2, 3, 4, 5])

# shuffle = True

X_train, X_test, y_train, y_test = train_test_split(X, 

                                                    y, 

                                                    test_size=0.4, 

                                                    shuffle=True, 

                                                    random_state=1004)

X_train

array([[ 2,  3],
       [ 8,  9],
       [ 6,  7],
       [14, 15],
       [10, 11],
       [ 4,  5]])

y_train

array([1, 4, 3, 7, 5, 2])

  (2) numpy random 클래스의 permutation 함수를 이용하여 train, test set 분할하기

# UDF of split train, test set using np.random.permutation()

# X: 2D array, y:1D array

def permutation_train_test_split(X, y, test_size=0.2, shuffle=True, random_state=1004):

    import numpy as np

    test_num = int(X.shape[0] * test_size)

    train_num = X.shape[0] - test_num

    if shuffle:

        np.random.seed(random_state)

        shuffled = np.random.permutation(X.shape[0])

        X = X[shuffled,:]

        y = y[shuffled]

        X_train = X[:train_num]

        X_test = X[train_num:]

        y_train = y[:train_num]

        y_test = y[train_num:]

    else:

        X_train = X[:train_num]

        X_test = X[train_num:]

        y_train = y[:train_num]

        y_test = y[train_num:]

    return X_train, X_test, y_train, y_test

# create 2D X and 1D y array

X = np.arange(20).reshape(10, 2)

y = np.arange(10)

# split train and test set using by random sampling

X_train, X_test, y_train, y_test = permutation_train_test_split(X, 

                                                                y, 

                                                                test_size=0.4, 

                                                                shuffle=True,

                                                                random_state=1004)

X_train

[Out]:

array([[ 0,  1],
       [12, 13],
       [16, 17],
       [18, 19],
       [ 2,  3],
       [ 8,  9]])

y_train

[Out]: array([0, 6, 8, 9, 1, 4])

  (3) numpy random 클래스의 choice 함수를 이용하여 train, test set 분할하기

def choice_train_test_split(X, y, test_size=0.2, shuffle=True, random_state=1004):

    test_num = int(X.shape[0] * test_size)

    train_num = X.shape[0] - test_num

    if shuffle:

        np.random.seed(random_state)

        train_idx = np.random.choice(X.shape[0], train_num, replace=False)

        #-- way 1: using np.setdiff1d()

        test_idx = np.setdiff1d(range(X.shape[0]), train_idx)

        X_train = X[train_idx, :]

        X_test = X[train_idx, :]

        y_train = y[test_idx]

        y_test = y[test_idx]

    else:

        X_train = X[:train_num]

        X_test = X[train_num:]

        y_train = y[:train_num]

        y_test = y[train_num:]

    return X_train, X_test, y_train, y_test

def choice_train_test_split(X, y, test_size=0.2, shuffle=True, random_state=1004):

    test_num = int(X.shape[0] * test_size)

    train_num = X.shape[0] - test_num

    if shuffle:

        np.random.seed(random_state)

        train_idx = np.random.choice(X.shape[0], train_num, replace=False)

        #-- way 2: using list comprehension with for loop

        test_idx = [idx for idx in range(X.shape[0]) if idx not in train_idx]

        X_train = X[train_idx, :]

        X_test = X[train_idx, :]

        y_train = y[test_idx]

        y_test = y[test_idx]

    else:

        X_train = X[:train_num]

        X_test = X[train_num:]

        y_train = y[:train_num]

        y_test = y[train_num:]

    return X_train, X_test, y_train, y_test

  (4) numpy random shuffle() 함수를 이용하여 train, test set 분할하기

    (split train, test set using np.random.shuffle() function)

# UDF of split train, test set using np.random.shuffle()

# X: 2D array, y:1D array

def shuffle_train_test_split(X, y, test_size=0.2, shuffle=True, random_state=1004):

    import numpy as np

    test_num = int(X.shape[0] * test_size)

    train_num = X.shape[0] - test_num

    if shuffle:

        np.random.seed(random_state) # for reproducibility

        Xy = np.column_stack((X, y)) # concatenate first

        np.random.shuffle(Xy)           # random shuffling second

        X_train = Xy[:train_num, :-1]  # slicing from 1 to train_num row, X column

        X_test = Xy[train_num:, :-1]   # slicing from 1 to train_num row, y column

        y_train = Xy[:train_num, -1]

        y_test = Xy[train_num:, -1]

    else:

        X_train = X[:train_num]

        X_test = X[train_num:]

        y_train = y[:train_num]

        y_test = y[train_num:]

    return X_train, X_test, y_train, y_test

# shuffle = True

X = np.arange(20).reshape(10, 2)

y = np.arange(10)

X_train, X_test, y_train, y_test = shuffle_train_test_split(X, 

                                                            y, 

                                                            test_size=0.4, 

                                                            shuffle=True)

X_train

[Out]:

array([[ 0,  1],
       [12, 13],
       [16, 17],
       [18, 19],
       [ 2,  3],
       [ 8,  9]])

y_train

[Out]: array([0, 6, 8, 9, 1, 4])