常連

注目の的

社会貢献

質問力

自己紹介

Keras(バックエンドはTensorFlow)を利用して、各バッチ処理毎に入力データと予測結果を取得したいです。

ドキュメントを読んだところ、精度等はコールバック関数を利用して取得できるのですが、入力データと予測結果の取得方法がわかりません。

何卒ご教示のほどお願い申し上げます。

Kerasのバッチ処理毎に入力データと出力データを取得したい

jupyterlabがNodejsを認識してくれなくて困っています。
エラーコマンドは以下のとおりです。
```
$ sudo jupyter labextension install @jupyterlab/plotly-extension
Errored, use --debug for full output:
ValueError: Please install nodejs 5+ and npm before continuing installation. nodejs may be installed using conda or directly from the nodejs website.

$ which node
/home/アカウント名/.nvm/versions/node/v9.8.0/bin/node
```

jupyterlabがnodejsを認識しない

#pandasでcsvを読み込んだ後の文字列処理について

pandasでcsvを読み込み、usecolsで指定列を読み込んだ後、
さらに、「商品名」というカラムの中から「●●●（文字列）」が入っている行だけ抜きだしました。
その後、文字列を置き変えたいのですが、抜き出した行だけでなくDataFrame全体の文字列が置き換えされてしまいました。

```# coding: UTF-8
import pandas as pd

df = pd.read_csv('201806251531.csv',encoding='shift_jis',usecols=[0,51,52,105,106,109,127])

output = df[df['商品名'].str.contains('文字列')]
cut = df['商品名'].str.replace('文字列','').str.replace('文字列２','').str.replace('文字列３','')

print(cut)
#cut.to_csv('aaaa.csv',encoding='shift_jis',mode='a')

```

最終的には文字列を削除したあとcsvで出力予定です。
お手数をおかけしますが宜しくお願い致します。

[python] pandasで読み込んだDataFrameの文字列処理について

タイトルの件、
下記のように「2019年04月05日(金)」という文字列から「yyyy-mm-dd」形式の文字列を取得したいのですが、ymd = の行でエラーとなってしまいます。
どこか書き方がおかしいでしょうか？
よろしくお願いいたします。

エラー内容
time data '2019年04月06日(金)' does not match format '%Y年%m月%d日(%a)'

```Python
inputYmd = "2019年04月05日(金)"

#ymdが"2019-04-05"になってほしい
ymd = datetime.datetime.strptime(inputYmd, '%Y年%m月%d日(%a)').strftime("%Y-%m-%d")
```

【Python】日付フォーマットについて

Pythonで親ディレクトリの親ディレクトリのファイルをimportしたいのですが
以下のようなコードでは, 読み込める時と読み込めない時があります。

読み込めない時と読み込めない時の例ですが
今日読み込めたのにもかかわらず、次の日に読み込めなくなるということが以下のコードでは起こります。


```Python
import sys,os
sys.path.append('../../') # 親ディレクトリの親ディレクトリを読み込む

from ... import *  # ... : 親ディレクトリの親ディレクトリのフォルダ名, * : そのフォルダ内のimportしたいプログラム名
```

他におすすめのファイルの読み込み方法はあるでしょうか。

よろしくお願いいたします。

Pythonで他のディレクトリからプログラムをimportするやり方

リストとイテレータの違いについてお聞きしたいです。
https://miga-dev.hatenablog.com/entry/iterator
の記事を読みながら、リストとイテレータの違いを調べています。

この記事によると、
リストは最後まで行ってもエラーが出ない、
イテレータは最後まで行くとエラーが出る、ものという認識です。

ただ、このくじで書かれている”状態を記憶する”というのがよく理解できません。
”状態を記憶する”から、イテレータは最後まで行くとエラーが出るのですか？？

ここでいう、”状態を記憶する”ということについての解説と、
リストとイテレータの違いの認識が間違ってないかをお聞きしたいです

