반응형
from random import seed
#from statistics import LinearRegression

from sklearn.ensemble import AdaBoostRegressor, ExtraTreesRegressor, GradientBoostingClassifier, GradientBoostingRegressor, RandomForestRegressor
from sklearn.metrics import mean_squared_error
from utils.utils import *
import numpy as np
import pandas as pd

#stock_financial('005930.KS','2018-01-01','2022-01-01')
#KRX_stock_list()
#stock_price('005930.KS','2018-01-01','2022-01-01')

import pandas_datareader.data as web

#### 데이터셋 가져오기 ####
#("MSFT IBM GOOGL")
#orelly_function_datareader("MSFT IBM GOOGL")
#orelly_function_datareader("DEXJPUS DEXUSUK",'fred')
#orelly_function_datareader("SP500 dJIA VIXCLS",'fred')


#### 전처리 과정 ####

#### index_col을 0번 인덱스로 하여, name, name설정 함. ㄷㄷ
stk_data = pd.read_csv("./data_collection/datasets/orelly_MSFT IBM GOOGL.csv",index_col=[0],header=[0,1])


#stk_data_header_0 = stk_data.columns.get_level_values(level=0)
#stk_data_header_1 = stk_data.columns.get_level_values(level=1)
#stk_data_header_2 = stk_data.columns.get_level_values(level=2).str.replace('Un.*','',regex=True)
#stk_data.columns = [stk_data_header_0,stk_data_header_1,stk_data_header_2]
#print(stk_data_header_0)
#print(stk_data_header_1)
#print(stk_data_header_2)

#print(stk_data.columns)
#print(stk_data.index)
#print(stk_data)
###############################


## Attriubtes : Adj Close : 조정 종가


ccy_data = pd.read_csv("./data_collection/datasets/orelly_DEXJPUS DEXUSUK.csv",index_col=[0])
idx_data = pd.read_csv("./data_collection/datasets/orelly_SP500 dJIA VIXCLS.csv",index_col=[0])

'''
stk_tickers = ['MSFT','IBM','GOOGL']
ccy_tickers = ['DEXJPUS','DEXUSUK']
idx_tickers = ['SP500','DJIA','VIXCLS']
stk_data = web.DataReader(stk_tickers,'yahoo')
ccy_data = web.DataReader(ccy_tickers, 'fred')
idx_data = web.DataReader(idx_tickers,'fred')
'''

return_period = 5
# diff 는 계차 구하는 것 (diff 안의 변수는 5일 지연, 5개 , 10개, 15개 ....)
## 모든행에 대해 'adj close만'

# Y는 ('Adj Close의 'MSFT' 칼럼 내 열 값을 log 취한다. -> 그 후, diff(5일 계차)구함 -> 5개행 만큼 위로 값 올림)
Y = np.log(stk_data.loc[:,('Adj Close','MSFT')]).diff(return_period).shift(-return_period)
#print(Y.index.name) # Date
#print(Y.name) # (Adj Close,MSFT)

Y.name = Y.name[-1] + '_pred'
X1 = np.log(stk_data.loc[:, ('Adj Close', ('GOOGL','IBM'))]).diff(return_period)
#print(X1)
#print(X1.columns)
#print(X1.columns.levels)
# MultiIndex 컬럼에서 튜플로 접근하는 것이 싫다면 droplevel()로 MultiIndex 컬럼을 SingleIndex 컬럼으로 변환합니다.
X1.columns = X1.columns.droplevel() # 코드상에서는 Attributes Adj Close 삭제됨 droplevel 디폴트 값 알아야됨.
#print(X1.columns)
#print(X1)

#X2 = np.log(ccy_data.loc[:,('DEXJPUS','DEXUSUK')]).diff(return_period)
X2 = np.log(ccy_data).diff(return_period)

X3 = np.log(idx_data).diff(return_period)
#### X4는 diff(5) diff(15) diff(30) diff(60) 계산-> axis 1이므로 오른쪽에 붙임 그리고 dropna null 날림
X4 = pd.concat([np.log(stk_data.loc[:,('Adj Close','MSFT')]).diff(i)\
    for i in [return_period, return_period*3,\
        return_period*6,return_period*12]],axis=1).dropna()
