chainerでなぜエラーになるのかわからない

Question

#エラーコード

Exception in main training loop: 
Invalid operation is performed in: Convolution2DFunction (Forward)

Expect: in_types[0].shape[1] == in_types[1].shape[1] * 1
Actual: 64 != 1
Traceback (most recent call last):
  File "/usr/local/lib/python3.6/dist-packages/chainer/training/trainer.py", line 315, in run
    update()
  File "/usr/local/lib/python3.6/dist-packages/chainer/training/updaters/standard_updater.py", line 165, in update
    self.update_core()
  File "/usr/local/lib/python3.6/dist-packages/chainer/training/updaters/standard_updater.py", line 177, in update_core
    optimizer.update(loss_func, *in_arrays)
  File "/usr/local/lib/python3.6/dist-packages/chainer/optimizer.py", line 680, in update
    loss = lossfun(*args, **kwds)
  File "/usr/local/lib/python3.6/dist-packages/chainer/link.py", line 242, in __call__
    out = forward(*args, **kwargs)
  File "/usr/local/lib/python3.6/dist-packages/chainer/links/model/classifier.py", line 143, in forward
    self.y = self.predictor(*args, **kwargs)
  File "<ipython-input-7-ce3592e45691>", line 108, in __call__
    F.relu(self.conv2(h))), 2, stride=2)
  File "/usr/local/lib/python3.6/dist-packages/chainer/link.py", line 242, in __call__
    out = forward(*args, **kwargs)
  File "/usr/local/lib/python3.6/dist-packages/chainer/links/connection/convolution_2d.py", line 173, in forward
    groups=self.groups)
  File "/usr/local/lib/python3.6/dist-packages/chainer/functions/connection/convolution_2d.py", line 572, in convolution_2d
    y, = fnode.apply(args)
  File "/usr/local/lib/python3.6/dist-packages/chainer/function_node.py", line 245, in apply
    self._check_data_type_forward(in_data)
  File "/usr/local/lib/python3.6/dist-packages/chainer/function_node.py", line 330, in _check_data_type_forward
    self.check_type_forward(in_type)
  File "/usr/local/lib/python3.6/dist-packages/chainer/functions/connection/convolution_2d.py", line 66, in check_type_forward
    x_type.shape[1] == w_type.shape[1] * self.groups,
  File "/usr/local/lib/python3.6/dist-packages/chainer/utils/type_check.py", line 546, in expect
    expr.expect()
  File "/usr/local/lib/python3.6/dist-packages/chainer/utils/type_check.py", line 483, in expect
    '{0} {1} {2}'.format(left, self.inv, right))
Will finalize trainer extensions and updater before reraising the exception.
---------------------------------------------------------------------------
InvalidType                               Traceback (most recent call last)

#プログラム

# -*- coding: utf-8 -*-
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.datasets import fetch_mldata
import chainer
import chainer.links as L
import chainer.functions as F
from chainer import optimizers, Chain, Variable, initializers
from chainer.training import extensions
from chainer.datasets import tuple_dataset
from chainer.datasets import mnist

# モデル設定
batch_size = 100  # バッチサイズ
n_epoch = 20  # エポック数
n_channel = 1  # channel数（画像の奥行的な。カラー画像ならRGBなので3、モノクロなら1）
n_label = 10  # 正解ラベルの種類数

class MLP(Chain):
	# 多層パーセプトロンによる分類
	def __init__(self):
		super(MLP, self).__init__()
		with self.init_scope():
			self.fc1 = L.Linear(None, 100)
			self.fc2 = L.Linear(100, n_label)
			self.bn1 = L.BatchNormalization(100)

	def __call__(self, x):
		h = F.sigmoid(self.fc1(x))
		h = self.bn1(h)
		return self.fc2(h)

class LeNet(Chain):
	# CNNを用いた分類
	def __init__(self):
		super(LeNet, self).__init__()
		with self.init_scope():
			self.conv1 = L.Convolution2D(n_channel,6,5,1)
			self.conv2 = L.Convolution2D(6,16,5,1)
			self.conv3 = L.Convolution2D(16,120,4,1)
			self.fc4 = L.Linear(None, 84)
			self.fc5 = L.Linear(84,n_label)

	def __call__(self, x):
		h = F.sigmoid(self.conv1(x))
		h = F.max_pooling_2d(h, 2, 2)
		h = F.sigmoid(self.conv2(h))
		h = F.max_pooling_2d(h,2,2)
		h = F.sigmoid(self.conv3(h))
		h = F.sigmoid(self.fc4(h))
		return self.fc5(h)

class Alex(Chain):
	# AlexNet
	def __init__(self):
	    super(Alex, self).__init__(
	        conv1 = L.Convolution2D(n_channel, 96, 11, stride=4),
	        conv2 = L.Convolution2D(96, 256, 5, pad=2),
	        conv3 = L.Convolution2D(256, 384, 3, pad=1),
	        conv4 = L.Convolution2D(384, 384, 3, pad=1),
	        conv5 = L.Convolution2D(384, 256, 3, pad=1),
	        fc6 = L.Linear(None, 4096),
	        fc7 = L.Linear(4096, 4096),
	        fc8 = L.Linear(4096, n_label),
	    )

	def __call__(self, x):
		h = F.max_pooling_2d(F.local_response_normalization(
		    F.relu(self.conv1(x))), 3, stride=2)
		h = F.max_pooling_2d(F.local_response_normalization(
		    F.relu(self.conv2(h))), 3, stride=2)
		h = F.relu(self.conv3(h))
		h = F.relu(self.conv4(h))
		h = F.max_pooling_2d(F.relu(self.conv5(h)), 2, stride=2)
		h = F.dropout(F.relu(self.fc6(h)))
		h = F.dropout(F.relu(self.fc7(h)))
		return self.fc8(h)

  ##
