Boost.Python を使って、Python から C/C++ の関数を呼び出しを、OSX でトライしたときの記録です。Python3 前提です。

OSX で Boost.Python を使う方法がうまく見つけられなかったので、記録として残しておきます。どれくらい需要があるかはナゾですが、、

情報はすべて 2020/07 現在のものです。（Python3.8）

手順

1. Boost.Python のインストール

Python3 版は boost-python3 という Formula になります。

brew install boost-python3

2. C/C++ コードのコンパイル

例えば、C++ ライブラリとして以下のようなコードを用意します。

my_sample.cpp

#include <string>
#include <boost/python.hpp>
using namespace std;

string add_hello( const string s )
{
    return "Hello, " + s;
}

// モジュールの初期化ルーチン:モジュール名=my_sample
BOOST_PYTHON_MODULE( my_sample )
{
    // C++のadd_hello関数を、greetという名前でpython用に公開
    boost::python::def( "greet", add_hello );
}

コンパイルのためのコマンドは下記になります。

g++ -shared -fPIC -I/usr/local/include -L/usr/local/lib \
    $(python3-config --includes --ldflags --embed) -lboost_python38 \
    my_sample.cpp -o my_sample.so

これで、Python からは my_sample.so を import my_sample として呼び出すことができるようになります。

3. Python からの呼び出し

import my_sample

print(my_sample.greet("hoge"))  # "Hello, hoge"

補足

私がトライしたときは、コンパイラは brew で入る g++-10 ではうまく行かず、XCode 付属の g++ でうまくいきました。C++ 標準が違う、みたいな警告が出てたので、boost_phthon38 が g++ でコンパイルされているから、ということでしょうか。

参考資料

• boost-python3 Formula のテストコード。ここの処理内容をみてようやく、OSX でのコンパイル方法がわかりました。

はじめに

こんにちは。Qiita初登校・エンジニア転職を目指し勉強中のものです。
プログラミングに初めて触れた、深層学習の勉強をまともに始めたのが今年の一月というかなりの初心者でございます。
学習のアウトプット発信の一環として本記事を発信させていただきます。
至らぬ点等ございますでしょうが、どうか暖かくご指摘・コメントを頂ければ幸いです。

環境

・Windows 10 Home 1909
・anaconda 2020.02
・python 3.7.6
・keras 2.3.1
・tslearn 0.4.1

目的

本記事では、GPSと取得時間のデータを用いて、道路状況を解析・予測をすることを目的とします。
解析・予測する道路状態は、「渋滞」についてです。

実施手順

1、リカレントネットワークを用いてGPS情報から次の時間の時速を予測するモデルを作成する。
作成したモデルから得られた予測値と実測値を比較し、誤差の大きい箇所を異常データ、小さい箇所を通常データとする。

2、tslearnを用いて時系列データのクラスタリングをする。
　 通常データと異常データそれぞれに対しクラスタリングを行い、分析・要因調査を行う。

3、kapler.glを用いて結果の可視化を行う。

※tslearnとはk-means法を用いて時系列クラスタリングをすることを目的としたpythonパッケージのこと
　参考：https://irukanobox.blogspot.com/2019/05/python.html?m=0

※kapler.glとはコードを全く使わずに位置情報データを可視化することができるウェブサービスのこと
　参考：https://note.com/kazukio/n/n3407e34d2985

それでは以下より、実施手順の詳細に入りたいと思います。

1. データの確認・前処理