#print(X4)
#print(X4.columns)
X4.columns = ['MSFT_DT','MSFT_3DT','MSFT_6DT','MSFT_12DT'] # multi column -> single column 됨
#print(X4)


#print(X1)
#print(X2)
#print(X3)
###########여기부터 다시 공부 시작 #####
X = pd.concat([X1,X2,X3,X4],axis=1)
#print(X)
dataset = pd.concat([Y,X],axis=1).dropna().iloc[::return_period,:]
Y=dataset.loc[:,Y.name]
X=dataset.loc[:,X.columns]
#print(dataset.head())




import matplotlib.pyplot as plt
'''
correlation = dataset.corr()
plt.figure(figsize=(15,15))
plt.title('Correlation Matrix')
import seaborn as sns
sns.heatmap(correlation,vmax=1, square=True,annot=True,cmap='cubehelix')
plt.show()
'''
################################p126######################
'''
from pandas.plotting import scatter_matrix

plt.figure(figsize=(15,15))
scatter_matrix(dataset,figsize=(12,12))
plt.show()
'''
##########################################################
#시계열 분석#
'''
import statsmodels.api as sm
res = sm.tsa.seasonal_decompose(Y,period=52) ### freq 대신 period??????????????????? 결과가 다름.
fig= res.plot()
fig.set_figheight(8)
fig.set_figwidth(15)
plt.show()
'''
##########################################################

# 5. 훈련.
validation_size = 0.2
train_size = int(len(X) * (1-validation_size))
print(len(X))
X_train, X_test = X[0:train_size],X[train_size:len(X)]
Y_train, Y_test = Y[0:train_size],Y[train_size:len(Y)]
print(X,Y)
### 테스트 옵션 및 평가 메트릭.(4장 참고)
num_folds = 10
scoring = 'neg_mean_squared_error'

###사이킷런을 이용한 머신러닝 모델
models = []
#### 회귀와 회귀 트리 알고리즘
from sklearn.linear_model import LinearRegression
from sklearn.linear_model import Lasso
from sklearn.linear_model import ElasticNet
from sklearn.tree import DecisionTreeRegressor
from sklearn.neighbors import KNeighborsRegressor
from sklearn.svm import SVR

models.append(('LR',LinearRegression()))
models.append(('LASSO',Lasso()))
models.append(('EN',ElasticNet()))
models.append(('KNN',KNeighborsRegressor()))
models.append(('CART',DecisionTreeRegressor()))
models.append(('SVR',SVR()))
# 신경망 알고리즘
from sklearn.neural_network import MLPRegressor
models.append(('MLP',MLPRegressor()))
#앙상블 모델
######### 부스팅 방법
models.append(('ABR',AdaBoostRegressor()))
models.append(('GBR', GradientBoostingRegressor()))

## 배깅 방법
models.append(('RFR',RandomForestRegressor()))
models.append(('ETR',ExtraTreesRegressor()))
#################################

from sklearn.model_selection import KFold, cross_val_score
names = []
kfold_results = []
test_results = []
train_results = []
for name, model in models:
    #print(name,model)
    names.append(name) ## k-겹 분석
    ### kfold 교차 검증 ###
    kfold = KFold(n_splits = num_folds, random_state= 100,shuffle=True) #Setting a random_state has no effect since shuffle is False. You should leave random_state to its default (None), or set shuffle=True. 발생시, shuffle=true 넣어주어야 한다.
    #print(kfold) KFold(n_splits=10, random_state=100, shuffle=True) 
    #평균 제곱 오차(MSE)를 양수로 변환함. 낮을 수록 좋음
    cv_results = -1*cross_val_score(model,X_train,Y_train,cv=kfold,scoring=scoring)#########오류 원인 분석중
    """
        #print(cv_results)
    [0.00037173 0.00141106 0.00114862 0.00121909 0.00123947 0.00228879 0.00073832 0.00092809 0.00031207 0.00081958] = 와 같이 cv_results 값 도출
    """
    
    ##예외가 발생했습니다. ValueError Cannot have number of splits n_splits=10 greater than the number of samples: n_samples=0.
    ### 해결ㄹ 못함 --> validaiotn 값 변경함
    ### Cannot clone object. You should provide an instance of scikit-learn estimator instead of a class.
    ### 'KNN' KNeighborsRegressor 로 작성해서 오류났었음.


    kfold_results.append(cv_results)
    # 총 훈련 기간
    res = model.fit(X_train,Y_train)
    train_result = mean_squared_error(res.predict(X_train),Y_train) # 학습이 완료된 모델에 predict를 넣으면 결과값을 반환
    train_results.append(train_result)
    # 테스트 결과
    test_result = mean_squared_error(res.predict(X_test),Y_test)
    test_results.append(test_result)

