(x,y,z)の３軸での加速度を用いた活動体位の予測の機械学習のデータの前処理について

Question

(x,y,z)の３軸での加速度を用いた活動体位の予測の機械学習について

こんにちは、Pythonを学び始めて１ヶ月の初心者です。とても初歩的なことかもしれないのですが質問させてください。
オンラインコースの課題で上記のような予測をするプログラムを作成するというものがあり、取り組んでいます。実装してみたのですが、制度がまったく出ず困っています。入力の値や各層の実装については問題ないと思うのですが、出力を見てみると結果的に全て一つの答えのみになってしまっています。どこが問題なのか等アドバイスをいただければ幸いです。Pythonは自学のみであり、周りに聞ける人もおらず八方塞がりなのでヒントだけでもいただけましたら幸いです。よろしくお願いいたします。

課題の詳細です。
このプロジェクトでは、スマートフォンの3軸加速度計データから身体活動のタイプ（例、歩く、階段を上る）を予測しようとします。

入力データ
このプロジェクトのトレーニングに使用される入力データは、2つのファイルで構成されています。最初のファイルtrain_time_series.csvには、収集された生の加速度計データが含まれており、その形式は次のとおりです。

タイムスタンプ、UTC時間、精度、x、y、z

タイムスタンプ列を時間変数として使用できます。また、ここではx、y、zとラベル付けされた最後の3つの列も必要です。これらは、3つの直交軸のそれぞれに沿った線形加速度の測定値に対応しています。

2番目のファイルtrain_labels.csvには身体活動のラベルが含まれており、これらのラベルを使用してモデルをトレーニングします。身体活動にはそれぞれ整数で番号が付けられています。1 =立つ、2 =歩く、3 =階段を下る、4 =階段を上がる、の４項目です。加速度計は高周波数でサンプリングされるため、train_labels.csvのラベルは、train_time_series.csvの10回ごとの観測に対して提供されます。

活動分類
目標は、さまざまな身体活動をできるだけ正確に分類することです。コードをテストするために、test_time_series.csvというファイルも提供され、プロジェクトの最後に、このテストデータセットのコードによって予測されるアクティビティラベルを提出します。コーススタッフだけがテストデータに対応する真のラベルを持ち、コードの正確さは正しい分類のパーセンテージとして決定されます。どちらの場合も、トレーニングとテストの場合、入力ファイルは単一（3次元）の時系列で構成されていることに注意してください。コードの精度をテストするには、予測をCSVファイルとしてアップロードするように求められます。 test_labels.csvと呼ばれるこのファイルは提供されていますが、予測に必要なタイムスタンプのみが含まれています。対応するクラス予測（1、2、3、4）を追加して、このファイルを拡張する必要があります。

該当のソースコード

%matplotlib inline

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt



def to_input(df):
    df["synthetic_acce"]=np.sqrt(df.x**2+df.y**2+df.z**2)
    #合成加速度を計算しn×10行列を作成します
    #まず、入力データは１０こで1つの動きを規定しています。（ex.入力データのインデックス０−９が一つの対位（座る））
    #そのため、１サンプルを１０この要素を含む配列に変換します。
    #そのためのインデックス として以下を書きます
    index = df.index
    index_s1= index[index%10==1]
    index_s2= index[index%10==2]
    index_s3= index[index%10==3]
    index_s4=index[index%10==4]
    index_s5=index[index%10==5]
    index_s6=index[index%10==6]
    index_s7=index[index%10==7]
    index_s8= index[index%10==8]
    index_s9= index[index%10==9]
    index_s10= index[index%10==0]
    #標準化させるために平均と標準偏差を計算します。
    ave_input=np.array([np.average(df.synthetic_acce[i:i+10]) for i in range(0,len(df.synthetic_acce),10)])
    std_input=np.array([np.std(df.synthetic_acce[i:i+10]) for i in range(0,len(df.synthetic_acce),10)])
    #合成加速度の値を作ったインデックスを利用して取り出しそれぞれを標準化させます
    s1=(df.synthetic_acce.values[index_s1] - ave_input) / std_input
    s2= (df.synthetic_acce.values[index_s2]- ave_input) / std_input
    s3=(df.synthetic_acce.values[index_s3]- ave_input) / std_input
    s4=(df.synthetic_acce.values[index_s4]- ave_input) / std_input
    s5=(df.synthetic_acce.values[index_s5]- ave_input) / std_input
    s6= (df.synthetic_acce.values[index_s6]- ave_input) / std_input
    s7=(df.synthetic_acce.values[index_s7]- ave_input) / std_input
    s8= (df.synthetic_acce.values[index_s8]- ave_input) / std_input
    s9= (df.synthetic_acce.values[index_s9]- ave_input) / std_input
    s10= (df.synthetic_acce.values[index_s10]- ave_input) / std_input
    #計算した１０この要素を積み重ねn×１０の行列を作成します

    c=np.vstack((s1,s2,s3,s4,s5,s6,s7,s8,s9,s10)).T
    #特徴を増やすために上記の操作をx軸、y軸、z軸でも行います。インデックスはそのまま使用しています。
    ave_x=np.array([np.average(df.x[i:i+10]) for i in range(0,len(df.x),10)])
    std_x=np.array([np.std(df.x[i:i+10]) for i in range(0,len(df.x),10)])
        
    x1=(df.x.values[index_s1]- ave_x) / std_x
    x2= (df.x.values[index_s2]- ave_x) / std_x
    x3=(df.x.values[index_s3]- ave_x) / std_x
    x4=(df.x.values[index_s4]- ave_x) / std_x
    x5=(df.x.values[index_s5]- ave_x) / std_x
    x6= (df.x.values[index_s6]- ave_x) / std_x
    x7=(df.x.values[index_s7]- ave_x) / std_x
    x8= (df.x.values[index_s8]- ave_x) / std_x
    x9= (df.x.values[index_s9]- ave_x) / std_x
    x10= (df.x.values[index_s10]- ave_x) / std_x
    x=np.vstack((x1,x2,x3,x4,x5,x6,x7,x8,x9,x10)).T
    
     
    ave_y=np.array([np.average(df.y[i:i+10]) for i in range(0,len(df.y),10)])
    std_y=np.array([np.std(df.y[i:i+10]) for i in range(0,len(df.y),10)])
      
    y1=(df.y.values[index_s1]- ave_y) / std_y
    y2= (df.y.values[index_s2]- ave_y) / std_y
    y3=(df.y.values[index_s3]- ave_y) / std_y
    y4=(df.y.values[index_s4]- ave_y) / std_y
    y5=(df.y.values[index_s5]- ave_y) / std_y
    y6= (df.y.values[index_s6]- ave_y) / std_y
    y7=(df.y.values[index_s7]- ave_y) / std_y
    y8= (df.y.values[index_s8]- ave_y) / std_y
    y9= (df.y.values[index_s9]- ave_y) / std_y
    y10= (df.y.values[index_s10]- ave_y) / std_y
    y=np.vstack((y1,y2,y3,y4,y5,y6,y7,y8,y9,y10)).T
 
    ave_z=np.array([np.average(df.z[i:i+10]) for i in range(0,len(df.z),10)])
    std_z=np.array([np.std(df.z[i:i+10]) for i in range(0,len(df.z),10)])
   
    z1=(df.z.values[index_s1]- ave_z) / std_z
    z2= (df.z.values[index_s2]- ave_z) / std_z
    z3=(df.z.values[index_s3]- ave_z) / std_z
    z4=(df.z.values[index_s4]- ave_z) / std_z
    z5=(df.z.values[index_s5]- ave_z) / std_z
    z6= (df.z.values[index_s6]- ave_z) / std_z
    z7=(df.z.values[index_s7]- ave_z) / std_z
    z8= (df.z.values[index_s8]- ave_z) / std_z
    z9= (df.z.values[index_s9]- ave_z) / std_z
    z10=(df.z.values[index_s10]- ave_z) / std_z
    
    z=np.vstack((z1,z2,z3,z4,z5,z6,z7,z8,z9,z10)).T
    #計算した物を全て積み重ね、それぞれ１０この要素を合わせたn×４０の行列を作成します。
    d=np.hstack((x,y,z,c))
    
    return d