今回はkaggle内にあるデータセット：Transjakarta Bus GPS Data( https://www.kaggle.com/rasyidstat/transjakarta-bus-gps-data )を用いて学習を行います。
2019年11月26日の14時から18時の間に走行したバスのGPSを30秒毎に取得したデータのようです。

なにはともあれ、データの中身を確認していきます。

gps_data = pd.read_csv('transjakarta_gps.csv')
gps_data.head()

bus_codeやtrip_idなどの位置情報に関係がなさそうな情報が多く含まれています。
他の情報はさておき、bus_codeとtrip_idが変化したタイミングではデータの連続性が危ぶまれそうです。

次に欠損値の確認を行います

print(len(gps_data))
print(gps_data.isnull().sum())

経度と緯度の情報がしっかり入っているため特に問題はなさそうです。

以下、numpy配列にし、時間変化・変位・時速の情報を追加していきます。

#np.arrayの配列を作成
bus_trip_gps = gps_data[["bus_code", "trip_id","gps_datetime", "longitude", "latitude"]]
bus_gps = bus_trip_gps.values

#距離の変位を調査する
bus_gps_plus = np.vstack((np.zeros(2).reshape(1,2), bus_gps[:, 3:5]))
bus_gps_minus = np.vstack((bus_gps[:, 3:5], np.zeros(2).reshape(1,2)))
delta_bus_gps = bus_gps_plus - bus_gps_minus

delta_bus_gps = delta_bus_gps[1:,:]

#直感的に異常値に気付けるように単位をkmにする
delta_bus_gps*=110.94297

#距離のデータを作成
delta_distans = (np.square(delta_bus_gps[:,0:1]) + np.square(delta_bus_gps[:, 1:2]))**0.5

#時間の変化のデータを作成
bus_time_minus = pd.to_datetime(bus_gps[:-1,2:3].reshape(-1))
bus_time_plus = pd.to_datetime(bus_gps[1:,2:3].reshape(-1))
delta_time_gps = bus_time_plus - bus_time_minus
delta_time_gps = delta_time_gps/np.timedelta64(1,'s')
delta_time_gps = np.array(delta_time_gps, dtype='float')
delta_time_gps = np.append(delta_time_gps,0)
delta_time_gps = delta_time_gps.reshape(len(delta_time_gps),1)

#変化量、速度を時速になおす
delta_bus_gps /= (delta_time_gps + 1e-8)/(60*60)
delta_distans /= (delta_time_gps + 1e-8)/(60*60)

#bus_gpsに変位と距離を追加する
bus_gps = np.insert(bus_gps,[5] , delta_bus_gps, axis=1)
bus_gps = np.insert(bus_gps,[7] , delta_distans, axis=1)
bus_gps = np.insert(bus_gps,[3] , delta_time_gps, axis=1)

では、時系列データの作成に取り掛かります。今回は、５つ連続するデータ（約150秒）で一つの時系列データとしました。
また、trip_idとbun_codeの変化が起きたときにデータの連続性が危ぶまれるため、その変化点で違う時系列データとして扱うように処理しています。

#5回の測定で一回の時系列データとする
#bus_codeとtrip_idで別々の時系列のデータとなるようにする。

gps_input_data=[]
gps_correct_data =[]

len_sequence = 5             # 時系列の長さ

bus_gps[:,0:2] = bus_gps[:,0:2].astype(np.str)
bus_code_list = np.unique(bus_gps[:,0:1])

for i in range(len(bus_code_list)): 
    bus_code = bus_code_list[i]
    bus_code_gps = bus_gps[np.any(bus_gps==bus_code,axis=1)]

    trip_id_list =np.unique(bus_code_gps[:,1:2])

    if i%100 == 0:
        print(i)

    for j in range(len(trip_id_list)):    
        trip_id =  trip_id_list[j]
        trip_id_gps = bus_code_gps[np.any(bus_code_gps[:,1:2]==str(trip_id),axis=1)]

        if len(trip_id_gps)>(len_sequence+2):
            for k in range(len(trip_id_gps)-(len_sequence+2)):
                gps_input_data.append(trip_id_gps[k:k+len_sequence,2:])
                gps_correct_data.append(trip_id_gps[k+len_sequence:k+(len_sequence+1),2:].reshape(7))


#インプット用のデータ                
#axis0 データ、axis1 同一データ内の時系列位置 axis2 時間、時間変化、緯度,経度,緯度方向変位(km),経度方向変位(km),時速(km/h)
gps_input_data=np.array(gps_input_data) 

#正解用のデータ
#axis0 データ、axis1 時間、時間変化、緯度,経度,緯度方向変位(km),経度方向変位(km),時速(km/h)
gps_correct_data =np.array(gps_correct_data)

これでモデルにインプットする用のデータ、正解用のデータが作成できました。

2. 異常値の削除

異常値の削除を行っていきます。削除するデータは以下の三つです。

1、時速が150km/hを超えているもの
2、時系列内で移動がほとんどないもの
3、データをおおよそ30秒毎に取得できていないもの

以下実行コードです。

#異常な値の削除
#正解の時速が150kmを超えているものを異常とみなす

high_distans_index0 = np.where(gps_input_data[:,:,-1]>150)
high_distans_index0 = high_distans_index0[0]

high_distans_index1 = np.where(gps_correct_data[:,-1]>150)
high_distans_index1 = high_distans_index1[0]

error_data_index=np.concatenate([high_distans_index0, high_distans_index1])
error_data_index=np.unique(error_data_index)

gps_input_data = np.delete(gps_input_data,error_data_index,axis=0)
gps_correct_data = np.delete(gps_correct_data,error_data_index,axis=0)

#データの時系列内での（1個目と5個目）移動距離が0.01km以下のものを異常とする

index_destans0 = np.where(((gps_input_data[:,:,4].sum(axis=1)**2 + gps_input_data[:,:,5].sum(axis=1)**2)**0.5) < 0.01)
index_destans0 = np.array(index_destans0)
index_destans0 = index_destans0.reshape(-1)

gps_input_data = np.delete(gps_input_data,index_destans0,axis=0)
gps_correct_data = np.delete(gps_correct_data,index_destans0,axis=0)

#時間の変位が25より小さい,35より大きいデータを異常とみなす

index_time_short0 = np.where(gps_input_data[:,:,1]<25)
index_time_short0 = index_time_short0[0]
index_time_short1 = np.where(gps_correct_data[:,1]<25)
index_time_short1 = index_time_short1[0]
index_time_short = np.concatenate([index_time_short0, index_time_short1])

index_time_long0 = np.where(gps_input_data[:,:,1]>35)
index_time_long0 = index_time_long0[0]
index_time_long1 = np.where(gps_correct_data[:,1]>35)
index_time_long1 = index_time_long1[0]
index_time_long = np.concatenate([index_time_long0, index_time_long1])

index_time_error = np.concatenate([index_time_long, index_time_short])
index_time_error = np.unique(index_time_error)

gps_input_data = np.delete(gps_input_data,index_time_error,axis=0)
gps_correct_data = np.delete(gps_correct_data,index_time_error,axis=0)

3. LSTM(keras)を用いた速度の予測モデルの作成

リカレントネットワークの作成に入る前に、データの分割を行います。
以下の三つにデータを分割します。

・学習用：ネットワークの学習に用いる。
・評価用：ネットワークの評価に用いる。過学習していないか、表現力が足りているかどうか等の判断材料にする。
・プロット用：学習後のモデルに対し、誤差を測定するデータに用いる。

各地点毎の標準的な速度をモデルに学習させるために、使用するデータは以下を用いることにしました。
・時間変化
・緯度 / 経度
・緯度経度から求めた速度

#データ分割用のインデックスの準備
np.random.seed(0)
all_data_number = len(gps_correct_data)
data_index =np.arange(all_data_number)
np.random.shuffle(data_index)

#時速データの準備
X = gps_input_data[:,:,(1,2,3,6)]
t = gps_correct_data[:,(1,2,3,6)]

#正規化
for i in range(len(t[0,:])):
    Xt_min = np.min((X[:,:,i].min(), t[:,i].min()))
    Xt_max = np.max((X[:,:,i].max(), t[:,i].max()))
    X[:,:,i] = (X[:,:,i]-Xt_min)/Xt_max
    t[:,i] = (t[:,i]-Xt_min)/Xt_max

#データの分割
train_data_number =(all_data_number*3)//5
plot_data_number = (all_data_number*1)//5

X_train = X[data_index[:train_data_number],:,:]
t_train = t[data_index[:train_data_number]]

X_test = X[data_index[train_data_number:(-plot_data_number)],:,:]
t_test = t[data_index[train_data_number:(-plot_data_number)]]

X_plot = X[data_index[(-plot_data_number):],:,:]
t_plot = t[data_index[(-plot_data_number):]]

それではモデルの構築に入ります。モデルの構築にはkerasを使用します。
使用するリカレント層はLSTMを使用し、リカレントドロップアウトを使用します。
誤差関数は、単純な回帰ということもあり、今回は直感的に誤差の速度を把握しやすい平均絶対誤差（mae）を使用します。

input_dim = 4                 # 入力データの次元数
output_dim = 1                # 出力データの次元数
num_hidden_units_1 = 64       # 隠れ層1のユニット数
num_hidden_units_2 = 32       # 隠れ層2のユニット数
batch_size = 1000             # ミニバッチサイズ
num_of_training_epochs = 200  # 学習エポック数

model = Sequential()
model.add(LSTM(num_hidden_units_1,
              input_shape=(len_sequence,input_dim),
              return_sequences = True,
              recurrent_dropout = 0.5))
model.add(LSTM(num_hidden_units_2,
              recurrent_dropout = 0.3))
model.add(Dense(output_dim))
model.compile(loss="mae", 
              optimizer=RMSprop())
model.summary()

それではモデルの学習を開始しましょう。

#モデルの学習
history=model.fit(X_train,
                  t_train[:,-1],
                  epochs=num_of_training_epochs,
                  batch_size=batch_size,
                  validation_data=(X_test,t_test[:,-1]))
#学習結果の可視化
plt.plot(range(num_of_training_epochs),history.history["loss"], 'bo',color='red', label='Training loss',markersize=3)
plt.plot(range(num_of_training_epochs),history.history["val_loss"], 'b',color='blue', label='Validation loss')
plt.title('Training and Validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss function')
plt.legend()

plt.show()

残念ながら結果だけ見ても学習結果が良いかどうか検討もつきません。
そこで仮想的に常識的なベースラインを設定しモデルの優位性を証明することにしました。

#時系列内で最後の一つ前から最後のデータの加速度が一定であると想定したときの平均絶対誤差(mae)を計算する
#ただしデータ取得の間隔が一定であると仮定する

batch_maes = []
for i in range(len(X_test)//batch_size):
    preds = X_test[i*batch_size:(i+1)*batch_size,-1,-1]*2 -X_test[i*batch_size:(i+1)*batch_size,-2,-1]
    terget = t_test[i*batch_size:(i+1)*batch_size,-1]
    mae = np.mean(np.abs(preds-terget))
    batch_maes.append(mae)

standard_mae = np.mean(batch_maes)
print("平均絶対誤差（正規化）：" + str(standard_mae)) #平均絶対誤差（正規化）：0.083268486903678
print("平均絶対誤差 （km/h） ：" + str(standard_mae * Xt_max)) #平均絶対誤差 （km/h） ：11.597705343596475

計算した常識的なベースラインの平均絶対誤差は0.0837となりました。
一方、モデルの損失関数の値は0.0461に収束しており、モデルの優位性を証明することができました。

それではプロット用のデータをモデルに読みこみ、予測値から各地点の誤差を取得したいと思います。
その後データを正常データと異常データに分けます。

plot_predict = model.predict(X_plot, batch_size=1)

#予測した値とy_plotとの絶対誤差を計算する
plot_predict_mae=np.abs(plot_predict[:,0]-t_plot[:,-1])

#plot用の絶対誤差と常識的な基準として作成した平均絶対誤差を比較する
#plot用の絶対誤差 < 常識的な平均絶対誤差 となるデータを正常とする
#plot用の絶対誤差 > 常識的な平均絶対誤差 となるデータを異常とする
clustering_normaly_gps = X_plot[np.where(plot_data[:,-1]<standard_mae)[0],:,-1]
clustering_anormaly_gps = X_plot[np.where(plot_data[:,-1]>standard_mae)[0],:,-1]

4. tslearnを用いた時系列データのクラスタリング

では、小さいデータ（正常データ）、誤差が大きいデータ（異常データ）それぞれに対してクラスタリングをしていきます。

今回使うデータでは時間軸に対してある程度ズレがあっても同じパターンとして認識してくれるように、
距離関数にはDynamic Time Wrapping(DTW)を用いるつもりでした。
しかし、計算コストがあまりに高いためユークリッド距離を用いることにします。
データの時系列が5つしかないため、さして問題はないと判断いたしました。

クラスタリングのクラスター数を確からしさを求めるために、シルエット値を利用します。
シルエット値とはクラスタリングが正しくできているかの指標です。
シルエット値は0から1の値を取り、１に近づけば同一クラスター内の距離がそれだけ近くなります。
クラスター数が2から50までのシルエット値を取得していきます。

# クラスタリングに用いるデータ数
clustering_data_normalnumber = 10000

#データ分割用のインデックスの準備
np.random.seed(0)
normaly_data_number = len(clustering_normaly_gps)
normaly_data_index = np.arange(normaly_data_number)
np.random.shuffle(normaly_data_index)
anormaly_data_number = len(clustering_anormaly_gps)
anormaly_data_index = np.arange(anormaly_data_number)
np.random.shuffle(anormaly_data_index)

#時速データの準備
normaly_ts_dataset = clustering_normaly_gps[normaly_data_index[:clustering_data_number],:]
anormaly_ts_dataset = clustering_anormaly_gps[anormaly_data_index[:clustering_data_number],:]

#データの保存
silhouette_normaly_data = []
km_normaly_labels = []
km_normaly_center = []
silhouette_anormaly_data = []
km_anormaly_labels = []
km_anormaly_center = []

#クラスタリングの実行
metric = 'euclidean'
n_clusters = [n for n in range(2, 50)]

print("正常値のクラスタリング")
for n in n_clusters: 
    km= TimeSeriesKMeans(n_clusters=n, metric=metric, verbose=False, random_state=1).fit(normaly_ts_dataset)
    print('クラスター数 ='+ str(n) + 'シルエット値 ='+ str(silhouette_score(normaly_ts_dataset, km.labels_, metric=metric)))
    silhouette_normaly_data.append(np.array([n, silhouette_score(normaly_ts_dataset, km.labels_, metric=metric)]))
    km_normaly_labels.append([n, km.labels_])
    km_normaly_center.append([n, km.cluster_centers_])

print("異常値のクラスタリング")
for n in n_clusters: 
    km= TimeSeriesKMeans(n_clusters=n, metric=metric, verbose=False, random_state=1).fit(anormaly_ts_dataset)
    print('クラスター数 ='+ str(n) + 'シルエット値 ='+ str(silhouette_score(anormaly_ts_dataset, km.labels_, metric=metric)))
    silhouette_anormaly_data.append(np.array([n, silhouette_score(anormaly_ts_dataset, km.labels_, metric=metric)]))
    km_anormaly_labels.append([n, km.labels_])
    km_anormaly_center.append([n, km.cluster_centers_])

結果を可視化すると以下のようになりました。

正常・異常データともにクラスター数が2の時シルエット値が最大になり、徐々に減少していきます。
異常データのシルエット値が正常データに比べ低いのは、速度の予測がしづらい＝時系列内でデータに整合性がないからでしょうか。

とりあえずクラスター数＝2の時のクラスタリングの結果を見てみましょう。
こちらが正常のデータの中心を取ったグラフ(n=2)

こちらがクラスター毎の実データです（計１００個）

・・・これはクラスタリングできているのでしょうか。
直感的に「渋滞時のデータ」と「正常時のデータ」となればうれしいのですが、そうはならない様子。

ちなみにこちらが異常のデータの中心を取ったグラフ（n=2)

正常のデータと若干波形が違います。これは単なる渋滞の位置ではなく渋滞の終わりの位置とを示しているのかもしれません。

n=2ではシルエット値は最大となるのですが道路状態を分割できるほどクラスタリングしていないため、
それらしくクラスタリングできているnの中で最大となる値を採用することにしました。
正常のデータではn=10、異常のデータではn=12より大きくなる際にシルエット値に解離が大きく見られたためその値を採用します。

正常データ(n=10)の各データの中心

n=2 渋滞の入り口
n=3 渋滞
n=7 渋滞の出口
となっているようです。実データを見ても把握することができます。

異常データ(n=12)の各データの中心

n=2 渋滞の入り口
n=7 渋滞
n=4 渋滞の出口
となっています。
（正常データと同様に実データを見てもそうなっている、今回は割愛）

これらをcsvに出力し、kepler.glに入れれる形にします。

#gps_correct_dataからプロット用のデータを作成
gps_plot_data = gps_correct_data[data_index[(-plot_data_number):],:]
plot_data=np.concatenate([gps_plot_data,plot_predict_mae.reshape(len(plot_predict_mae),1)], axis=1)
plot_data=plot_data[:,(0,2,3,7)]

plot_normaly_gps = plot_data[np.where(plot_data[:,-1]<standard_mae)[0],:]
plot_anormaly_gps = plot_data[np.where(plot_data[:,-1]>standard_mae)[0],:]

#normal用データ作成
n_cluster = 10
lavel = 2

km_labels = km_normaly_labels[n_cluster-2][1]#
normaly_plot_data = plot_normaly_gps[normaly_data_index[:clustering_data_number],:]#
normaly_plot_data_label = normaly_plot_data[np.where(km_labels.reshape(clustering_data_number,1)==lavel)[0],:]#
df_normaly_plot_lavel = pd.DataFrame(normaly_plot_data_label0, columns=['gps_datetime', 'longitude', 'latitude', 'error'])
df_normaly_plot_lavel.to_csv('normaly_plot_lavel='+str(lavel)+'(渋滞の入り口).csv')

5. kepler.glを用いたデータの可視化

それではデータの可視化を行います。
渋滞のデータを時間毎にプロットしたものが下になります。

・水色のデータ：予測に使用した全データ
・黄色のデータ：正常・異常、入口・出口問わずクラスタリングにて渋滞と判断された全データ

少々荒いですが、時間ごとにどこで渋滞が起きているのかを把握することができます。
予測に使用した全データを同時にプロットすることにより、黄色の面積が少ない箇所は「データの取得率が単純に少ないのでは？」と指摘される心配がなくなります。
これにより、渋滞の度合いをより直感的に把握してもいい画面ということが保証されました。

どうやら都市部を中心に渋滞が起きているようです。一方で都市部から少し離れれば快適な運転が可能なことがうかがえます。

では、渋滞の入り口と出口の違いを見てみましょう。
・薄い水色のデータ：正常・異常の渋滞データ
・黄色のデータ：正常・異常の渋滞入口データ
・緑色のデータ：正常・異常の渋滞出口データ

ぼんやりとデータを眺めていると、はじめは渋滞出口データが多く、渋滞がおだやかに緩和されていることが分かります。
しかし、徐々に渋滞入口データが多くなったと思ったら、あっという間に渋滞の箇所がとても多くなってしまいました。

このことから、渋滞入口データと渋滞出口データは大きな範囲での道路状態を予測するのに役立つ情報になる可能性が分かります。
渋滞のまわりに渋滞の入口が発生するのではなく、渋滞の入口があつまっていつのまにか渋滞が発生しているようなので、
渋滞入口・出口の情報のみでは、ピンポイントでこの場所が渋滞になる、という予測は難しそうです。

最後に正常・異常データの比較を行いましょう。
プロットデータ：正常・異常の渋滞・渋滞入口・渋滞出口のデータ
縦軸・色：モデルでの予測値との誤差

一方こちらは渋滞とそうでないところの境い目で誤差が大きくなっているようです。
誤差が大きくなっている境界で、いつも間にか渋滞に発生したり渋滞が緩和されたりしています。

この情報を用いれば次に渋滞の発生・緩和される個所の場所をある程度絞ることができそうです。

結果

速度予測のモデルとクラスタリングを用いいることによって以下のことを把握できました。
　現状：渋滞の位置
　予測：今後渋滞が緩和されるか、渋滞が発生するか。どの場所でそれが起こりうるか
　

今後の課題・反省点

全体の進め方の反省

データ分析をする際に目的が不明確なまま開始してしまった。
特に、速度予測モデルに関しては「こんなことできたら面白いな」という興味本位で取り組んでしまった。

データの選択について

結果的に渋滞を予測することとなったが、今回のデータではバス停で止まっているのか渋滞で遅延しておるのか判断をすることができない。
また、予測した速度もおそらく実際の速度とは解離があり、もっとデータ取得間隔の短いデータを用いるか、
地図と位置をリンクさせ、経路を予想したうえで速度を予測するべきであった。

モデルについて

学習・予測の際にデータ取得位置の情報も入れるべきかの判断を正しく行えなかった。
位置を入れることで地点毎に道路状態を学習させるというと聞こえはいいが、
誤差が高くなってほしい箇所（渋滞の境い目など）を学習し、誤差が不必要に低くなるリスクがあることを考慮できなかった。

クラスタリングについて

結果的にユークリッド距離を使用したため、わざわざ tslearn を使用した意味がなくなってしまった。
また、正常データ・異常データ別々にクラスタリングしたが、今回の解析ではプロットデータのクラスタリングを行うのみで十分であった。

ここまでご覧くださりありがとうございました。
まだまだ学ぶことが多いことを改めて思い知らされました。
これからも日々勉強を続けていきたいと思います。

以上。

「PyAutoItをちょっとだけ触ってみた」では、PyAutoItについて簡単な記事を投稿しました。

今回はAutoItとPyAutoItの違いについて触れたいと思います。

はじめに

PyAutoItは以前の記事で紹介した通り、AutoItをラップしたものとなっています。
そのためAutoItとメソッドの多くはPyAutoItでも共通しています。
しかしそのまま使えるわけではないので注意してください。

参考までにAutoItのメソッドについて参考リンクを貼っておきます。

Function Refarence：https://open-shelf.appspot.com/AutoIt3.3.6.1j/html/functions.htm
AutoItで使用可能な関数の一覧が見られます。

AutoItとPyAutoItでの関数の違い

実際に同じ処理をそれぞれのルールに沿ってプログラミングをしてみたいと思います。

例として、下記のシナリオをそれぞれの書き方で記述してみます。
1. メモ帳を開く
2. "Hello World!"と入力する
3. 保存せずにメモ帳を閉じる

AutoIt

AutoIt

Run("notepad.exe")    'メモ帳の起動
WinWaitActive("[CLASS:Notepad]")    'メモ帳が開くまで待機
ControlSend("[CLASS:Notepad]", "", "Edit1", "hello world!")    'hello world! と入力する
WinClose ("[CLASS:Notepad]")    'メモ帳を閉じる
ControlClick ( "メモ帳", "いいえ(&N)", "Button2")    '保存せずに終了する

PyAutoIt

PyAutoIt

import autoit

autoit.run("notepad.exe")    #メモ帳の起動
autoit.win_wait_active("[CLASS:Notepad]", 3)    #メモ帳が開くまで待機
autoit.control_send("[CLASS:Notepad]", "Edit1", "hello world{!}")   #hello world! と入力する
autoit.win_close("[CLASS:Notepad]")   #メモ帳を閉じる
autoit.control_click("[Class:#32770]", "Button2")   #保存せずに終了する

比較

AutoItとPyAutoItを比較してみました。

操作内容	AutoIt	PyAutoIt	比較
起動	Run("notepad.exe")	autoit.run("notepad.exe")	大きな違いはありませんね
表示待機	WinWaitActive("[CLASS:Notepad]")	autoit.win_wait_active("[CLASS:Notepad]", 3)	引数の数が違います
文字入力	ControlSend("[CLASS:Notepad]", "", "Edit1", "hello world!")	autoit.control_send("[CLASS:Notepad]", "Edit1", "hello world{!}")	内容はほぼ同じですが、ちょっと違いますね
終了	WinClose ("[CLASS:Notepad]")	autoit.win_close("[CLASS:Notepad]")	内容はほぼ同じですが、ちょっと違いますね
ボタン操作	ControlClick ( "メモ帳", "いいえ(&N)", "Button2")	autoit.control_click("[Class:#32770]", "Button2")	引数も内容も少々違います

それぞれの違いについて

比較をした表を見ると、以下のことが分かりました。

• 関数の記述方法が違う
  pyAutoItでは、[ _ ]で関数名が分かれています。
  AutoItだと「winClose」でもPyAutoItでは「Win_Close」となっているようです。

• 引数の数が違う
  WinWaitActive , Win_Wait_Active　でそれぞで引数が違います。
  なぜ違うのかは正直分かりません。

• プロパティの定義が少し違う
  関数内で指定するプロパティがAutoItとPyAutoItでは異なります。
  何が違うのか、その法則性が分からずにいます。

終わりに

AutoIt　と　PyAutoIt
使える関数はほぼ共通していますが、使い方が微妙に異なるため、
AutoItの関数一覧を見ても、そのまま適用することが出来ない場合が多いです。

また、PyAutoItの関数についてまとめられているサイトや記事は私が探した限り見つからず、
正直手探りで使っていくしかないのが現状です。

だれかにまとめを作ってほしいのが正直な気持ちです...

テンプレートに値を渡す方法

下記のように辞書形式で渡す。

return TemplateResponse(request, '*****.html',
                        {"変数名": 変数})

引数をhtml内で使用する方法

下記のように記載すれば変数と同様に扱える。

<h1>{{ 変数名 }}</h1>

モデル等複数要素で構成されていれば、下記のように記載すれば同様に変数として扱える。

<h1>{{ 変数名.要素名 }}</h1>

はじめに

GoogleColaboratoryからyoutube-dlを利用する方法について書きます。
動画と音声を別々でDLします。

なんでColab使うの

GoogleDriveに直接保存するのが簡単だからです。
SSDを圧迫したくないPCから実行したかったんです。

コード

youtube-dlインストール

Colabで新規ファイルを作成したら、まずはyoutube-dlをインストールします
"!"を先頭につけることで、コマンドプロンプトと同じコマンドが使えます。

!pip install youtube-dl

このコマンドはColabを開くたびに1度だけ実行しないといけません。
どうやらそうしなくてもいい方法もあるようなのですが、私は試してもできませんでした……。

Driveマウント

次にGoogleDriveをマウントします。
このノートブックに自分のDriveを使ってもいいよと許可するイメージです。

ytdlbest.py

from google.colab import drive
drive.mount('/content/drive')

これを実行するとURLを提示されるので、そこにアクセスして色々許可します。
すると文字列が提示されるので、それをコピーしてColabに戻り、コードの下の入力欄に入力すればマウント完了です。

動画(音声なし)のダウンロード

マイドライブ(Driveのトップのフォルダ)の下にprojectsフォルダを作成していることを前提とします。

ytdlbest.py

def videodl(url:str):
    vdl_opts = {'outtmpl':'/content/drive/My Drive/projects/%(title)s_video.%(ext)s','format':'bestvideo'}

    vdl = youtube_dl.YoutubeDL(vdl_opts)
    vdl.extract_info(url,download=True)

youtube-dlのディレクトリ指定は、outtmpl オプションから行います。
このオプションは保存するファイルの名前を指定するものですが、保存先の指定にも使えます。

更にフォーマットをbestvideo にすることで、最も画質の高い動画をDLできます。

音声のダウンロード

マイドライブ(Driveのトップのフォルダ)の下にprojectsフォルダを作成していることを前提とします。

ytdlbest.py

def audiodl(url:str):
    adl_opts = {'outtmpl':'/content/drive/My Drive/projects/%(title)s_audio.%(ext)s', 'format':'bestaudio/best'}

    adl = youtube_dl.YoutubeDL(adl_opts)
    adl.extract_info(url, download=True)

動画の場合と同様です。

本来音声のみのDLはffmpegのインストールが必要なのですが、GoogleColaboratoryにはデフォルトで入っているようなので、このままで通ります。
Colab素晴らしいですね。

実行

ytdlbest.py

def main():
    url = "https://www.youtube.com/watch?v=hogehoge"

    videodl(url)
    audiodl(url)
    print("DL完了")

if __name__ == "__main__":
    main()

url = 以下にYoutubeのURLを貼り付けてください。
そしたら実行できます。お疲れさまでした。

その他

動画と音声をくっつけたいなら、

How to get information from youtube-dl in python ??
https://stackoverflow.com/questions/23727943/how-to-get-information-from-youtube-dl-in-python

このあたりを参考に保存する動画/音声のファイル名を取得して、ffmpegで合成すれば出来ると思います。

はじめに

GoogleColaboratoryからyoutube-dlを利用する方法について書きます。
動画と音声を別々でDLします。

なんでColab使うの

GoogleDriveに直接保存するのが簡単だからです。
SSDの小さいPCから実行したかったんです。

コード

youtube-dlインストール

Colabで新規ファイルを作成したら、まずはyoutube-dlをインストールします
"!"を先頭につけることで、コマンドプロンプトと同じコマンドが使えます。

!pip install youtube-dl

このコマンドはColabを開くたびに1度だけ実行しないといけません。

Driveマウント

次にGoogleDriveをマウントします。
このノートブックに自分のDriveを使ってもいいよと許可するイメージです。

ytdlbest.py

from google.colab import drive
drive.mount('/content/drive')

これを実行するとURLを提示されるので、そこにアクセスして色々許可します。
すると文字列が提示されるので、それをコピーしてColabに戻り、コードの下の入力欄に入力すればマウント完了です。

動画(音声なし)のダウンロード

マイドライブ(Driveのトップのフォルダ)の下にprojectsフォルダを作成していることを前提とします。

ytdlbest.py

def videodl(url:str):
    vdl_opts = {'outtmpl':'/content/drive/My Drive/projects/%(title)s_video.%(ext)s','format':'bestvideo'}

    vdl = youtube_dl.YoutubeDL(vdl_opts)
    vdl.extract_info(url,download=True)

youtube-dlのディレクトリ指定は、outtmpl オプションから行います。
このオプションは保存するファイルの名前を指定するものですが、保存先の指定にも使えます。

更にフォーマットをbestvideo にすることで、最も画質の高い動画をDLできます。

音声のダウンロード

マイドライブ(Driveのトップのフォルダ)の下にprojectsフォルダを作成していることを前提とします。

ytdlbest.py

def audiodl(url:str):
    adl_opts = {'outtmpl':'/content/drive/My Drive/projects/%(title)s_audio.%(ext)s', 'format':'bestaudio/best'}

    adl = youtube_dl.YoutubeDL(adl_opts)
    adl.extract_info(url, download=True)

動画の場合と同様です。

本来音声のみのDLはffmpegのインストールが必要なのですが、GoogleColaboratoryにはデフォルトで入っているようなので、このままで通ります。
Colab素晴らしいですね。

実行

ytdlbest.py

def main():
    url = "https://www.youtube.com/watch?v=hogehoge"

    videodl(url)
    audiodl(url)
    print("DL完了")

if __name__ == "__main__":
    main()

url = 以下にYoutubeのURLを貼り付けてください。
そしたら実行できます。お疲れさまでした。

その他

動画と音声をくっつけたいなら、

How to get information from youtube-dl in python ??
https://stackoverflow.com/questions/23727943/how-to-get-information-from-youtube-dl-in-python

このあたりを参考に保存する動画/音声のファイル名を取得して、ffmpegで合成すれば出来ると思います。

概要

【Python】LINEからYoutubeの曲や動画を落としたい1/3
【Python】LINEからYoutubeの曲や動画を落としたい2/3

LINEへの返答、GoogleDriveへのアップロード部分の作成

前回では、youtubeやsoundcloud、ニコニコ動画に対応するダウンローダーのプログラムを作成しました。
今回はyoutube-dlを使い実際にLINEに応答を返したりGoogleDriveへアップロードする部分を作成します。

まず、始める前にGoogleDriveへアップロードできるか確認しておきましょう。

GoogleDriveへのアップロードができるか確認する(手順は大きく3つ)

①GoogleDriveで共有のフォルダを一つ作成する。
GoogleDrive上で右クリック → 新しいフォルダ → 名前を入力 → 名前を付けたフォルダを右クリック →
共有可能なリンクを取得 → [制限付き▼]をクリック → リンクを知っている全員に変えておく。
※ここを変えておかないと、LINEから直接音楽を聴いたりができなくなります。
(LINEサーバ上にデータは保管されず、あくまでストリーミングとしてGoogleDrive上の音楽を取得しに行ってるからです。)

②共有フォルダーのフォルダーIDを確認する。
フォルダーを作成できたらそのフォルダを開く → URLを確認 → https://drive.google.com/drive/folders/
以降のランダムな文字列がフォルダーIDになります。

③GoogleDriveへのアップロードを行う部分のテストプログラムを作成して確認する
前回作成したyoutube.pyと同じディレクトリ上で作業します。

・client_idとclient_secret、GoogleDriveAPIの有効化が必要です。参考

まずはsettings.yamlファイルを作成します

cd $HOME/line
vim settings.yaml

settings.yaml

client_config_backend: settings
client_config:
  client_id: "ここにGoogleClientID"
  client_secret: "ここにSecretID"

save_credentials: True
save_credentials_backend: file
save_credentials_file: credentials.json

get_refresh_token: True

oauth_scope:
  - https://www.googleapis.com/auth/drive.file
  - https://www.googleapis.com/auth/drive.install

次にyoutube-dlを使用してGoogleDriveへのアップロードまでのプログラム

vim upload.py

upload.py

#!/bin/env python
import youtube
import os
from pydrive.auth import GoogleAuth
from pydrive.drive import GoogleDrive

#ダウンロードディレクトリ
dl_dir = "youtube/"
#GoogleFolderID
folder_id = 'フォルダーID'
#GoogleDrive認証設定
gauth = GoogleAuth()
gauth.CommandLineAuth()
drive = GoogleDrive(gauth)

message = "/mp3 GoogleDriveへアップロードしたいyoutubeの曲"
url = message.split()[1]
transaction = message.split()[0]

file_name = youtube.main(transaction,url,dl_dir)

for i in range(len(file_name)):
    f = drive.CreateFile({'title': file_name[i],
        'mimeType': 'audio/mpeg',
        'parents': [{'kind': 'drive#fileLink', 'id':folder_id}]})
    f.SetContentFile(dl_dir + f['title'])

    #UploadGoogleDrive
    f.Upload()

ここまでできたら、実行してアップロードできるか確認してみましょう。

$ chmod +x upload.py
$ ./upload.py

問題なくアップロードできたら、次にLINE BOTアプリを作成していきます。

LINE BOTアプリを作成する

環境変数に登録する

//未登録であることを確認
export -p
//登録を実施
echo 'export LINE_CHANNEL_ACCESS_TOKEN="ここにアクセストークン"' >> ~/.bash_profile
echo 'export LINE_CHANNEL_SECRET="ここにチャンネルシークレット"' >> ~/.bash_profile
source ~/.bash_profile
//登録されていることを確認
export -p

アプリの作成

vim app.py

app.py

#!/bin/env python
import os
import re
import youtube
import math
from flask import Flask, request, abort
from linebot import LineBotApi, WebhookHandler
from linebot.exceptions import InvalidSignatureError
from linebot.models import (
   MessageEvent, TextMessage, TextSendMessage,
   AudioSendMessage
)
from pydrive.auth import GoogleAuth
from pydrive.drive import GoogleDrive
from mutagen.mp3 import MP3

#アプリケーションフレームワーク
app = Flask(__name__)
#LINE Channel Secret
LINE_CHANNEL_SECRET = os.environ['LINE_CHANNEL_SECRET']
#LINE Access Token
LINE_CHANNEL_ACCESS_TOKEN = os.environ['LINE_CHANNEL_ACCESS_TOKEN']

line_bot_api = LineBotApi(LINE_CHANNEL_ACCESS_TOKEN)
handler = WebhookHandler(LINE_CHANNEL_SECRET)

#DownloadDirectory
dl_dir = "youtube/"
os.makedirs(dl_dir, exist_ok=True)

#GoogleDriveAuthSettings
gauth = GoogleAuth()
gauth.CommandLineAuth()
drive = GoogleDrive(gauth)

#GoogleFolderShareID
folder_id = 'GoogleDriveの共有フォルダーIDを記入'

#User_Input
Input_dict = {
    '/mp3':'/mp3',
    '/mov':'/mov',
    '/nomov':'/nomov'
}

@app.route("/callback", methods=['POST'])
def callback():
    # get X-Line-Signature header value
    signature = request.headers['X-Line-Signature']

    # get request body as text
    body = request.get_data(as_text=True)
    app.logger.info("Request body: " + body)
    # handle webhook body
    try:
        handler.handle(body, signature)
    except InvalidSignatureError:
        abort(400)
    return 'OK'

#Message
def messagebox(event,transaction,url):
    transaction_dict = {
        '/mp3':'曲',
        '/mov':'本の動画',
        '/nomov':'本の動画'
    }
    set_transaction = transaction_dict.get(transaction)
    if "&list=" in url:
        line_bot_api.reply_message(event.reply_token,
                TextSendMessage(text="プレイリストの" + set_transaction
                    + "をGoogleDriveにアップロードします。\n"
                    + "処理に時間が掛かる場合があります。"))
    elif "nicovideo" in url:
        line_bot_api.reply_message(event.reply_token,
                TextSendMessage(text="ニコニコ動画は処理に時間が掛かる場合があります。"))
    else:
        line_bot_api.reply_message(event.reply_token,
                TextSendMessage(text="1" + set_transaction  + "をGoogleDriveにアップロードします。"))

#Music
def music(get_id,file_name):
    if "ERROR" in str(file_name):
        line_bot_api.push_message(get_id,messages=(
            TextSendMessage(text="曲のダウンロード処理に失敗しました。")))

    for i in range(len(file_name)):
        f = drive.CreateFile({'title': file_name[i],
                      'mimeType': 'audio/mpeg',
                      'parents': [{'kind': 'drive#fileLink', 'id':folder_id}]})
        f.SetContentFile(dl_dir + f['title'])

        #UploadGoogleDrive
        f.Upload()

        file_id = drive.ListFile({'q': 'title =\"' + file_name[i] +  '\"'}).GetList()[0]['id']

        if len(file_name) == 1 :
            file_length = MP3(dl_dir + file_name[i]).info.length
            link = "https://drive.google.com/uc?export=view&id=" + file_id
            dur = math.floor(file_length * 1000)
            line_bot_api.push_message(get_id,messages=(
                        TextSendMessage(text=file_name[i]),
                        AudioSendMessage(original_content_url=link,duration=dur)))

            line_bot_api.push_message(get_id,messages=(TextSendMessage(text=link)))
            os.remove(dl_dir + file_name[i])
            break

        os.remove(dl_dir + file_name[i])

    else:
        line_bot_api.push_message(get_id,messages=(
            TextSendMessage(text=str(len(file_name))
                + "曲をGoogleDriveにアップロードしました。\n"
                + "https://drive.google.com/drive/folders/" + folder_id)))
#Video
def video(get_id,file_name):
    video_ext_dicts = {
        '.mp4':'video/mp4',
        '.webm':'video/webm',
        '.mkv':'video/x-matroska'
    }
    if "ERROR" in str(file_name):
        line_bot_api.push_message(get_id,messages=(
            TextSendMessage(text="動画のダウンロード処理に失敗しました。")))

    for i in range(len(file_name)):
        root, ext = os.path.splitext(file_name[i])
        mimeType = video_ext_dicts.get(ext)

        f = drive.CreateFile({'title': file_name[i],
                      'mimeType': mimeType,
                      'parents': [{'kind': 'drive#fileLink', 'id':folder_id}]})
        f.SetContentFile(dl_dir + f['title'])

        #UploadGoogleDrive
        f.Upload()
        os.remove(dl_dir + file_name[i])

    line_bot_api.push_message(get_id,messages=(
        TextSendMessage(text=str(len(file_name))
            + "本をGoogleDriveにアップロードしました。\n"
            + "https://drive.google.com/drive/folders/" + folder_id)))

@handler.add(MessageEvent, message=(TextMessage))
def contents(event):
    #LINE Message
    message = event.message.text
    try:
        get_id = event.source.group_id
    except AttributeError:
        get_id = event.source.user_id

    set_input = Input_dict.get(message.split()[0])
    try:
        if message.startswith(set_input):
            url = message.split()[1]
            messagebox(event,set_input,url)

            #youtube-dl
            file_name = youtube.main(set_input,url,dl_dir)

            if set_input == "/mp3":
                music(get_id,file_name)
            else:
                video(get_id,file_name)
    except TypeError: pass

if __name__ == "__main__":
    app.run(host="127.0.0.1", port="9000")

ここまでできればほぼ完成です。あとはシェルスクリプトを書いて、挙動を確認して終了です。
ではまた次回でお会いしましょう。

とある課題でRNNを使った気温の予測をしようと思ったのですが、（詳しくは後述しますが）結果が微妙だったので没になりました。なので、ここで没供養させていただければと思います。

概要

気象庁の観測データを基にRNNを使用して平均気温の将来予測をします。
得られたデータをちょっと考察します
筆者が実行したコードは github においてあります

ライブラリのインポート

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

from sklearn.metrics import mean_squared_error
from sklearn.metrics import r2_score

from keras.layers.recurrent import SimpleRNN
from keras.models import Sequential
from keras.optimizers import Adam
from keras.layers import Dense, Activation
from tensorflow.keras.callbacks import EarlyStopping

ここは特に言うことはないですかね

データの取得

データは 気象庁のHP からダウンロードできます。ちなみに筆者は諸事情で別に入手しました。
ダウンロードしたデータには品質情報と均質番号があると思いますが、これは基本的に無視して大丈夫です。
あと一度にダウンロードできるデータ数に制限があるので、20年ごとに分割してダウンロードしたものをpandasで結合しました。

# 読み込み
tokyo1=pd.read_csv("data/tokyo_1961-1980.csv", header=2,skiprows=[4],encoding="shift-jis",parse_dates=["年月日"])
tokyo2=pd.read_csv("data/tokyo_1981-2000.csv", header=2,skiprows=[4],encoding="shift-jis",parse_dates=["年月日"])
tokyo3=pd.read_csv("data/tokyo_2001-.csv", header=2,skiprows=[4],encoding="shift-jis",parse_dates=["年月日"])
tokyo=pd.concat([tokyo1, tokyo2, tokyo3], ignore_index=True)
tokyo=tokyo.sort_values("date", ignore_index=True)
tokyo["year"]=tokyo["年月日"].dt.year

日時情報をdatetime型にしたいのでparse_dates=["年月日"]としています。なお筆者はこのコードで実行していないのでどっか間違ってたらごめんなさい

データの整形

#整形
tem=tokyo["avtem"]
timesteps = 20

x = np.empty([len(tem)-timesteps, timesteps], dtype=np.float32)
y = np.empty(len(tem)-timesteps, dtype=np.float32)

for i in range(len(x)):
    x[i] = tem[i:i+timesteps].T
    y[i] = tem[i+timesteps]

data_len = timesteps*int(len(x)/timesteps)

x = x[:data_len].reshape(data_len,timesteps,-1)
y = y[:data_len].reshape(data_len,-1)
x_train=x[:21164]
y_train=y[:21164]
x_test=x[21164:21529]
y_test=y[21164:21529]

データの整形は これ を参考にしました。
trainデータは2018年までのもの、testデータは2019年のものを手動で行番号を探して取り出しました(1961年1月1日からのデータを用いると同じ行数になると思います)。

モデルの作成

#モデルの作成
model = Sequential()
model.add(SimpleRNN(50, input_shape=(timesteps, 1), kernel_initializer='random_normal'))
model.add(Dense(1))
model.add(Activation('linear'))

model.compile(loss='mean_squared_error', optimizer=Adam(lr=0.01, beta_1=0.9, beta_2=0.999))
early_stopping = EarlyStopping(monitor='val_loss', mode='auto', patience=3)
model.fit(x_train, y_train, batch_size=1024, epochs=20, validation_split=0.1,callbacks=[early_stopping])

y_pred = model.predict(x_test)
print("RMSE:",np.sqrt(mean_squared_error(y_test, y_pred)))
print("r2  :",r2_score(y_test,y_pred),"\n")

モデルの作成では これ を参考にしました。trainデータ数が2万以上あったので、バッチサイズ512と大きめに設定しています。
これを実行すると、12回ぐらいで精度が上がらくなり、スコアは、

• RMSE: 2.0795848
• r^2 : 0.9290615357147783

でした。 気象庁の予測精度 が最高気温でRMSE1.5強なので精度があまりよくないことがわかります。
特にちょっと考えてもらえばわかると思いますが平均気温は最高気温に比べてぶれにくいので平均気温でこんだけの誤差が出てしまうのではちょっと使い物にならない感がすごいです。なお、実際にこのプログラムを最高気温でやってみるとRMSE3.2程度でした。

考察（というほどでもないですが）

テストデータ（2019年）の気温予測と実際の値を比較してみました。

主に上下に大きく変動しちゃったとこが予測できていないことがわかります。これは過去のデータから傾向で予測しているという都合上しょうがないと思います。
そもそも気温というか天気は気圧配置などに影響されるわけで、それに明確にパターンが決められているのかといえばそうではない気がするので、気象庁は様々な観測データから数値計算して気温を求めてるのでパターンがなくても予測することが可能であることを考えると、RNNでそこまでの精度は出ないのかなという気がします。

ちなみにもっと一部分を拡大してみるとこんな感じでした。

いや、予測しているというより、前日の観測データの後追いしてるだけやん

参考文献

• 初心者のRNN(LSTM) | Kerasで試してみる
• 気象庁HP「天気予報の精度検証結果」
• infiniteloop「入門 Keras (7) 最終回：リカレントニューラルネットワークを体験する」
• Helve’s Python memo「KerasのステートフルRNNで学習を高速化する」

なんだか最近Socket通信に書くこと多いと気がします…まぁ、なぜかよく問い合わせきましたから。
なので今回三菱RCPUとPythonを通信すること書きます。

この記事は以下のBlogにも乗っています。よろしくおねがいします。
http://soup01.com/ja/2020/07/21/mels-iqr-sockt/

前書き

Socket通信すには、Port番号の設定によって異なる外部デバイスと通信することができます。それらのデバイスはTCP/IP・UDP/IPも使えます。

そしてTCP/IP protocolはActive openとPassive Openがあります。
簡単にいいますと、Active OpenはClientですね。
Passive OpenはServerですね。

Active Open Flow

Passive Open Flow

Connectionを切断するタイミング

• Timeout
• 相手側から切断要求きたとき。そして同じのConnectionを再接続には最低限500msの間隔をあげましょう。（Manualがそういっただけですー）

TCP/IP protocolに必要なもの

• 自分のIP
• 自分のPort
• 相手のIP
• 相手のPort

Flow

使用するFunction

SP_SOCOPEN

Connectionを開くFunctionです。

• EN:Bool
  • 立ち上げるとFunctionを実行する
• U:String[1]
  • Dummyです。
• S1:Word
  • Connectionの番号です。
• S2: Array [0..9] of Word
  • Control Data最初から始まるメモリ番地。
• d:Array[0..1]of Bool
  • Function実行後の状態、もしエラーがある場合Array[0]とArray[1]も1サイクルOnになります。
• ENO:Bool
  • 実行結果。

Control Word

• S2+0
  • 0000H-Open setting のエンジニアツールを使う、なんらんかはしりません。
  • 8000H-S2+2~+9のコントロールデータを使います。今回はこれを利用します。
• S2+1
  • 実行後のStatusです。もし0でなければエラーがあります。エラーコードはここで格納します。
• S2+2
  • Connectionの設定ですね。
  • 
• S2+3
  • 自分のPort番号です。
• S2+4、+5
  • 相手のIPアドレスです。
• S2+6
  • 相手のPort番号です。
• S2+7-+9
  • 使用禁止です。

Time-Chart

SP_SOCCLOSE

Connectionを切断するFunctionです。

• EN:Bool
  • 立ち上げるとFunctionを実行する
• U:String[1]
  • Dummyです。
• S1:Word
  • Connectionの番号です。
• S2: Array [0..1] of Word
  • Control Data最初から始まるメモリ番地。
• d:Array[0..1]of Bool
  • Function実行後の状態、もしエラーがある場合Array[0]とArray[1]も1サイクルOnになります。
• ENO:Bool
  • 実行結果。

Time Chart

SP_SOCCINF

Connectionの設定をもらうFunctionです。

• EN:Bool
  • 立ち上げるとFunctionを実行する
• U:String[1]
  • Dummyです。
• S1:Word
  • Connectionの番号です。
• S2::Array [0..1] of Word
  • Control Data最初から始まるメモリ番地。Function実行後の状態、もしエラーがある場合Array[1]がエラーコードが格納されます。
• d:Array[0..4]of Word
  • Connectionの設定格納されます。
• ENO:Bool
  • 実行結果。

d

• S2+0,+1
  • 相手のIPアドレス
• S2+2
  • 相手のPort
• S2+3
  • 自分のPort
• S2+4
  • Connectionの構成Word
  • 

SP_SOCSND

データを送信するFunctionです。

• EN:Bool
  • 立ち上げるとFunctionを実行する
• U:String[1]
  • Dummyです。
• S1:Word
  • Connectionの番号です。
• S2:Array[0..1] of Word
  • ControlデータでもしFunction実行エラーがある場合Word[1]がエラーコードが格納されます。
• S3: Array [0..n] of Word
  • 送信するデータ最初から始まるメモリ番地。Function実行後の状態、もしエラーがある場合Array[1]がエラーコードが格納されます。
• d:Array[0..4]of Word
  • Connectionの設定格納されます。
• ENO
  • Boolで実行結果。

S3

• S3+0
  • 送るデータの長さ(Byteで計算)
• S3+1-N
  • データの番地

Time Chart

S_SOCRCVS

データ受信するFunctionです。

• EN:Bool
  • ONするとFunctionを実行する
• U:String[1]
  • Dummyです。
• S:Word
  • Connectionの番号です。
• d: Word
  • データ受信するときこの番地から始まります。Dは受信するデータの長さ・D+1からはデータの格納先です。
• ENO:Bool
  • 実行結果。

d

Time Chart

実装

バージョン

CPU

Hardware設定

Parameter>R08CPU>Module ParameterでIPを設定します。
そしてExternal Device Configurationの隣“Detailed Setting”をクリックしConnectionの設定をします。

右のModule List>Ethernet Device(General)でActive Connection Moduleを選んでひっばります。
次はSocket Communicationを選んで、自分のPort番号設定します。今回の例は4000にします。次はちょっと右にScrollし…

こちらで相手側のIPとPortを設定し、
“Close with Reflecting the Setting”を。

最後はApply。
よし、これでConnection完了です。

プログラム

Socket設定するためにFunctionを3つ作っています。

• FC_SocketIPConfig
  • IPアドレスを綺麗に一つのDWORDにまとめるFunction。
• FC_SocketConectionConfig
  • Active使うか、なにないツール使うかのに設定するワードをまとめるFunction。
• FC_SocketConfig
  • FC_SocketIPConfig、FC_SocketConectionConfigも含め、Port番号を全部設定するFunctionです。

FC_SocketIPConfig

Interface

Program

例え192.168.0.251はHC0A800FBです。このように百倍ずつ大きくしてプラスすれば同じの値になります。

IPConfig1:=iConfig[1];
IPConfig2:=iConfig[2];
IPConfig3:=iConfig[3];
IPConfig4:=iConfig[4];

ipConfig:=IPConfig4+int_to_Dint(IPConfig3*H100)
+(IPConfig2*H10000)
+(IPConfig1*H1000000);

FC_SocketIPConfig:=ipConfig;

Properties

FC_SocketConectionConfig

このようなワークを組みます。

Interface

• IConfig[0]はTCPを使うかどうか。
• IConfig[1]はSubFeatures、つまりPredefined Protocol Settingを使うかどうか。
• IConfig[2]はActive Open使うとき。
• IConfig[3]はFull Passive使うとき。
• IConfig[2]とIConfig[3]もONしないならUnPassiveを使う。

Program

//init
ConnectionConfig:=0;


TCP:=iCconfig[0];
SubFeatures:=iCconfig[1];
Active:=iCconfig[2];
FullPassive:=iCconfig[3];


//b0-b7 Always OFF
ConnectionConfig.0:=FALSE;
ConnectionConfig.1:=FALSE;
ConnectionConfig.2:=FALSE;
ConnectionConfig.3:=FALSE;
ConnectionConfig.4:=FALSE;
ConnectionConfig.5:=FALSE;
ConnectionConfig.6:=FALSE;
ConnectionConfig.7:=FALSE;

IF TCP THEN
    ConnectionConfig.8:=FALSE;
ELSE
    ConnectionConfig.8:=TRUE;
END_IF;

//b9 Always ON
ConnectionConfig.9:=TRUE;

IF SubFeatures THEN
    ConnectionConfig.a:=TRUE;
ELSE
    ConnectionConfig.a:=FALSE;
END_IF;

//b11-13 Always OFF
ConnectionConfig.b:=FALSE;
ConnectionConfig.c:=FALSE;
ConnectionConfig.d:=FALSE;


IF Active THEN
    ConnectionConfig.e:=FALSE;
    ConnectionConfig.f:=FALSE;

ELSIF FullPassive THEN
    ConnectionConfig.e:=TRUE;
    ConnectionConfig.f:=TRUE;
ELSE
    ConnectionConfig.e:=FALSE;
    ConnectionConfig.f:=TRUE;
END_IF;


FC_SocketConnectionConfig:=ConnectionConfig;

Properties

FC_SocketConfig

このControl Dataを組みます。

Interface

Program

Z0:=iOffset;

//+0
IF iUseControlWord THEN
    D0Z0:=H8000;
ELSE
    D0Z0:=H0000;
END_IF;

//+2
Z0:=iOffset+2;
D0Z0:=FC_SocketConnectionConfig(iMyConfig);

//+3
Z0:=iOffset+3;
D0Z0:=iMyPort;

//+4,5
Z0:=iOffset+4;
_tDWord:=FC_SocketIPConfig(iParnterIP);
//D0Z0:D:=_tDWord;
DMOV(TRUE,_tDWord,D0Z0);

//+6
Z0:=iOffset+6;
D0Z0:=iParnterPort;

Properties

Main Program

まずこんな感じの流れです。
STの文法などの説明ここでやめとおきます。ネット上で自分よりう前説明がたくさんあると思いますので…

Interface

Program

//Init

    insConNums      :=1;
    insConnDelay    :=30;
    insSendDelay    :=2;
    insRetry        :=3;

    insENO:=OUT_T(
                    NOT insInit                     //Timer Trigger1
                    AND NOT  insSOCOPENSts[1]       //Timer Trigger2
                    ,InsT2                          //Timer Register
                    ,insConnDelay                   //Time Setup
                    );

//OPEN Connection   

    //IP Settings
    insMyIP[1]      :=192;
    insMyIP[2]      :=168;
    insMyIP[3]      :=0;
    insMyIP[4]      :=251;

    //Connection Configs
    insMyConfig[0]  :=TRUE;
    insMyConfig[1]  :=FALSE;
    insMyConfig[2]  :=TRUE;
    insMyConfig[3]  :=FALSE;

    //Config Setup Function
    insENO:=FC_SocketConfig( 
                4000            //DB Offset
                ,TRUE           //Use Control Word Or not
                ,insMyConfig    //[0]=Use TCP?,
                                //[1]=SubFeatures?,
                                //[2]=Active Connection?,
                                //[3]=Full Passive Connection
                ,4000           //My Port
                ,4000           //Parnter Port
                ,insMyIP        //Parnter IP
                );


    //Connection Delay
    insSOCOPEN:=InsT2.S;

    //Function
    SP_SOCOPEN( 
                insSOCOPEN  //EN
                ,insString  //Dummy
                ,insConNums //Connection Numbers
                ,D4000      //Control Word
                ,insSOCOPENSts//Status
                );

    //Result
    IF insSOCOPENSts[0] AND NOT insSOCOPENSts[1] THEN
        insConnected:=TRUE;
        insInit:=TRUE;
        insSendRetry:=0;
        insConnRetry:=0;
    ELSIF  insSOCOPENSts[0] AND  insSOCOPENSts[1] THEN
        insConnected:=FALSE;

    END_IF;

    //Retry Count
    IF insSOCOPENSts[1] THEN
        insConnRetry:=insConnRetry+1;
    END_IF;


//Get Connection Info

    //Config ControlWord for SP_SOCCINF
    D200:D:=D4004:D;        //Parnter IP
    D202:=HFA0;             //Parnter Port
    D203:=HFA0;             //My Port
    D204:=D4002;            //Connection Config

    //Function
    SP_SOCCINF(
                insSOCCINF  //EN
                ,insString  //Dummy
                ,insConNums //Connection Numbers
                ,D200       //Control Words
                ,D600       //Result
                );

//Send  

    //Data
    D999:=20;               //Length of bytes that need to sent
    D1000:=H23;             //Data
    D1002:=H59;             //Data
    D1004:=H99;             //Data
    D1009:=H53;             //Data

    //Send Trigger
    IF insConnected 
        AND NOT insSOCSNDSts[0] 
        AND NOT insSOCSNDSts[1]  
        AND insSendRetry < insRetry THEN
        insSend:=TRUE;
    ELSE
        insSend:=FALSE;
    END_IF;

    //Retry Count
    IF insSOCSNDSts[1] THEN
        insSendRetry:=insSendRetry+1;
    END_IF;

    //Send Delay
    insENO:=OUT_T(
                    insSend             //Trigger
                    ,insT1              //Timer Register
                    ,insSendDelay       //Time Setup
                    );

    //Send Command
    insSOCSND:=insT1.S;

    //Function
    SP_SOCSND(
                insSOCSND       //EN
                ,insString      //Dummy
                ,insConNums     //Connection Numbers
                ,D400           //Control Data,if Error,+1<>0
                ,D999           //Data Trasnfer
                ,insSOCSNDSts   //Status
                );

//Recv

    //Data
    D1099:=10;

    //Function
    S_SOCRCVS(
                TRUE            //EN
                ,insString      //Dummy
                ,insConNums     //Connection Numbers
                ,D1099          //Data
                );

//Close

    //Close Command
    insSOCCLOSE:=    insSendRetry >= insRetry;

    //Function
    SP_SOCCLOSE(
                insSOCCLOSE     //EN
                ,insString      //Dummy
                ,insConNums     //Connection Numbsers
                ,D300           //Control Data,if Error,+1<>0
                ,insSOCCLOSESts //Status
                );

    //Connect Again
    IF insSOCCLOSESts[0] THEN
        insInit:=FALSE;
    END_IF;

Python

import socket
import time

DESTINATION_ADDR = '192.168.0.39'
SOURCE_PORT, DESTINATION_PORT = 4000, 4000
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('192.168.0.251', SOURCE_PORT))
sock.listen(1)
conn, addr = sock.accept()
i =0
while i<3000:

    if i %2 == 0:
        ba1 = bytearray(b"4abcdefas0")
    else:
        ba1 = bytearray(b"9kaekfyei2")

    response = conn.recv(1440)

    conn.send(ba1)