### 교차 검증 결과
fig = plt.figure()
fig.suptitle('Algorithm Comparison: Kfold results')
ax = fig.add_subplot(111)
plt.boxplot(kfold_results)
ax.set_xticklabels(names)
fig.set_size_inches(15,8)
plt.show()


#### 훈련 및 테스트 오차 ####
fig = plt.figure()
ind = np.arange(len(names)) # 그룹의 x 위치
width = 0.35 # 막대 폭
fig.suptitle('Algorithm Comparison')
ax = fig.add_subplot(111)
plt.bar(ind - width/2,train_results, width=width, label='Train Error')
plt.bar(ind + width/2, test_results, width=width, label='Test Error')
fig.set_size_inches(15,8)
plt.legend()
ax.set_xticks(ind)
ax.set_xticklabels(names)
plt.show()
반응형
반응형
##########################################주가 예측 ##################################################

# 예제의 목적 : "상관 자산" + "과거 데이터" => "MS 주가 예측"

""" ############################################################################################ 1번 문제 정의 ############################################################################################"""
# MS 과거데이터 + 독립변수로 사용되는 상관 자산 : (주식 + 환율 + 인덱스)

""" ############################################################################################2번 문제 데이터 불러오기############################################################################################"""
import numpy as np
import pandas as pd
from sklearn.metrics import mean_squared_error
import matplotlib.pyplot as plt

#################################################
###############데이터 불러오기####################
'''
stk_tickers = ['MSFT','IBM','GOOGL']  # 주식 데이터 (MSFT,IBM,GOOGL)
ccy_tickers = ['DEXJPUS','DEXUSUK'] # 환율 데이터 (DEXJP US, DEXUS UK)
idx_tickers = ['SP500','DJIA','VIXCLS'] # 인덱스 지수 데이터 (SP500,DJIA,VIXCLS 받아옴.)
stk_data = web.DataReader(stk_tickers,'yahoo')
ccy_data = web.DataReader(ccy_tickers, 'fred')
idx_data = web.DataReader(idx_tickers,'fred')
'''
#################################################
############CSV파일에서 불러오기##################
stk_data = pd.read_csv("./data_collection/datasets/orelly_MSFT IBM GOOGL.csv",index_col=[0],header=[0,1]) # index_col -> default (None) // 0열을 인덱스로 불러온다. // header -> default (첫번째 행) // 0~1행을 열이름으로 지정해서 불러온다.
ccy_data = pd.read_csv("./data_collection/datasets/orelly_DEXJPUS DEXUSUK.csv",index_col=[0]) # index_col -> default (None) // 0열을 인덱스로 불러온다. 
idx_data = pd.read_csv("./data_collection/datasets/orelly_SP500 dJIA VIXCLS.csv",index_col=[0]) # index_col -> default (None) // 0열을 인덱스로 불러온다. 

##################################################
##################################################
"""
##################stk_data###########

               GOOGL       IBM   DEXJPUS   DEXUSUK     SP500      dJIA    VIXCLS   MSFT_DT  MSFT_3DT  MSFT_6DT  MSFT_12DT
2017-04-11 -0.014996 -0.022835 -0.009071  0.003772 -0.002707 -0.001835  0.245454 -0.003810  0.019586  0.023174   0.049428
2017-04-19  0.019607 -0.053524 -0.004392  0.022857 -0.002887 -0.009141 -0.054737 -0.006743 -0.003836  0.009889   0.038547
...              ...       ...       ...       ...       ...       ...       ...       ...       ...       ...        ...
"""

