[時計ブーム]Chapter 09

9.時計列のための機械学習

クロック列分類

from cesium import featurize.featurize_time_series as ft
features_to_use = ["amplitude", "percent_beyond_1_std", "percent_close_to_median", "skew", "max_slope"]
fset_cesium = ft(times = eeg["times"], values = eeg["measurements"], errors = None, features_to_use = features_to_use, scheduler = None)

けっていじゅほうしき

サンプルコード

from sklearn.ensemble import RandomForestClassifier
rf_clf = RandomForestClassifier(n_estimators = 10, max_depth = 3, random_state = 21)
rf_clf.fit(X_train, y_train)

import xgboost as xgb
xgb_clf = xgb.XGBClassifier(n_estimators = 10, max_depth = 3, random_state = 21)
xgb_clf.fit(X_train, y_train)

## 같은 수의 트리(10), 그러나 복잡성은 낮춘 경우를 테스트
## max_depth = 2

## XGBoost
xgb_clf = xgb.XGBClassifier(n_estimators = 10, max_depth = 2, random_state = 21)
xgb_clf.fit(X_train, y_train)

## 랜덤포레스트
rf_clf = RandomForestClassifier(n_estimators = 10, max_depth = 2, random_state = 21)
rf_clf.fit(X_train, y_train)

分類と回帰

クラスタ

📌 データからフィーチャーを作成するには

## 범주형 데이터 그래프
plt.plot(words.iloc[1, 1:-1])
## 히스토그램
plt.hist(words.iloc[1, 1:-1], 10)

x = np.array([])
y = np.array([])

w = 12
selected_words = words[words.word == w]
selected_words.shape

for idx, row in selected_words.iterrows():
	y = np.hstack([y, row[1:271]])
    x = np.hstack([x, np.array(range(270))])
    
fig, ax = plt.subplots()

from cesium import featurize.featurize_time as ft

word_vals = words.iloc[:, 1:271]
times = []
word_values = []
for idx, row in word_vals.iterrows():
	word_values.append(row.values)
    times.append(np.array([i for i in range(row.values.shape[0])]))
    
features_to_use = ['amplitude', 'percent_beyond_1_std', 'percent_close_to_median']
featurized_hists = ft(times = times, values = word_values, errors = None, features_to_use = features_to_use, scheduler = None)

## 히스토그램에서 파생된 일부 특징을 생성
times = []
hist_values = []
for idx, row in words_features.iterrows():
	hist_values.append(np.histogram(row.values, bins = 10, range=(-2.5, 5.0))[0]+.0001)
	## 0들은 하위 작업에서 문제를 초래
    times.append(np.array([i for i in range(9)]))
    
features_to_use = ["amplitude", "percent_close_to_median", "skew"]
featurized_hists = ft(times = times, values = hist_values, errors = None, features_to_use = features_to_use, scheduler = None)

features = pd.concat([featurized_words.reset_index(drop=True), featurized_hists], axis = 1)

📌 時間を識別する距離測定法

def distDTW(ts1, ts2):
	## 설정과정
    DTW = {}
    for i in range(len(ts1)):
    	DTW[(i, -1)] = np.inf
    for i in range(len(ts2)):
    	DTW[(-1, i)] = np.inf
    DTW[(-1, -1)] = 0
    
    ## 한 번에 한 단계씩
    ## 최적값 계산
    for i in range(len(ts1)):
    	for j in range(len(ts2)):
        	dist = (ts1[i] - ts2[j])**2
            DTW[(i, j)] = dist + min(DTW[(i-1, j)], DTW[(i, j-1)], DTW[(i-1, j-1)])
            
    ## 동적 프로그래밍의 한 예
    ## 완전한 경로를 찾으면 그 경로를 반환한다
    return sqrt(DTW[len(ts1-1, len(ts2)-1])

from sklearn import preprocessing
feature_values = preprocessing.scale(features.values)

from sklearn.cluster import AgglomerativeClustering
feature_clustering = AgglomerativeClustering(n_clusters = 50, linkage = 'ward')
feature_clustering.fit(feature_values)
words['feature_labels'] = feature_clustering.fit_predict(p)

from sklearn .metrics.cluster import homogeneity_score
homogeneity_score(words.word, words.feature_labels)

p = pairwise_distances(X, metric = distDTW)
## 계산하는 데 시간이 꽤 걸리므로 재사용을 위해 따로 저장
with open("pairwise_word_distances.npy", "wb") as f: np.save(f, p)

from sklearn.cluster import AgglomerativeClustering
dtw_clustering = AgglomerativeClustering(linkage = 'average', n_clusters = 50, affinity = 'precomputed')
words['dtw_labels'] = dtw_clustering.fit_predict(p)

from sklearn.metrics.cluster import homogeneity_score, completeness_score
homogeneity_score(words.word, words.dtw_labels)
completeness_score(words.word, words.dtw_labels)