#     print(response)
    print("current:"+str(i))
    i+=1

sock.close()
conn.close()

本記事は、Pandas の公式ドキュメントのUser Guide - Working with text dataを機械翻訳した後、一部の不自然な文章を手直ししたものである。

誤訳の指摘・代訳案・質問等があればコメント欄や編集リクエストでお願いします。

テキストデータの操作

テキストデータの型

バージョン 1.0.0 から

pandasではテキストデータを保持する方法が２つあります。

• objectデータ型の NumPy 配列。
• StringDtype拡張型。

StringDtypeを使用してテキストデータを保持することをお勧めします。

pandas 1.0 以前は、objectデータ型が唯一の方法でした。これは多くの理由で不便でした。

1. 誤って文字列と非文字列を混在させてobjectデータ型配列に格納する可能性があります。専用のデータ型があるのが良いでしょう。
2. objectデータ型は、DataFrame.select_dtypes()のようなデータ型固有の操作に適用できません。依然としてobjectデータ型の列である非テキスト列を除外しながら、テキストのみの列を選択する有効的な方法はありません。
3. コードを読むとき、obejctデータ型配列の内容は'string'よりも明示的ではありません。

現在、文字列を格納したobjectデータ型配列とarray.StringArrayのパフォーマンスはほぼ変わり有りません。今後の機能強化により、StringArrayのパフォーマンスが大幅に向上し、メモリオーバーヘッドが低下することが予想されます。