"""

"""
return_period = 5 # 5일 지연 변수를 사용하기 위해 
Y = np.log(stk_data.loc[:,('Adj Close','MSFT')]).diff(return_period).shift(-return_period) 
"""
Adj Close 멀티 인덱스에서 MSFT 주가 column만을 긁어 온다. (loc[:,('Adj Close','MSFT)])
diff(return_period)이므로 5일기준으로 이산(차이)을 구한다.
shift(-return_period)이므로 Date 인덱스기준으로2009-12-31 위의 튜플로 주가 값을 올린다.
Date
2009-12-31    0.005888
2010-01-04   -0.022216
2010-01-05   -0.029168
2010-01-06   -0.013744
2010-01-07    0.016610
                ...
2019-12-24         NaN
2019-12-26         NaN
2019-12-27         NaN
2019-12-30         NaN
2019-12-31         NaN
"""
Y.name = Y.name[-1] + '_pred' ### Y.name = MSFT

# Y와 동일하게 진행
X1 = np.log(stk_data.loc[:, ('Adj Close', ('GOOGL','IBM'))]).diff(return_period)
"""
Adj close 멀티 인덱스에서 GOOGL,IBM 주가 column만을 긁어온다.
diff(return_period)이므로 5일 기준으로 이산(차이)를 구한다.

Attributes Adj Close
Symbols        GOOGL       IBM
Date
2009-12-31       NaN       NaN
2010-01-04       NaN       NaN
2010-01-05       NaN       NaN
2010-01-06       NaN       NaN
2010-01-07       NaN       NaN
...              ...       ...
2019-12-24 -0.007750  0.005646
2019-12-26  0.007781  0.003713
2019-12-27 -0.001328  0.005263
2019-12-30 -0.008555 -0.020716
2019-12-31 -0.008357 -0.011202
"""
X1.columns = X1.columns.droplevel() # 코드상에서는 Attributes Adj Close 삭제됨 // droplevel이란 특정 레벨의 attribute를 삭제. 

X2 = np.log(ccy_data).diff(return_period)

"""
##################X2 결과###########################
DEXJPUS   DEXUSUK
DATE
2017-04-04       NaN       NaN
2017-04-05       NaN       NaN
2017-04-06       NaN       NaN
2017-04-07       NaN       NaN
2017-04-10       NaN       NaN
...              ...       ...
2022-03-21  0.009699  0.011964
2022-03-22  0.020683  0.014664
2022-03-23  0.021212  0.008819
2022-03-24  0.030186  0.001822
2022-03-25  0.023306  0.001821
"""
X3 = np.log(idx_data).diff(return_period)

"""
##################X3 결과###########################
SP500      dJIA    VIXCLS
DATE
2017-04-04       NaN       NaN       NaN
2017-04-05       NaN       NaN       NaN
2017-04-06       NaN       NaN       NaN
2017-04-07       NaN       NaN       NaN
2017-04-10       NaN       NaN       NaN
...              ...       ...       ...
2022-03-28  0.025307  0.011593 -0.181217
2022-03-29  0.026248  0.013887 -0.193720
2022-03-30  0.032283  0.025015 -0.198316
2022-03-31  0.002265 -0.000853 -0.052581
2022-04-01  0.000616 -0.001233       NaN
"""
### concat 함수는 사용법에 따라 튜플을 추가하거나, attribute를 추가하는 형식으로 사용이 가능하다.
### 아래 X4의 경우, MSFR_DT 기준으로, 5일 지연 변수, 30일, 60일 기준 행렬 생성 ###
X4 = pd.concat([np.log(stk_data.loc[:,('Adj Close','MSFT')]).diff(i)\
    for i in [return_period, return_period*3,\
        return_period*6,return_period*12]],axis=1).dropna()