def to_one_hot(df):
    #解答のラベルが１−４の整数であるので、ワンホット表現に変換します。
    
    target_vector = [0,1,2,3]               # 整数をベクトルにします
    n_labels = len(np.unique(target_vector))  # 解答は 4種類です
    ind=np.eye(n_labels)[target_vector] 
    x=[]
    for i in df["label"]:
        if i ==1 :
            x.append(ind[0])
        elif i ==2:
            x.append(ind[1])
        elif i ==3:
            x.append(ind[2])
        elif i ==4:
            x.append(ind[3])
        else:
            x.append(np.zeros(4))#エラー対策でそれ以外はゼロの配列にします。
    df["one_hot"]=x
    
    v=np.zeros(4)
    for i in df.one_hot.values:
        v=np.vstack((v,i))

    vl = np.delete(v, 0, 0)
    return vl

#入力データはなぜかぴったりではなかったので３４７０こまでを取り出しています。
df_input_train=pd.read_csv("https://courses.edx.org/assets/courseware/v1/b98039c3648763aae4f153a6ed32f38b/asset-v1:HarvardX+PH526x+1T2020+type@asset+block/train_time_series.csv")[:3740]


#解答のラベルです
df_correct_train=pd.read_csv("https://courses.edx.org/assets/courseware/v1/d64e74647423e525bbeb13f2884e9cfa/asset-v1:HarvardX+PH526x+1T2020+type@asset+block/train_labels.csv", index_col=0)[:374]



input_data =   to_input(df_input_train)# 入力データを定義します
correct_data =to_one_hot(df_correct_train)  #  正解のラベルを定義します

input_train=input_data[0::2]#訓練データとテストデータに２分割させます。こちらは訓練データにします
correct_train=correct_data[0::2 ]#こちらは訓練データの解答となります
input_test=input_data[1::2]#訓練データとテストデータに２分割させます。こちらはテストデータにします
correct_test=correct_data[1::2]#こちらはテストデータの解答となります



n_data = len(correct_data) # サンプル数を定義します
n_train =len(input_train)
n_test =len(input_test)

#テストであるかどうかを判定します。
is_train=True

# -- 各設定値 --
n_in = 40 # 入力層のニューロン数（s：合成加速度１０＋x：x軸加速度１０＋y：y軸加速度１０z：z軸加速度１０＝合計４０です）
n_mid =25  # 中間層のニューロン数
n_out = 4  # 出力層のニューロン数

wb_width = 0.1  # 重みとバイアスの広がり具合
eta = 0.01  # 学習係数
epoch = 1000
batch_size = 10
interval = 100  # 経過の表示間隔

#以下の各層の実装は’はじめてのディープラーニング’著　我妻幸長　のIrisの品種分類の部分を参考にしています。
#文字数超えて書けず、ところどころ抜かして書きました。中間層活性化：ReLU、出力層活性化：ソフトマックス関数、損失関数：交差エントロピー誤差、最適化アルゴリズム：AdaGrad、ドロップ層：２層です。


#dropout層を追加
class Dropout:
    def __init__(self, dropout_ratio):
        self.dropout_ratio=dropout_ratio
        
    def forward(self,x,is_train):
        if is_train:
            rand=np.random.rand(*x.shape)
            self.dropout=np.where(rand>self.dropout_ratio,1,0)
            self.y=x*self.dropout
        else:
            self.y=(1-self.dropout_ratio)*x
            
    def backward(self,grad_y):

        self.grad_x=grad_y* self.dropout_ratio

#各層の初期化
middle_layer_1=MiddleLayer(n_in,n_mid)
dropout_1=Dropout(0.9)
middle_layer_2=MiddleLayer(n_mid,n_mid)
dropout_2=Dropout(0.5)
output_layer=OutputLayer(n_mid,n_out)

#順伝播
def forward_propagation(x,is_train):
    middle_layer_1.forward(x)
    dropout_1.forward(middle_layer_1.y,is_train)
    middle_layer_2.forward(dropout_1.y)
    dropout_2.forward(middle_layer_2.y,is_train)
    output_layer.forward(dropout_2.y)