警告
StringArrayは現在、実験的と見なされています。実装と部分的な API は、警告なしに変更される場合があります。

後方互換性のために、文字列のリストから推測する際のデフォルトの型は依然としてobjectデータ型です。

In [**]: pd.Series(['a', 'b', 'c'])
Out[**]:
0    a
1    b
2    c
dtype: object

stringデータ型を明示的に要求するには、dtypeを指定します。

In [**]: pd.Series(['a', 'b', 'c'], dtype="string")
Out[**]:
0    a
1    b
2    c
dtype: string

In [**]: pd.Series(['a', 'b', 'c'], dtype=pd.StringDtype())
Out[**]:
0    a
1    b
2    c
dtype: string

または、既に存在するSeriesまたはDataFrameにastypeを適用して、

In [**]: s = pd.Series(['a', 'b', 'c'])

In [**]: s
Out[**]:
0    a
1    b
2    c
dtype: object

In [**]: s.astype("string")
Out[**]:
0    a
1    b
2    c
dtype: string

バージョン 1.1.0 から

非文字列データを文字列データ型に変換するのにStringDtype・"string"を使用することもできます。

In [**]: s = pd.Series(['a', 2, np.nan], dtype="string")

In [**]: s
Out[**]:
0       a
1       2
2    <NA>
dtype: string