X4.columns = ['MSFT_DT','MSFT_3DT','MSFT_6DT','MSFT_12DT'] # multi column -> single column(['MSFT_DT','MSFT_3DT','MSFT_6DT','MSFT_12DT']) 됨 (X기준으로 설명한 내용)
"""
##################X4 결과###########################
MSFT_DT  MSFT_3DT  MSFT_6DT  MSFT_12DT
Date
2010-03-30 -0.003688  0.033126  0.048874  -0.018904
2010-03-31 -0.012216  0.010986  0.024190  -0.050461
2010-04-01 -0.028733 -0.000685  0.006537  -0.055233
2010-04-05 -0.013236  0.000000  0.017230  -0.045312
2010-04-06 -0.009166  0.001024  0.020328  -0.033151
...              ...       ...       ...        ...
2019-12-24  0.017240  0.052639  0.077701   0.127371
2019-12-26  0.027475  0.057192  0.079315   0.149732
2019-12-27  0.020657  0.058484  0.079510   0.169371
2019-12-30  0.001143  0.037762  0.065776   0.148682
2019-12-31  0.001841  0.041033  0.053656   0.135968
"""
X = pd.concat([X1,X2,X3,X4],axis=1) # axis=1인 경우 오른쪽에 추가 한다고 생각하면 된다.

dataset = pd.concat([Y,X],axis=1).dropna().iloc[::return_period,:] # dropna란 NA(NULL 정해지지 않은 값)을 삭제 // iloc[::return_period,:]????????????????????


Y=dataset.loc[:,Y.name] ### Y의 shape (129,)
X=dataset.loc[:,X.columns] ### X의 shape (129,11)



""" ############################################################################################ 3.2 탐색적 데이터 분석 (데이터 시각화) ############################################################################################"""



""" ############################################################################################ 5. 모델 평가 ##########################################################################################"""
from statsmodels.tsa.arima.model import ARIMA
validation_size = 0.2 ###### 80%를 (train_set)/// 20%를 (train_set)
train_size = int(len(X) * (1-validation_size)) ## len(X)는 129 // train_size 103

X_train, X_test = X[0:train_size],X[train_size:len(X)]
Y_train, Y_test = Y[0:train_size],Y[train_size:len(Y)]
"""
########## X ###########

               GOOGL       IBM   DEXJPUS   DEXUSUK     SP500      dJIA    VIXCLS   MSFT_DT  MSFT_3DT  MSFT_6DT  MSFT_12DT
2017-04-11 -0.014996 -0.022835 -0.009071  0.003772 -0.002707 -0.001835  0.245454 -0.003810  0.019586  0.023174   0.049428
2017-04-19  0.019607 -0.053524 -0.004392  0.022857 -0.002887 -0.009141 -0.054737 -0.006743 -0.003836  0.009889   0.038547
...              ...       ...       ...       ...       ...       ...       ...       ...       ...       ...        ...
[129 rows x 11 columns] 예시

########## Y ###########

2017-04-19    0.042002
2017-04-27    0.007879
                ...
Name: MSFT_pred, Length: 129, dtype: float64                

"""

### 테스트 옵션 및 평가 메트릭.(4장 참고)
num_folds = 10 #K-fold(10겹) N 겹 진행 초기 변수 설정
scoring = 'neg_mean_squared_error' # sklearn은 MSE에 음수를 취해서 오차를 점수로 바꾼다. 즉, MSE와 같은 개념 점수가 클수록 좋은 결과값.

X_train_ARIMA = X_train.loc[:,['GOOGL','IBM','DEXJPUS','SP500','dJIA','VIXCLS']] ###교재는 DJIA -> dJIA
X_test_ARIMA = X_test.loc[:,['GOOGL','IBM','DEXJPUS','SP500','dJIA','VIXCLS']] ### 교재는 DJIA -> dJIA

#print("길이: {}".format(len(X_test_ARIMA))) # (103,6)

tr_len= len(X_train_ARIMA) # 103
te_len = len(X_test_ARIMA) # 26
to_len = len(X) # 129 (103+26)

####### ARIMA(Autoregressive integrated moving average) #########
modelARIMA=ARIMA(endog=Y_train,exog=X_train_ARIMA,order=[1,0,0]) # endog = 내생 변수 / order : 사용할 AR 매겨변수 ( p,d,q) / exog 외생 변수
## p는 자기 회귀의 차수, d는 첫 디퍼런싱의 정도, q는 이동평균 부분의 차수이다.

model_fit = modelARIMA.fit() # 해당 학습 데이터로 학습