#逆伝播
def backpropagation(t):
    output_layer.backward(t)
    dropout_2.backward(output_layer.grad_x)
    middle_layer_2.backward(dropout_2.grad_x)
    dropout_1.backward(middle_layer_2.grad_x)
    middle_layer_1.backward(dropout_1.grad_x)

# -- 重みとバイアスの更新 --
def uppdate_wb():
    middle_layer_1.update(eta)
    middle_layer_2.update(eta)
    output_layer.update(eta)

# -- 誤差を計算 --
def get_error(t, batch_size):
    return -np.sum(t * np.log(output_layer.y+ 1e-7)) / batch_size  # 交差エントロピー誤差



  # -- 学習 -- 
    index_random = np.arange(n_train)
    np.random.shuffle(index_random)  # インデックスをシャッフルする
    for j in range(n_batch):
        
        # ミニバッチを取り出す
        mb_index = index_random[j*batch_size : (j+1)*batch_size]
        x = input_train[mb_index, :]
        t = correct_train[mb_index, :]
        

        forward_propagation(x,is_train)
        backpropagation(t)
        
        # 重みとバイアスの更新
        uppdate_wb() 

        

試したこと

各層のニューロン数や重み、バッチ数の変更をしたり特徴を足し引きしたり、ドロップアウトの割合を変えたりとりあえず思いつくことはやってみたのですが、制度は６０パーセントを超えませんでした。出力層のyの値を見てみると最大の要素はインデックスの1に全て集まっておりargmaxを使った時に全て１になっていました。各層の実装は'はじめてのディープラーニング’著　我妻幸長　のIrisの品種分類の部分を参考に書いたためミスはないと思います。入力のデータの前処理がうまくいっていないのかと思うのですが原因がわかりません。

補足情報（FW/ツールのバージョンなど）

jupyter noteで動かしています。全く初心者で質問の際に何を書けばいいのかということもわかっておりませんので追加で必要な部分があればぜひそこも教えていただければと思います。

Answer 1

気になったところをコメントします。

まず。df_input_trainとdf_correct_trainをUTC timeでマージしたところ、マージした結果の最初の4件が1セットになっており、10件で1セットという質問に記載のルールに合わないデータが存在します。
まず、ここを考慮せずに単純にdf_input_trainの3470件を説明変数として用いてしまうと状態（x,y,z）とラベルの対応関係が整合しなくなってしまいます。マージしてから10件で1セットのデータを取り出す必要があると思います。

次に「#合成加速度を計算しn×10行列を作成します」としていますが、これだと運動量をうまく表現できると思うのですが、階段を下りるや階段を上るといった運動の向きはうまく表現できていないように思います。
せっかく3軸で加速度がデータとして入手できているのであれば、初期値（10件を一括りとしたときの1っ件目）から3軸方向にどのくらい移動したのかを計算して説明変数にしたほうがいいように感じます。うまく計算できれば、立つの場合は上方向へ大きく移動し、前後・左右はほぼ移動なしや歩くの場合は前後に大きく移動するが上下は移動なし、という感じに前処理でデータを作ることができれば、どんなモデルでもかなりの性能が出るような気がします。

Comments

[hidebonneidee]

ご解答いただきありがとうございます！データの数が合わず後ろを切ってしまっていましたが最初の４件が変だったのですね。。盲点でした、、ご指摘ありがとうございます。とても参考になります！加速度のデータを処理することに気を取られて時間変数を使うことを失念しておりました、初期値からの移動量というのも自分では絶対に思いつくことができなかったので本当にありがたいです。頂いたアドバイスを参考にもう少しチャレンジしてみようと思います。本当にありがとうございます。

Answer 2

各層のニューロン数や重み、バッチ数の変更をしたり特徴を足し引きしたり、ドロップアウトの割合を変えたりとりあえず思いつくことはやってみたのですが、制度は６０パーセントを超えませんでした。出力層のyの値を見てみると最大の要素はインデックスの1に全て集まっておりargmaxを使った時に全て１になっていました。各層の実装は'はじめてのディープラーニング’著　我妻幸長　のIrisの品種分類の部分を参考に書いたためミスはないと思います。入力のデータの前処理がうまくいっていないのかと思うのですが原因がわかりません。

