常連

注目の的

社会貢献

質問力

お世話になります。

openpyxl(Pythonライブラリ)を使ってExcelの特定の行をコピーしたいです。
調べてみましたが特定の行全体をコピーして、特定の行(位置)に貼り付け(挿入)する方法が書かれたサイトを見つけることができませんでした。
どなたか教えて下さい。

スクリプトと同じ階層にSample.xlsxがあり、A1にaaaという文字列があります。
A1のセルだけではなく、この1行目全体を3行目にコピーしたいです。
方法が書かれたサイトを見つけることができずここまでしかできていません。

```
import openpyxl
wb = openpyxl.load_workbook("Sample.xlsx")
ws = wb["Sheet1"]
value1 = ws['A1'].value
value2 = ws['C1'].value
value3 = ws['E1'].value
```

```
print(value1)
print(value2)
print(value3)
aaa
bbb
eee
```

環境は以下です。
・CentOS7(64bit)
・openpyxl 3.0.4
・python 3.8.3

openpyxl(Pythonライブラリ)を使ってExcelの特定の行をコピーしたい

### 前提・実現したいこと

Pythonでxlwingsを呼び出し、
以下のセル範囲を別のブックのセルへペーストしたいです。

理論上は該当のソースコードで問題なく選択、貼り付けを行えますが、
末尾に指定するセルを「E7」とマジックナンバーのように指定するのではなく、
「値の入っている行列の全選択」として汎用的に範囲指定できるようにしたいです。

![イメージ説明](2f59f145bb9da428fd90a866e35b27cf.png)

### 該当のソースコード

```Python
import xlwings as xw

path1 = r"C:\Users\xxxxxx\Documents\xl_sample1.xlsx"
path2 = r"C:\Users\xxxxxx\Documents\xl_sample2.xlsx"

wb1 = xw.Book(path1)
wb2 = xw.Book(path2)

# シート１＿Aタブ＿A列～E列　→　シート２＿Bタブ＿A1セル
my_values = wb1.sheets['Sheet_A'].range('A1:E7').options(ndim=2).value 
wb2.sheets['Sheet_B'].range('A1').value = my_values

wb2.save()
wb2.app.quit()
```

### 試したこと

以下の記事を参考にendメソッドも試しましたが、
これはExcel上の操作でいう「Ctrl + ↓/→」となってしまい、
本来求めている「Ctrl + Shift + ↓/→」となる方法ではないようでした。