error_Training_ARIMA = mean_squared_error(Y_train,model_fit.fittedvalues) # MSE 도출  => sigma(Y_train-model_fit.fittedvalues)^2 값 // fittedvalues : ## 추정값 (skit-learn 라이브러리에서만 가능한것으로 보임)
predicted = model_fit.predict(start = tr_len - 1, end = to_len -1,exog= X_test_ARIMA)[1:] # ## 예측값 도출 (자세한 사용법 확인 필요.)
error_Test_ARIMA = mean_squared_error(Y_test,predicted) # MSE 도출
print(error_Test_ARIMA) ## 0.00030985051584437283

seq_len = 2 # LSTM에 대한 시퀸스 길이 (자세한 역할 확인 필요!!!!!!!!!!!!!!!!!)
Y_train_LSTM, Y_test_LSTM = np.array(Y_train)[seq_len-1:], np.array(Y_test) #Y_train의 [swq_len-1:] 인덱스만 Y_train_LSTM에 포함 , 나머지는 test_LSTM으로 만듬.
X_train_LSTM = np.zeros((X_train.shape[0]+1-seq_len,seq_len, X_train.shape[1])) # np.zeros로 0으로만 이루어진 행렬 생성
X_test_LSTM = np.zeros((X_test.shape[0],seq_len,X.shape[1])) # 동일
#print(X_train.shape) (103,11)

for i in range(seq_len): # iter문을 사용해서 2차원 -> 3차원으로 변경하는 작업
    X_train_LSTM[:,i,:] = np.array(X_train)[i:X_train.shape[0]+i+1-seq_len,:]
    X_test_LSTM[:,i,:] = np.array(X)[X_train.shape[0]+i-1:X.shape[0]+i+1-seq_len,:]
#(X_test_LSTM.shape) (102,2,11)
#(X_train_LSTM.shape) (26, 2, 11)



#LSTM 망
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizer_v1 import SGD ### instead of optimizers import SGD
from keras.layers import LSTM
names = []
test_results = []
train_results = []

##### model -> model.add() -> ... -> model.compile -> 
#### 큰틀의 학습 방범 model 구축 -> fit 함수로 모델 학습-> predict로 학습된 모델에 예측값을 넣어 예측값 반환
def create_LSTMmodel(learn_rate = 0.1,momentum=0):
    #모델 생성
    model = Sequential()
    model.add(LSTM(50,input_shape=(X_train_LSTM.shape[1],X_train_LSTM.shape[2])))
    #필요시 더 많은 셀 추가
    model.add(Dense(1)) # 출력 뉴런(노드)의 수  결정(마지막 레이어의 노드의 갯수는 출력 데이터 y의 갯수와 동일하게 1개로 지정.) // (additional argument는 ) ### https://ebbnflow.tistory.com/120
    optimizer = SGD(lr=learn_rate,momentum=momentum) #많이 쓰는 otpimizer 함수 : SGD(스토캐스틱 graident 함수) // 파아미터는 : lr(학습률), momentum : 모멘텀   /// 교재에서는 써놓고 사용을 안하는 변수
    model.compile(loss='mse',optimizer='adam') #옵티마이저는 adam 사용 // 손실함수는 mse
    return model  # model 값을 리턴

LSTMModel = create_LSTMmodel(learn_rate=0.01,momentum=0) # 함수 실행
LSTMModel_fit = LSTMModel.fit(X_train_LSTM,Y_train_LSTM,validation_data=(X_test_LSTM,Y_test_LSTM),epochs=330,batch_size=72,verbose=0,shuffle=False) # fit함수로 학습데이터 학습


plt.plot(LSTMModel_fit.history['loss'],label='train',) # 오차율 기록
plt.plot(LSTMModel_fit.history['val_loss'],'--',label='test',) # val_loss // test함수에서 정확도 측정
plt.legend() #범례설정(위에서 선언한 label들 보이게 호출)
plt.show()



error_Training_LSTM = mean_squared_error(Y_train_LSTM,LSTMModel.predict(X_train_LSTM)) # predict함수로 train에서의 MSE의 예측값을 error_training_LSTm 변수에 저장.
predicted = LSTMModel.predict(X_test_LSTM) # 주가 예측 데이터에서 예측값 변수에 저장.
error_Test_LSTM = mean_squared_error(Y_test,predicted) # 실제 주가와 predicted과의 괴리율을 저장??