class VGG16(Chain):
    def __init__(self):
        super(VGG16, self).__init__(
            conv1 = L.Convolution2D(n_channel, 64, 3, stride=1, pad=1),
            conv2 = L.Convolution2D(64, 64, 3, stride=1, pad=1),

            conv3 = L.Convolution2D(64, 128, 3, stride=1, pad=1),
            conv4 = L.Convolution2D(128, 128, 3, stride=1, pad=1),

            conv5 = L.Convolution2D(128, 256, 3, stride=1, pad=1),
            conv6 = L.Convolution2D(256, 256, 3, stride=1, pad=1),
            conv7 = L.Convolution2D(256, 256, 3, stride=1, pad=1),

            conv8 =L.Convolution2D(256, 512, 3, stride=1, pad=1),
            conv9 =L.Convolution2D(512, 512, 3, stride=1, pad=1),
            conv10 =L.Convolution2D(512, 512, 3, stride=1, pad=1),

            conv11 =L.Convolution2D(512, 512, 3, stride=1, pad=1),
            conv12 =L.Convolution2D(512, 512, 3, stride=1, pad=1),
            conv13 =L.Convolution2D(512, 512, 3, stride=1, pad=1),

            fc14 =L.Linear(None, 4096),
            fc15 =L.Linear(4096, 4096),
            fc16 =L.Linear(4096, num_class),
        )

    def __call__(self, x):
        h = F.relu(self.conv1(x))
        h = F.max_pooling_2d(F.local_response_normalization(
            F.relu(self.conv2(h))), 2, stride=2)

        h = F.relu(self.conv3(h))
        h = F.max_pooling_2d(F.local_response_normalization(
            F.relu(self.conv4(h))), 2, stride=2)

        h = F.relu(self.conv5(h))
        h = F.relu(self.conv6(h))
        h = F.max_pooling_2d(F.local_response_normalization(
            F.relu(self.conv7(h))), 2, stride=2)

        h = F.relu(self.conv8(h))
        h = F.relu(self.conv9(h))
        h = F.max_pooling_2d(F.local_response_normalization(
            F.relu(self.conv10(h))), 2, stride=2)

        h = F.relu(self.conv11(h))
        h = F.relu(self.conv12(h))
        h = F.max_pooling_2d(F.local_response_normalization(
            F.relu(self.conv13(h))), 2, stride=2)

        h = F.dropout(F.relu(self.fc14(h)))
        h = F.dropout(F.relu(self.fc15(h)))
        h = self.fc16(h)

        return h
      
      
class DeepLearningClassifier:
	def __init__(self):
		model = VGG()
		self.model = L.Classifier(model)
		self.opt = optimizers.Adam()
		self.opt.setup(self.model)

	def fit(self,X_train, y_train):
		train_data = tuple_dataset.TupleDataset(X_train, y_train)
		train_iter = chainer.iterators.SerialIterator(train_data, batch_size)
		updater = chainer.training.StandardUpdater(train_iter, self.opt)
		self.trainer = chainer.training.Trainer(updater, (n_epoch, 'epoch'), out='result')
		self.trainer.extend(extensions.LogReport())
		self.trainer.extend(extensions.PrintReport(['epoch', 'main/accuracy']))
		self.trainer.extend(extensions.ProgressBar())
		self.trainer.run()

	def fit_and_score(self, X_train, y_train, X_test, y_test):
		train_data = tuple_dataset.TupleDataset(X_train, y_train)
		test_data = tuple_dataset.TupleDataset(X_test, y_test)
		train_iter = chainer.iterators.SerialIterator(train_data, batch_size)
		test_iter = chainer.iterators.SerialIterator(test_data, batch_size, repeat=False, shuffle=False)
		updater=chainer.training.StandardUpdater(train_iter, self.opt)
		self.trainer = chainer.training.Trainer(updater, (n_epoch, 'epoch'), out='result')
		self.trainer.extend(extensions.Evaluator(test_iter, self.model))
		self.trainer.extend(extensions.LogReport())
		#self.trainer.extend(extensions.PrintReport(['epoch', 'main/accuracy', 'validation/main/accuracy']))
		self.trainer.extend(extensions.ProgressBar())
 
		self.trainer.run()

	def predict(self, X_test):
		x=Variable(X_test)
		y=self.model.predictor(x)
		answer=y.data
		answer=np.argmax(answer, axis=1)
		return answer

	def score(self, X_test, y_test):
		y=self.predict(X_test)
		N=y_test.size
		return 1.0-np.count_nonzero(y-y_test)/N

	def predict_proba(self, X_test):
		x=Variable(X_test)
		y=self.model.predictor(x)
		y=np.exp(y.data)
		H=y.sum(1).reshape(-1,1)
		return np.exp(y)/H

if __name__=='__main__':
	# mnist 使用例
	# 前処理
	mnist = fetch_mldata('MNIST original', data_home="./")
	X = mnist.data
	y = mnist.target
	X =X/X.max()
	X = X.astype(np.float32)
	y = y.astype(np.int32)
	X =X .reshape(70000,1,28,28)  # 必ず（データの総数, channel数, 縦, 横）の形にしておく
	X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

	# 定義
	clf = DeepLearningClassifier()
	# トレーニング
	clf.fit(X_train, y_train)
	# 予測
	prediction = clf.predict(X_test)
	# 精度測定
	acc = clf.score(X_test, y_test)

#困っている事
class VGG16を追加したらプログラムが動かなくなってしまった．

#環境
Google Colaboratory
chainer