[https://ysko909.github.io/posts/edit-excel-with-python-and-xlwings/#:~:text=%E6%9C%80%E7%B5%82%E5%88%97%E3%81%BE%E3%81%9F%E3%81%AF%E6%9C%80%E7%B5%82%E8%A1%8C%E3%82%92%E8%AA%BF%E3%81%B9%E3%82%8B](https://ysko909.github.io/posts/edit-excel-with-python-and-xlwings/#:~:text=%E6%9C%80%E7%B5%82%E5%88%97%E3%81%BE%E3%81%9F%E3%81%AF%E6%9C%80%E7%B5%82%E8%A1%8C%E3%82%92%E8%AA%BF%E3%81%B9%E3%82%8B)

【xlwings】値の入っている行列の全選択をコピーし指定のセルへペーストしたい

keras-yolo3で画像認識を行いたいです。

tensorflow_gpu 1.14.0をインストールしGPUが認識されていることを以下のコマンドで確認
```python
from tensorflow.python.client import device_lib
device_lib.list_local_devices()
```

```

[name: "/device:CPU:0"
device_type: "CPU"
memory_limit: 268435456
locality {
}
incarnation: 13425312240760914474
, name: "/device:GPU:0"
device_type: "GPU"
memory_limit: 4838588416
locality {
  bus_id: 1
  links {
  }
}
incarnation: 7886438113299407581
physical_device_desc: "device: 0, name: GeForce RTX 2060, pci bus id: 0000:01:00.0, compute capability: 7.5"
]
```

その後、yolo3で学習を開始したのですが
タスクマネージャーを見ると、GPUが３％程度しか使用されていません。

GPUの使用率を上げるには、どのようにすればよいでしょうか。

keras-yolo3　学習時にGPUが３％しか使われない

#行で重複した際の処理について

いつもありがとうございます！
今回はどうすればいいか全く歯がたたず・・・
コードの記載ができないですがご了承いただければ幸いです。。

![](def4cbe075d585d20f76181f0812caef.jpeg)

上記のイメージの様なデータを読み込み、新しいcsvを出力予定です。

![](0c55929e7e4d0a8e82df53727d9e3bc9.jpeg)

二つ目の画像のような状態にしたいのですが…
どうやって手を付けていいか全く想像がつきません。
ヒントを頂けると幸いです。

不躾な質問だとはひゃくも承知でございますが何卒よろしくお願い申し上げます。

[python]行で重複した値の処理

dataframe をreshapesしたいです。
具体的には
```Python
df = pd.DataFrame(np.arange(6).reshape(3, 2),
                  columns=['col_0', 'col_1'],
                  index=['row_0', 'row_1', 'row_2'])
print(df)

     col_0	col_1
row_0	0	1
row_1	2	3
row_2	4	5

```

このデータを

```Python
        col_0	col_1   col_0_r1 col_1_r1 col_0_r2 col_1_r2 
row	     0   	1　     2  	3    　4  	5

```
のようにしたいのですがどのようにすればよいでしょうか。
カミサマ教えて下さい！！

【Python】Pandas dataframe のreshapeをしたい

pythonを使用してcsvを二次元配列格納したいと考えています。
検索しても良い結果が得られないため教えてほしいです。

pythonでcsvデータを二次元配列に格納

XGBoostで学習した結果、以下のようなグラフが得られました。

rounds=500で実験を行ったとき、rounds=188でlossが最小になっていることが分かりました。
この場合を用いて推測を行いたいのですが、どのように指定すればいいのでしょうか。



![イメージ説明](52379f260fe0326a33347c3e63562cd5.png)

何が回答に必要なのかわからないので、この表を出すまでのコードを一応掲載しておきます。
```Python
from sklearn.model_selection import train_test_split
import xgboost as xgb

X_train, Y_train, X_target, Y_target = train_test_split(train, target, random_state=0)

dtrain = xgb.DMatrix(X_train, label=X_target)
dvalid = xgb.DMatrix(Y_train, label=Y_target)
num_round = 500
evallist = [(dvalid, "eval"), (dtrain, "train")]
evals_result = {}
param = {
    "max_depth": 3,
    "eta": 0.01,
    "objective": "reg:squarederror",
}
bst = xgb.train(
                        param, dtrain,
                        num_round,
                        evallist,
                        evals_result=evals_result,
                        # 一定ラウンド回しても改善が見込めない場合は学習を打ち切る
                        early_stopping_rounds=1000
)

plt.figure(figsize=(10, 5))
train_metric = evals_result['train']['rmse']
plt.plot(train_metric, label='train rmse')
eval_metric = evals_result['eval']['rmse']
plt.plot(eval_metric, label='eval rmse')
plt.grid()
plt.legend()
plt.xlabel('rounds')
plt.ylabel('rmse')
plt.ylim(5, 40)
plt.show()
```

Python_XGBoost

連番でファイルを作成して保存しようとしていますがどのように指定したらよろしいのでしょうか。読み込みのときは分かるのですが、保存の時の仕方が分かりません。

count : for文で連続した値が入る 0,1,2,3,4...

write_file_name = "comb" + count + ".jpg"
cv2.imwrite( path + write_file_name, 本体)

作りたいのは
comb000.jpg
comb001.jpg
comb002.jpg
みたいなファイルです。

繰り返しで画像を保存するときのファイル名の付け方

機械学習に用いられるxgboostにおける質問です。
xgboostで学習を行う際に、fitとtrainがありますがそれらの違いがわかりません。
fitとtrainのパフォーマンスの違いなどがあれば教えていただけるとありがたいです。

xgboostのfitとtrainの違いがわからない。

pythonでLSTMの行う際に、隠れ層を多層にしたいです。

1層でのプログラムなら動いたのですが、二層にするとエラーが発生します。
```Python


model = Sequential()
input_shape=(max_len, n_in)

model.add(LSTM(n_hidden, kernel_initializer=weight_variable, input_shape=input_shape))
model.add(Dropout(0.5))

model.add(LSTM(n_hidden, kernel_initializer=weight_variable))
model.add(Dropout(0.5))

model.add(Dense(n_out, kernel_initializer=weight_variable))
model.add(Activation('linear'))

optimizer = Adam(lr=0.001, beta_1=0.9, beta_2=0.999)
model.compile(loss="mse", optimizer=optimizer)

epochs = 100
batch_size = 64

history = model.fit(X_train, Y_train,
          batch_size=batch_size,
          epochs=epochs,
          validation_data=(X_val, Y_val),
          callbacks=[lr_decay])

```


ValueError: Input 0 is incompatible with layer lstm_12: expected ndim=3, found ndim=2


どこがいけないか教えていただきたいです。

LSTMで多層を実装したい

時系列の関連するデータ予測をしています。

時系列予測には、ARやMR、ARIMA、SARIMAなどさまざまなモデルがありますが、これらはすべて単変量の予測なのでしょうか？

説明変数の時間dsとそのy（目的変数の過去の値）をもとに、予測するしかないのでしょうか？

例えば、2018年の気温(y)を予測するとき、2016,2017年の気温以外に、同年の海水温度や晴れの日の数（実際に、気温に関係するかはわかりませんが）を説明変数として使うことはできないのでしょうか？

過去の値以外を説明変数に用いたいときがあると思うんですが、そうしたときはどのようなモデルを使うのでしょうか？重回帰分析ということになるのでしょうか？（しかし、重回帰分析では時系列をうまく扱えませんよね・・・？）

それとも、モデル選択の問題ではないのでしょうか？

質問内容に対する逆質問は歓迎します。回答よろしくお願いします。

説明変数が複数ある時系列予測をするには？

###実現したいこと
pythonにおいて指定したディレクトリ内の画像を例えば7:3とかの割合に(できればランダムで)分けて2つのディレクトリに保存したいと考えています。自分の知識では思いつかなかったので、皆様の力をお借りしたいです。

###階層例
例えば

__img__
|-img1.jpg
|-img2.jpg
     .
     .
     .

というディレクトリを

__img__
|-dir1
| |-img1_1.jpg
| |-img1_2.jpg
| .
| .
| .
|-dir2
| |-img2_1.jpg
| |-img2_2.jpg
| .
| .
| .

というように２つのディレクトリに分けたいということです。図がわかりづらくて申し訳ありません。

###使用環境
python 3.6.3

フォルダ内の画像をランダムで特定の割合に分けたい

Kerasの`fit_generator`を用いた画像認識用の学習を行っているのですが、
バッチ処理とエポックの関係について理解が足りていないので教えて頂きたく思います。
（とりあえず実働はしているのですが、どういう流れで動いているか把握しきれていない状態です）

前提条件として、学習用画像が2000枚（100種類のラベルが存在し、1ラベルにつき20枚の画像が存在）、
バッチ数を32、エポック数を10としています。（評価用画像は今は割愛）

---

**質問１．`steps_per_epoch = 2000 / 32 = 62`としました。**
[Sequentialモデル - Keras Documentation](https://keras.io/ja/models/sequential/)
のsteps_per_epochにある「典型的には」の計算式を用いています（画像総数/バッチ数）
この場合、以下のような挙動をするという認識で合っていますでしょうか？
```
■1エポック目
・1回目のバッチ処理：1〜32枚目の画像を学習
・2回目のバッチ処理：33〜64枚目の画像を学習
……
・62回目のバッチ処理：2017〜2048枚目の画像を学習（実際は17〜48枚目？）

■以降10エポック目まで1エポック目と同じことの繰り返し
→結果的に2048枚を10回学習する。
```
---
**質問２．一部分ごとの学習がしたかった為、`steps_per_epoch = 2000 / 32 / 10 = 6`としました。**
この場合、以下のような挙動をするという認識で合っていますでしょうか？
```
■1エポック目
・1回目のバッチ処理：1〜32枚目の画像を学習
・2回目のバッチ処理：33〜64枚目の画像を学習
……
・6回目のバッチ処理：161〜192枚目の画像を学習

■2エポック目
・1回目のバッチ処理：193〜224枚目の画像を学習
・2回目のバッチ処理：224〜256枚目の画像を学習
……
・6回目のバッチ処理：353〜384枚目の画像を学習

（以下省略）
→結果的に steps_per_epoch*エポック数*バッチ = 6*10*32 = 1920枚 を1回学習する。
```
---
**質問３．質問２が正しい場合。**
`steps_per_epoch=6, initial_epoch=1, epochs=2`と設定した`fit_generator`を２回呼んだとします。
この場合、「質問２の2エポック目（193〜384枚目）を2回学習する（他の画像は学習しない）」という扱いになるのでしょうか？

fit_generatorにおけるバッチ処理とエポックの関係

kerasでCNNを構築しました。
画像の読み取りにはimagedatageneratorを使用しています。
かさ増しするためzoom_range等を使用しました。
かさ増しする画像枚数を指定したいのですがソースコードがよくわかりません。
回答お願いしましす
```import keras
from keras.models import Sequential, Model
from keras.layers import Conv2D, MaxPooling2D
from keras.layers import Activation, Dropout, Flatten, Dense
from keras.optimizers import Adam
from keras.preprocessing.image import ImageDataGenerator
import matplotlib.pyplot as plt
from PIL import Image
import numpy as np

batch_size = 5
epochs = 25

#モデル構築
def Mymodel():
    model = Sequential()
    #畳み込み層１
    model.add(Conv2D(32, (3, 3), input_shape=(50, 50, 3)))
    model.add(Activation('relu'))
    #プーリング層１
    model.add(MaxPooling2D(pool_size=(2, 2)))
    
    #畳み込み層２
    model.add(Conv2D(64, (3, 3)))
    model.add(Activation('relu'))
    #プーリング層２
    model.add(MaxPooling2D(pool_size=(2, 2)))
    
    #畳み込み層３
    model.add(Conv2D(96, (3, 3)))
    model.add(Activation('relu'))
    #プーリング層３
    model.add(MaxPooling2D(pool_size=(2, 2)))
    
    #畳み込み層４
    model.add(Conv2D(128, (3, 3)))
    model.add(Activation('relu'))
    #プーリング層４
    model.add(MaxPooling2D(pool_size=(2, 2)))
    
    #1次配列に変更
    model.add(Flatten())
    model.add(Dense(96))
    model.add(Activation('relu'))
    model.add(Dropout(0.5))
    model.add(Dense(5))
    model.add(Activation('softmax'))
    
    model.summary()
    
    return model


model = Mymodel()

for layer in model.layers:
    layer.trainable = True

model.compile(loss='categorical_crossentropy',
              optimizer='Adam',
              metrics=['accuracy'])

train_datagen = ImageDataGenerator(
   rescale=1.0 / 255,
   shear_range=0.2,
   zoom_range=0.2,
   horizontal_flip=True)


test_datagen = ImageDataGenerator(rescale=1.0 / 255)

train_generator = train_datagen.flow_from_directory(
   'ダウンロード/train1',
   target_size=(50, 50),
   batch_size=batch_size,
   class_mode='categorical')

validation_generator = test_datagen.flow_from_directory(
   'ダウンロード/test1',
   target_size=(50, 50),
   batch_size=batch_size,
   class_mode='categorical')

print(train_generator.class_indices)

hist = model.fit_generator(
  train_generator,
  steps_per_epoch=20,
  nb_epoch=epochs,
  validation_data=validation_generator,
  validation_steps=75)

model.save('Mymodel.h5')

score = model.evaluate_generator(validation_generator, val_samples=75, verbose=1)
print('test loss', score[0])
print('test acc', score[1])

model = Mymodel()


model.load_weights('Mymodel.h5')


filepath = 'ダウンロード/load1-1.jpeg'
plt.show(filepath)
img = Image.open(filepath).convert('RGB')
img = img.resize((50, 50))
x = np.array(img, dtype=np.float32)
x = x / 255.
x = x[None, ...]

pred = model.predict(x, batch_size=1, verbose=1)
score = np.max(pred)
pred_label = np.argmax(pred)
print(pred_label)
print(score)

loss = hist.history['loss']
val_loss = hist.history['val_loss']
acc = hist.history['acc']
val_acc = hist.history['val_acc']
epochs = len(loss)
plt.plot(range(epochs), loss, marker='.', label='loss()')
plt.plot(range(epochs), val_loss, marker='.', label='val_loss()')
plt.legend(loc='best')
plt.grid()
plt.xlabel('epochs')
plt.ylabel('loss')
plt.show()

plt.plot(range(epochs), acc, marker='.', label='acc()')
plt.plot(range(epochs), val_acc, marker='.', label='val_acc()')
plt.legend(loc='best')
plt.grid()
plt.xlabel('epochs')
plt.ylabel('acc')
plt.show()

```

Keras CNNでImageDataGenerator使用　かさ増し枚数を指定する

###前提・実現したいこと
プログラミング初心者です以下当然のことを記載していたらすいません。

TensorFlowでアニメゆるゆりの制作会社を識別する(http://kivantium.hateblo.jp/entry/2015/11/18/233834)のブログを参考に画像認識識別をしようと実行したところ下記のように同じ結果しかでません。

１番最初に動かした時はstep145くらいまで精度があがり最高0.992843までいきましたが、step146になった途端精度が0.0889571に下がりそれ以降全200step行いましたがずっとその精度が表示され、その後何度試しても下記のような結果がでてしまうようになりました。

正常に動かない原因は何でしょうか。

###発生している問題・エラーメッセージ

```
step 0 training accuracy 0.0889571
test accuracy 0.2
step 1 training accuracy 0.0889571
test accuracy 0.2
step 2 training accuracy 0.0889571
test accuracy 0.2
step 3 training accuracy 0.0889571
test accuracy 0.2
step 4 training accuracy 0.0889571
test accuracy 0.2
step 5 training accuracy 0.0889571
test accuracy 0.2
step 6 training accuracy 0.0889571
test accuracy 0.2
step 7 training accuracy 0.0889571
test accuracy 0.2
step 8 training accuracy 0.0889571
test accuracy 0.2
step 9 training accuracy 0.0889571
test accuracy 0.2
step 10 training accuracy 0.0889571
test accuracy 0.2
step 11 training accuracy 0.0889571
test accuracy 0.2
step 12 training accuracy 0.0889571
test accuracy 0.2
step 13 training accuracy 0.0889571
test accuracy 0.2
step 14 training accuracy 0.0889571
test accuracy 0.2
step 15 training accuracy 0.0889571
test accuracy 0.2
step 16 training accuracy 0.0889571
test accuracy 0.2
step 17 training accuracy 0.0889571
test accuracy 0.2
step 18 training accuracy 0.0889571
test accuracy 0.2
step 19 training accuracy 0.0889571
test accuracy 0.2
```

###該当のソースコード
```ここに言語を入力
import sys
import cv2
import numpy as np
import tensorflow as tf
import tensorflow.python.platform

NUM_CLASSES =10  
IMAGE_SIZE = 28 
IMAGE_PIXELS = IMAGE_SIZE*IMAGE_SIZE*3

flags = tf.app.flags
FLAGS = flags.FLAGS

flags.DEFINE_string('train', '/home/k123/anaconda2/envs/tensorflow/data/train2.txt', 'File name of train data')
flags.DEFINE_string('test', '/home/k123/anaconda2/envs/tensorflow/data/test.txt', 'File name of train data')
flags.DEFINE_string('train_dir', '/home/k123/anaconda2/envs/tensorflow/data/gazo', 'Directory to put the training data.')
flags.DEFINE_integer('max_steps', 20, 'Number of steps to run trainer.')
flags.DEFINE_integer('batch_size', 10, 'Batch size'
                     'Must divide evenly into the dataset sizes.')
flags.DEFINE_float('learning_rate', 1e-4, 'Initial learning rate.')

def inference(images_placeholder, keep_prob):
     # 重みを標準偏差0.1の正規分布で初期化
    def weight_variable(shape):
    initial = tf.truncated_normal(shape, stddev=0.1)
      return tf.Variable(initial)

    # バイアスを標準偏差0.1の正規分布で初期化
    def bias_variable(shape):
    initial = tf.constant(0.1, shape=shape)
      return tf.Variable(initial)

    # 畳み込み層の作成
    def conv2d(x, W):
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

    # プーリング層の作成
    def max_pool_2x2(x):
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                            strides=[1, 2, 2, 1], padding='SAME')
    
    # 入力を28x28x3に変形
    x_image = tf.reshape(images_placeholder, [-1, 28, 28, 3])

    # 畳み込み層1の作成
    with tf.name_scope('conv1') as scope:
        W_conv1 = weight_variable([5, 5, 3, 32])
        b_conv1 = bias_variable([32])
        h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)

    # プーリング層1の作成
    with tf.name_scope('pool1') as scope:
        h_pool1 = max_pool_2x2(h_conv1)
    
    # 畳み込み層2の作成
    with tf.name_scope('conv2') as scope:
        W_conv2 = weight_variable([5, 5, 32, 64])
        b_conv2 = bias_variable([64])
        h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)

    # プーリング層2の作成
    with tf.name_scope('pool2') as scope:
        h_pool2 = max_pool_2x2(h_conv2)

    # 全結合層1の作成
    with tf.name_scope('fc1') as scope:
        W_fc1 = weight_variable([7*7*64, 1024])
        b_fc1 = bias_variable([1024])
        h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
        h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
        # dropoutの設定
        h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

    # 全結合層2の作成
    with tf.name_scope('fc2') as scope:
        W_fc2 = weight_variable([1024, NUM_CLASSES])
        b_fc2 = bias_variable([NUM_CLASSES])

    # ソフトマックス関数による正規化
    with tf.name_scope('softmax') as scope:
        y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

    # 各ラベルの確率のようなものを返す
    return y_conv

def loss(logits, labels):
     # 交差エントロピーの計算
    cross_entropy = -tf.reduce_sum(labels*tf.log(logits))
    # TensorBoardで表示するよう指定
    tf.scalar_summary("cross_entropy", cross_entropy)
    return cross_entropy

def training(loss, learning_rate):
    train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss)
    return train_step

def accuracy(logits, labels):
    correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(labels, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
    tf.scalar_summary("accuracy", accuracy)
    return accuracy

if __name__ == '__main__':
    # ファイルを開く
    f = open(FLAGS.train, 'r')
    # データを入れる配列
    train_image = []
    train_label = []
    for line in f:
        # 改行を除いてスペース区切りにする
        line = line.rstrip()
        l = line.split()
        # データを読み込んで28x28に縮小
        img = cv2.imread(l[0])
        img = cv2.resize(img, (28, 28))
        # 一列にした後、0-1のfloat値にする
        train_image.append(img.flatten().astype(np.float32)/255.0)
        # ラベルを1-of-k方式で用意する
        tmp = np.zeros(NUM_CLASSES)
        tmp[int(l[1])] = 1
        train_label.append(tmp)
    # numpy形式に変換
    train_image = np.asarray(train_image)
    train_label = np.asarray(train_label)
    f.close()

    f = open(FLAGS.test, 'r')
    test_image = []
    test_label = []
    for line in f:
        line = line.rstrip()
        l = line.split()
        img = cv2.imread(l[0])
        img = cv2.resize(img, (28, 28))
        test_image.append(img.flatten().astype(np.float32)/255.0)
        tmp = np.zeros(NUM_CLASSES)
        tmp[int(l[1])] = 1
        test_label.append(tmp)
    test_image = np.asarray(test_image)
    test_label = np.asarray(test_label)
    f.close()

with tf.Graph().as_default():
        # 画像を入れる仮のTensor
        images_placeholder = tf.placeholder("float", shape=(None, IMAGE_PIXELS))
        # ラベルを入れる仮のTensor
        labels_placeholder = tf.placeholder("float", shape=(None, NUM_CLASSES))
        # dropout率を入れる仮のTensor
        keep_prob = tf.placeholder("float")

        # inference()を呼び出してモデルを作る
        logits = inference(images_placeholder, keep_prob)
        # loss()を呼び出して損失を計算
        loss_value = loss(logits, labels_placeholder)
        # training()を呼び出して訓練
        train_op = training(loss_value, FLAGS.learning_rate)
        # 精度の計算
        acc = accuracy(logits, labels_placeholder)

        # 保存の準備
        saver = tf.train.Saver()
        # Sessionの作成
        sess = tf.Session()
        # 変数の初期化
        sess.run(tf.initialize_all_variables())
        # TensorBoardで表示する値の設定
        summary_op = tf.merge_all_summaries()
        summary_writer = tf.train.SummaryWriter(FLAGS.train_dir, sess.graph_def)

 # 訓練の実行
for step in range(FLAGS.max_steps):
            for i in range(len(train_image)//FLAGS.batch_size):
                # batch_size分の画像に対して訓練の実行
                batch = FLAGS.batch_size*i
                # feed_dictでplaceholderに入れるデータを指定する
                sess.run(train_op, feed_dict={
                  images_placeholder: train_image[batch:batch+FLAGS.batch_size],
                  labels_placeholder: train_label[batch:batch+FLAGS.batch_size],
                  keep_prob: 0.5})

            # 1 step終わるたびに精度を計算する
            train_accuracy = sess.run(acc, feed_dict={
                images_placeholder: train_image,
                labels_placeholder: train_label,
                keep_prob: 1.0})
            print('step %d training accuracy %g'%(step, train_accuracy))

            # 1 step終わるたびにTensorBoardに表示する値を追加する
            summary_str = sess.run(summary_op, feed_dict={
                images_placeholder: train_image,
                labels_placeholder: train_label,
                keep_prob: 1.0})
            summary_writer.add_summary(summary_str, step)

    # 訓練が終了したらテストデータに対する精度を表示
            print('test accuracy %g'%(sess.run(acc, feed_dict={
        images_placeholder: test_image,
        labels_placeholder: test_label,
        keep_prob: 1.0})))

    # 最終的なモデルを保存
            save_path = saver.save(sess, "model0.ckpt")
```

###試したこと
◎画像の分類するクラス数を減らして実行したところ、トレーニング精度の数値が現在の0.889571から変わったもののやはり学習回数をいくらつんでも同じ精度しか表示されませんでした。
◎モデルファイル”model0.ckpt”を一回消して実行してみましたが変わりませんでした。

###補足情報(言語/FW/ツール等のバージョンなど)
ubuntu16.04/python3.5
画像形式はjpgまたはpngです。

Tensorflow画像識別実行結果がおかしい

こちらのブログを参考にしてTensorFlowを用いた顔認識のプログラムを作成しています。
『[ディープラーニングでザッカーバーグの顔を識別するAIを作る③（データ学習編）](https://qiita.com/AkiyoshiOkano/items/9d49570b19e8a397e9b4)』

学習データを生成するmain.pyを実行したのですが、accuracyの値が少しも変動しません。

```ここに言語を入力
step 0, training accuracy 0.102362
step 1, training accuracy 0.102362
step 2, training accuracy 0.102362
step 3, training accuracy 0.102362
step 4, training accuracy 0.102362
step 5, training accuracy 0.102362
…
step 46, training accuracy 0.102362
step 47, training accuracy 0.102362
step 48, training accuracy 0.102362
step 49, training accuracy 0.102362
test accuracy 0.101773
```
各クラスの学習画像の枚数は
クラス1 623枚
クラス2 3376枚
クラス3 2096枚
になります。

解決方法を教えていただきたいです。
よろしくお願いします。

python3系、tensorflow (1.4.1)になります。

以下コード全文です。。

```python
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import cv2
import random
import numpy as np
import tensorflow as tf
import tensorflow.python.platform

# 識別ラベルの数（分類フォルダの個数）
NUM_CLASSES = 3
# 画像サイズの１辺
IMAGE_SIZE = 28
# サイズ×サイズ×色（RGB）=3
IMAGE_PIXELS = IMAGE_SIZE*IMAGE_SIZE*3

# 学習に必要なデータのpathや学習の規模を設定
# パラメタの設定、デフォルト値やヘルプ画面の説明文を登録できるTensorFlow組み込み関数
flags = tf.app.flags
FLAGS = flags.FLAGS
# 学習用データ
flags.DEFINE_string('train', './train.txt', 'File name of train data')
# 検証用テストデータ
flags.DEFINE_string('test', './test.txt', 'File name of train data')
# データを置いてあるフォルダ
flags.DEFINE_string('train_dir', './images', 'Directory to put the training data.')
# データ学習訓練の試行回数
flags.DEFINE_integer('max_steps', 50, 'Number of steps to run trainer.')
# 1回の学習で何枚の画像を使うか
flags.DEFINE_integer('batch_size', 20, 'Batch size Must divide evenly into the dataset sizes.')
# 学習率、小さすぎると学習が進まないし、大きすぎても誤差が収束しなかったり発散したりしてダメとか
flags.DEFINE_float('learning_rate', 1e-4, 'Initial learning rate.')

sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=True))

# AIの学習モデル部分(ニューラルネットワーク)を作成する
# images_placeholder: 画像のplaceholder, keep_prob: dropout率のplace_holderが引数になり
# 入力画像に対して、各ラベルの確率を出力して返す
def inference(images_placeholder, keep_prob):

  # 重みを標準偏差0.1の正規分布で初期化する
  def weight_variable(shape):
    initial = tf.truncated_normal(shape, stddev=0.1)
    return tf.Variable(initial)

  # バイアスを標準偏差0.1の正規分布で初期化する
  def bias_variable(shape):
    initial = tf.constant(0.1, shape=shape)
    return tf.Variable(initial)

  # 畳み込み層を作成する
  def conv2d(x, W):
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

  # プーリング層を作成する
  def max_pool_2x2(x):
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                          strides=[1, 2, 2, 1], padding='SAME')

  # ベクトル形式で入力されてきた画像データを28px * 28pxの画像に戻す(?)。
  # 今回はカラー画像なので3(モノクロだと1)
  x_image = tf.reshape(images_placeholder, [-1, IMAGE_SIZE, IMAGE_SIZE, 3])

  # 畳み込み層第1レイヤーを作成
  with tf.name_scope('conv1') as scope:
    # 引数は[width, height, input, filters]。
    # 5px*5pxの範囲で画像をフィルターしている。今回はカラー画像なのでinputは3?
    # 32個の特徴を検出する
    W_conv1 = weight_variable([5, 5, 3, 32])
    # バイアスの数値を代入
    b_conv1 = bias_variable([32])
    # 特徴として検出した有用そうな部分は残し、特徴として使えなさそうな部分は
    # 0として、特徴として扱わないようにしているという理解(Relu関数)
    h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)

  # プーリング層1の作成
  # 2*2の枠を作り、その枠内の特徴を1*1分にいい感じに圧縮させている。
  # その枠を2*2ずつスライドさせて画像全体に対して圧縮作業を適用するという理解
  # ざっくり理解で細分化された特徴たちをもうちょっといい感じに大まかにまとめる(圧縮する)
  with tf.name_scope('pool1') as scope:
    h_pool1 = max_pool_2x2(h_conv1)

  # 畳み込み層第2レイヤーの作成
  with tf.name_scope('conv2') as scope:
    # 第一レイヤーでの出力を第2レイヤー入力にしてもう一度フィルタリング実施。
    # 64個の特徴を検出する。inputが32なのはなんで?(教えて欲しい)
    W_conv2 = weight_variable([5, 5, 32, 64])
    # バイアスの数値を代入(第一レイヤーと同じ)
    b_conv2 = bias_variable([64])
    # 検出した特徴の整理(第一レイヤーと同じ)
    h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)

  # プーリング層2の作成(ブーリング層1と同じ)
  with tf.name_scope('pool2') as scope:
    h_pool2 = max_pool_2x2(h_conv2)

  # 全結合層1の作成
  with tf.name_scope('fc1') as scope:
    W_fc1 = weight_variable([7*7*64, 1024])
    b_fc1 = bias_variable([1024])
    # 画像の解析を結果をベクトルへ変換
    h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
    # 第一、第二と同じく、検出した特徴を活性化させている
    h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
    # dropoutの設定
    # 訓練用データだけに最適化して、実際にあまり使えないような
    # AIになってしまう「過学習」を防止の役割を果たすらしい
    h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

  # 全結合層2の作成(読み出しレイヤー)
  with tf.name_scope('fc2') as scope:
    W_fc2 = weight_variable([1024, NUM_CLASSES])
    b_fc2 = bias_variable([NUM_CLASSES])

  # ソフトマックス関数による正規化
  # ここまでのニューラルネットワークの出力を各ラベルの確率へ変換する
  with tf.name_scope('softmax') as scope:
    y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

  # 各ラベルの確率(のようなもの?)を返す
  return y_conv

# 予測結果と正解にどれくらい「誤差」があったかを算出する
# logitsは計算結果:  float - [batch_size, NUM_CLASSES]
# labelsは正解ラベル: int32 - [batch_size, NUM_CLASSES]
def loss(logits, labels):
  # 交差エントロピーの計算
  cross_entropy = -tf.reduce_sum(labels*tf.log(logits))
  # TensorBoardで表示するよう指定
  tf.summary.scalar("cross_entropy", cross_entropy)
  # 誤差の率の値(cross_entropy)を返す
  return cross_entropy

# 誤差(loss)を元に誤差逆伝播を用いて設計した学習モデルを訓練する
# 裏側何が起きているのかよくわかってないが、学習モデルの各層の重み(w)などを
# 誤差を元に最適化して調整しているという理解(?)
# (誤差逆伝播は「人工知能は人間を超えるか」書籍の説明が神)
def training(loss, learning_rate):
  #この関数がその当たりの全てをやってくれる様
  train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss)
  return train_step

# inferenceで学習モデルが出した予測結果の正解率を算出する
def accuracy(logits, labels):
  # 予測ラベルと正解ラベルが等しいか比べる。同じ値であればTrueが返される
  # argmaxは配列の中で一番値の大きい箇所のindex(=一番正解だと思われるラベルの番号)を返す
  correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(labels, 1))
  # booleanのcorrect_predictionをfloatに直して正解率の算出
  # false:0,true:1に変換して計算する
  accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
  # TensorBoardで表示する様設定
  tf.summary.scalar("accuracy", accuracy)
  return accuracy

if __name__ == '__main__':
  # ファイルを開く
  f = open(FLAGS.train, 'r')
  # データを入れる配列
  train_image = []
  train_label = []
  for line in f:
    # 改行を除いてスペース区切りにする
    line = line.rstrip()
    l = line.split()
#    print ("aaaaa line[%s] %s %s"%(line,l[0],l[1]))
    # データを読み込んで28x28に縮小
    img = cv2.imread(l[0])
    img = cv2.resize(img, (IMAGE_SIZE, IMAGE_SIZE))
    # 一列にした後、0-1のfloat値にする
    train_image.append(img.flatten().astype(np.float32)/255.0)
    # ラベルを1-of-k方式で用意する
    tmp = np.zeros(NUM_CLASSES)
    tmp[int(l[1])] = 1
    train_label.append(tmp)
  # numpy形式に変換
  train_image = np.asarray(train_image)
  train_label = np.asarray(train_label)
  f.close()

  f = open(FLAGS.test, 'r')
  test_image = []
  test_label = []
  for line in f:
    line = line.rstrip()
    l = line.split()

    img = cv2.imread(l[0])
    img = cv2.resize(img, (IMAGE_SIZE, IMAGE_SIZE))
    test_image.append(img.flatten().astype(np.float32)/255.0)
    tmp = np.zeros(NUM_CLASSES)
    tmp[int(l[1])] = 1
    test_label.append(tmp)
  test_image = np.asarray(test_image)
  test_label = np.asarray(test_label)
  f.close()

  #TensorBoardのグラフに出力するスコープを指定
  with tf.Graph().as_default():
    # 画像を入れるためのTensor(28*28*3(IMAGE_PIXELS)次元の画像が任意の枚数(None)分はいる)
    images_placeholder = tf.placeholder("float", shape=(None, IMAGE_PIXELS))
    # ラベルを入れるためのTensor(3(NUM_CLASSES)次元のラベルが任意の枚数(None)分入る)
    labels_placeholder = tf.placeholder("float", shape=(None, NUM_CLASSES))
    # dropout率を入れる仮のTensor
    keep_prob = tf.placeholder("float")

    # inference()を呼び出してモデルを作る
    logits = inference(images_placeholder, keep_prob)
    # loss()を呼び出して損失を計算
    loss_value = loss(logits, labels_placeholder)
    # training()を呼び出して訓練して学習モデルのパラメーターを調整する
    train_op = training(loss_value, FLAGS.learning_rate)
    # 精度の計算
    acc = accuracy(logits, labels_placeholder)

    # 保存の準備
    saver = tf.train.Saver()
    # Sessionの作成(TensorFlowの計算は絶対Sessionの中でやらなきゃだめ)
    sess = tf.Session()
    # 変数の初期化(Sessionを開始したらまず初期化)
    sess.run(tf.global_variables_initializer())
    # TensorBoard表示の設定(TensorBoardの宣言的な?)
    summary_op = tf.summary.merge_all()
    # train_dirでTensorBoardログを出力するpathを指定
    summary_writer = tf.summary.FileWriter(FLAGS.train_dir, sess.graph)

    # 実際にmax_stepの回数だけ訓練の実行していく
#    with tf.Session() as sess:
    for step in range(FLAGS.max_steps):
        for i in range(len(train_image)//FLAGS.batch_size):
        # batch_size分の画像に対して訓練の実行
            batch = FLAGS.batch_size*i
        # feed_dictでplaceholderに入れるデータを指定する
            sess.run(train_op, feed_dict={
                images_placeholder: train_image[batch:batch+FLAGS.batch_size],
                labels_placeholder: train_label[batch:batch+FLAGS.batch_size],
                keep_prob: 0.5})

      # 1step終わるたびに精度を計算する
        train_accuracy = sess.run(acc, feed_dict={
            images_placeholder: train_image,
            labels_placeholder: train_label,
            keep_prob: 1.0})

        print( "step %d, training accuracy %g"%(step, train_accuracy))

      # 1step終わるたびにTensorBoardに表示する値を追加する
        summary_str = sess.run(summary_op, feed_dict={
            images_placeholder: train_image,
            labels_placeholder: train_label,
            keep_prob: 1.0})
        summary_writer.add_summary(summary_str, step)

  # 訓練が終了したらテストデータに対する精度を表示する
  print ("test accuracy %g"%sess.run(acc, feed_dict={
    images_placeholder: test_image,
    labels_placeholder: test_label,
    keep_prob: 1.0}))

  # データを学習して最終的に出来上がったモデルを保存
  # "model.ckpt"は出力されるファイル名
  save_path = saver.save(sess, "./model.ckpt")

```

TensorFlowのaccuracyの値が少しも変動しません。

書籍を参考にしてkerasを使ってXOR回路を計算させるコードを書いてみました。
```python
import numpy as np
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras.optimizers import SGD

np.random.seed(0)

model = Sequential()
model.add(Dense(input_dim=2, units=1))
model.add(Activation('sigmoid'))

model.compile(loss='binary_crossentropy', optimizer=SGD(lr=0.1))

#XOR
X = np.array([[0,0],[0,1],[1,0],[1,1]])
Y = np.array([[0],[1],[1],[0]])

model.fit(X, Y, epochs=200, batch_size=1)

#学習結果の確認
classes = model.predict_classes(X, batch_size=1)
prob = model.predict_proba(X, batch_size=1)

print('classified:')
print(Y == classes)
print()
print('output probability:')
print(prob)

#出力結果
#classified:
#[[False]
# [ True]
# [ True]
# [False]]
#
#output probability:
#[[ 0.50147235]
# [ 0.50298554]
# [ 0.50041449]
# [ 0.50192779]]
```

そこでいくつか質問があります。

1.
[チュートリアル](https://keras.io/ja/models/sequential/)によれば、
predict_classesとpredict_probaは「クラスの予測」と「確率の予測値」とありますが、これが具体的何を指すのかがわかりません。「確率の予測値」というのは、その学習したモデルに[0,0]などと入れて正しく「0」と返ってくる確率が50.147325%ということなのでしょうか（つまり全然学習できていない（！？））。「クラスの予測」に関しては想像つかないくらいわかっていません・・。

2.またどのくらい学習できているかを可視化するために、
未学習時のモデルに[0,0]を入れて計算させると何が出力されるか、
100エポック目のモデルに同じように計算させると何が出力されるか、
そして学習が終わった後に[0,0]とか[0,1]とかを入れて計算させると何が出力されるのか。
といったものを出力するためのメソッドはkerasに用意されていますでしょうか。
実際に学習しているqiitaなどを見ても上記のように確率（？）を出して終わっています。

勉強不足で、もっと基礎的なところでものすごく大きな誤解をしていて、だいぶ的外れな質問をしているかもしれません。

質問が多いですが、よろしくお願いします。

kerasで学習したモデルを実際に試す方法

表記の件について、下記のようにプログラムを作成したところ、最後の3行でDimension 0 in both shapes must be equal, but are 3 and 64. Shapes are [3,3,1,64] and [64,3,3,3]. for 'Assign' (op: 'Assign') with input shapes: [3,3,1,64], [64,3,3,3]. といったエラーが発生しました。カラースケールにしたときはうまくいったのですが、今回うまくいかなかった理由がわかりませんでした。どうかアドバイスを教えて頂きたいです。よろしくお願いします。


```Python
filenames = os.listdir(r"100dataset_train") #dataというフォルダにある画像を読み込み
Path = "./100dataset_train/"
save_PATH = '71VGG16'
h = 256
w = 256

train = np.zeros((num_files, h, w)) #画像データの箱を用意し
# #画像をひとつずつ読み込み箱に入れていく
# two_data = cv2.imread(Path+filenames[1], 0)
# plt.imshow(two_data, cmap = "gray")
# plt.show()
for i,filename in zip(range(num_files),filenames):
    one_data = cv2.imread(Path+filename, 0) #cv2で画像を読み込んで
#     plt.imshow(one_data)
#     plt.show()
#     one_data = cv2.resize(one_data,(h, w)) #認識NNに合わせてサイズ変換し
    train[i] = one_data[400:656, 400:656]
del one_data

x_train = train.reshape(-1, w, h, 1)/255
del train
#VGG16
#Conv層
input_tensor = Input(shape = (w, h, 1))
vgg16 = VGG16(include_top=False,input_tensor=input_tensor)
vgg16.summary()
```

kerasのVGG16モデルに対し、グレースケールの画像を入力する方法について

[Keras](https://qiita.com/hiroeorz@github/items/ecb39ed4042ebdc0a957)こちらのサイトを参考にKerasで画像分類を行っていますが、エラーが出ました。入力層の問題だと思うのですが何が間違っているでしょうか。エラーは、レイヤーを定義した後に発生しました。

追記
上記のサイトの通りにコードを書いたら96％の正解率が出ました。畳み込みやプーリングを使っていないように見えるのですが、どのような構成になっているのでしょうか。また畳み込みやプーリングの層を付け加えてこれ以上の正答率が出るでしょうか。最終的には転移学習で、AlexnetやVGGの中間層の特徴抽出を行いたいと思っています。

```python
#fc2
from keras.models import Sequential
from keras.layers import Activation, Dense, Dropout, Convolution2D, MaxPooling2D, Flatten
from keras.utils.np_utils import to_categorical
from keras.optimizers import Adagrad
from keras.optimizers import Adam
import numpy as np
from PIL import Image
import os

image_list = []
label_list = [] # 訓練データとバリデーションデータを生成するジェネレータを作成

for dir in os.listdir("data/train"):
    if dir == ".DS_Store":
        continue

    dir1 = "data/train/" + dir 
    label = 0

    if dir == "A": 
        label = 0
    elif dir == "B":  
        label = 1
    elif dir == "C": 
        label = 2
        
    for file in os.listdir(dir1):
        if file != ".DS_Store":
            # 配列label_listに正解ラベルを追加(りんご:0 オレンジ:1)
            label_list.append(label)
            filepath = dir1 + "/" + file
            # 画像を25x25pixelに変換し、1要素が[R,G,B]3要素を含む配列の25x25の２次元配列として読み込む。
            # [R,G,B]はそれぞれが0-255の配列。
            image = np.array(Image.open(filepath).resize((28, 28)))
            print(filepath)
            # 配列を変換し、[[Redの配列],[Greenの配列],[Blueの配列]] のような形にする。
            image = image.transpose(2, 0, 1)
            # さらにフラットな1次元配列に変換。最初の1/3はRed、次がGreenの、最後がBlueの要素がフラットに並ぶ。
            image = image.reshape(1, image.shape[0] * image.shape[1] * image.shape[2]).astype("float32")[0]
            # 出来上がった配列をimage_listに追加。

            image_list.append(image / 255.)

# kerasに渡すためにnumpy配列に変換。
image_list = np.array(image_list)

# ラベルの配列を1と0からなるラベル配列に変更
# 0 -> [1,0], 1 -> [0,1] という感じ。
Y = to_categorical(label_list)

# モデルを生成してニューラルネットを構築
model = Sequential()
model.add(Convolution2D(32, 3, 3, input_shape=(1, 28, 28 ,3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Convolution2D(32, 3, 3))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Convolution2D(64, 3, 3))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Flatten())
model.add(Dense(64))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(3))
model.add(Activation('softmax'))

# オプティマイザにAdamを使用
opt = Adam(lr=0.001)
# モデルをコンパイル
model.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"])
# 学習を実行。10%はテストに使用。
model.fit(image_list, Y, nb_epoch=1500, batch_size=100, validation_split=0.1)


__**エラー発生**__

# テスト用ディレクトリ(./data/train/)の画像でチェック。正解率を表示する。
total = 0.
ok_count = 0.

for dir in os.listdir("data/train"):
    if dir == ".DS_Store":
        continue

    dir1 = "data/test/" + dir 
    label = 0

    if dir == "A": 
        label = 0
    elif dir == "B":  
        label = 1
    elif dir == "C": 
        label = 2

    for file in os.listdir(dir1):
        if file != ".DS_Store":
            label_list.append(label)
            filepath = dir1 + "/" + file
            image = np.array(Image.open(filepath).resize((28, 28)))
            print(filepath)
            image = image.transpose(2, 0, 1)
            image = image.reshape(1, image.shape[0] * image.shape[1] * image.shape[2]).astype("float32")[0]
            result = model.predict_classes(np.array([image / 255.]))
            print("label:", label, "result:", result[0])

            total += 1.

            if label == result[0]:
                ok_count += 1.

print("seikai: ", ok_count / total * 100, "%")
```

Kerasで画像分類

python2.7,openCV4.0.0を使っています．
添付してある画像は見てもらうとわかりますが白とグレーからなる地図の画像です．
この画像に対し．色と色との間に黒で輪郭をつけそれを元にopenCVで輪郭取得を
したいとおもっております．

この輪郭取得は分かるのですが画像にpythonを用いて輪郭をつける方法がわかりません．