test_results.append(error_Test_ARIMA)
test_results.append(error_Test_LSTM)
train_results.append(error_Training_ARIMA)
train_results.append(error_Training_LSTM)
names.append("ARIMA")
names.append("LSTM")


def evaluate_arima_model(arima_order):
    #predicted = list
    modelARIMA = ARIMA(endog=Y_train,exog=X_train_ARIMA,order=arima_order)
    model_fit = modelARIMA.fit()
    error = mean_squared_error(Y_train, model_fit.fittedvalues) # fittedvalues : ## 추정값
    return error

# ARIMA 모델에 대한 p,d,q 값 조합 평가
## 아래 evaluate 모델은 약식 함수임(세개의 변수만으로는 평가가 완벽하지 않음.)
def evaluate_models(p_values,d_values,q_values):
    best_score,best_cfg = float("inf"), None
    for p in p_values:
        for d in d_values:
            for q in q_values:
                order = (p,d,q)
                try:
                    mse = evaluate_arima_model(order)
                    if mse < best_score: # best_score보다 MSE(오차)가 낮을 경우 더 좋은 값이므로 
                        best_score, best_cfg = mse, order # 변수를 업데이트한다.
                    print('ARIMA%s MSE=%.7f' % (order,mse))
                except:
                    continue
    print('Best ARIMA%s MSE=%.7f' % (best_cfg, best_score))

#매개변수 평가
import warnings
p_values = [0,1,2]
d_values = range(0,2)
q_values = range(0,2)
warnings.filterwarnings("ignore") #경고 메시지 숨기기
evaluate_models(p_values, d_values,q_values) # p,d,q 주어진 범위내에서 BEST값 추출.

##7.모델 확정
#모델 준비
modelARIMA_tuned = ARIMA(endog=Y_train,exog=X_train_ARIMA,order=[2,0,1]) # 가장 좋은 ARIMA 파라미터로 학습 진행.
model_fit_tuned = modelARIMA_tuned.fit()

#검증셋에 대한 정확도 추정
#estimate accuracy on validation set
predicted_tuned = model_fit.predict(start=tr_len-1,end=to_len-1,exog=X_test_ARIMA)[1:]
print(mean_squared_error(Y_test,predicted_tuned))


# 실제 데이터와 예측 데이터 그래프
predicted_tuned.index = Y_test.index # 실제 데이터와 예측 데이터 그래프의 index를 맞춘다.
plt.plot(np.exp(Y_test).cumprod(), 'r',label='actual',)  # exp(지수함수화.) # cumprod는 배열에서 주어진 축에 따라 누적되는 원소들의 누적 값을 계산하는 함수 ex) [1,2,3] => [1, 1*2, 1*2*3]


# t와 a 분리하여 그리기
plt.plot(np.exp(predicted_tuned).cumprod(),'b--',label='predicted')
plt.legend()
plt.rcParams["figure.figsize"] = (8,5) ## mlpt 전역 변수 
plt.show()
반응형

'IT 인터넷 > 머신러닝' 카테고리의 다른 글

파생 상품(옵션) - KFold  (0) 2022.05.17
주가예측 - KFOLD(교차검증-)  (0) 2022.05.16
아나콘다 dlib 설치 오류 해결방법  (0) 2022.01.15
반응형

Fork()는 부모 프로세스와 동일한 자식프로세스를 생성한다.

아래의 코드로 이해를 도와보자.