In [**]: type(s[1])
Out[**]: str

または、既に存在するpandasのデータを変換して、

In [**]: s1 = pd.Series([1, 2, np.nan], dtype="Int64")

In [**]: s1
Out[**]:
0       1
1       2
2    <NA>
dtype: Int64

In [**]: s2 = s1.astype("string")

In [**]: s2
Out[**]:
0       1
1       2
2    <NA>
dtype: string

In [**]: type(s2[0])
Out[**]: str

動作の違い

以下に、StringDtypeオブジェクトの動作がobjectデータ型と異なる点を紹介します。

1. StringDtypeの場合、数値の出力を返す文字列アクセサメソッドは、NA 値の存在に応じて、整数または浮動小数データ型ではなく、常に欠損値許容整数データ型（Int64データ型）を返します。真偽値の出力を返すメソッドは、欠損値許容真偽値データ型（booleanデータ型）を返します。

   In [**]: s = pd.Series(["a", None, "b"], dtype="string")
   
   In [**]: s
   Out[**]:
   0       a
   1    <NA>
   2       b
   dtype: string
   
   In [**]: s.str.count("a")
   Out[**]:
   0       1
   1    <NA>
   2       0
   dtype: Int64
   
   In [**]: s.dropna().str.count("a")
   Out[**]:
   0    1
   2    0
   dtype: Int64
   

   両方とも出力はInt64データ型です。オブジェクトデータ型と比較してください。

   In [**]: s2 = pd.Series(["a", None, "b"], dtype="object")
   
   In [**]: s2.str.count("a")
   Out[**]:
   0    1.0
   1    NaN
   2    0.0
   dtype: float64
   
   In [**]: s2.dropna().str.count("a")
   Out[**]:
   0    1
   2    0
   dtype: int64
   

   オブジェクトデータ型では、NA 値が存在する場合、出力データ型は float64 になります。真偽値を返すメソッドの場合も同様です。

   In [**]: s.str.isdigit()
   Out[**]:
   0    False
   1     <NA>
   2    False
   dtype: boolean
   
   In [**]: s.str.match("a")
   Out[**]:
   0     True
   1     <NA>
   2    False
   dtype: boolean
   

