stock data handling and utilization
- 1st: DSML test
- 2nd: Capstone test
- pandas์ฌ์ฉ ver ; with open ๊ตฌ๋ฌธ ver
์ ํ๋
---- ๊ฒ์์ด: scikit-learn ํ๊ท๋ชจ๋ธ
'regression model ์ข ๋ฅ'๋ ๋ณ ๋์ ์๋จ
๋ค์ํ ํ๊ท๋ชจ๋ธ๋ค - ํ๊ท ์ฝ๋์ ์ฐธ๊ณ ํจ
๋ค์ค์ ํํ๊ท
ํ๊ท ๊ฐ๋ , ๋ถ๋ฅ
/project/guri/forposter/Result1.์ ํ๋.ipynb ์ฐธ๊ณ
ํ ์ค๋ก ์กฐ๊ฑด์ ๋ง๋ df ์ด ์์ฑํ๊ธฐ.
** ์กฐ๊ฑด์ ๋ฐ๋ฅธ df ์ด ๋ฐ๊พธ๊ธฐ ์๋์ ์ฃผ์!!
<์์>
df['new_col'] = np.where(df['base_col'] == 1, 'new', 'old')์กฐ๊ฑด์ ๋ง์กฑํ๋ฉด 'new' ์์ฑ, ๋ง์กฑํ์ง ์์ผ๋ฉด 'old' ์์ฑ.
np.where(condition, x, y); ์กฐ๊ฑด ์ถฉ์กฑ์ x, ๊ทธ๋ ์ง ์์ผ๋ฉด y ๋ฐํ.
data split - random ,,, shuffle
๋น์๊ณ์ด ๋ฐ์ดํฐ๋ shuffle ํด๋ random์ด๋ ๊ฐ์.
๋จ, ์๊ณ์ด ๋ฐ์ดํฐ๋ shuffle๊ณผ random์ด ๋ค๋ฅธ ์๋ฏธ์ด๋ ์ฃผ์.
(์๊ณ์ด ๋ฐ์ดํฐ๋ ์์๊ฐ ์ค์ํ๋ฏ๋ก)
ํ๊ท cross_val_score()์ hyper param
cross_val_score()์ ๊ณต์ doc
๊ฒ์์ด : [pipeline.fit.transform ํ์ด์ฌ]
transpose()๊ฐ ๋ญ์ง ๋ด์ผํจ.1 - ์ฝ์
-- fit & transform ๊ณผ fit_transform์ ์ฐจ์ด
Q. [fit & transform ๊ณผ fit_transform์ ์ฐจ์ด?]
A. ์ฌ์ดํท๋ฐ์ ๋ฐ์ดํฐ๋ฅผ ๋ณํํ๋ ๋๋ถ๋ถ์ ๋ก์ง์์ fit()๊ณผ transform()์ ์์ผ๋ก ์ฌ์ฉ
ํ์ต๋ฐ์ดํฐ ์ธํธ์์ ๋ณํ์ ์ํ ๊ธฐ๋ฐ ์ค์
(์๋ฅผ ๋ค์ด ํ์ต ๋ฐ์ดํฐ ์ธํธ์ ์ต๋๊ฐ/์ต์๊ฐ๋ฑ)
์ ๋จผ์ fit()์ ํตํด์ ์ค์ ํ ๋ค์
์ด๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ์ต ๋ฐ์ดํฐ์ transform()์ ์ํํ๋
ํ์ต ๋ฐ์ดํฐ์์ ์ค์ ๋ ๋ณํ์ ์ํ ๊ธฐ๋ฐ ์ค์ ์ ๊ทธ๋๋ก ํ
์คํธ ๋ฐ์ดํฐ์๋ ์ ์ฉํ๊ธฐ ์ํด์์
๋๋ค.
์ฆ ํ์ต ๋ฐ์ดํฐ ์ธํธ๋ก fit() ๋ Scaler๋ฅผ ์ด์ฉํ์ฌ ํ
์คํธ ๋ฐ์ดํฐ๋ฅผ ๋ณํํ ๊ฒฝ์ฐ์๋
ํ
์คํธ ๋ฐ์ดํฐ์์ ๋ค์ fit()ํ์ง ์๊ณ
๋ฐ๋์ ๊ทธ๋๋ก ์ด Scaler๋ฅผ ์ด์ฉํ์ฌ transform()์ ์ํํด์ผ ํฉ๋๋ค.
transpose()๊ฐ ๋ญ์ง ๋ด์ผํจ.2 - ์์ง ์ ์ฝ์.
xticks
python plt arrow
annotate()
dummy regressor ์๋ก์ด ๋ฐฉ๋ฒ; ๊ฒ์์ด dummyregressor ์ฌ์ฉ๋ฐฉ๋ฒ
- classification ๊ฒฐ๊ณผ ๋ค๋ฅธ ์ด์ ๋ y ๋๋๋ ๊ธฐ์ค๊ฐ์ด ๋ฌ๋๊ณ , ์์ฐ์ด cv๋ฅผ ์ํ๊ธฐ ๋๋ฌธ.
- reg dummy ๊ฒฐ๊ณผ ๋ฌ๋๋ ์ด์ ๋ scoring ๋ฐฉ๋ฒ์ด ๋ฌ๋๊ธฐ ๋๋ฌธ. + ๋๋ cv๋ฅผ ์ํจ.
[cross_val_score๋ ๊ทธ๋ฅ x,y๋ง ๋๋ ๋์ ๋ฐ์ดํฐ ์ง์ด๋ฃ์ผ๋ฉด ์์์ ๋น์จ ์ง์ ๋ฐ์ดํฐ ๋ถํ ํด์ cv ํด์ฃผ๋๊ฐ์ ๋ํ์ฌ... ==> ์ด๋ฏธ ์ ์๋ ๊ฐ์ ์๋ฌธ์ ๊ฐ์ก์์ผ๋ฉฐ, ๋ต๋ ์ ์ด๋ . cv default == 5 (5ํ cross checking)]
์ ๋ชจ๋ธ๋ง์ด ์๋๋ผ cv๋ฉด ์ ์ฒด ๋ฐ์ดํฐ๋ฅผ ๋ฃ์ด์ผํ๋๊ฑฐ๊ตฌ๋.
cross_val_score()์ default๋ r^2(๊ฒฐ์ ๊ณ์)
๊ต์ฐจ ๊ฒ์ฆ์ ์ ํ๋๋ฅผ ๊ฐ๋จํ๊ฒ ๋ํ๋ผ ๋๋ ํ๊ท ์ผ๋ก...
dummy์ cv๊ฐ ํ์ํ๊ฐ์ ๋ํ์ฌ...
- ์์ง ๋ง์ํ ํ ์ฌํญ: ๋ค ํจ์๋ก ๋ง๋ค์ด์ ์ฌ์ฉ์ค์ด๊ธฐ ๋๋ฌธ์ ์
๋ ฅ์ด ๋งค๊ฐ๋ณ์์.
๋งค๊ฐ๋ณ์๊ฐ ๊ธฐ์กด์ ๋ง๋ค์ด๋ ๋ณ์๋ ์ด๋ฆ์ด ๊ฐ์์ ํท๊ฐ๋ ธ์.
[๋ชจ๋ธ๋ง ๋จ๊ณ]
-
data split (1์ฐจ: x๋ y, 2์ฐจ: xy๊ฐ๊ฐ์ train๋ test๋ก)
-
model fitting with train data
-
predict with test data
-
scoring with test data, predict data
(์ผ๋ง๋ ๋ง์๋์ง.)
๊ทผ๋ฐ ์ ์ฐ๋ฆฌ๊ฐ ์ผ๋ reg๋ fitting์ ํ์ง ์๋ ๊ฐ์ ๋ํ์ฌ... ๋ด๊ฐ ์ค๋ก์ง cvํ๋ ๊ฒ์ ๋ํ ํฌ์คํ
์ ์ฐพ์๊ฑด๊ฐ...
ํ๊ท๋ชจ๋ธ๋ง ํฌ์คํ
์ด์์..
๊ทธ๋ฅ ๊ทธ ๋ถ์ด fitting์ ๋นผ๋จน์ผ์ ๊ฑฐ์ธ๋ฏ.
error message: The least populated class in y has only 1 member, which is too few. The minimum number of groups for any class cannot be less than 2.
ํ๊ท๋ ๊ณ์ธต์ split์ด ์๋จ. ์ฃผ์!!!!!
sss (Stratified Shuffle Split) ์ฐ๋ฉด ์๋๊ณ , ss (Shuffle Split) ์จ์ผํจ.
์ ์๋ฌ๋ฉ์ธ์ง ์๋ชป๋ ํด์
The least populated class in y has only 1 member, which is too few. The minimum number of groups for any class cannot be less than 2.
==> ์ฆ, y shape์ด (1,)์ผ๋ก ๋ผ์์ ๊ฒ์ด๋ฏ๋ก reshapeํ๋ ์๋ฆฌ์. (______,1)์ด ๋๊ฒ๋.
y.reshape(-1,1)
[๊ธฐํ ์ค๋ ์ฐธ๊ณ ํ ๋ธ๋ก๊ทธ๋ค]
๊ธฐํ 1. cross_val_score() ์ cross_validate() - ์๋ง cv ํ ๋ fitting์ ์์์ ํด์ฃผ๋๊ฑด์ง ํด์ ์ฐพ์๋ณธ ๋ฏ.
๊ธฐํ 2. ๋ฌธ์ ํ์ด๋ฅผ ํตํ reg ์ดํด - ์๋ง reg๋ ์์ธกํ ๋ fitting์ ์ํ๋๊ฑด๊ฐ ํด์ ์ฐพ์๋ณธ ๊ฒ์ผ๋ฏ.
๊ธฐํ 3. ๋จธ์ ๋ฌ๋ ํ์ต์ ๊ณ ๋ คํด์ผ ํ ๊ฒ: Test data์ CV data - ์๋ง ์ฐธ๊ณ ํ ์์ ๋ธ๋ก๊ทธ์์ cv ํ ๋ fitting ์ํ ๊ฒ ๋๋ฌธ์ cvํ ๋๋ fitting ์ํ๋๊ฑด์ง, ํน์ ์์์ ํ๋๊ฑด์ง ํด์ ์ฐพ์๋ณธ ๋ฏ.
๊ธฐํ 4. ์ ํํ๊ท (linear reg) - ํ๊ท๋ fitting์ ์ํ๋๊ฑด์ง ํด์ ์ฐพ์๋ด.
๊ธฐํ 5. ์ ํํ๊ท ๋ชจ๋ธ - def์ ๋งค๊ฐ๋ณ์์ ํจ์ ์์ฑ ์ ์ ๋ง๋ค์๋ ๋ณ์๊ฐ ๊ฐ์์ ํ๊ท pred๋ df ์ ์ฒด๋ฅผ ์ฌ์ฉํ๋๊ฑด์ง ํท๊ฐ๋ ธ์ด์ ์ฐพ์๋ด.
๊ธฐํ 6. ํ๊ท๋ก ์์ธกํ๊ธฐ - ํ๊ท๋ ์์ธก์ ์ train์ผ๋ก fitting ์ํ๋ ํด์ ์ฐพ์๋ด.
==> ๋
ผ์ธ๋ก ์ฌ๊ธฐ ๋ธ๋ก๊ทธ ๊ธฐ๋ฅ์ด ์ ๊ธฐํด์ ๋ง์ ๋ค์์.
๊ธฐํ 7. ํ์ด์ฌ ํ๊ท๋ถ์ ๊ธฐ๋ณธ ์ฌ์ฉ๋ฒ ์ ๋ฆฌ scikit-learn, statsmodels - ํ๊ท๋ ์์ธก ์ ์ train์ผ๋ก fitting ์ํ๋ ํด์ ...
๊ธฐํ 8. ํ์ด์ฌ์ผ๋ก ์ ํํ๊ท ๋ถ์ํ๊ธฐ ์์ - ํ๊ท๋ ์์ธก ์ ์ train์ผ๋ก fitting ์ํ๋ ํด์ ...
๊ธฐํ 9. ๋ชจ๋ธ ํ๊ฐ์ ์ฑ๋ฅํฅ์ - ๊ต์ฐจ๊ฒ์ฆ - ๋ cross_val_score ๊ด๋ จ...
-
์ค๋์ ์ด์
cross_val_score
ํ๊ท๋ train data๋ก fitting์ ํด์ฃผ์ง ์๋๊ฐ์ ๋ํ์ฌ... -
๊ฒฐ๋ก :
ํ๊ท๋ fitting ํด์ค์ผ ํ๋๊ฑด๋ฐ ์ฐธ๊ณ ํ๋ ๊ทธ ๋ธ๋ก๊ทธ๊ฐ fitting ๊ณผ์ ์ ์๋ฃ์๊ฒ ๊ฐ์์.
cross_val_score๋ ๊ฒฐ๊ตญ ๋จ์ํ score ๋ด๋ ๊ฑฐ๋ผ์ fitting์ ํด์ฃผ์ง๋ ์๋๋ค๊ณ ํ๋จ. ์์ง ํ์คํ์ง ์์. -
์ค๋ ์๊ฒ๋ ๊ฒ:
list์๋ meanํจ์๊ฐ ๋ฐ๋ก ๋ด์ฅ๋ผ์์ง ์๋ค. -
๊ตฌ๋ฌธ ํต์งธ๋ก ์์๋๋ฉด ์ข์ lambdaํจ์ ์ฌ์ฉ ์์, ๊ทธ๋ฆฌ๊ณ ๋ด์ฅํจ์ sorted():
sorted(dic.items(), key = lambda t : t[1])
# dictionary์ value์ ๋ํด ์์ ์์ผ๋ก ์ค ์ธ์์ง.- issue
- ๋งค๋ฒ split ๊ฐ์ด ๊ฐ์์ง ์ฌ๋ถ ํ์ธ ํ ๋ค๋ฅด๋ค๋ฉด
shuffle split์ ํจ์ ๋ฐ์์ ์คํํ๊ณ cv ํ ๊ฒ.
๐ ๊ทผ๋ฐ random_state ์ง์ ํด์ค์ ๊ฐ์์. ๋ฐ๋ผ์ ์๋ก ๋ญ ํ ํ์ ์์.
- HW
-
scaling์ ๋ํด ๊ณต๋ถํด์ฌ ๊ฒ.
๊ต์๋๊ป์ ๋ณด๋ด์ฃผ์ ์ฐธ๊ณ ํ์ด์ง, ์ฐ๋ฆฌ๊ฐ ์ง๊ธ ์ฐ๋ ๋ฐ์ดํฐ์.
column ๋ณ minmax ํด์ค์ผํจ. -
์ ๋ธ๋ก๊ทธ์์ ๋งํ๋ 3๋ฒ minmax๋ฐฉ์์ ์ฌ์ฉํ๋ ค๋ฉด
ํ์ฌ ์ฐ๊ณ ์๋ cv ๋ฐฉ์์ ๋ฐ๊ฟ ํ์๊ฐ ์์ด๋ณด์.๋ฐ์์ train test ๋ค ๋๋๊ณ , idx๋ก ํด์ผํ ๊ฒ ๊ฐ์.(??????์ฅ,,, x,y๋ง ๋๋ ์ผ idx๋ก cv ํ ์ ์๋ ๊ฒ์.)
==> ํ .... cv ๋๋ฆฌ๋ ค๋ฉด for๋ฌธ ์์์ train test ๋๋๋๊ฒ ๋ง์๋ณด์.
- ์ค๋์ python TMI
np.append() ์ฌ์ฉ๋ฒ
ndarray dtype ํ ๋ฒ์ ๋ฐ๊พธ๊ธฐ; astype(np.int64)
- inhovation~ blog 3๋จ๊ณ ์ดํดํ๊ธฐ
๋ณผ๋ฆฐ์ ๋ฐด๋์ MA20; MA20์ 20์ผ ์ดํ์ ์ผ๋ก, ๋์์ ๋ณผ๋ฆฐ์ ๋ฐด๋์ ์ค์ฌ์ ์ด๋ค.
๋ณผ๋ฆฐ์ ๋ฐด๋ ์์
-
ํ ์ค ์ฉ csv file ์์ฑํ๋ ์ต๋ํ ๊ธฐ๋ณธ ํจ์๋ฅผ ์ด์ฉํ ์ฝ๋ (๊ฒฐ๊ตญ csv ๋ชจ๋์ ๋ถ๋ฌ์ด...):
-
[๊ทธ๋ฅ open ver]
ํ์ฌ๊น์ง ๋ฐ๊ฒฌํ ์ต์ ..? import csv ํ์...
ํจ๊ป ๋ณด๊ธฐ
- [with open ver]
with ๋ฌธ ์ฌ์ฉํ๊ธฐ
import csv
# ์ ์ฅํ ํ์ผ๋ช
, ์ธ์ฝ๋ฉ ํ์
์
๋ ฅ
f = open('new file.csv', 'w', encoding = 'utf-8-sig')
w = csv.writer(f)
w.writerow(list)
w.writerow(list)
w.writerow(list) # ํ๋ค๋ณด๋ฉด ์์ฑ๋จ.
f.close()- for๋ฌธ์ loop name์ ๊ฐ๊ฒํด์ for loop์ด ๊ณ์ ๋๋ ๊ฒ์ธ๊ฐ..?
lambda์ if๋ฌธ 1, lambda๋ ์ ์ฉ์ํฌ ํจ์ ์ง๋ ๊ฒ,,, map ๊ฒฐ๊ณผ๋ list๋ก ๋ณผ ์ ์์.
# lambda ์์
list(map(lambda x:x**2, range(5)))pandas ๋ถ๋ฌ์จ ๋ฐ์ดํฐ ์ดํด๋ณด๊ธฐ
df.head()
df.shape()
df.info()
df.describe()
df.value_counts()
df.unique()
df.nunique()(NaT) null ๊ฐ ํ์ธํ๊ธฐ 1
(NaT) null ๊ฐ ํ์ธํ๊ธฐ 2
notnull, notempty ์ฐจ์ด
# NaT๋ ์ด๋ป๊ฒ ํ๋จ..?
# ์ ๋ต
pd.isnull(df[col][n])
pd.notnull(df[col][n])
################################### ์ด ์๋ ์ฝ๋๋ค๋ก๋ ๊ทธ ์ด ๋ด ์์ ํ ๊ฐ ํ๋จ์ ๋ชป ํจ.
pd.NA
np.where(df['col1'].isnull())
df['col1'].isna()
df['col1'].notnull()
df['col1'].notna()- ํ์ผ์ฌ๋ซ๊ณ ์ฝ๊ณ ์ฐ๊ธฐ
open์ผ๋ก ํ์ผ์ ์ด๋ฉด .close()๋ก ๋ซ์์ค์ผํจ.
with open์ผ๋ก ์ด๋ฉด ์๋ซ์์ค๋ ๋จ. ์์์ ๋ซํ.
๊ณผ์ :
- ์กด์์ผ 500์ผ ์ด์.
- 20์ผ ๊ฐ ๊ฑฐ๋ ์๋ ์ 5์ผ ์ดํ,
- Trading_Value 100์ต ์ด์,
- ๋น์ผ ๋ณ๋ํญ(๊ณ ๊ฐ/์ ๊ฐ) > 1.05 ์ธ ์ข ๋ชฉ๊ณผ ๋ ์ง ์ ๋ณ.
attention lstm,,,
- LSTM ์ธต์ rnn layer๋ผ๊ณ ๋ถ๋ฅด๋ ์ด์ ๊ฐ ๊ถ๊ธํ๋ค.
RNN๊ณผ LSTM์ ์ดํดํด๋ณด์!
TensolFlow LSTM layer ํ์ฉ๋ฒ
[๋จธ์ ๋ฌ๋ ์ํ๋ง] LSTM์ ๋ชจ๋ ๊ฒ
- numpy์ unique๋ np.unique(ndarray)
- ๋ฌธ์์ด ํ๋จ method
isalpha # ๊ธ์์ธ์ง
isdigit # ์ซ์์ธ์ง
isdecimal # ์ซ์์ธ์ง
isnumeric # ์ซ์์ธ์ง
isalnum # ์ซ์ ๋๋ ๊ธ์์ธ์ง
isspace
isprintable
isidentifier- ์กฐ๊ฑด๋ง์กฑcd_dt (by ์ต์ข
๋ณ๋ํญcd_dt).txt
- ์กฐ๊ฑด๋ง์กฑcd_dt (by ffin).txt
์กฐ๊ฑดdf.csv
๋ฐ์ดํฐ ์ฝ๊ณ ์ฐ๊ณ ์ ์ฅํ๊ธฐ .to_feather, .to_pickle, .to_csv ๋น๊ต
100GB ์ดํ์ data์์๋ partition ๋ฐฉ์์ modin.pandas ์ฌ์ฉํ๋ ๊ฒ์ด ์ข์.
## ma_df: ๋ณด์กฐ์งํ ์ถ๊ฐํ df
## object๋ณด๋ค๋ category type์ผ๋ก ์ ์ฅ, ์ฌ์ฉํ๋ ๊ฒ์ด ์ฉ๋๋ฉด์์ ๋ ๋์ ์ ํ์ผ๊ฒ.
!pip install pyarrow # feather๋ก ์ ์ฅํ๋ ค๋ฉด pyarrow ์ค์น ๋จผ์
# feather์ pickle์ index ํ๋ผ๋ฏธํฐ๊ฐ ๋ฐ๋ก ์์ผ๋ฏ๋ก reset_index ๋จผ์
ma_df.reset_index(inplace = True)
ma_df.drop('index', axis = 1, inplace = True)
## ์ฉ๋ ftr < pkl < csv
# feather๋ก ์ ์ฅ, ํ์ฅ์ .ftr
ma_df.to_feather('๋ณด์กฐ์งํ์ถ๊ฐ_cd_nuniq=2348.ftr')
# ์ฝ๊ธฐ
pd.read_feather("๋ณด์กฐ์งํ์ถ๊ฐ_cd_nuniq=2348.ftr", columns = None, use_threads = True)
# pickle๋ก ์ ์ฅ, ํ์ฅ์ .pkl
ma_df.to_pickle('๋ณด์กฐ์งํ์ถ๊ฐ_cd_nuniq=2348.pkl')
# ์ฝ๊ธฐ
pd.read_pickle("๋ณด์กฐ์งํ์ถ๊ฐ_cd_nuniq=2348.pkl")[11w] 4 ์์ผ๋ก 10์ผ, ์๊ฐ๋จ์ถ.ipynb ํ์ผ๋ก ์ ์ฒ๋ฆฌ ์๋ฃ, ํ์ผ๋ช
d9d0.txt
csv๋ ๋์ ํ ์๊ฐ์ด ์ค๋๊ฑธ๋ ค์ ํฌ๊ธฐ
** [11w] 3 ํ์ผ์ ์๋ด๋ ๋จ, ์์ผ๋ก 10์ผ ํ๋ ค๋ค ์๊ฐ ๋๋ฌด ๊ฑธ๋ ค์ ๋ฒ๋ฆผ.
[11w] d9d0.txt to csv, fin_df ์ ์ฅ.ipynb ํ์ผ๋ก
d9d0.csv ์์ฑ,
col ๊ตฌ์ฑ ๋ฐ๊พผ fin_df.csv ์์ฑ
[๋จธ์ ๋ฌ๋] ํ์ต์๊ฐ ๋จ์ถ?
๋ฐ์ดํฐ์์ด ๋๋ฌด ๋ง์์ ์๊ฐ์ด ๋๋ฌด ์ค๋๊ฑธ๋ฆฌ๋ ๋ฌธ์ ...
๊ทธ๋ฅ ๋ฐ์ดํฐ ์ฆ๊ฐ์ด ํ์ต์๋ ์ ํ๋ฅผ ์ผ๊ธฐํ๋ค๋ ๊ฒ๋ง ๋์์์.
โโโโ์งฑ ์น์ ... 100๋ง๊ฐ ์ ๋ ๋ฐ์ดํฐ๋ก ๋จธ์ ๋ฌ๋ ์ํํ๋ ๊ฒฝ์ฐ ํ์ต ์๋ ๋์ด๋ ๋ฐฉ๋ฒ์ ๋ํ ์ง๋ฌธ
<<<ํ์ํ ๋ด์ฉ๋ง ๋ฐ์ท>>>
๋ฐ๋ผ์ 100๋ง๊ฐ ์ ๋์ ๋ฐ์ดํฐ๊ฐ ์๋ฒ ๋ฉ๋ชจ๋ฆฌ์ ์ฌ๋ผ๊ฐ ์ ์๋์ง ๋ถํฐ ํ์ธํด์ผ ํฉ๋๋ค.
100๋ง๊ฐ ๋ ์ฝ๋์ด์ง๋ง Feature๊ฐ ๋ง์ง ์๋ค๋ฉด ์ถฉ๋ถํ 8GB์ ๋์ ์ฌ๋ผ๊ฐ๋๋ค. ==> ์ฐ๋ฆฌ ๋ฐ์ดํฐ์ ๊ฒฝ์ฐ 10.7GB
๋จผ์ Pandas๋ก data๋ฅผ ๋ก๋ ํ ๋ค์ DataFrame.memory_usage() ๋ก ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ํ์ธํด ๋ณด์๋ฉด ์ ์ ์์ต๋๋ค. ==> ์์ง ํ์ธ ์ํด๋ด.
2. ๋จธ์ ๋ฌ๋์ ์๋๋ฅผ ๋์ด๋ ๋ฐฉ๋ฒ
A. ์๋๊ฐ ๋น ๋ฅธ ์๊ณ ๋ฆฌ์ฆ์ ์ ์ฉ,
Tree๊ธฐ๋ฐ ์์๋ธ๋ณด๋ค๋ ์ ํ ๊ณ์ด์ด ๋น ๋ฆ.
์ฆ Logistic Regression > Random Forest
๊ฐ์ Tree๊ธฐ๋ฐ ์์๋ธ์ด๋๋ผ๋ Random Forest > Gradient Boosting
XGboost < LightGBM & LightGBM์ด ๋ฉ๋ชจ๋ฆฌ๋ ๋ ์ ๊ฒ ์ฌ์ฉ
ํ์ง๋ง ์์ธก ์ ํ๋(์ฑ๋ฅ)๋ฅผ ๋ ์ค์์ ํ๋ค๋ฉด ํ์ต์๋๋ฅผ ํฌ๊ธฐํด์ผํ ์๋ ์์.
B. Multi processing ์ผ๋ก ์๊ณ ๋ฆฌ์ฆ์ ์ ์ฉํ๋ ๊ฒ.
์๋ฒ๋ฅผ ์ฌ๋ฌ๊ฐ Core๋ฅผ ๊ฐ์ง ์์คํ
์ผ๋ก ๊ตฌ์ฑ.
์ฌ์ดํท๋ฐ์ ๋ฉํฐ core๋ก ๋ณ๋ ฌ ์ฒ๋ฆฌ๋ฅผ ์ง์
n_jobs=-1์ Estimator ๊ฐ์ฒด์ ์ด๊ธฐ ํ๋ผ๋ฏธํฐ๋ก ์ค์ ํ๋ฉด ์์คํ
์ด ๊ฐ์ง ๋ชจ๋ CPU ์ฝ์ด๋ฅผ ๋ณ๋ ฌ๋ก ์ฌ์ฉํ์ฌ ํ์ตํ๊ฒ ๋จ. - n_jobs = ์ซ์๋งํผ cpu ์ฌ์ฉ
8Core CPU๊ฐ 1Core CPU๋ณด๋ค ๋ ๋น ๋ฅด๊ฒ ํ์ตํจ.(๊ทธ๋ ๋ค๊ณ 8๋ฐฐ ๋น ๋ฅด์ง๋ ์์. ์ ํ ์ฑ๋ฅ ํ์ฅ์ ์ ์ฝ o).
์์ฝํ์๋ฉด 100๋ง๊ฐ Record์ ๋ฐ์ดํฐ ์ธํธ์ ํผ์ฒ ๊ฐฏ์๊ฐ ๋ช ๊ฐ์ด๋ ๊ฐ์
๋ฉ๋ชจ๋ฆฌ์๋ง ๋ค์ด์จ๋ค๋ฉด 1~2 ์๊ฐ๋ด์ ํ์ต์ด ๊ฐ๋ฅํ๋ฉฐ,
๋ง์ฝ ํ์ต ์๊ฐ์ ๋ ์ค์ด๊ณ ์ ํ๋ค๋ฉด 8 Core์ด์์ ์์คํ
์์ ๊ตฌ๋ํ์๋ฉด ํจ์ฌ ํ์ต ์๊ฐ์ ๊ฐ์ ํ ์ ์์ ๊ฒ...
๋ฅ ๋ฌ๋ ๋ชจ๋ธ ํ์ต์ ๋น ๋ฅด๊ฒ ํ๊ธฐ ์ํ 6๊ฐ์ง tipโ
<<<์์ง ๋๊น์ง ์์ฝ์.>>>
1. ๋ค๋ฅธ ํ์ต๋ฅ ์กฐ์ ๊ณํ ์ฌ์ฉ ๊ณ ๋ ค ???
2. DataLoader ๋ฐ ํ์ด์ง ์ ๊ธ ๋ฉ๋ชจ๋ฆฌ์์ ์ฌ๋ฌ ๋ณด์กฐ ํ๋ก์ธ์ค ์ฌ์ฉ ???
3. ๋ฐฐ์น ํฌ๊ธฐ ์ต๋ํ
4. ์๋ ํผํฉ ์ ๋ฐ AMP ์ฌ์ฉ ???
5. gradient ํ์ฑํ checkpoint ์ฌ์ฉ ???
6. .tensor() ๋์ .as_tensor() ์ฌ์ฉ ???
- ๋ถ์ฐํ์ต
... ๊ทธ๋ฅ ๋ฐ๋ก lstm์ผ๋ก ๊ฐ๊น...
lstm์ ๊ฒฝ์ฐ epoch์ ์ค์ด๊ณ batch ์ฌ์ด์ฆ๋ ์ต๋๋ก ํค์์ ํด๊ฒฐ...?
์ธ๊ณต์ง๋ฅ > ๋จธ์ ๋ฌ๋ > ๋ฅ๋ฌ๋
<<์ ํ์ด์ง์์ ๋ณผ ๋ด์ฉ๋ง ๋ฐ๋ก ์ ๋ฆฌ>>
๋ฅ๋ฌ๋์ผ๋ก ๋ํ๋๋ ์ธ๊ณต์ ๊ฒฝ๋ง์ ๋จธ์ ๋ฌ๋์ ๊ตฌํํ๋ ๊ธฐ์ ์ ํ๋๋ก,
์ธ๊ฐ ๋์ ๋์ ๋ฐฉ์์์ ์ฐฉ์ํ์ฌ ๊ฐ๋ฐํ ํ์ต๋ฐฉ๋ฒ...
[๊ธฐ์กด(rule-based AI)]์๋ ๊ท์น์ ์๋ ค์ค์ผํ์. (๊ท์น์ ํ๋ก๊ทธ๋๋ฐํด์ผ ํ์.)
==> [๋จธ์ ๋ฌ๋]์ ๋ต์์ง๋ฅผ ๋ฏธ๋ฆฌ ์ฃผ๋ฉด ์์์ ๊ท์น์ ํ์ตํจ. (๊ท์น์ ํ๋ก๊ทธ๋๋ฐํ์ง ์์๋ ๋จ.)
๋ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ: <์ฌ์ดํท๋ฐ>
[์ธ๊ณต์ ๊ฒฝ๋ง]์ ๊ธฐ์กด์ ๋จธ์ ๋ฌ์ธ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ๋ค๋ฃจ๊ธฐ ์ด๋ ค์ ๋ ์ด๋ฏธ์ง, ์์ฑ, ํ
์คํธ ๋ถ์ผ์์ ๋ฐ์ด๋ ์ฑ๋ฅ์ ๋ฐ์, ์ข
์ข
๋ฅ๋ฌ๋์ด๋ผ๊ณ ๋ ๋ถ๋ฆ.
๋ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ: <ํ
์ํ๋ก>, <ํ์ดํ ์น>
์๊ณ์ด ์์น์
๋ ฅ ์์น์์ธก ๋ชจ๋ธ๋ ์ํผ
lightbgm์ ์ด์ฉํ ํ๊ท์์ธก ์นํธ์ฝ๋ - ๋ฐ๋ผํด๋ด.
lightgbm ๊ณต์๋ฌธ์ 1 - ํ๋ผ๋ฏธํฐ์ ๋ํ ๋ณด๋ค ๋ ์์ธํ ์ค๋ช
lightgbm ๊ณต์๋ฌธ์ 2
lightgbm์ ์ด๋ป๊ฒ ์ฌ์ฉํ ๊น? - sample code - lightgbm์ผ๋ก classification (๋ถ๋ฅ)ํ๊ธฐ
multi core ๋ฉํฐ์ฝ์ด ์ฐธ๊ณ ์๋ฃ
# cpu ๊ฐ์ ํ์ธ ๋ฐฉ๋ฒ
import os
os.cpu_count()๋ฌด์์ ๋ฐ๋ผํ๋ EDA
ํ์ด์ฌ์ผ๋ก ์ฃผ์ ๋ณด์กฐ์งํ ๊ตฌํ๊ธฐ TA
ํ์ด์ผ ์ฃผ์๋ฐ์ดํฐ ๋ถ์, ์ฃผ์ ๋ณด์กฐ์งํ ํ์ธํ๋ ๋ฐฉ๋ฒ์?
ํ์ด์ฌ, ์ฃผ์์ฐจํธ์ ๋ณด์กฐ์งํ ๊ทธ๋ฆฌ๊ธฐ(plotly)
์์์ ์ฝ๋ ๋ณด๊ธฐ
-> ์ฌ๊ธฐ์ ๋ฉํฐ ํ๋ก์ธ์ฑ ๊ด๋ จ ์ฝ๋ ๋์์์
[๊ฒ์์ด]: ๋ฉํฐ ํ๋ก์ธ์ฑ ์์ ์ฝ๋ ํ์ด์ฌ
ํ๋ค์ค ๋ฉํฐ ํ๋ก์ธ์ฑ ๊ณต์ ๋ฌธ์
๋ฉํฐ ํ๋ก์ธ์ฑ ๊ตฌํ์์ ๋ฐ ๋ฉํฐ ์ฐ๋ ๋์ ์คํ์๊ฐ ๋น๊ต ๋ถ์
ํ์ด์ฌ multi processing ์ฌ์ฉ๋ฒ
[๋ณ๋ ฌ ํ๋ก๊ทธ๋๋ฐ] 3. multi-process ์ฌ์ฉํ๊ธฐ with python - ์ค ๋ณ๋ก ์ค๋ช
, ์น์
4์ด ์ ๋ ๊ฑธ๋ฆฌ๋ ์์
์ ๋จ์ถ์ํค๋ ์์
Python multiprocessing.Pool ๋ฉํฐํ๋ก์ธ์ฑ 2
Python | Multiprocessing(ํ์ด์ฌ ๋ฉํฐํ๋ก์ธ์ฑ)
6์ฃผ์ฐจ, ๋ณ๋ ฌ์ฒ๋ฆฌ, ํ๋ก์ธ์ค, ์ฐ๋ ๋ - ์ฝ๋๊ฐ ์์๊ฒ ๋์์์ง๋ ์์.
wikidocs ๋ฉํฐํ๋ก์ธ์ฑ ๋ฌธ์
ํ์ด์ฌ - multiprocessing ์ค๋ช
๋ฐ ์์
multi processing python
๋ฉํฐ ์ฐ๋ ๋(x) ๋ฉํฐ ํ๋ก์ธ์ฑ
โค๐๐๐จ ์ฝ๋ ์ค Ray๋ฅผ ์ด์ฉํด Python ๋ณ๋ ฌ ์ฒ๋ฆฌ ์ฝ๊ฒ ํ๊ธฐ - ๋ณ๋ ฌ์ฒ๋ฆฌ๋ฅผ ํ๋ ์ด์ ๊ฐ ๋์์์, ์์ฑ์๊ฐ multiprocessing ์ฌ์ฉ๋ฒ์ด ๋ง์ ์๋ค์์ง๋ง ๊ทธ๋๋ ์จ๋ดค๋ค๊ณ ํจ.
๋ฉํฐ ํ๋ก์ธ์ฑ์ ํ๋ ์ด์ : ํฐ ํ
์ดํฐ์ ๋ํ ์์
์ ๋ ๋น ๋ฅด๊ฒ ํ๊ธฐ์ํด..........
ํ์ด์ฌ์์ ๊ธฐ๋ณธ์ผ๋ก ์ ๊ณตํด์ฃผ๋ multiprocessing์ด๋ผ๋ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ
multi processing์ Pool ๊ฐ์ฒด
์ฌ๋ฌ ์
๋ ฅ ๊ฐ์ ๊ฑธ์ณ ํจ์์ ์คํ ๋ณ๋ ฌ์ฒ๋ฆฌ
์
๋ ฅ ๋ฐ์ดํฐ๋ฅผ ํ๋ก์ธ์ค์ ๋ถ์ฐ์ํค๋ ๋ฐฉ๋ฒ ์ ๊ณต
==> ๋ฐ์ดํฐ ๋ณ๋ ฌ์ฒ๋ฆฌ
from multiprocessing import Pool
def f(x):
return x*x
if __name__ == '__main__':
with Pool(5) as p:
print(p.map(f, [1, 2, 3]))numpy ๋ฐฐ์ด ์ ์ฅ ๋ฐ ๋ถ๋ฌ์ค๊ธฐ
import numpy as np
data = np.arange(100) # ์ ์ฅํ๋ ๋ฐ์ดํฐ
np.save('my_data.npy', data) # numpy.ndarray ์ ์ฅ. @ํ์ผ๋ช
, @๊ฐ
data2 = np.load('my_data.npy') # ๋ฐ์ดํฐ ๋ก๋. @ํ์ผ๋ช
๐๐๐จ ์ฌ์ดํท๋ฐ์ ์ด์ฉํด ๋จธ์ ๋ฌ๋ ๋ชจ๋ธ๋ง ํด๋ณด๊ธฐ - plot ๊ทธ๋ฆฌ๋ ๊ฒ๋ ๋์์์.
csv to numpy methods, methods3, 5 ์ด์ฉ
Method 3: Using the Pandas Dataframe
Method 5: Using Pandas Dataframe Values
np.concatenate([arr1, arr2]) # ์๋๋ก ์๊ธฐ (์ด ์๊ฐ ๊ฐ์์ผ ํจ.)
np.concatenate([arr1, arr2], axis = 1) # ์์ผ๋ก ์๊ธฐ (ํ ์๊ฐ ๊ฐ์์ผ ํจ.)๋จธ์ ๋ฌ๋ ๋ชจ๋ธ๋ง์ NaN๊ฐ ์์ผ๋ฉด ์๋จ.(๋ณดํต์ ์๋๋๋ฐ ๋๋ ๊ฒฝ์ฐ๊ฐ ์๊ธฐ๋ ํจ. ex) rf...)
๊ทธ๋์ isnull์ ํ์ธํด์ฃผ๊ณ ,
fillna๋ฅผ ํด์ฃผ๋ ๊ฒ.
[๋จธ์ ๋ฌ๋ ๋ชจ๋ธ ์
๋ ฅ์ NaN๊ฐ] ์ด๋ฐ๊ฑฐ ๊ฒ์ํ๋ค๊ฐ ๊ธฐ์ต ๋จ. ๊ฒ์๊ฒฐ๊ณผ ๋ฐ๋ก ๋ณด์ง ์์.
๋จธ์ ๋ฌ๋ ๋ชจ๋ธ ์ฑ๋ฅ ํ๊ฐ mse for regression, acc for classification, ...
RMSE / MSE / logloss # for Regression Accuracy / f1-score # for Classification
Accuracy๋ฅผ ํ๊ฐ ์ฒ๋๋ก ์ฌ์ฉํ๋ค๋ฉด ๊ท ํ(Balanced) ๋ฐ์ดํฐ์์ ์ฌ์ฉํ์๊ธธ ๊ถ์
๋ถ๊ท ํ ๋ฐ์ดํฐ ์ํ์์๋ F1 Score๋ฅผ ์ด์ฉ
๋จธ์ ๋ฌ๋ ๋ชจ๋ธ ์ฑ๋ฅ ํ๊ฐ ๊ด๋ จ + ์์ ์ฝ๋
ํ๊ท/ ๋ถ๋ฅ์ ์๋ง์ metric๊ณผ ์ค๋ช
- ์์ฃผ ์น์ , ๊ด์ฐฎ์ ๋ณด์, ํ๊ท์ ๊ฒฝ์ฐ ์์๊ฐ ์ฃผ์๋ฐ์ดํฐ
์ค์ ๊ฐ๊ณผ ๋ชจ๋ธ์ด ์์ธกํ๋ ๊ฐ์ ์ฐจ์ด์ ๊ธฐ๋ฐ์ ๋ metric ์ฌ์ฉ.
๋ํ์ ์ผ๋ก
- RSS(๋จ์ ์ค์ฐจ ์ ๊ณฑ ํฉ)
- MSE(ํ๊ท ์ ๊ณฑ ์ค์ฐจ)
- MAE(ํ๊ท ์ ๋๊ฐ ์ค์ฐจ)
RSS : ์์ธก๊ฐ๊ณผ ์ค์ ๊ฐ์ ์ค์ฐจ์ ์ ๊ณฑํฉ
MSE : RSS๋ฅผ ๋ฐ์ดํฐ์ ๊ฐ์๋งํผ ๋๋ ๊ฐ
MAE : ์์ธก๊ฐ๊ณผ ์ค์ ๊ฐ์ ์ค์ฐจ์ ์ ๋๊ฐ์ ํ๊ท
++ RMSE์ RMAE๋ผ๋ ๊ฒ๋ ์๋๋ฐ,
๊ฐ๊ฐ MSE์ MAE์ ๋ฃจํธ๋ฅผ ์์ด ๊ฐ์
๋๋ค.
MSE์ ๊ฒฝ์ฐ ์ค์ฐจ์ ์ ๊ณฑ์ด ๋๊ธฐ ๋๋ฌธ์ ์ด์์น(outlier)๋ฅผ ์ก์๋ด๋ ๋ฐ ํจ๊ณผ์ .
ํ๋ฆฐ ๊ฑธ ๋ ๋ง์ด ํ๋ ธ๋ค๊ณ ์๋ ค์ฃผ๋ ๊ฒ.
MAE์ ๊ฒฝ์ฐ ๋ณ๋์น๊ฐ ํฐ ์งํ์ ๋ฎ์ ์งํ๋ฅผ ๊ฐ์ด ์์ธกํ๋ ๋ฐ ํจ๊ณผ์ .
๋ ๋ค ๊ฐ์ฅ ๊ฐ๋จํ ํ๊ฐ ๋ฐฉ๋ฒ์ผ๋ก ์ง๊ด์ ์ธ ํด์์ด ๊ฐ๋ฅํ์ง๋ง,
ํ๊ท ์ ๊ทธ๋๋ก ์ด์ฉํ๊ธฐ ๋๋ฌธ์ ๋ฐ์ดํฐ์ ํฌ๊ธฐ์ ์์กดํ๋ค๋ ๋จ์ ์ด ์์.
MSE๋ ์ ์ฒด ๋ฐ์ดํฐ์ ํฌ๊ธฐ์ ์์กดํ๊ธฐ ๋๋ฌธ์
์๋ก ๋ค๋ฅธ ๋ ๋ชจ๋ธ์ MSE๋ง์ ๋น๊ตํด์ ์ด๋ค๊ฒ ๋ ์ข์ ๋ชจ๋ธ์ธ์ง ํ๋จํ๊ธฐ ์ด๋ ต๋ค๋ ๋จ์ ์ด ์์.
- ์ด๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํ metric์ผ๋ก R2 (๊ฒฐ์ ๊ณ์)๊ฐ ์์.
R2๋ ํ๊ท ๋ชจ๋ธ์ ์ค๋ช ๋ ฅ์ ํํํ๋ ์งํ
๊ทธ ๊ฐ์ด 1์ ๊ฐ๊น์ธ์๋ก ๋์ ์ฑ๋ฅ์ ๋ชจ๋ธR2์ ์์์ ๋ถ์์ธ RSS์ ๊ทผ๋ณธ์ ์ค์ ๊ฐ๊ณผ ์์ธก๊ฐ์ ์ฐจ์ด์ธ๋ฐ,
๊ทธ ๊ฐ์ด 0์ ๊ฐ๊น์ธ์๋ก ๋ชจ๋ธ์ด ์ ์์ธก์ ํ๋ค๋ ๋ป์ด๋ฏ๋ก
R2๊ฐ์ด 1์ ๊ฐ๊น์์ง๊ฒ ๋ฉ๋๋ค.
- ๊ฒ์์ด: [linear regression ํ์ดํผ ํ๋ผ๋ฏธํฐ ํ๋]
๐๐๐จ๐ซ [ ํธ์ฆ ์จ ๋จธ์ ๋ฌ๋ 2ํ ] pandas, sklearn์ ํตํ ๋ชจ๋ธ ํ์ต๊ณผ ํ๋์ ์ด๋ป๊ฒ ํ๋ ๊ฒ์ผ๊น? (3) - GridSearchCV, ์ฌ๊ธฐ๋ ์์ฃผ ์น์
์ด์ 2๊ฐ์ ํฌ์คํ
์ ๊ฒฐ์ณ ์ฐ๋ฆฌ๋ ์ง๊ธ๊น์ง ๋ฌธ์ ๋ฅผ ์ ์ํ๊ณ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด๋ค์ฌ ํ์ํ์์ต๋๋ค.
๊ทธ๋ฆฌ๊ณ ๋ฐ์ดํฐ๋ฅผ training set๊ณผ test set์ผ๋ก ๋๋๊ณ ํ์ต์ ์ํ ๋จธ์ ๋ฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ฃผ์
ํ ๋ฐ์ดํฐ๋ฅผ ์๋์ผ๋ก ์ ์ฒ๋ฆฌํ๊ณ ์ ์ ํ๋ ํ์ดํ๋ผ์ธ๊น์ง ๋ง๋ค์ด ๋ณด์์ต๋๋ค.
์ด๋ฒ ํฌ์คํ
์์๋ ๋จธ์ ๋ฌ๋ ๋ชจ๋ธ์ ์ ํํ๊ณ ํ๋ จ์์ผ ์ธ๋ถ์ ์ผ๋ก ํ๋ํ๋ ๋ฒ๊น์ง ๋ค๋ค๋ณด๊ฒ ์ต๋๋ค.
๋๋ถ๋ถ ๊ตฌ์ญ์ median house value๊ฐ
120000 ~ 265000 ์ฌ์ด์ธ ๊ฒ์ ๊ฐ์ํ๋ฉด,
$68628์ ์ค์ฐจ๋ ๊ทธ๋ฆฌ ์ข์ ํธ์ ์๋ ๊ฒ ๊ฐ์ต๋๋ค.
์ด๋ฌํ ๊ฒฐ๊ณผ๋ ๋ชจ๋ธ์ด ๊ณผ์ ์ ํฉ(Underfit) ๋์๊ธฐ ๋๋ฌธ์ด๋ฉฐ,
์ด๋ ๋ฐ์ดํฐ๊ฐ ๋ถ์กฑํ๊ฑฐ๋, ๋ชจ๋ธ์ด ๊ฐ๋ ฅํ์ง ๋ชปํ ํ
์ฐ์ ์ข ๋ ๋ณต์กํ ๋ชจ๋ธ์ ์๋ํด์ ์ด๋ป๊ฒ ๋๋์ง ํ์ธํด๋ณด๊ฒ ์ต๋๋ค.
- ์ด ๋ชจ๋ธ์ ๊ฐ๋ ฅ, ๋ฐ์ดํฐ์์ ๋ณต์กํ ๋น์ ํ๊ด๊ณ๋ฅผ ์ฐพ์ ์ ์์.
ํ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ 0.0์ด ๋์ด.
=> ์ค์ฐจ๊ฐ ์๋ค๋ ๋ป์ธ๋ฐ, ๋ชจ๋ธ์ด ์๋ฒฝํ ๋ฆฌ๋ ์์ผ๋ฏ๋ก
์๋ง ๋ฐ์ดํฐ๊ฐ ์ฌ๊ฐํ๊ฒ ๊ณผ๋์ ํฉ(Overfit) ๋์์ ํ๋ฅ ์ด ํผ.
ํ์ง๋ง ์ด ๋ํ ํ์ ํ ์ ์์ผ๋ฏ๋ก
training set์์ ์ผ๋ถ๋ฅผ ๊ต์ฐจ๊ฒ์ฆ (cross-validation) ๋ฐ์ดํฐ๋ก ๋ถ๋ฆฌ์์ผ
๋ชจ๋ธ์ ํ๊ฐํ๋๋ฐ์ ์ฌ์ฉํด์ผ ํจ.
train_test_split ํจ์๋ฅผ ์ฌ์ฉํ์ฌ training set์ ๋ ์์ traing set๊ณผ cv set์ผ๋ก ๋๋๊ณ ,
training set์์๋ ๋ชจ๋ธ ํ๋ จ์,
cv set์์๋ ๋ชจ๋ธ ํ๊ฐ๊ฐ ์ด๋ฃจ์ด์ง๊ฒ ํ๋ฉด ๋จ.
ํน์ ํ๋ฅญํ ๋์์ผ๋ก sklearn์ k-fold cross-validation ๊ธฐ๋ฅ์ ์ฌ์ฉํ ์ ์์.
์ด๋ training set์ fold๋ผ ๋ถ๋ฆฌ๋ 10๊ฐ์ subset (k-fold, ์์ฑ์์ ์์ ์ฝ๋์์ k = 10)์ผ๋ก ๋ฌด์์ ๋ถํ
๊ทธ ํ DecisionTree ๋ชจ๋ธ์ 10๋ฒ ํ๋ จํ๊ณ ํ๊ฐํ๋๋ฐ,
์ด๋ ๋งค๋ฒ ๋ค๋ฅธ ํ๋์ fold๋ฅผ ์ฌ์ฉํ์ฌ ํ๊ฐํ๊ณ ๋๋จธ์ง 9๊ฐ๋ ํ๋ จ์ ์ฌ์ฉ.
๊ทธ๋ฆฌ๊ณ 10๊ฐ์ ํ๊ฐ ์ ์๊ฐ ๋ด๊ธด ๋ฐฐ์ด์ด ๊ฒฐ๊ณผ๊ฐ ๋ฉ๋๋ค.
np.sqrt()์ -scores๊ฐ ๋ค์ด๊ฐ ๊ฒ์ cross_val_score() ๋ฉ์๋์ scoring ๋งค๊ฐ๋ณ์๊ฐ
๋ฎ์์๋ก ์ข์ loss function์ด ์๋๋ผ,
ํด์๋ก ์ข์ utility function์ ๊ธฐ๋ํ๊ธฐ ๋๋ฌธ์
๋ฐ๋ผ์ MSE์ ๋ฐ๋ ์ฆ ์์ซ๊ฐ์ ๊ณ์ฐํ๋ neg_mean_squared_error ํจ์๋ฅผ ์ฌ์ฉํจ.
๊ทธ๋์ ์ ๊ณฑ๊ทผ ๊ณ์ฐ์ ์ํ์ฌ -scores๋ก ๋ถํธ๋ฅผ +๋ก ๋ฐ๊พผ ๊ฒ.
ํธ์ฆ์จ ๋จธ์ ๋ฌ๋(3) - ๋จธ์ ๋ฌ๋ ํ๋ก์ ํธ 6[๋ง๋ฌด๋ฆฌ]
[๋จธ์ ๋ฌ๋][๊ต์ฐจ๊ฒ์ฆ, ํ๋ผ๋ฏธํฐ ํ๋]
3.1. ์ ํ ํ๊ท(Linear Regression)
[Sklearn] ํ์ด์ฌ ๋๋ค ํฌ๋ ์คํธ ๋ชจ๋ธ ํ์ต, ํ์ดํผํ๋ผ๋ฏธํฐ ํ๋ - RandomForestClassifier
๋ถ๋ฅ์ฑ๋ฅํ๊ฐ์งํ Precision, Recall, Accuracy
imbalanceํ ๋ฌธ์ ์์๋ precision๊ณผ recall์ด ์ ์ฉํ๊ฒ ์ฌ์ฉ๋ ์ ์์. ๋ ์งํ๋ฅผ ๋์์ ์ ์ด์ฉํ๋ค๋ฉด imbalance dataset์ด ์ฃผ์ด์ง ์ํฉ์์ ์ข ๋ ์ข์ ๋ชจ๋ธ์ ์ ํํ ์ ์์ง ์์๊น
Precision, Recall, F1 score
๊ณผ์ ์ ๊ฒฝ์ฐ ์์ธก ๋ชจ๋ธ์ด ์ค๋ฅผ ๊ฒ์ด๋ผ๊ณ ์์ธกํ๋๋ฐ, ์ค์ ๋ก ์ค๋ฅด๋ ์ง๋ฅผ ํ๊ฐํด์ผ ํ๋ฏ๋ก ์ ๋ฐ๋๋ฅผ ๋ ๋น์ค์๊ฒ ์ดํด๋ด์ผ ํจ.
์ ๋ฐ๋์ ์ฌํ์จ ์์์, ์ค์ฐจํ๋ ฌ ์ํท๊ฐ๋ฆฌ๋ ๋ฐฉ๋ฒ, ๋ถ๋ฅ๋ชจ๋ธ ํ๊ฐ์งํ
๐F1 score๊ฐ ๋์ ์๋ก ์ ๊ตํ ๋ชจ๋ธ์.
ํต๊ณ์ ๊ฒ์ฆ ๊ฒฐ๊ณผ
๊ต์ฐจ๊ฒ์ฆ ๋ฐ ํต๊ณ์ ๊ฒ์ ์ค์ต, ์ ์์ฑ ๊ฒ์ฆ
๊ต์ฐจ๊ฒ์ฆ ๋ฐ ํต๊ณ์ ๊ฒ์
์ฌ์ฉํ๋ ๋ฐ์ดํฐ(d1221.ftr): d2012 ~ d2021 ์๋๋ก ๋ณํฉ์ํจ ๊ฒ
๋ฐ์ดํฐ ํํฐ๋ง, tr > 10์ต
์ฌ์ฉํ๋ ๋ฐ์ดํฐ (d1221 10thr.ftr)
์ฃผ์ ํฌ์์์ ์์ฌ๊ฒฐ์ ์ง์์ ์ํ ๋ฐ์ดํฐ๋ง์ด๋ ๋๊ตฌ
์ฃผ์์์ฅ์์์ ์ง๋จ์ฌ๋ฆฌ(2)
(๊ณต์, ๊ตญ๊ฐ๊ธฐ๋ก์) ๋ํ๋ฏผ๊ตญ ์ฃผ์์์ฅ์ ์ญ์ฌ
์ฌ๋ก๊ธฐ๋ฐํ์ต์ ์ด์ฉํ ์ฃผ์ ๋ฐ์ดํฐ ์์ธก ๋ฐฉ๋ฒ
์ฃผ์ ํฌ์์์ 1%๋ง ์๋ ๊ตฌ๊ธ ์คํ๋ ๋์ํธ๋ก ์ฃผ์ ๋ฐ์ดํฐ ๋ถ๋ฌ์ค๋ ๋ฐฉ๋ฒ
๋ฅ๋ฌ๋์ ํ์ฉํ ์ค์๊ฐ ์ฃผ์๊ฑฐ๋์์์ ๋งค๋งค ๋น๋ ํจํด๊ณผ ์์ธก ์์ ์ ๊ดํ ์ฐ๊ตฌ: KOSDAQ ์์ฅ์ ์ค์ฌ์ผ๋ก
ํค์ ์ ๋๋ฆฌ์คํธ
investing.com์์ ํ์ฌ ์ฌ๋ผ์ง (ํน์ ์์ฅํ์ง๋) ๊ธฐ์
์ ๊ณผ๊ฑฐ ์ฃผ์๋ฐ์ดํฐ ์ฐจํธ ๋ณผ ์ ์์
[ํ์ดํผํ๋ผ๋ฏธํฐํ๋ ์์์ฝ๋]
๊ฒ์์ด:
linear regression hyperparameter tuning
linear regression hyperparameter tuning python code
ridge hyperparameter tuning python code
์์์ฝ๋ ์์. Hyperparameter Tuning in Lasso and Ridge Regressions - linear reg์ ๋ํ ํ์ดํผํ๋ผ๋ฏธํฐํ๋ ๋ชปํ๋ ridge, lasso, elasticnet์ผ๋ก ํ๋ผ๋ ์คํ์ค๋ฒํ๋ก์ฐ ์กฐ์ธ ๋ณด๊ณ ๊ฒ์ํด์ ๋ฐ๊ฒฌํ ๊ฒฐ๊ณผ์.
์์์ฝ๋ ์์. Tuning ML Hyperparameters - LASSO and Ridge Examples
How to Develop Ridge Regression Models in Python
[for ppt๊ฒฐ์ธก๊ฐ์ ์ ์ฑ์๋ฃ์ด์ผ ํ๋๊ฐ?]
์ผ๋ฐ์ ์ผ๋ก ๋จธ์ ๋ฌ๋ ๋ชจ๋ธ์ ์
๋ ฅ ๊ฐ์ผ๋ก ๊ฒฐ์ธก๊ฐ(Null,NaN) ์ฌ์ฉ ๋ถ๊ฐ๋ฅ !ํ๋ฏ๋ก fillna๋ฅผ ํตํด ๊ฒฐ์ธก์น๋ฅผ ๊ฐ ์ด์ ํ๊ท ๊ฐ์ผ๋ก ์ฑ์์ฃผ์์.
https://suminn0.tistory.com/34
(๊ฐ์ ๋ด์ฉ https://velog.io/@phphll/Machine-Learning)
์ข์ ๋จธ์ ๋ฌ๋ ๋ชจ๋ธ์ ๊ตฌ์ถํ๋ ๋ฐ ๋์์ด ๋๋ ํต์ฌ์ ์ธ ์ ์ฒ๋ฆฌ ๊ธฐ๋ฒ
๊ฒฐ์ธก๊ฐ์ด ์๋ ๊ฒฝ์ฐ ๋ชจ๋ธ์ด ์
๋ ฅ์ ์์ ํ์ง ๋ชปํ๋ ๊ฒฝ์ฐ๋ ์๋ค.
๊ฒฐ์ธก์น ์ ์ฑ์์ผ ํ๋ ๊ฐ์ ๋ํด dacon ๋ฐ๋ฆ์ด study.txt ์ฐธ๊ณ
๐๐[์ ์ผ ์ค์!!!!!!!] randomCV regressor ์์ ์ฝ๋, ์์ฐ์ฝ๋ ์ฐธ๊ณ !!!!!!, ํ์ดํผํ๋ผ๋ฏธํฐ ์กฐ์ clf
grid search cv์ Lasso๋ฅผ ๊ฒฐํฉํ LassoCV๋ผ๋ ๊ฒ ์๋ค.
๊ทธ๋ฆฌ๋์์น cv ์ฌ์ฉ๋ฒ
grid search CV ์ฌ์ฉ๋ฒ
๐==> ๊ทธ๋ฆฌ๋ ์์น cv๋ ๋ด๊ฐ ์ ํด์ค ๊ฐ๋ค ๋ด์์๋ง ๋์๊ฐ.
๐==> ๋๋ค ์์น cv๋ ์ ํ๋ ๊ฐ์กฐ์ฐจ๋ ๋๋คํ๊ฒ ์ ํ.
fdr, pykrx ๋น๊ต
ํฌ๋กค๋งํ๋ค๊ฐ ๋งํ ์ฌ๋ก
2020๋
๋ํ๊ฐ๋ฏธ ์ด๋์ ๋ํ ์ดํ, [MonthlyNow] ๋จ๊ฑฐ์ ๋ 2020 ์ฃผ์์์ฅ, ์ฝ์คํผ 3000์๋ ๊ฐ๋ง์ด ๋์์
2020 ์ฃผ์๊ฑฐ๋ ํ๋ ๊ณ์ข, ์ค๋งํธ 2030 ๊ฐ๋ฏธ
2030 ๊ฐ๋ฏธ๋ค์ด ์ผ๊ตฐ โ์ฝ์คํผ 3,000โ์ ๋ช
๊ณผ ์
ํ์ด์ฌ ์ฆ๊ถ ๋ฐ์ดํฐ ์์ง๊ณผ ๋ถ์์ผ๋ก ์ ํธ์ ์์ ์ฐพ๊ธฐ
์ฃผ์ ํฌ์์์ ์์ฌ๊ฒฐ์ ์ง์์ ์ํ ๋ฐ์ดํฐ๋ง์ด๋ ๋๊ตฌ
๋น
๋ฐ์ดํฐ๋ฅผ ํ์ฉํ ์ธ๊ณต์ง๋ฅ ์ฃผ์ ์์ธก ๋ถ์
๋น
๋ฐ์ดํฐ๋ฅผ ํ์ฉํ ๊ตญ๋ด์ฃผ์์์ฅ ๋ถ์ ๊ธฐ๋ฒ ์ ์์ ๊ดํ ์ฐ๊ตฌ
๐๐!!!!๊ฐ์ฅ ์ค์!!!!!! Azure Machine Learning - ํ์ดํผ ๋งค๊ฐ ๋ณ์ ํ๋์ ์๋ํํ๊ณ ๋ณ๋ ฌ๋ก ์คํ์ ์คํํ์ฌ ํ์ดํผ ๋งค๊ฐ ๋ณ์๋ฅผ ํจ์จ์ ์ผ๋ก ์ต์ ํ
๋ฒ ์ด์ง์ ์ตํฐ๋ง์ด์ ์ด์
grid search, random search, bayesian optimization
ํ๊ท๋ชจ๋ธ ์ฑ๋ฅํ๊ฐ์งํ, ๊ฒฐ์ ๊ณ์ R2๋?, ์กฐ์ ๋ ๊ฒฐ์ ๊ณ์ (adj_R2)
๋ถ๋ฅ์ฑ๋ฅํ๊ฐ์งํ
[ํ๊ท ์ต์ ์ ํ์ดํผํ๋ผ๋ฏธํฐ ๋ชจ์(?)]
linear, ridge, lasso, elasicnet
๋ฆฟ์ง, ๋ผ์
๐๋ฆฟ์ง, ๋ผ์, ์๋ผ์คํฑ๋ท -> alpha = 0.0001, ์์ ํด์ + CODE ์ ๋ฆฌ
[ML] Regression metric ๊ณผ Elastic net regression
์ง๋ํ์ต ํ์ดํผํ๋ผ๋ฏธํฐ
How to Develop LASSO Regression Models in Python
[LGBM]
Light GBM(LGBM)์ ๊ฐ์์ ํ๋ผ๋ฏธํฐ ์ ์์ ๋ํด
LGBM์ ์ด๋ป๊ฒ ์ฌ์ฉํ ๊น
๐LGBM์ด๋? ๊ทธ๋ฆฌ๊ณ ํ์ดํผํ๋ผ๋ฏธํฐ ํ๋ํ๊ธฐ