#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main()
{
    pid_t pid, pid1; /* pid 변수 생성 */
    printf("현재 내 pid : %d , ppid : %d\n",getpid(),getppid());
    pid = fork(); /* fork 로 자식 프로세스 생성 */
    printf("fork 실행 결과값 :  %d\n",pid); /* fork 실행시, 반환되는 pid 값 보기 */
    if (pid < 0) { /* 에러 발생시 */
        fprintf(stderr, "Fork Failed");
        return 1;
    }
    else if (pid == 0) { /* fork 실행시, 반환값으로 pid가 0이랑 같게 나올 경우, 자식 프로세스 */
        pid1 = getpid(); /* getpid()함수로 현재본인  pid 값을 pid1 에 저장 */
        printf("자식 프로세스 : pid = %d\n",pid); /* A 가 의미하는 것은 fork() 반환 값 pid ==0 => 현재 여기는 자식 프로세스 다. */
        printf("자식 프로세스 : pid1 = %d\n",pid1); /* B 가 의미하는 것은 자식 프로세스의 PID 값 */
        printf("자식의 부모  프로세스 : ppid = %d\n",getppid()); /* 이 행이 의미하는 것은 자식 프로세스의 부모 프로세스 PID 값 */
        pause();
    }
    else { /* fork 실행시, 반환값으로 pid 가 0 보다 크게 나올 경우 =  부모 프로세스 */
        pid1 = getpid(); /* getpid()함수로 현재본인  pid 값을 pid1에 저장 */
        printf("부모 프로세스: pid = %d\n",pid); /* C가 의미하는 것은 fork() 반환값 pid >0 => 현재 여기는 부모 프로세스이며, PID는값은 자식 프로세스 getpid() 와 동일  출력*/
        printf("부모 프로세스: pid1 = %d\n",pid1); /* D 부모 프로세스자기 자신의 pid값 출력*/
        printf("부모의 부모 프로세스: ppid = %d\n",getppid()); /* 이 행이 의미하는 것은 부모의 부모 프로세스 PID값 */
        wait(NULL);
        pause();
    }
    return 0;
}

view {파일명}.c 로 위의 내용을 입력후,

gcc {파일명}.c 로 컴파일 한다.

컴파일을 성공하면, a.out 파일이 생성된다.

./a.out 과 같이 실행을 해보자.

실행 결과는 아래와 같다.

 

반응형
반응형
import numpy as np

def strassen(n,A,B,C):
    threshold = 2
    A11 = np.array([[A[rows][cols] for cols in range(int(n/2))] for rows in range(int(n/2))])
    A12 = np.array([[A[rows][cols] for cols in range(int(n/2),n)] for rows in range(int(n/2))])
    A21 = np.array([[A[rows][cols] for cols in range(int(n/2))] for rows in range(int(n/2),n)])
    A22 = np.array([[A[rows][cols] for cols in range(int(n/2),n)] for rows in range(int(n/2),n)])

    B11 = np.array([[B[rows][cols] for cols in range(int(n/2))] for rows in range(int(n/2))])
    B12 = np.array([[B[rows][cols] for cols in range(int(n/2),n)] for rows in range(int(n/2))])
    B21 = np.array([[B[rows][cols] for cols in range(int(n/2))] for rows in range(int(n/2),n)])
    B22 = np.array([[B[rows][cols] for cols in range(int(n/2),n)] for rows in range(int(n/2),n)])

    #print("{} \n{} \n{} \n{} \n{} \n{} \n{} \n{}".format(A11, A12, A21, A22, B11, B12, B21, B22))
    
    if (n <= threshold):
        C = np.array(A)@np.array(B)
        #print(C)
    else:
        M1 = M2 = M3 = M4 = M5 = M6 = M7 = np.array([])
        M1 = strassen(int(n/2), (A11 + A22), (B11 + B22),M1)
        M2 = strassen(int(n/2), (A21 + A22), (B11) ,M2)
        M3 = strassen(int(n/2), (A11), (B12 - B22),M3)
        M4 = strassen(int(n/2), (A22), (B21 - B11),M4)
        M5 = strassen(int(n/2), (A11 + A12), (B22),M5)
        M6 = strassen(int(n/2), (A21 - A11), (B11 + B12),M6)
        M7 = strassen(int(n/2), (A12 - A22), (B21 + B22),M7)
        
        C = np.vstack([ np.hstack([M1+M4 -M5 + M7,M3+M5]),np.hstack([M2+M4,M1+M3 -M2 + M6]) ])
    
    return C
    

n=4
#A = [[1 for cols in range(n)]for rows in range(n)]
#B = [[2 for cols in range(n)]for rows in range(n)]
A=[ [1,2,0,2], [3,1,0,0], [0,1,1,2],[2,0,2,0]]
B=[ [0,3,0,2], [1,1,4,0], [1,1,0,2],[0,5,2,0]]
#print(np.array(A))
#print(np.array(B))
C = np.array(A)@np.array(B)
print(C)
D = [[0 for cols in range(n)] for rows in range(n)]
D = strassen(n,A,B,D)
print(D)
반응형

+ Recent posts