2. StringArrayはバイトではなく文字列のみを保持するため、Series.str.decode()などの一部の文字列メソッドはStringArrayでは使用できません。

3. 比較操作では、array.StringArrayおよびStringArrayを基にしたSeriesは、boolデータ型オブジェクトではなくBooleanDtypeのオブジェクトを返します。StringArrayの欠損値は、numpy.nanのように常に等しくないという結果を返すのではなく、比較演算を行っても伝播します。

このドキュメントの以下で紹介する、その他の関数・メソッド等は、stringとobjectデータ型に等しく適用されます。

文字列メソッド

Series および Index には、配列の各要素を簡単に操作できる一連の文字列処理メソッドが実装されています。これらのメソッドが欠損値・ NA 値を自動的に除外することは、重要なことかもしれません。これらはstr属性を介してアクセスされ、多くの場合、同等の（スカラー）組み込み文字列メソッドに一致する名前を持ちます。

In [**]: s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog', 'cat'],
   ....:               dtype="string")
   ....:

In [**]: s.str.lower()
Out[**]:
0       a
1       b
2       c
3    aaba
4    baca
5    <NA>
6    caba
7     dog
8     cat
dtype: string

In [**]: s.str.upper()
Out[**]:
0       A
1       B
2       C
3    AABA
4    BACA
5    <NA>
6    CABA
7     DOG
8     CAT
dtype: string

In [**]: s.str.len()
Out[**]:
0       1
1       1
2       1
3       4
4       4
5    <NA>
6       4
7       3
8       3
dtype: Int64

In [**]: idx = pd.Index([' jack', 'jill ', ' jesse ', 'frank'])

In [**]: idx.str.strip()
Out[**]: Index(['jack', 'jill', 'jesse', 'frank'], dtype='object')

In [**]: idx.str.lstrip()
Out[**]: Index(['jack', 'jill ', 'jesse ', 'frank'], dtype='object')

In [**]: idx.str.rstrip()
Out[**]: Index([' jack', 'jill', ' jesse', 'frank'], dtype='object')

Index における文字列メソッドは、DataFrame の列のクリーンアップまたは変換に特に役立ちます。たとえば、先頭または末尾に空白がある列がある場合を考えます。

In [**]: df = pd.DataFrame(np.random.randn(3, 2),
   ....:                   columns=[' Column A ', ' Column B '], index=range(3))
   ....:

In [**]: df
Out[**]:
    Column A    Column B
0    0.469112   -0.282863
1   -1.509059   -1.135632
2    1.212112   -0.173215

df.columnsは Index オブジェクトなので、.strアクセサを使用できます。

In [**]: df.columns.str.strip()
Out[**]: Index(['Column A', 'Column B'], dtype='object')

In [**]: df.columns.str.lower()
Out[**]: Index([' column a ', ' column b '], dtype='object')

これらの文字列メソッドを使用して、必要に応じて列をクリーンアップできます。次の例は、先頭と末尾の空白を削除し、すべての名前を小文字にし、残りの空白をアンダースコアに置き換えています。

In [**]: df.columns = df.columns.str.strip().str.lower().str.replace(' ', '_')

In [**]: df
Out[**]:
   column_a  column_b
0  0.469112 -0.282863
1 -1.509059 -1.135632
2  1.212112 -0.173215

注
多数の要素が繰り返されるSeriesがある場合（つまり、Series内の一意の要素の数がSeriesの長さよりもはるかに小さい場合）、元のSeriesをcategory型の一つに変換してから.str.<method>や.dt.<property>をそれに適用する方が高速です。このパフォーマンスの違いは、category型のSeriesの場合、文字列操作はSeriesの各要素ではなく.categoriesで実行されることに因ります。

文字列の.categoriesを持つcategory型のSeriesには、文字列型のSeriesと比較していくつかの制限があることに注意してください（例えばs + " " + sは、sがcategory型のSeriesの場合機能しません。）。また、list型の要素を操作する.strメソッドも、そのようなSeriesでは使用できません。

警告
バージョン 0.25.0 以前は、.strアクセサは最も初歩的な型チェックのみを行いました。バージョン 0.25.0 以降、より厳密に、Series の型が推測され、許容される型（つまり文字列）が適用されます。

一般的に、.strアクセサは文字列でのみ機能するように設計されています。非常に少数の例外を除いて、他の用途はサポートされておらず、後で無効になる可能性があります。

文字列の分割と置換

splitなどのメソッドは、リストからなるSeriesを返します。

In [**]: s2 = pd.Series(['a_b_c', 'c_d_e', np.nan, 'f_g_h'], dtype="string")