リストとイテレータの違いについて

###前提・実現したいこと
Python（Keras）でCNNを用い2種類の画像を判別するプログラムを作っております。
その時に学習したモデルを活用して判定時にどこに注目したのかを
grad-camにより、表現したいと考えております。
grad-camについては
https://github.com/jacobgil/keras-grad-cam/blob/master/grad-cam.py
こちらのコードを参考にしており自分のモデルに合わせて対象箇所を変えたつもりです。

モデルはこちらになります。
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d_1 (Conv2D)            (None, 62, 62, 32)        896       
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 31, 31, 32)        0         
_________________________________________________________________
dropout_1 (Dropout)          (None, 31, 31, 32)        0         
_________________________________________________________________
zero_padding2d_1 (ZeroPaddin (None, 33, 33, 32)        0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 31, 31, 96)        27744     
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (None, 15, 15, 96)        0         
_________________________________________________________________
dropout_2 (Dropout)          (None, 15, 15, 96)        0         
_________________________________________________________________
zero_padding2d_2 (ZeroPaddin (None, 17, 17, 96)        0         
_________________________________________________________________
conv2d_3 (Conv2D)            (None, 15, 15, 96)        83040     
_________________________________________________________________
max_pooling2d_3 (MaxPooling2 (None, 7, 7, 96)          0         
_________________________________________________________________
flatten_1 (Flatten)          (None, 4704)              0         
_________________________________________________________________
dense_1 (Dense)              (None, 1024)              4817920   
_________________________________________________________________
dropout_3 (Dropout)          (None, 1024)              0         
_________________________________________________________________
dense_2 (Dense)              (None, 2)                 2050      
=================================================================
Total params: 4,931,650
Trainable params: 4,931,650
Non-trainable params: 0
_________________________________________________________________


###発生している問題・エラーメッセージ

```
IndexError                                Traceback (most recent call last)
<ipython-input-3-2fe13b62daac> in <module>()
    128 
    129 predicted_class = np.argmax(predictions)
--> 130 cam, heatmap = grad_cam(model, preprocessed_input, predicted_class, "conv2d_3")
    131 cv2.imwrite("gradcam.jpg", cam)
    132 

<ipython-input-3-2fe13b62daac> in grad_cam(input_model, image, category_index, layer_name)
     92 
     93     loss = K.sum(model.layers[-1].output)
---> 94     conv_output =  [l for l in model.layers[0].layers if l.name is layer_name][0].output
     95     grads = normalize(K.gradients(loss, conv_output)[0])
     96     gradient_function = K.function([model.layers[0].input], [conv_output, grads])

IndexError: list index out of range
```

###該当のソースコード
```python
from keras.preprocessing import image
from keras.layers.core import Lambda
from keras.models import Sequential ,load_model
from tensorflow.python.framework import ops
import keras.backend as K
import tensorflow as tf
import numpy as np
import keras
import sys
import cv2

def target_category_loss(x, category_index, nb_classes):
    return tf.multiply(x, K.one_hot([category_index], nb_classes))

def target_category_loss_output_shape(input_shape):
    return input_shape

def normalize(x):
    # utility function to normalize a tensor by its L2 norm
    return x / (K.sqrt(K.mean(K.square(x))) + 1e-5)

def load_image(path):
    img_path = path
    img = image.load_img(img_path, target_size=(64, 64))
    x = image.img_to_array(img)
    x = np.expand_dims(x, axis=0)
    return x

def register_gradient():
    if "GuidedBackProp" not in ops._gradient_registry._registry:
        @ops.RegisterGradient("GuidedBackProp")
        def _GuidedBackProp(op, grad):
            dtype = op.inputs[0].dtype
            return grad * tf.cast(grad > 0., dtype) * \
                tf.cast(op.inputs[0] > 0., dtype)

def compile_saliency_function(model, activation_layer='conv2d_3'):
    input_img = model.input
    layer_dict = dict([(layer.name, layer) for layer in model.layers[1:]])
    layer_output = layer_dict[activation_layer].output
    max_output = K.max(layer_output, axis=3)
    saliency = K.gradients(K.sum(max_output), input_img)[0]
    return K.function([input_img, K.learning_phase()], [saliency])

def modify_backprop(model, name):
    g = tf.get_default_graph()
    with g.gradient_override_map({'Relu': name}):

        # get layers that have an activation
        layer_dict = [layer for layer in model.layers[1:]
                      if hasattr(layer, 'activation')]

        # replace relu activation
        for layer in layer_dict:
            if layer.activation == keras.activations.relu:
                layer.activation = tf.nn.relu

        # re-instanciate a new model
        new_model = model
    return new_model

def deprocess_image(x):
    '''
    Same normalization as in:
    https://github.com/fchollet/keras/blob/master/examples/conv_filter_visualization.py
    '''
    if np.ndim(x) > 3:
        x = np.squeeze(x)
    # normalize tensor: center on 0., ensure std is 0.1
    x -= x.mean()
    x /= (x.std() + 1e-5)
    x *= 0.1

    # clip to [0, 1]
    x += 0.5
    x = np.clip(x, 0, 1)

    # convert to RGB array
    x *= 255
    if K.image_dim_ordering() == 'th':
        x = x.transpose((1, 2, 0))
    x = np.clip(x, 0, 255).astype('uint8')
    return x

def grad_cam(input_model, image, category_index, layer_name):
    model = Sequential()
    model.add(input_model)

    nb_classes = 2
    target_layer = lambda x: target_category_loss(x, category_index, nb_classes)
    model.add(Lambda(target_layer,
                     output_shape = target_category_loss_output_shape))

    loss = K.sum(model.layers[-1].output)
    conv_output =  [l for l in model.layers[0].layers if l.name is layer_name][0].output
    grads = normalize(K.gradients(loss, conv_output)[0])
    gradient_function = K.function([model.layers[0].input], [conv_output, grads])

    output, grads_val = gradient_function([image])
    output, grads_val = output[0, :], grads_val[0, :, :, :]

    weights = np.mean(grads_val, axis = (0, 1))
    cam = np.ones(output.shape[0 : 2], dtype = np.float32)

    for i, w in enumerate(weights):
        cam += w * output[:, :, i]

    cam = cv2.resize(cam, (64, 64))
    cam = np.maximum(cam, 0)
    heatmap = cam / np.max(cam)

    #Return to BGR [0..255] from the preprocessed image
    image = image[0, :]
    image -= np.min(image)
    image = np.minimum(image, 255)

    cam = cv2.applyColorMap(np.uint8(255*heatmap), cv2.COLORMAP_JET)
    cam = np.float32(cam) + np.float32(image)
    cam = 255 * cam / np.max(cam)
    return np.uint8(cam), heatmap

# 判定画像の読み込み
preprocessed_input = load_image('image.jpeg')

model = load_model('mymodel.h5')
model.summary()

predictions = model.predict(preprocessed_input)

predicted_class = np.argmax(predictions)
cam, heatmap = grad_cam(model, preprocessed_input, predicted_class, "conv2d_3")
cv2.imwrite("gradcam.jpg", cam)

register_gradient()
guided_model = modify_backprop(model, 'GuidedBackProp')
saliency_fn = compile_saliency_function(guided_model)
saliency = saliency_fn([preprocessed_input, 0])
gradcam = saliency[0] * heatmap[..., np.newaxis]
cv2.imwrite("guided_gradcam.jpg", deprocess_image(gradcam))
```

###試したこと
1行1行入力してみたもののどこが問題かわからず、
もともと専門外で初心者なこともあり、お手上げ状態です…

###補足情報(言語/FW/ツール等のバージョンなど)
tensorflow (1.1.0)
Keras (2.0.4)

【Keras】grad-camの実装において自作の学習済モデルを作りたい…がエラーが出ます…

###質問
VGG16のモデルにおけるパラメータ数がどのように求められているのかを教えてください。
例えば、全結合層のひとつではパラメータ数が4096となっていますがそれはなぜなのでしょうか。
また最初の畳み込み層のパラメータ数は1792なのもなぜでしょうか。

よろしければ計算式を教えていただけると嬉しいです。

###参考
http://aidiary.hatenablog.com/entry/20170104/1483535144

VGG16モデルのパラメータ数について

# やりたいこと
特定キーワードのGoogle検索結果を定点観測したい（競合の広告文、順位の変動など）。

イメージ例）
1　タイトルAAA　aaa.com
2　タイトルBBB　bbb.com
3　タイトルCCC　ccc.com
4　タイトルDDD　ddd.com

条件
・上記結果を計測ツールの兼ね合い上、Googleスプレッドシートに書き込みたい
・特定キーワードは100近くあり、毎日計測してデータとして残したい

## 相談内容
PythonのライブラリBeautifulSoupを使い、
スクレイピングするところまでは成功しましたが、
スプレッドシートに書き込む方法で悩んでいます。

Google APIを有効化して、ライブラリgspreadを使い、
直接書き込むことは出来ましたが、処理時間がかかり、
APIの使用条件に抵触するのではないかと懸念しています。

ちなみに、コードは以下です。

```
import gspread
from oauth2client.service_account import ServiceAccountCredentials
scope = ['https://spreadsheets.google.com/feeds','https://www.googleapis.com/auth/drive']

credentials = ServiceAccountCredentials.from_json_keyfile_name('<jsonファイル名>', scope)
gc = gspread.authorize(credentials)
wb = gc.open("＜スプレッドファイル名＞")
sh = wb.worksheet("＜スプレッドシート名＞")

for i in range(0,len(lists)):  

# lists はスクレイピングしたデータ
# 例）
#[['日付', 順位1, 'タイトル', 'URL1'],
# ['日付', 順位2, 'タイトル', 'URL2']]

    sh.update_cell(i+1,1,lists[i][0])
    sh.update_cell(i+1,2,lists[i][1])
    sh.update_cell(i+1,3,lists[i][2])
    sh.update_cell(i+1,4,lists[i][3])

```

別案としては、Python経由でスプレッドシートに書き込みはしないで、
一度CSVに保存をさせて、Google Apps Script で保存したCSVを
スプレッドシードに書き込むなども考えています。

本状況において、ご助言いただけると幸いです。
よろしくお願いします。

PythonでスクレイピングしたデータをGoogleスプレッドシートに保存したい

###サンプル数を少なくする工夫について

最近機械学習を始めて、ＭＮＩＳＴ等の精度を上げるためにいろいろ調べました。
そこでふと思ったのですが、サンプル数を少なくする方法は研究とかは行われるのでしょうか。

もし人が新しい言語・数字を学習するとしたら数万個も同じ文字の例を探さずに、
正解の文字をしっかり学習することから始めるかと思いますが、機械学習はその逆を行っているように感じるので。

そういう研究・論文をどこかで見かけたことはあるでしょうか。

深層学習でのサンプル数について

```python3
from sys import argv

def f(x):
    if int(x) < 2:
        return print("wonderful")
    elif int(x) >= 2 and int(x) <= 8:
        return print("bad")
    elif int(x) > 8:
        return print("OK")

print(f(argv[1]))
```
という関数のスクリプトを作り、コマンドラインで
~$python3　 ~.py 　数字（例：5）
と打つと、

bad
**None**

とアウトプットが出てきます。
なぜ、このNoneが出てきてしまうのでしょうか？
よろしくお願いします。

pythonのsysモジュールのargvを使うとnoneが出る

Macで

~/.jupyter/jupyter_notebook_config.py

というファイルをエディタで開きたいのですが、Userのホームディレクトリ以下にこれを見つけることができません。

.jupyterの.が関連しているのかな思い、調べましたが解決できませんでした。

よろしくお願いします。

ターミナルで以下を実行しました。

```ここに言語を入力
jupyter notebook --generate-config

Writing default config to: /Users/myname/.jupyter/jupyter_notebook_config.py
```

.jupyterというpath

KerasのConv2D関数のパラメーターfilters: 「使用するカーネルの数」って意味不明です。
カーネルサイズ(Gaussian関数のσに相当)が指定されれば、そのfilterも唯一に決められ、一つしかないと思いますが、どうして「使用するカーネルの数」というパラメーターがあるのでしょうか。

もしかして、同じfilterを使って画像を連続的に(結果を継承的に)平滑する回数の事を指しているのでしょうか。
そうだったら、同じ画像に対して何十回も繰り返し平滑したら、画像内容がなくなりますね！？

filters: 「使用するカーネルの数」を解釈できる方お願い致します。

KerasのConv2D関数のパラメーターfilters: 使用するカーネルの数、って意味不明

kerasでディープラーニングの計算をする際に、一日放置していた時、モデルが過学習を起こしていたので、指定したepochごとに学習したモデルとlossなどの計算結果を保存するプログラムが欲しいです。
fitで学習を実行したときに引数のcallbacksでログを保存することは知っているのですが、それだと最終結果しか保存されないので困っています。
よろしくお願いします。

kerasで指定したepoch数ごとに学習したモデルを保存する方法について

``````
l = []
for i in range(30):
    n = random.randint(0, 100)
    l.append(n)
    
    
k = sorted(l)

print(k[0])
```



上記のようにリストの最小値を求めているコードをかいたのですが、
このコードをsorted()やmin()を使わず最小値を求めるためにはfor文でどうに記述したらいいのか
わかりませ。
おそらく、リストの中身を取り出して、大小を比べる感じだとはなんとな考えてますが、
記述方法がわからず悩んでいます。
どうかヒントをお願いします。

python 　最小値の求め方

tensorflowで以下のようなニューラルネット(Domain adversarial neuralnetwork)を組んで学習させていたのですが，feature extractorと書いてある部分のLSTM層のところにdropout（tf.nn.dropout）を挟んだところ，学習が進まなくなってしまいました。(labelの二値分類が0.5の精度からほとんど動かない。dropout挟む前は普通に学習できていた)

dropout層の後の出力を可視化してみてみたのですが，dropoutに入力する前の値と変化がありませんでした。。

tf.nn.dropoutの使い方が間違っているのでしょうか？ご存知の方教えていただけると助かります。

```python
    import tensorflow as tf

    X = tf.placeholder(tf.float32, [None,time_steps,input_row], name='X') # Input data
    Y_ind = tf.placeholder(tf.int32, [None], name='Y_ind')  # Class index
    D_ind = tf.placeholder(tf.int32, [None], name='D_ind')  # Domain index
    l = tf.placeholder(tf.float32, [], name='l')        # Gradient reversal scaler
 
    Y = tf.one_hot(Y_ind, 2)
    D = tf.one_hot(D_ind, 3)
 
    # Feature extractor
    lstm_1 = tf.nn.rnn_cell.BasicLSTMCell(15, name='blstmc1')
    lstm_2 = tf.nn.rnn_cell.BasicLSTMCell(15, name='blstmc2')
    lstm_3 = tf.nn.rnn_cell.BasicLSTMCell(15, name='blstmc3')
 
    lstm_out_1,states_op = tf.nn.dynamic_rnn(lstm_1,X,dtype=tf.float32,time_major=False)
    lstm_out_1_drop = tf.nn.dropout(lstm_out_1, 0.5)##ここ
    lstm_out_2,states_op = tf.nn.dynamic_rnn(lstm_2,lstm_out_1_drop,dtype=tf.float32,time_major=False)
    lstm_out_2_drop = tf.nn.dropout(lstm_out_2, 0.5)##ここ
    lstm_out_3,states_op = tf.nn.dynamic_rnn(lstm_3,lstm_out_2_drop,dtype=tf.float32,time_major=False)
 
    lstm_out_last = lstm_out_3[:,-1,:]
 
    W11 = weight_variable([15, 15])
    b11 = bias_variable([15])
    f_logit = tf.matmul(lstm_out_last, W11) + b11
    feature_vector = tf.nn.softmax(f_logit)
 
    # Label predictor
 
    W1 = weight_variable([15, 2])
    b1 = bias_variable([2])
    p_logit = tf.matmul(feature_vector, W1) + b1
    p = tf.nn.softmax(p_logit)
    p_loss = tf.nn.softmax_cross_entropy_with_logits(logits=p_logit, labels=Y)
 
    # Domain predictor
    f_ = flip_gradient(feature_vector, l)
 
    W2 = weight_variable([15, 8])
    b2 = bias_variable([8])
    h2 = tf.nn.relu(tf.matmul(f_, W2) + b2)
 
    W3 = weight_variable([8, 3])
    b3 = bias_variable([3])
    d_logit = tf.matmul(h2, W3) + b3
    d = tf.nn.softmax(d_logit)
    d_loss = tf.nn.softmax_cross_entropy_with_logits(logits=d_logit, labels=D)
 
    # Optimization
    pred_loss = tf.reduce_sum(p_loss, name='pred_loss')
    domain_loss = tf.reduce_sum(d_loss, name='domain_loss')
    total_loss = tf.add(pred_loss, domain_loss, name='total_loss')
     
    #for dann_train_op
    dann_train_op = tf.train.AdamOptimizer().minimize(total_loss, name='dann_train_op')
     
```

tensorflowでのdropout使用方法について

```ここに言語を入力import pandas as pd # Example data definition 
df = pd.DataFrame(
    {"wing" : [12, 10, 13, 10, 13, 12, 15, 12],
     "body" : [15, 20, 23, 27, 30, 36, 39, 42], 
     "type" : [0, 0, 0, 0, 1, 1, 1, 1]
}) 
df.head()
import matplotlib.pyplot as plt
plt.scatter(df.loc[:, 'wing'], df.loc[:, 'body'], c=df.loc[:, 'type'], cmap=plt.cm.cool) 
plt.legend()
plt.show()
```

ここでplt.scatter(df.loc[:, 'wing'], df.loc[:, 'body'], c=df.loc[:, 'type'], の:,はなにをいみしているのでしょうか？

pythonについて

現在９軸センサー（加速度、ジャイロ、コンパス）を内蔵したボールを用いて,unityと連動することを試みています。具体的に目標としているのが、現実のボールが転がった方向に、unity上のボールも同じ方向に回転移動するというものです。

transform.rotation =Quaternion.Euler (mag [0], mag [1], mag [2]);

magはコンパスから計算された姿勢角がそのまま代入されています。上記のプログラムを実行するとunity上のボールがカクカク回転しまうため、この方法は適していないと考えました。

rb.velocity = Quaternion.Euler (mag [0], mag [1], mag [2]) * new Vector3 (v[0], v[1], v[2]);

ｖは加速度センサの値を代入し、姿勢角方向に加速度ベクトルの分だけ速度を与える方法を実行してみたのですが、あまり良い挙動になりませんでした。
よろしければまだこういう方法があるなど教えていただけないでしょうか？

9軸センサーとunityの連動

if __name__ == '__main__': の必要性がわかりません。
```ここに言語を入力
# coding: utf-8

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import os
import time
import tensorflow as tf

import model as model

from reader import Cifar10Reader

FLAGS = tf.app.flags.FLAGS
tf.app.flags.DEFINE_integer('epoch',30,"訓練するEpoch数")
tf.app.flags.DEFINE_string('data_dir','./data/',"訓練データのディレクトリ")
tf.app.flags.DEFINE_string('checkpoint_dir','./checkpoints/',"チェックポイントを保存するディレクトリ")

filenames = [
    os.path.join(FLAGS.data_dir,'data_batch_%d.bin' % i) for i in range(1,6)
]


def main(argv=None):
    train_placeholder = tf.placeholder(tf.float32,shape=[32,32,3],name='input_image')
    image_node = tf.expand_dims(train_placeholder,0)

    logits = model.inference(image_node)

    with tf.Session() as sess:
        sess.run(tf.initialize_all_variables())

        total_duration = 0

        for epoch in range(1,FLAGS.epoch+1):
            start_time = time.time()

            for file_index in range(5):
                print('Epoch %d: %s' % (epoch,filenames[file_index]))
                reader = Cifar10Reader(filenames[file_index])

                for index in range(10000):
                    image = reader.read(index)

                    logits_value = sess.run([logits],feed_dict={
                        train_placeholder:image.byte_array,
                    })

                    if index % 1000 ==0:
                        print('[%d]: %r'% (image.label,logits_value))

            reader.close()

            duration = time.time() - start_time
            total_duration += duration

            print('epoch %d duration = %d sec'%(epoch,duration))

            tf.train.SummaryWriter(FLAGS.checkpoint_dir,sess.graph)
        print('Total duration = %d sec'% total_duration)

if __name__ == '__main__':
    tf.app.run()
```
というCIFAR-10形式のデータセットを推論するプログラムを書きました。
このコードの最後に
```ここに言語を入力
if __name__ == '__main__':
    tf.app.run()
```
という記述がありますが、この記述の必要性がわかりません。
http://azuuun-memorandum.hatenablog.com/entry/2015/05/09/002549
の記事を読んで、if __name__ == '__main__':
メソッドの機能はわかりました。（トップレベルファイルで実行された時にのみ、テスト用の値出力処理が行われるようにすることができる 事）
しかし、この記述がこのコードの一番下で必要な理由がわかりません。
どうしてこの記述は必要なのでしょうか？

if __name__ == '__main__':　の必要性

### 前提・実現したいこと
|         time        | data |
|:-------------------:|:----:|
| 2018-06-01 00:**03**:00 | 0    |
| 2018-06-01 00:04:00 | 1    |
| 2018-06-01 01:**05**:00 | 0    |
| 2018-06-01 01:06:00 | 1    |

この様な抜けのある時系列データを、一時間単位でDataFrame.resampleすると

|         time        | data |
|:-------------------:|:----:|
| 2018-06-01 00:**00**:00 | 1    |
| 2018-06-01 01:**00**:00 | 1    |

この様に最初のデータのタイムスタンプが**00**始まりになります。
これを元のデータと同じ開始時刻に揃え、
|         time        | data |
|:-------------------:|:----:|
| 2018-06-01 00:**03**:00 | 1    |
| 2018-06-01 01:**05**:00 | 1    |

この様にしたいのです。

### 該当のソースコード

```python
import pandas as pd

df = pd.DataFrame(
    {'data':[0,1,0,1]},
    index = ["2018-06-01 00:03:00",
             "2018-06-01 00:04:00",
             "2018-06-01 01:05:00",
             "2018-06-01 01:06:00",])
df.index = pd.to_datetime(df.index)

print(df)
#                     data
#2018-06-01 00:03:00     0
#2018-06-01 00:04:00     1
#2018-06-01 01:05:00     0
#2018-06-01 01:06:00     1 

print(df.resample('1H').sum())
#                     data
#2018-06-01 00:00:00     1
#2018-06-01 01:00:00     1
```

### 試したこと

実際のデータは巨大で、for文ではかなり時間が掛かってしまいました。
出来るだけ高速に実現する方法を探しています。