iris は簡単な問題ですから、適当なモデルを使ってもほぼ100%の精度が出ます。
4クラスなので、完全にランダムに答えたら、25%になるはずですから、60%でも全然ダメということはないと思います。
iris と同じやり方で他のデータセットでも精度が出るということは言えないので、問題に応じて、前処理やモデルをいろいろ試す必要があります。
入力が数値データの場合、ディープラーニングがいいとも限らないので、他のモデル等も試してみてください。

追記

R.Shigemori さんのコメントをみて、マージして確認してみたところ、たしかに最初のサンプルだけ4時刻分しかないようなので、train_time_series.csv の4データとtrain_labels.csvの最初の1データを除いて、374個のサンプルデータにするべきみたいです。

データ読み込み

import pandas as pd

# CSV を読みこむ。
data = pd.read_csv("train_time_series.csv", skiprows=[1, 2, 3, 4])  # 最初の4行分のデータはスキップ
labels = pd.read_csv("train_labels.csv", skiprows=[1])  # 最初の1行分のデータはスキップ

n_samples = data.shape[0] // 10
X = data[["x", "y", "z"]].values.reshape(-1, 10, 3)
y = labels["label"].values.astype(int) - 1  # ラベルを 0 始まりにする
print(X.shape, y.shape)  # (374, 10, 3) (374,)

SVC の学習サンプル

from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler

# 学習データとテストデータに分割する。
X_flatten = X.reshape(len(X), -1)  # (374, 10, 3) -> (374, 30)
X_train, X_test, y_train, y_test = train_test_split(
    X_flatten, y, test_size=0.2, random_state=42
)

# SVM で学習する。
clf = make_pipeline(StandardScaler(), SVC(gamma="auto"))
clf.fit(X_train, y_train)

y_pred = clf.predict(X_test)
acc = accuracy_score(y_test, y_pred)
print(f"{acc:.2%}")  # 66.67%

サンプルを可視化した例

import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D

fig = plt.figure(figsize=(12, 10))

class_ids = np.unique(y)
class_names = ["立つ", "歩く", "階段を下る", "階段を登る"]
cols = 5

for i, class_id in enumerate(class_ids):
    some_samples = X[np.where(y == class_id)][:cols]
    for j, sample in enumerate(some_samples):
        ax = fig.add_subplot(4, cols, i * cols + j + 1, projection="3d")
        ax.plot(sample[:, 0], sample[:, 1], sample[:, 2])
        ax.set_title(class_names[class_id])

plt.show()

---

• 1つのサンプルが10時刻分の x, y, z なので、上記では潰して30次元にしてしまいましたが、時系列データとして扱えるモデルも試すといいかもしれません。
• 標準化やディープラーニングの学習など、ライブラリで代用できるものは独自実装ではなく、ライブラリを使ったほうがいいと思います。数値計算の実装でバグがあったりすると、見つけるのはなかなか大変です。

Comments

[hidebonneidee]

ご解答頂きありがとうございます。まだまだ勉強不足でSVMというものを知らず、wikiで読みました！こんな便利なものがあったのですね！！教えていただきましてありがとうございます！ライブラリを使えば書く量も減らせていいことだらけですね！reshapeの使い方等自分では全く思いつかなかった方法ばかりでとても参考になります。学習させるならディープラーニング ！と完全に視野が狭かったので、他のモデルも試してみようと思います！時刻データも他のデータの処理に気を取られていたのですが組み込んでみたいと思います！
色々なアドバイスをいただきまして本当にありがとうございます。

[tiitoi]

R.Shigemori さんがご指摘くださってるように最初のサンプルだけ4時刻しかないようですね
その点だけ回答のコードを修正しました。可視化サンプルも追加しました。
モデルより、既存の特徴量から新しい特徴量を作る前処理が重要になってきそうですね。

[hidebonneidee]

tiitoiさま、追加でコメント&編集いただきまして本当にありがとうございます！可視化いただきとても分かりやすくなりました！やはり時間を使った新しい特徴量を作るのが良さそうですね。。本当にありがとうございます、とても参考になりました！