In [**]: s2.str.split('_')
Out[**]:
0    [a, b, c]
1    [c, d, e]
2         <NA>
3    [f, g, h]
dtype: object

分割したリストの要素には、getまたは[]表記を使用してアクセスできます。

In [**]: s2.str.split('_').str.get(1)
Out[**]:
0       b
1       d
2    <NA>
3       g
dtype: object

In [**]: s2.str.split('_').str[1]
Out[**]:
0       b
1       d
2    <NA>
3       g
dtype: object

expand引数によって簡単に、これを展開してDataFrameとして返すことができます。

In [**]: s2.str.split('_', expand=True)
Out[**]:
      0     1     2
0     a     b     c
1     c     d     e
2  <NA>  <NA>  <NA>
3     f     g     h

元のSeriesにStringDtypeがある場合、出力列もすべてStringDtypeになります。

分割数を制限することもできます。

In [**]: s2.str.split('_', expand=True, n=1)
Out[**]:
      0     1
0     a   b_c
1     c   d_e
2  <NA>  <NA>
3     f   g_h

rsplitはsplitと似ていますが、逆方向、つまり文字列の末尾から文字列の先頭に向かって動作する点が異なります。

In [**]: s2.str.rsplit('_', expand=True, n=1)
Out[**]:
      0     1
0   a_b     c
1   c_d     e
2  <NA>  <NA>
3   f_g     h

replaceは、デフォルトでは正規表現による置換を行います。

In [**]: s3 = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca',
   ....:                 '', np.nan, 'CABA', 'dog', 'cat'],
   ....:                dtype="string")
   ....:

In [**]: s3
Out[**]:
0       A
1       B
2       C
3    Aaba
4    Baca
5
6    <NA>
7    CABA
8     dog
9     cat
dtype: string

In [**]: s3.str.replace('^.a|dog', 'XX-XX ', case=False)
Out[**]:
0           A
1           B
2           C
3    XX-XX ba
4    XX-XX ca
5
6        <NA>
7    XX-XX BA
8      XX-XX
9     XX-XX t
dtype: string

正規表現を念頭に置くには、いくつかの注意が必要です！たとえば、次のコードは $ の正規表現の意味のために問題を引き起こします。

# 不適切な形式の財務データを考えます
In [**]: dollars = pd.Series(['12', '-$10', '$10,000'], dtype="string")

# これは単純にあなたがやりたいことが実行されます
In [**]: dollars.str.replace('$', '')
Out[**]:
0        12
1       -10
2    10,000
dtype: string

# しかしこれは働きません
In [**]: dollars.str.replace('-$', '-')
Out[**]:
0         12
1       -$10
2    $10,000
dtype: string

# （２文字以上のとき）特殊文字をエスケープする必要があります
In [**]: dollars.str.replace(r'-\$', '-')
Out[**]:
0         12
1        -10
2    $10,000
dtype: string

バージョン 0.23.0 から

（str.replace()と同様の）文字列のリテラルな置換を行いたい場合は、各文字をエスケープするのではなく、オプションのregexパラメーターをFalseに設定します。この場合、patとreplは両方とも文字列でなければなりません。

# 次の２つは同等です
In [**]: dollars.str.replace(r'-\$', '-')
Out[**]:
0         12
1        -10
2    $10,000
dtype: string

In [**]: dollars.str.replace('-$', '-', regex=False)
Out[**]:
0         12
1        -10
2    $10,000
dtype: string

replaceメソッドは、関数を呼び出して置換することもできます。re.sub()を使用して、すべてのpatに対して呼び出されます。呼び出し可能オブジェクトは、１つの位置引数（正規表現オブジェクト）を受け取り、文字列を返す必要があります。

# 小文字のアルファベットをすべて逆さにします
In [**]: pat = r'[a-z]+'

In [**]: def repl(m):
   ....:     return m.group(0)[::-1]
   ....:

In [**]: pd.Series(['foo 123', 'bar baz', np.nan],
   ....:           dtype="string").str.replace(pat, repl)
   ....:
Out[**]:
0    oof 123
1    rab zab
2       <NA>
dtype: string

# 正規表現グループを使います
In [**]: pat = r"(?P<one>\w+) (?P<two>\w+) (?P<three>\w+)"

In [**]: def repl(m):
   ....:     return m.group('two').swapcase()
   ....:

In [**]: pd.Series(['Foo Bar Baz', np.nan],
   ....:           dtype="string").str.replace(pat, repl)
   ....:
Out[**]:
0     bAR
1    <NA>
dtype: string

replaceメソッドは、パターンとしてre.compile()からコンパイルされた正規表現オブジェクトも受け入れます。すべてのフラグは、コンパイル済みの正規表現オブジェクトに含める必要があります。

In [**]: import re

In [**]: regex_pat = re.compile(r'^.a|dog', flags=re.IGNORECASE)

In [**]: s3.str.replace(regex_pat, 'XX-XX ')
Out[**]:
0           A
1           B
2           C
3    XX-XX ba
4    XX-XX ca
5
6         NaN
7    XX-XX BA
8      XX-XX
9     XX-XX t
dtype: string

コンパイルされた正規表現オブジェクトでreplaceを呼び出すときにflags引数を使うと、ValueErrorが発生します。

In [**]: s3.str.replace(regex_pat, 'XX-XX ', flags=re.IGNORECASE)
---------------------------------------------------------------------------
ValueError: case and flags cannot be set when pat is a compiled regex

結合

seriesやIndexをそれ自体ないし他と結合するには、すべてcat()またはIndex.str.catに基づいたいくつかの方法があります。

単一の Series と文字列の結合

Series（またはIndex）の各要素を結合できます。

In [**]: s = pd.Series(['a', 'b', 'c', 'd'], dtype="string")

In [**]: s.str.cat(sep=',')
Out[**]: 'a,b,c,d'

区切り文字を指定する引数sepが指定されていない場合、デフォルトとして空の文字列sep=''になります。

In [**]: s.str.cat()
Out[**]: 'abcd'

デフォルトでは、欠損値は無視されます。na_repを使用して、表現を指定できます。

In [**]: t = pd.Series(['a', 'b', np.nan, 'd'], dtype="string")

In [**]: t.str.cat(sep=',')
Out[**]: 'a,b,d'

In [**]: t.str.cat(sep=',', na_rep='-')
Out[**]: 'a,b,-,d'

Seriesにリスト等を結合

cat()の最初の引数には、呼び出し元のSeries（またはIndex）の長さと一致する、リストライクなオブジェクトを渡すことができます。

In [**]: s.str.cat(['A', 'B', 'C', 'D'])
Out[**]:
0    aA
1    bB
2    cC
3    dD
dtype: string

na_repが指定されていない場合、どちらか一方にでも欠損値があれば、結果も欠損値になります。

In [**]: s.str.cat(t)
Out[**]:
0      aa
1      bb
2    <NA>
3      dd
dtype: string

In [**]: s.str.cat(t, na_rep='-')
Out[**]:
0    aa
1    bb
2    c-
3    dd
dtype: string

Seriesに配列等を結合

バージョン 0.23.0 から

othersパラメーターには２次元のデータを渡すこともできます。この場合、行数は呼び出し元のSeries（またはIndex）の長さと一致する必要があります。

In [**]: d = pd.concat([t, s], axis=1)

In [**]: s
Out[**]:
0    a
1    b
2    c
3    d
dtype: string

In [**]: d
Out[**]:
      0  1
0     a  a
1     b  b
2  <NA>  c
3     d  d

In [**]: s.str.cat(d, na_rep='-')
Out[**]:
0    aaa
1    bbb
2    c-c
3    ddd
dtype: string

Series にインデックスに基づいてオブジェクトを結合

SeriesまたはDataFrameとの結合の場合、joinキーワードを設定することにより、結合する前にインデックスを調整できます。

In [**]: u = pd.Series(['b', 'd', 'a', 'c'], index=[1, 3, 0, 2],
   ....:               dtype="string")
   ....:

In [**]: s
Out[**]:
0    a
1    b
2    c
3    d
dtype: string

In [**]: u
Out[**]:
1    b
3    d
0    a
2    c
dtype: string

In [**]: s.str.cat(u)
Out[**]:
0    aa
1    bb
2    cc
3    dd
dtype: string

In [**]: s.str.cat(u, join='left')
Out[**]:
0    aa
1    bb
2    cc
3    dd
dtype: string

警告
joinキーワードが渡されない場合、cat()メソッドは現在、バージョン 0.23.0 より前の動作（つまり、整列なし）にフォールバックしますが、将来のバージョンではこのデフォルトがjoin='left'に変更されるため、関連するインデックスのいずれかが異なる場合はFutureWarningが発生します。

joinには通常のオプションを使用できます（'left', 'outer', 'inner', 'right'のいずれか）。ここで行われるアラインメントは、長さを一致させる必要がないことも意味します。

In [**]: v = pd.Series(['z', 'a', 'b', 'd', 'e'], index=[-1, 0, 1, 3, 4],
   ....:               dtype="string")
   ....:

In [**]: s
Out[**]:
0    a
1    b
2    c
3    d
dtype: string

In [**]: v
Out[**]:
-1    z
 0    a
 1    b
 3    d
 4    e
dtype: string

In [**]: s.str.cat(v, join='left', na_rep='-')
Out[**]:
0    aa
1    bb
2    c-
3    dd
dtype: string

In [**]: s.str.cat(v, join='outer', na_rep='-')
Out[**]:
-1    -z
 0    aa
 1    bb
 2    c-
 3    dd
 4    -e
dtype: string

同様に、othersがDataFrameであっても実行可能です。

In [**]: f = d.loc[[3, 2, 1, 0], :]

In [**]: s
Out[**]:
0    a
1    b
2    c
3    d
dtype: string

In [**]: f
Out[**]:
      0  1
3     d  d
2  <NA>  c
1     b  b
0     a  a

In [**]: s.str.cat(f, join='left', na_rep='-')
Out[**]:
0    aaa
1    bbb
2    c-c
3    ddd
dtype: string

Series と複数のオブジェクトの結合

複数の配列ライクのオブジェクト（具体的には、Series・Index・および１次元のnp.ndarrayバリアント）は、リストライクなコンテナ（イテレータやdict-views などを含む）を用いて結合することができます。

In [**]: s
Out[**]:
0    a
1    b
2    c
3    d
dtype: string

In [**]: u
Out[**]:
1    b
3    d
0    a
2    c
dtype: string

In [**]: s.str.cat([u, u.to_numpy()], join='left')
Out[**]:
0    aab
1    bbd
2    cca
3    ddc
dtype: string

渡されたリストのうち、インデックスのない要素（例：np.ndarray）は呼び出し元のSeries（またはIndex）と長さが一致している必要がありますが、SeriesやIndexは（join=Noneで整列が無効にされていない限り）長さは自由です。

In [**]: v
Out[**]:
-1    z
 0    a
 1    b
 3    d
 4    e
dtype: string

In [**]: s.str.cat([v, u, u.to_numpy()], join='outer', na_rep='-')
Out[**]:
-1    -z--
 0    aaab
 1    bbbd
 2    c-ca
 3    dddc
 4    -e--
dtype: string

othersに渡したリストが異なるインデックスを含む状態でjoin='right'を指定した場合、返されるオブジェクトはこれらのインデックスの和（union）に基づいて形成されます。

In [**]: u.loc[[3]]
Out[**]:
3    d
dtype: string

In [**]: v.loc[[-1, 0]]
Out[**]:
-1    z
 0    a
dtype: string

In [**]: s.str.cat([u.loc[[3]], v.loc[[-1, 0]]], join='right', na_rep='-')
Out[**]:
-1    --z
 0    a-a
 3    dd-
dtype: string

.strを用いた索引

[]記法を使用して、位置の場所を指定することで直接索引できます。文字列の末尾を超えて索引すると、結果はNaNになります。

In [**]: s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan,
   ....:                'CABA', 'dog', 'cat'],
   ....:               dtype="string")
   ....:

In [**]: s.str[0]
Out[**]:
0       A
1       B
2       C
3       A
4       B
5    <NA>
6       C
7       d
8       c
dtype: string

In [**]: s.str[1]
Out[**]:
0    <NA>
1    <NA>
2    <NA>
3       a
4       a
5    <NA>
6       A
7       o
8       a
dtype: string

部分文字列の抽出

各要素の最初の一致を抽出（extract）

警告
バージョン 0.23 より前では、extractメソッドのexpand引数のデフォルトはFalseに設定されていました。expand=Falseの場合、expandは、対象文字列と正規表現パターンに応じて、SeriesかIndexかDataFrameを返します。expand=Trueの場合、常にDataFrameを返します。これは、ユーザーの観点から見ると、より一貫性があり、混乱が少ないです。expand=Trueは、バージョン 0.23.0 以降はデフォルトになりました。

extractメソッドは、少なくとも１つのキャプチャグループを持つ正規表現を受け取ります。

複数のグループを持つ正規表現を抽出すると、グループごとに１つの列を持つ DataFrame が返されます。

In [**]: pd.Series(['a1', 'b2', 'c3'],
   ....:           dtype="string").str.extract(r'([ab])(\d)', expand=False)
   ....:
Out[**]:
      0     1
0     a     1
1     b     2
2  <NA>  <NA>

一致しない要素は、NaNで満たされた行を返します。したがって、乱雑な文字列の Series は、タプルまたはre.matchオブジェクトにアクセスするのにget()を必要とせずに、クリーンアップされた、またはより有用な文字列の同様のインデックス付き Series または DataFrame に「変換」できます。一致が見つからず、結果がNaNのみであっても、データ型は常にオブジェクトです（訳注：元がstringの場合はstringになるはず）。

名前付きグループ

In [**]: pd.Series(['a1', 'b2', 'c3'],
   ....:           dtype="string").str.extract(r'(?P<letter>[ab])(?P<digit>\d)',
   ....:                                       expand=False)
   ....:
Out[**]:
  letter digit
0      a     1
1      b     2
2   <NA>  <NA>

オプションのグループ

In [**]: pd.Series(['a1', 'b2', '3'],
   ....:           dtype="string").str.extract(r'([ab])?(\d)', expand=False)
   ....:
Out[**]:
      0  1
0     a  1
1     b  2
2  <NA>  3

を使用することもできます。正規表現のキャプチャグループ名は、それぞれの列名に使用されることを覚えておいてください。キャプチャグループ名が存在しない場合は、キャプチャグループ番号が使用されます。

グループを１つだけ持つ正規表現によって抽出すると、expand=Trueの場合、１つの列からなるDataFrameが返されます。

In [**]: pd.Series(['a1', 'b2', 'c3'],
   ....:           dtype="string").str.extract(r'[ab](\d)', expand=True)
   ....:
Out[**]:
      0
0     1
1     2
2  <NA>

expand=Falseの場合は、Seiresが返されます。

In [**]: pd.Series(['a1', 'b2', 'c3'],
   ....:           dtype="string").str.extract(r'[ab](\d)', expand=False)
   ....:
Out[**]:
0       1
1       2
2    <NA>
dtype: string

Indexに対してキャプチャグループを丁度１つだけ持つ正規表現で呼び出すと、expand=Trueの場合、１つの列からなるDataFrameが返されます。

In [**]: s = pd.Series(["a1", "b2", "c3"], ["A11", "B22", "C33"],
   ....:               dtype="string")
   ....:

In [**]: s
Out[**]:
A11    a1
B22    b2
C33    c3
dtype: string

In [**]: s.index.str.extract("(?P<letter>[a-zA-Z])", expand=True)
Out[**]:
  letter
0      A
1      B
2      C

expand=Falseの場合は、Indexが返されます。

In [**]: s.index.str.extract("(?P<letter>[a-zA-Z])", expand=False)
Out[**]: Index(['A', 'B', 'C'], dtype='object', name='letter')

Indexに対してキャプチャグループを複数持つ正規表現で呼び出すと、expand=Trueの場合、DataFrameが返されます。

In [**]: s.index.str.extract("(?P<letter>[a-zA-Z])([0-9]+)", expand=True)
Out[**]:
  letter   1
0      A  11
1      B  22
2      C  33

expand=Falseの場合は、ValueErrorが発生します。

>>> s.index.str.extract("(?P<letter>[a-zA-Z])([0-9]+)", expand=False)
ValueError: only one regex group is supported with Index

次の表は、extract(expand=False)の動作をまとめたものです（１列目は入力サブジェクト、１行目は正規表現のグループ数）。

	1 グループ	>1 グループ
Index	Index	ValueError
Series	Series	DataFrame

各要素のすべての一致を抽出（extractall）

（最初の一致のみを抽出する）extractとは異なり、

In [**]: s = pd.Series(["a1a2", "b1", "c1"], index=["A", "B", "C"],
   ....:               dtype="string")
   ....:

In [**]: s
Out[**]:
A    a1a2
B      b1
C      c1
dtype: string

In [**]: two_groups = '(?P<letter>[a-z])(?P<digit>[0-9])'

In [**]: s.str.extract(two_groups, expand=True)
Out[**]:
  letter digit
A      a     1
B      b     1
C      c     1

extractallメソッドはすべての一致を返します。extractallの結果は常に、MultiIndexを行に持つDataFrameです。MultiIndexの最低レベルはmatchという名前で、要素の順序を示します。

In [**]: s.str.extractall(two_groups)
Out[**]:
        letter digit
  match
A 0          a     1
  1          a     2
B 0          b     1
C 0          c     1

Series の各要素の文字列に１回だけ一致する場合、

In [**]: s = pd.Series(['a3', 'b3', 'c2'], dtype="string")

In [**]: s
Out[**]:
0    a3
1    b3
2    c2
dtype: string

extractall(pat).xs(0, level='match')は、extract(pat)と同じ結果になります。

In [**]: extract_result = s.str.extract(two_groups, expand=True)

In [**]: extract_result
Out[**]:
  letter digit
0      a     3
1      b     3
2      c     2

In [**]: extractall_result = s.str.extractall(two_groups)

In [**]: extractall_result
Out[**]:
        letter digit
  match
0 0          a     3
1 0          b     3
2 0          c     2

In [**]: extractall_result.xs(0, level="match")
Out[**]:
  letter digit
0      a     3
1      b     3
2      c     2

Indexは.str.extractallもサポートしています。デフォルトの（0から始まる）インデックスを持つSeries.str.extractallと同じ結果の、DataFrameを返します。

In [**]: pd.Index(["a1a2", "b1", "c1"]).str.extractall(two_groups)
Out[**]:
        letter digit
  match
0 0          a     1
  1          a     2
1 0          b     1
2 0          c     1

In [**]: pd.Series(["a1a2", "b1", "c1"], dtype="string").str.extractall(two_groups)
Out[**]:
        letter digit
  match
0 0          a     1
  1          a     2
1 0          b     1
2 0          c     1

パターンに一致する、またはパターンを含む文字列のテスト

要素にパターンが含まれているかどうかを確認できます。

In [**]: pattern = r'[0-9][a-z]'

In [**]: pd.Series(['1', '2', '3a', '3b', '03c', '4dx'],
   ....:           dtype="string").str.contains(pattern)
   ....:
Out[**]:
0    False
1    False
2     True
3     True
4     True
5     True
dtype: boolean

また、要素がパターンに一致するかどうかも確認できます。

In [**]: pd.Series(['1', '2', '3a', '3b', '03c', '4dx'],
   ....:           dtype="string").str.match(pattern)
   ....:
Out[**]:
0    False
1    False
2     True
3     True
4    False
5     True
dtype: boolean

バージョン 1.1.0 から

In [**]: pd.Series(['1', '2', '3a', '3b', '03c', '4dx'],
   ....:           dtype="string").str.fullmatch(pattern)
   ....:
Out[**]:
0    False
1    False
2     True
3     True
4    False
5    False
dtype: boolean

注
match・fullmatch・containsの違いは厳密さです。fullmatchは文字列全体が正規表現にマッチするかどうかをテストし、matchは文字列の先頭を見て正規表現にマッチするかどうかをテストし、containsは文字列内の任意の位置に正規表現にマッチする部分があるかどうかをテストします。

これら３つの一致モードは、reパッケージにおけるre.fullmatch・re.match・re.searchにそれぞれ対応します。

match・fullmatch・contains・startswith・endswithなどのメソッドはオプションのna引数を受け取って、欠損値を True または False と見なすことができます。

In [**]: s4 = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog', 'cat'],
   .....:                dtype="string")
   .....:

In [**]: s4.str.contains('A', na=False)
Out[**]:
0     True
1    False
2    False
3     True
4    False
5    False
6     True
7    False
8    False
dtype: boolean

標識変数の作成

文字列の列をダミー変数化できます。たとえば、|で区切られている場合、

In [**]: s = pd.Series(['a', 'a|b', np.nan, 'a|c'], dtype="string")

In [**]: s.str.get_dummies(sep='|')
Out[**]:
   a  b  c
0  1  0  0
1  1  1  0
2  0  0  0
3  1  0  1

文字列Indexは、MultiIndexを返すget_dummiesもサポートしています。

In [**]: idx = pd.Index(['a', 'a|b', np.nan, 'a|c'])

In [**]: idx.str.get_dummies(sep='|')
Out[**]:
MultiIndex([(1, 0, 0),
            (1, 1, 0),
            (0, 0, 0),
            (1, 0, 1)],
           names=['a', 'b', 'c'])

get_dummies()についての説明もご覧ください。

主なメソッド

メソッド	説明
cat()	文字列を連結
split()	区切り文字を指定して文字列を分割
rsplit()	区切り文字を指定して文字列を末尾から分割
get()	各要素へのインデックス（i 番目の要素を取得）
join()	渡された区切り文字でシリーズの各要素の文字列を結合
get_dummies()	区切り文字を指定して文字列を分割し、ダミー変数化した DataFrame を返す
contains()	各文字列にパターン・正規表現が含まれるかどうかの、真偽値配列を返す
replace()	パターン・正規表現・文字列に一致する部分を、他の文字列または呼び出し可能オブジェクトの戻り値に置換
repeat()	文字列を複製（s.str.repeat(3)はx * 3に等しい）
pad()	文字列の左・右または両側に空白を追加
center()	str.centerに同じ
ljust()	str.ljustに同じ
rjust()	str.rjustに同じ
zfill()	str.zfillに同じ
wrap()	長い文字列を指定した値以下の長さの行に分割
slice()	Series の各文字列をスライス
slice_replace()	スライスした Series の各文字列を、指定した値に置換
count()	パターンの出現回数をカウント
startswith()	各要素に対してstr.startswith(pat)を適用するのと同じ
endswith()	各要素に対してstr.endswith(pat)を適用するのと同じ
findall()	各文字列に対して、全てのパターン・正規表現の一致リストを返す
match()	各要素に対してre.matchを適用し、パターン・正規表現に一致するかどうかの真偽値配列を返す
extract()	各要素に対してre.searchを適用し、各要素が行、各正規表現キャプチャグループが列の DataFrame を返す
extractall()	各要素に対してre.findallを適用し、各要素が行、各正規表現キャプチャグループが列の DataFrame を返す
len()	文字列の長さ
strip()	str.stripに同じ
rstrip()	str.rstripに同じ
lstrip()	str.lstripに同じ
partition()	str.partitionに同じ
rpartition()	str.rpartitionに同じ
lower()	str.lowerに同じ
casefold()	str.casefoldに同じ
upper()	str.upperに同じ
find()	str.findに同じ
rfind()	str.rfindに同じ
index()	str.indexに同じ
rindex()	str.rindexに同じ
capitalize()	str.capitalizeに同じ
swapcase()	str.swapcaseに同じ
normalize()	Unicode 標準形式を返す。unicodedata.nnormalizeに同じ
translate()	str.translateに同じ
isalnum()	str.isalnumに同じ
isalpha()	str.isalphaに同じ
isdigit()	str.isdigitに同じ
isspace()	str.isspaceに同じ
islower()	str.islowerに同じ
isupper()	str.isupperに同じ
istitle()	str.istitleに同じ
isnumeric()	str.isnumericに同じ
isdecimal()	str.isdecimalに同じ