GoogLeNet计算过程

量太大，欢迎大家指错
GoogLeNet:
Input:
10x3x224x224
按照我们的要求将数据集reshape成我们期望的格式，即3channel,height224,width224，一次处理10张（暂且按一张处理）

Layer 1 7x7 convolution
7x7，输出64，Padding为3，Stride为3，还有一个bias；
首先在输入加3depth的padding，共（224*3*4+3*3*4）*3=8172次操作，变成3*230*230；
对于每个filter，每一步有3*7*7个权重，1个bias，即共（3*7*7+112*112）个参数，共3*7*7次乘法和加法，共要进行112*112步，即3*7*7*112*112次乘、加法，共有64个filter，共（3*7*7+112*112）*64个参数，则需要3*7*7*112*112*64=118,013,952次乘、加法，输出为112*112*64
ReLU：做112*112*64=802,816次的max(0,x)比较操作，输出依然为112*112*64

Layer 2 3x3 max pooling
3x3的核，stride为2，无padding
输入为112*112*64，每个112*112要进行56*56次的9个数取最值操作，即共56*56*64=200,704次的9个数取最值操作，共56*56*64*8=1,605,632次比较操作，输出为56*56*64
Layer 3 Local Response Normalization
N：64
n：5
alpha: 0.0001
beta: 0.75
i=1：1——3 4个乘，3个加，1个开beta方，1个除法；
i=2：1——4 5个乘，4个加，1个开beta方，1个除法；
i=3：1——5 6个乘，5个加，1个开beta方，1个除法；
i=4：1——6 7个乘，6个加，1个开beta方，1个除法；
i=5：2——7 7个乘，6个加，1个开beta方，1个除法；
： 7个乘，6个加，1个开beta方，1个除法；
i=61：57——62 7个乘，6个加，1个开beta方，1个除法；
i=61：58——63 7个乘，6个加，1个开beta方，1个除法；
i=62：59——63 6个乘，5个加，1个开beta方，1个除法；
i=63：60——63 5个乘，4个加，1个开beta方，1个除法；
i=64：61——63 4个乘，3个加，1个开beta方，1个除法；
对于每一个（x,y）,共有：436个乘，372个加，64个开beta方，64个除法
56*56个（x,y），共有：1,367,296个乘，1,166,592个加，200,704个开beta方，200,704个除法, 输出为56*56*64

Layer 4 1x1 convolution/ 3x3_reduce
1x1，输出64，还有一个bias；
输入为56*56*64，对于每个filter，每一步有64*1*1个权重，1个bias，即共（64+36*36）个参数，共64次乘法和加法，共要进行56*56步，即64*56*56次乘、加法，共有64个filter，共（64+56*56）*64个参数，则需要64*56*56*64=12,845,056次乘、加法，输出为56*56*64
ReLU：做56*56*64=200,704次的max(0,x)比较操作，输出依然为56*56*64
Layer 5 3x3 convolution
3x3，输出192，padding为1，1个bias
输入为56*56*64,首先在输入加1depth的padding，共57*4*64=14,592次操作，变成58*58*64；
对于每个filter，每一步有64*3*3个权重，1个bias，即共（64*3*3+56*56）个参数，共64*3*3次乘法和加法，共要进行56*56步，即64*3*3*56*56次乘、加法，共有192个filter，共（64*3*3+56*56）*192个参数，则需要64*3*3*56*56*192=346,816,512次乘、加法，输出为56*56*192
ReLU：做56*56*192=602,112次的max(0,x)比较操作，输出依然为56*56*192

Layer 6 Local Response Normalization
N：192
n：5
alpha: 0.0001
beta: 0.75
i=1：1——3 4个乘，3个加，1个开beta方，1个除法；
i=2：1——4 5个乘，4个加，1个开beta方，1个除法；
i=3：1——5 6个乘，5个加，1个开beta方，1个除法；
i=4：1——6 7个乘，6个加，1个开beta方，1个除法；
i=5：2——7 7个乘，6个加，1个开beta方，1个除法；
： 7个乘，6个加，1个开beta方，1个除法；
： 7个乘，6个加，1个开beta方，1个除法；
i=188：185——190 7个乘，6个加，1个开beta方，1个除法；
i=189：186——191 7个乘，6个加，1个开beta方，1个除法；
i=190：187——191 6个乘，5个加，1个开beta方，1个除法；
i=191：188——191 5个乘，4个加，1个开beta方，1个除法；
i=192：189——191 4个乘，3个加，1个开beta方，1个除法；
对于每一个（x,y）,共有：1332个乘，1140个加，192个开beta方，192个除法
56*56个（x,y），共有：4,177,152个乘，3,575,040个加，602,112个开beta方，602,112个除法, 56*56*192

Layer 7 3x3 max pooling
3x3的核，stride为2，无padding
输入为56*56*192，每个56*56要进行28*28次的9个数取最值操作，即共28*28*192=150,528次的9个数取最值操作，共28*28*192*8=1,204,224次比较操作，输出为28*28*192

Layer 8 inception_3a
1x1 convolution
1x1，输出64，还有一个bias；
输入为28*28*192，对于每个filter，每一步有192*1*1个权重，1个bias，即共（192+28*28）个参数，共192次乘法和加法，共要进行28*28步，即192*18*18次乘、加法，共有64个filter，共（192+28*28）*64=62,464个参数，则需要192*28*28*64=9,633,792次乘、加法，输出为28*28*64
ReLU：做28*28*64=50,176次的max(0,x)比较操作，输出依然为28*28*64
3x3_reduce（1x1 convolution）
1x1，输出96，还有一个bias；
输入为28*28*192，对于每个filter，每一步有192*1*1个权重，1个bias，即共（192+28*28）个参数，共192次乘法和加法，共要进行18*18步，即192*28*28次乘、加法，共有96个filter，共（192+28*28）*96=93,696个参数，则需要192*28*28*96=14,450,688次乘、加法，输出为28*28*96
ReLU：做28*28*96=75,264次的max(0,x)比较操作，输出依然为28*28*96
3x3 convolution
3x3，输出128，padding为1，1个bias
输入为28*28*96,首先在输入加1depth的padding，共29*4*96=11,136次操作，变成30*30*64；
对于每个filter，每一步有96*3*3个权重，1个bias，即共（96*3*3+28*28）个参数，共96*3*3次乘法和加法，共要进行28*28步，即96*3*3*28*28次乘、加法，共有128个filter，共（96*3*3+28*28）*128=210,944个参数，则需要96*3*3*28*28*128=86,704,128次乘、加法，输出为28*28*128
ReLU：做28*28*128=100,352次的max(0,x)比较操作，输出依然为28*28*128
5x5_reduce（1x1 convolution）
1x1，输出16，还有一个bias；
输入为28*28*192，对于每个filter，每一步有192*1*1个权重，1个bias，即共（192+28*28）个参数，共192次乘法和加法，共要进行28*28步，即192*28*28次乘、加法，共有16个filter，共（192+28*28）*16=15,616个参数，则需要192*28*28*16=2,408,448次乘、加法，输出为28*28*16
ReLU：做28*28*16=12,544次的max(0,x)比较操作，输出依然为28*28*16
5x5 convolution
5x5，输出32，padding为2，1个bias
输入为28*28*16,首先在输入加2depth的padding，共60*4*16=3,840次操作，变成32*32*16；
对于每个filter，每一步有16*5*5个权重，1个bias，即共（16*5*5+28*28）个参数，共16*5*5次乘法和加法，共要进行28*28步，即16*5*5*28*28次乘、加法，共有32个filter，共（16*5*5+28*28）*32=37,888个参数，则需要16*5*5*28*28*32=10,035,200次乘、加法，输出为28*28*32
ReLU：做28*28*32=25,088次的max(0,x)比较操作，输出依然为28*28*32
3x3 max pooling
3x3的核，stride为1，padding为1
输入为28*28*192，,首先在输入加1depth的padding，共29*4*192=22,272次操作，变成30*30*192；
每个30*30要进行28*28次的9个数取最值操作，即共28*28*192=150,528次的9个数取最值操作，共28*28*192*8=1,204,224次比较操作，输出为28*28*192
pool_projection（1x1 convolution）
1x1，输出32，还有一个bias；
输入为28*28*192，对于每个filter，每一步有192*1*1个权重，1个bias，即共（192+28*28）个参数，共192次乘法和加法，共要进行28*28步，即192*28*28次乘、加法，共有32个filter，共（192+28*28）*32=31,232个参数，则需要192*28*28*32=4,816,896次乘、加法，输出为28*28*32
ReLU：做28*28*32=25,088次的max(0,x)比较操作，输出依然为28*28*32
Concatenation
将1x1 convolution的28*28*64，3x3 convolution的28*28*128，5x5 convolution

Layer 9 inception_3b
1x1 convolution
1x1，输出128，还有一个bias；
输入为28*28*256，对于每个filter，每一步有256*1*1个权重，1个bias，即共（256+28*28）个参数，共256次乘法和加法，共要进行28*28步，即256*28*28次乘、加法，共有128个filter，共（256+28*28）*128=133,120个参数，则需要256*28*28*128=25,690,112次乘、加法，输出为28*28*128
ReLU：做28*28*128=100,352次的max(0,x)比较操作，输出依然为28*28*128
3x3_reduce（1x1 convolution）
1x1，输出128，还有一个bias；
输入为28*28*256，对于每个filter，每一步有256*1*1个权重，1个bias，即共（256+28*28）个参数，共256次乘法和加法，共要进行28*28步，即256*28*28次乘、加法，共有128个filter，共（256+28*28）*128=133,120个参数，则需要256*28*28*128=25,690,112次乘、加法，输出为28*28*128
ReLU：做28*28*128=100,352次的max(0,x)比较操作，输出依然为28*28*128
3x3 convolution
3x3，输出192，padding为1，1个bias
输入为28*28*128,首先在输入加1depth的padding，共29*4*128=14,848次操作，变成30*30*128；
对于每个filter，每一步有128*3*3个权重，1个bias，即共（128*3*3+28*28）个参数，共128*3*3次乘法和加法，共要进行18*18步，即128*3*3*28*28次乘、加法，共有192个filter，共（256*3*3+28*28）*192=592,896个参数，则需要128*3*3*28*28*192=173,408,256次乘、加法，输出为28*28*192
ReLU：做28*28*192=150,528次的max(0,x)比较操作，输出依然为28*28*192
5x5_reduce（1x1 convolution）
1x1，输出32，还有一个bias；
输入为28*28*256，对于每个filter，每一步有256*1*1个权重，1个bias，即共（256+28*28）个参数，共256次乘法和加法，共要进行18*18步，即256*28*28次乘、加法，共有32个filter，共（256+28*28）*32=33,280个参数，则需要256*28*28*32=6,422,528次乘、加法，输出为28*28*32
ReLU：做28*28*32=25,088次的max(0,x)比较操作，输出依然为28*28*32
5x5 convolution
5x5，输出96，padding为2，1个bias
输入为28*28*32,首先在输入加2depth的padding，共60*4*32=7,680次操作，变成32*32*32；
对于每个filter，每一步有32*5*5个权重，1个bias，即共（32*5*5+28*28）个参数，共32*5*5次乘法和加法，共要进行28*28步，即32*5*5*28*28次乘、加法，共有96个filter，共（32*5*5+28*28）*96=152,064个参数，则需要32*5*5*28*28*96=24,883,200次乘、加法，输出为28*28*96
ReLU：做28*28*96=31,104次的max(0,x)比较操作，输出依然为28*28*96
3x3 max pooling
3x3的核，stride为1，padding为1
输入为28*28*256，,首先在输入加1depth的padding，共29*4*256=29,696次操作，变成30*30*256；
每个30*30要进行28*28次的9个数取最值操作，即共28*28*256=200,704次的9个数取最值操作，共28*28*256*8=1,605,632次比较操作，输出为28*28*256
pool_projection（1x1 convolution）
1x1，输出64，还有一个bias；
输入为28*28*256，对于每个filter，每一步有256*1*1个权重，1个bias，即共（256+28*28）个参数，共256次乘法和加法，共要进行28*28步，即256*28*28次乘、加法，共有64个filter，共（256+28*28）*64=66,560个参数，则需要256*28*28*64=12,845,056次乘、加法，输出为28*28*64
ReLU：做28*28*64=50,176次的max(0,x)比较操作，输出依然为28*28*64
Concatenation
将1x1 convolution的28*28*128，3x3 convolution的28*28*192，5x5 convolution
的28*28*96，pool_projection（1x1 convolution）的28*28*64级联在一起，形成28*28*480的特征图集

Layer 10 3x3 max pooling
3x3的核，stride为2，无padding
输入为28*28*480，每个28*28要进行14*14次的9个数取最值操作，即共14*14*480=94,080次的9个数取最值操作，共14*14*480*8=752,640次比较操作，输出为14*14*480

Layer 11 inception_4a
1x1 convolution
1x1，输出192，还有一个bias；
输入为14*14*480，对于每个filter，每一步有480*1*1个权重，1个bias，即共（480+14*14）个参数，共480次乘法和加法，共要进行14*14步，即480*14*14次乘、加法，共有192个filter，共（480+14*14）*192=129,792个参数，则需要480*14*14*192=18,063,360次乘、加法，输出为14*14*192
ReLU：做14*14*192=37,632次的max(0,x)比较操作，输出依然为14*14*192
3x3_reduce（1x1 convolution）
1x1，输出96，还有一个bias；
输入为14*14*480，对于每个filter，每一步有480*1*1个权重，1个bias，即共（480+14*14）个参数，共480次乘法和加法，共要进行14*14步，即480*14*14次乘、加法，共有96个filter，共（480+14*14）*96=64,896个参数，则需要480*14*14*96=9,031,980次乘、加法，输出为14*14*96
ReLU：做14*14*96=18,816次的max(0,x)比较操作，输出依然为14*14*96
3x3 convolution
3x3，输出208，padding为1，1个bias
输入为14*14*96,首先在输入加1depth的padding，共15*4*96=5,760次操作，变成16*16*128；
对于每个filter，每一步有96*3*3个权重，1个bias，即共（96*3*3+14*14）个参数，共96*3*3次乘法和加法，共要进行14*14步，即96*3*3*14*14次乘、加法，共有208个filter，共（96*3*3+14*14）*208=220,480个参数，则需要96*3*3*14*14*208=35,223,552次乘、加法，输出为14*14*208
ReLU：做14*14*208=40,768次的max(0,x)比较操作，输出依然为14*14*208
5x5_reduce（1x1 convolution）
1x1，输出16，还有一个bias；
输入为14*14*480，对于每个filter，每一步有480*1*1个权重，1个bias，即共（480+14*14）个参数，共480次乘法和加法，共要进行14*14步，即480*14*14次乘、加法，共有16个filter，共（480+14*14）*16=10,816个参数，则需要480*14*14*16=1,505,280次乘、加法，输出为14*14*16
ReLU：做14*14*16=3,136次的max(0,x)比较操作，输出依然为14*14*16
5x5 convolution
5x5，输出48，padding为2，1个bias
输入为14*14*16,首先在输入加2depth的padding，共32*4*16=2,048次操作，变成18*18*16；
对于每个filter，每一步有16*5*5个权重，1个bias，即共（16*5*5+14*14）个参数，共16*5*5次乘法和加法，共要进行14*14步，即16*5*5*14*14次乘、加法，共有48个filter，共（16*5*5+14*14）*48=28,608个参数，则需要16*5*5*14*14*48=3,763,200次乘、加法，输出为14*14*48
ReLU：做14*14*48=9,408次的max(0,x)比较操作，输出依然为14*14*48
3x3 max pooling
3x3的核，stride为1，padding为1
输入为14*14*480，,首先在输入加1depth的padding，共15*4*480=19,200次操作，变成16*16*480；
每个16*16要进行14*14次的9个数取最值操作，即共14*14*480=94,080次的9个数取最值操作，共14*14*480*8=752,640次比较操作，输出为14*14*480
pool_projection（1x1 convolution）
1x1，输出64，还有一个bias；
输入为14*14*480，对于每个filter，每一步有480*1*1个权重，1个bias，即共（480+14*14）个参数，共480次乘法和加法，共要进行14*14步，即480*14*14次乘、加法，共有64个filter，共（480+14*14）*64=43,264个参数，则需要480*14*14*64=6,021,120次乘、加法，输出为14*14*64
ReLU：做14*14*64=12,544次的max(0,x)比较操作，输出依然为14*14*64
Concatenation
将1x1 convolution的14*14*192，3x3 convolution的14*14*208，5x5 convolution的14*14*48，pool_projection（1x1 convolution）的14*14*64级联在一起，形成14*14*512的特征图集

Layer 12 inception_4b
1x1 convolution
1x1，输出160，还有一个bias；
输入为14*14*512，对于每个filter，每一步有512*1*1个权重，1个bias，即共（512+14*14）个参数，共512次乘法和加法，共要进行14*14步，即512*14*14次乘、加法，共有160个filter，共（512+14*14）*160=113,280个参数，则需要512*14*14*160=16,056,320次乘、加法，输出为14*14*160
ReLU：做14*14*160=31,360次的max(0,x)比较操作，输出依然为14*14*160
3x3_reduce（1x1 convolution）
1x1，输出112，还有一个bias；
输入为14*14*512，对于每个filter，每一步有512*1*1个权重，1个bias，即共（512+14*14）个参数，共512次乘法和加法，共要进行14*14步，即512*14*14次乘、加法，共有112个filter，共（512+14*14）*112=79,296个参数，则需要512*14*14*112=11,239,424次乘、加法，输出为14*14*112
ReLU：做14*14*112=21,952次的max(0,x)比较操作，输出依然为14*14*112
3x3 convolution
3x3，输出224，padding为1，1个bias
输入为14*14*112,首先在输入加1depth的padding，共15*4*112=6,720次操作，变成16*16*112；
对于每个filter，每一步有112*3*3个权重，1个bias，即共（112*3*3+14*14）个参数，共112*3*3次乘法和加法，共要进行14*14步，即112*3*3*14*14次乘、加法，共有224个filter，共（112*3*3+14*14）*224=269,696个参数，则需要112*3*3*14*14*224=44,255,232次乘、加法，输出为14*14*224
ReLU：做14*14*224=43,904次的max(0,x)比较操作，输出依然为14*14*224
5x5_reduce（1x1 convolution）
1x1，输出24，还有一个bias；
输入为14*14*512，对于每个filter，每一步有512*1*1个权重，1个bias，即共（512+14*14）个参数，共512次乘法和加法，共要进行14*14步，即512*14*14次乘、加法，共有24个filter，共（512+14*14）*24=16,992个参数，则需要512*14*14*24=2,408,448次乘、加法，输出为14*14*24
ReLU：做14*14*24=4,704次的max(0,x)比较操作，输出依然为14*14*24
5x5 convolution
5x5，输出64，padding为2，1个bias
输入为14*14*24,首先在输入加2depth的padding，共32*4*24=3,072次操作，变成18*18*24；
对于每个filter，每一步有24*5*5个权重，1个bias，即共（24*5*5+14*14）个参数，共24*5*5次乘法和加法，共要进行14*14步，即24*5*5*14*14次乘、加法，共有64个filter，共（24*5*5+14*14）*64=50,944个参数，则需要24*5*5*14*14*64=7,526,400次乘、加法，输出为14*14*64
ReLU：做14*14*64=12,544次的max(0,x)比较操作，输出依然为14*14*64
3x3 max pooling
3x3的核，stride为1，padding为1
输入为14*14*512，,首先在输入加1depth的padding，共15*4*512=30,720次操作，变成16*16*512；
每个16*16要进行14*14次的9个数取最值操作，即共14*14*512=100,352次的9个数取最值操作，共14*14*512*8=802,816次比较操作，输出为14*14*512
pool_projection（1x1 convolution）
1x1，输出64，还有一个bias；
输入为14*14*512，对于每个filter，每一步有512*1*1个权重，1个bias，即共（512+14*14）个参数，共512次乘法和加法，共要进行14*14步，即512*14*14次乘、加法，共有64个filter，共（512+14*14）*64=45,312个参数，则需要512*14*14*64=6,422,528次乘、加法，输出为14*14*64
ReLU：做14*14*64=12,544次的max(0,x)比较操作，输出依然为14*14*64
Concatenation

Layer 13 inception_4c
1x1 convolution
1x1，输出128，还有一个bias；
输入为14*14*512，对于每个filter，每一步有512*1*1个权重，1个bias，即共（512+14*14）个参数，共512次乘法和加法，共要进行14*14步，即512*14*14次乘、加法，共有128个filter，共（512+14*14）*128=90,624个参数，则需要512*14*14*128=12,845,056次乘、加法，输出为14*14*128
ReLU：做14*14*128=25,088次的max(0,x)比较操作，输出依然为14*14*128
3x3_reduce（1x1 convolution）
1x1，输出128，还有一个bias；
输入为14*14*512，对于每个filter，每一步有512*1*1个权重，1个bias，即共（512+14*14）个参数，共512次乘法和加法，共要进行14*14步，即512*14*14次乘、加法，共有128个filter，共（512+14*14）*128=90,624个参数，则需要512*14*14*128=12,845,056次乘、加法，输出为14*14*128
ReLU：做14*14*128=25,088次的max(0,x)比较操作，输出依然为14*14*128
3x3 convolution
3x3，输出256，padding为1，1个bias
输入为14*14*128,首先在输入加1depth的padding，共15*4*128=7,680次操作，变成16*16*128；
对于每个filter，每一步有128*3*3个权重，1个bias，即共（128*3*3+14*14）个参数，共128*3*3次乘法和加法，共要进行14*14步，即128*3*3*14*14次乘、加法，共有256个filter，共（128*3*3+14*14）*256=302,080个参数，则需要128*3*3*14*14*256=57,802,752次乘、加法，输出为14*14*256
ReLU：做14*14*256=50,176次的max(0,x)比较操作，输出依然为14*14*256
5x5_reduce（1x1 convolution）
1x1，输出24，还有一个bias；
输入为14*14*512，对于每个filter，每一步有512*1*1个权重，1个bias，即共（512+14*14）个参数，共512次乘法和加法，共要进行14*14步，即512*14*14次乘、加法，共有24个filter，共（512+14*14）*24=16,992个参数，则需要512*14*14*24=2,408,448次乘、加法，输出为14*14*24
ReLU：做14*14*24=4,074次的max(0,x)比较操作，输出依然为14*14*24
5x5 convolution
5x5，输出64，padding为2，1个bias
输入为14*14*24,首先在输入加2depth的padding，共32*4*24=3,072次操作，变成18*18*24；
对于每个filter，每一步有24*5*5个权重，1个bias，即共（24*5*5+14*14）个参数，共24*5*5次乘法和加法，共要进行14*14步，即24*5*5*14*14次乘、加法，共有64个filter，共（24*5*5+14*14）*64=50,944个参数，则需要24*5*5*14*14*64=7,526,400次乘、加法，输出为14*14*64
ReLU：做14*14*64=12,544次的max(0,x)比较操作，输出依然为14*14*64
3x3 max pooling
3x3的核，stride为1，padding为1
输入为14*14*512，,首先在输入加1depth的padding，共15*4*512=30,720次操作，变成16*16*512；
每个16*16要进行14*14次的9个数取最值操作，即共14*14*512=100,352次的9个数取最值操作，共14*14*512*8=802,816次比较操作，输出为14*14*512
pool_projection（1x1 convolution）
1x1，输出64，还有一个bias；
输入为14*14*512，对于每个filter，每一步有512*1*1个权重，1个bias，即共（512+14*14）个参数，共512次乘法和加法，共要进行14*14步，即512*14*14次乘、加法，共有64个filter，共（512+14*14）*64=45,312个参数，则需要512*14*14*64=6,422,528次乘、加法，输出为14*14*64
ReLU：做14*14*64=12,544次的max(0,x)比较操作，输出依然为14*14*64
Concatenation
将1x1 convolution的14*14*128，3x3 convolution的14*14*256，5x5 convolution的14*14*64，pool_projection（1x1 convolution）的14*14*64级联在一起，形成14*14*512的特征图集

Layer 14 inception_4d
1x1 convolution
1x1，输出112，还有一个bias；
输入为14*14*512，对于每个filter，每一步有512*1*1个权重，1个bias，即共（512+14*14）个参数，共512次乘法和加法，共要进行14*14步，即512*14*14次乘、加法，共有112个filter，共（512+14*14）*112=79,296个参数，则需要512*14*14*112=11,239,424次乘、加法，输出为14*14*112
ReLU：做14*14*112=21,952次的max(0,x)比较操作，输出依然为14*14*112
3x3_reduce（1x1 convolution）
1x1，输出144，还有一个bias；
输入为14*14*512，对于每个filter，每一步有512*1*1个权重，1个bias，即共（512+14*14）个参数，共512次乘法和加法，共要进行14*14步，即512*14*14次乘、加法，共有144个filter，共（512+14*14）*144=101,952个参数，则需要512*14*14*144=14,450,688次乘、加法，输出为14*14*144
ReLU：做14*14*144=28,224次的max(0,x)比较操作，输出依然为14*14*144
3x3 convolution
3x3，输出288，padding为1，1个bias
输入为14*14*144,首先在输入加1depth的padding，共15*4*144=8,640次操作，变成16*16*144；
对于每个filter，每一步有144*3*3个权重，1个bias，即共（144*3*3+14*14）个参数，共144*3*3次乘法和加法，共要进行14*14步，即144*3*3*14*14次乘、加法，共有288个filter，共（144*3*3+14*14）*288=429,696个参数，则需要144*3*3*14*14*288=73,156,608次乘、加法，输出为14*14*288
ReLU：做14*14*288=56,448次的max(0,x)比较操作，输出依然为14*14*288
5x5_reduce（1x1 convolution）
1x1，输出32，还有一个bias；
输入为14*14*512，对于每个filter，每一步有512*1*1个权重，1个bias，即共（512+14*14）个参数，共512次乘法和加法，共要进行14*14步，即512*14*14次乘、加法，共有32个filter，共（512+14*14）*32=22,656个参数，则需要512*14*14*32=3,211,264次乘、加法，输出为14*14*32
ReLU：做14*14*32=6,272次的max(0,x)比较操作，输出依然为14*14*32
5x5 convolution
5x5，输出64，padding为2，1个bias
输入为14*14*32,首先在输入加2depth的padding，共32*4*32=4,096次操作，变成16*16*32；
对于每个filter，每一步有32*5*5个权重，1个bias，即共（32*5*5+14*14）个参数，共32*5*5次乘法和加法，共要进行14*14步，即32*5*5*14*14次乘、加法，共有64个filter，共（32*5*5+14*14）*64=63,744个参数，则需要32*5*5*14*14*64=10,035,200次乘、加法，输出为14*14*64
ReLU：做14*14*64=15,544次的max(0,x)比较操作，输出依然为14*14*64
3x3 max pooling
3x3的核，stride为1，padding为1
输入为14*14*512，,首先在输入加1depth的padding，共15*4*512=30,720次操作，变成16*16*512；
每个16*16要进行14*14次的9个数取最值操作，即共14*14*512=100,352次的9个数取最值操作，共14*14*512*8=802,816次比较操作，输出为14*14*512
pool_projection（1x1 convolution）
1x1，输出64，还有一个bias；
输入为14*14*512，对于每个filter，每一步有512*1*1个权重，1个bias，即共（512+14*14）个参数，共512次乘法和加法，共要进行14*14步，即512*14*14次乘、加法，共有64个filter，共（512+14*14）*64=45,312个参数，则需要512*14*14*64=6,422,528次乘、加法，输出为14*14*64
ReLU：做14*14*64=12,544次的max(0,x)比较操作，输出依然为14*14*64
Concatenation
将1x1 convolution的14*14*112，3x3 convolution的14*14*288，5x5 convolution的14*14*64，pool_projection（1x1 convolution）的14*14*64级联在一起，形成14*14*528的特征图集

Layer 15 inception_4e
1x1 convolution
1x1，输出256，还有一个bias；
输入为14*14*528，对于每个filter，每一步有528*1*1个权重，1个bias，即共（528+14*14）个参数，共528次乘法和加法，共要进行14*14步，即528*14*14次乘、加法，共有256个filter，共（528+14*14）*256=185,344个参数，则需要528*14*14*256=26,492,928次乘、加法，输出为14*14*256
ReLU：做14*14*256=50,176次的max(0,x)比较操作，输出依然为14*14*256
3x3_reduce（1x1 convolution）
1x1，输出160，还有一个bias；
输入为14*14*528，对于每个filter，每一步有528*1*1个权重，1个bias，即共（528+14*14）个参数，共528次乘法和加法，共要进行14*14步，即528*14*14次乘、加法，共有160个filter，共（528+14*14）*160=115,840个参数，则需要528*14*14*160=16,558,080次乘、加法，输出为14*14*160
ReLU：做14*14*160=31,360次的max(0,x)比较操作，输出依然为14*14*160
3x3 convolution
3x3，输出320，padding为1，1个bias
输入为14*14*160,首先在输入加1depth的padding，共15*4*160=9,600次操作，变成16*16*160；
对于每个filter，每一步有160*3*3个权重，1个bias，即共（160*3*3+14*14）个参数，共160*3*3次乘法和加法，共要进行14*14步，即160*3*3*14*14次乘、加法，共有320个filter，共（160*3*3+14*14）*320=523,520个参数，则需要160*3*3*14*14*320=90,316,800次乘、加法，输出为14*14*320
ReLU：做14*14*320=62,720次的max(0,x)比较操作，输出依然为14*14*320
5x5_reduce（1x1 convolution）
1x1，输出32，还有一个bias；
输入为14*14*528，对于每个filter，每一步有528*1*1个权重，1个bias，即共（528+14*14）个参数，共528次乘法和加法，共要进行14*14步，即528*14*14次乘、加法，共有32个filter，共（528+14*14）*32=23,168个参数，则需要528*14*14*32=3,311,616次乘、加法，输出为14*14*32
ReLU：做14*14*32=6,272次的max(0,x)比较操作，输出依然为14*14*32
5x5 convolution
5x5，输出128，padding为2，1个bias
输入为14*14*32,首先在输入加2depth的padding，共32*4*32=4,096次操作，变成18*18*32；
对于每个filter，每一步有32*5*5个权重，1个bias，即共（32*5*5+14*14）个参数，共32*5*5次乘法和加法，共要进行14*14步，即32*5*5*14*14次乘、加法，共有128个filter，共（32*5*5+14*14）*128=127,488个参数，则需要32*5*5*14*14*128=20,070,400次乘、加法，输出为14*14*128
ReLU：做14*14*128=25,088次的max(0,x)比较操作，输出依然为14*14*128
3x3 max pooling
3x3的核，stride为1，padding为1
输入为14*14*528，,首先在输入加1depth的padding，共15*4*528=31,680次操作，变成16*16*528；
每个11*11要进行14*14次的9个数取最值操作，即共14*14*528=103,488次的9个数取最值操作，共14*14*528*8=827,904次比较操作，输出为14*14*528
pool_projection（1x1 convolution）
1x1，输出128，还有一个bias；
输入为14*14*528，对于每个filter，每一步有528*1*1个权重，1个bias，即共（528+14*14）个参数，共528次乘法和加法，共要进行9*9步，即528*14*14次乘、加法，共有128个filter，共（528+14*14）*128=92,672个参数，则需要528*14*14*128=13,246,464次乘、加法，输出为14*14*128
ReLU：做14*14*128=25,088次的max(0,x)比较操作，输出依然为14*14*128
Concatenation
将1x1 convolution的14*14*256，3x3 convolution的14*14*320，5x5 convolution的14*14*128，pool_projection（1x1 convolution）的14*14*128级联在一起，形成14*14*832的特征图集
Layer 16 3x3 max pooling
3x3的核，stride为2，无padding
输入为14*14*832，每个14*14要进行7*7次的9个数取最值操作，即共7*7*832=40,768次的9个数取最值操作，共7*7*832*8=326,144次比较操作，输出为7*7*832

Layer 17 inception_5a
1x1 convolution
1x1，输出256，还有一个bias；
输入为7*7*832，对于每个filter，每一步有832*1*1个权重，1个bias，即共（832+7*7）个参数，共832次乘法和加法，共要进行7*7步，即832*7*7次乘、加法，共有256个filter，共（832+7*7）*256=225,536个参数，则需要832*7*7*256=10,436,608次乘、加法，输出为7*7*256
ReLU：做7*7*256=12,544次的max(0,x)比较操作，输出依然为7*7*256
3x3_reduce（1x1 convolution）
1x1，输出160，还有一个bias；
输入为7*7*832，对于每个filter，每一步有832*1*1个权重，1个bias，即共（832+7*7）个参数，共832次乘法和加法，共要进行7*7步，即832*7*7次乘、加法，共有160个filter，共（832+7*7）*160=140,960个参数，则需要832*7*7*160=6,522,880次乘、加法，输出为7*7*160
ReLU：做7*7*160=7,840次的max(0,x)比较操作，输出依然为7*7*160
3x3 convolution
3x3，输出320，padding为1，1个bias
输入为7*7*160,首先在输入加1depth的padding，共8*4*160=5,120次操作，变成9*9*160；
对于每个filter，每一步有160*3*3个权重，1个bias，即共（160*3*3+7*7）个参数，共160*3*3次乘法和加法，共要进行7*7步，即160*3*3*7*7次乘、加法，共有320个filter，共（160*3*3+7*7）*320=476,480个参数，则需要160*3*3*7*7*320=22,579,200次乘、加法，输出为9*9*320
ReLU：做7*7*320=15,680次的max(0,x)比较操作，输出依然为7*7*320
5x5_reduce（1x1 convolution）
1x1，输出32，还有一个bias；
输入为7*7*832，对于每个filter，每一步有832*1*1个权重，1个bias，即共（832+7*7）个参数，共832次乘法和加法，共要进行7*7步，即832*7*7次乘、加法，共有32个filter，共（832+7*7）*32=28,192个参数，则需要832*7*7*32=1,304,576次乘、加法，输出为7*7*32
ReLU：做7*7*32=1,568次的max(0,x)比较操作，输出依然为7*7*32
5x5 convolution
5x5，输出128，padding为2，1个bias
输入为7*7*32,首先在输入加2depth的padding，共18*4*32=2,304次操作，变成11*11*32；
对于每个filter，每一步有32*5*5个权重，1个bias，即共（32*5*5+7*7）个参数，共32*5*5次乘法和加法，共要进行7*7步，即32*5*5*7*7次乘、加法，共有128个filter，共（32*5*5+7*7）*128=108,672个参数，则需要32*5*5*7*7*128=5,017,600次乘、加法，输出为7*7*128
ReLU：做7*7*128=6,272次的max(0,x)比较操作，输出依然为7*7*128
3x3 max pooling
3x3的核，stride为1，padding为1
输入为7*7*832，,首先在输入加1depth的padding，共8*4*832=26,624次操作，变成9*9*832；
每个11*11要进行7*7次的9个数取最值操作，即共7*7*832=40,768次的9个数取最值操作，共7*7*832*8=326,144次比较操作，输出为7*7*832
pool_projection（1x1 convolution）
1x1，输出128，还有一个bias；
输入为7*7*832，对于每个filter，每一步有832*1*1个权重，1个bias，即共（832+7*7）个参数，共832次乘法和加法，共要进行7*7步，即832*7*7次乘、加法，共有128个filter，共（832+7*7）*128=112,768个参数，则需要832*7*7*128=5,218,304次乘、加法，输出为7*7*128
ReLU：做7*7*128=6,272次的max(0,x)比较操作，输出依然为7*7*128
Concatenation
将1x1 convolution的7*7*256，3x3 convolution的7*7*320，5x5 convolution的7*7*128，pool_projection（1x1 convolution）的7*7*128级联在一起，形成7*7*832的特征图集

Layer 18 inception_5b
1x1 convolution
1x1，输出384，还有一个bias；
输入为7*7*832，对于每个filter，每一步有832*1*1个权重，1个bias，即共（832+7*7）个参数，共832次乘法和加法，共要进行7*7步，即832*7*7次乘、加法，共有384个filter，共（832+7*7）*384=338,304个参数，则需要832*7*7*384=15,654,912次乘、加法，输出为7*7*384
ReLU：做7*7*384=18,816次的max(0,x)比较操作，输出依然为7*7*384
3x3_reduce（1x1 convolution）
1x1，输出192，还有一个bias；
输入为7*7*832，对于每个filter，每一步有832*1*1个权重，1个bias，即共（832+7*7）个参数，共832次乘法和加法，共要进行7*7步，即832*7*7次乘、加法，共有192个filter，共（832+7*7）*192=169,152个参数，则需要832*7*7*192=7,827,456次乘、加法，输出为7*7*192
ReLU：做7*7*192=9,408次的max(0,x)比较操作，输出依然为7*7*192
3x3 convolution
3x3，输出384，padding为1，1个bias
输入为7*7*192,首先在输入加1depth的padding，共8*4*192=6,144次操作，变成9*9*192；
对于每个filter，每一步有192*3*3个权重，1个bias，即共（192*3*3+7*7）个参数，共192*3*3次乘法和加法，共要进行7*7步，即192*3*3*7*7次乘、加法，共有384个filter，共（192*3*3+7*7）*384=682,368个参数，则需要192*3*3*7*7*384=32,514,048次乘、加法，输出为7*7*384
ReLU：做7*7*384=18,816次的max(0,x)比较操作，输出依然为7*7*384
5x5_reduce（1x1 convolution）
1x1，输出48，还有一个bias；
输入为7*7*832，对于每个filter，每一步有832*1*1个权重，1个bias，即共（832+7*7）个参数，共832次乘法和加法，共要进行7*7步，即832*7*7次乘、加法，共有48个filter，共（832+7*7）*48=42,288个参数，则需要832*7*7*48=1,956,864次乘、加法，输出为7*7*48
ReLU：做7*7*48=2,352次的max(0,x)比较操作，输出依然为7*7*48
5x5 convolution
5x5，输出128，padding为2，1个bias
输入为7*7*48,首先在输入加2depth的padding，共18*4*48=3,456次操作，变成11*11*48；
对于每个filter，每一步有48*5*5个权重，1个bias，即共（48*5*5+7*7）个参数，共48*5*5次乘法和加法，共要进行7*7步，即48*5*5*7*7次乘、加法，共有128个filter，共（48*5*5+7*7）*128=159,872个参数，则需要48*5*5*7*7*128=7,526,400次乘、加法，输出为7*7*128
ReLU：做7*7*128=6,272次的max(0,x)比较操作，输出依然为7*7*128
3x3 max pooling
3x3的核，stride为1，padding为1
输入为7*7*832，,首先在输入加1depth的padding，共8*4*832=26,624次操作，变成9*9*832；
每个9*9要进行7*7次的9个数取最值操作，即共7*7*832=40,768次的9个数取最值操作，共7*7*832*8=326,144次比较操作，输出为7*7*832
pool_projection（1x1 convolution）
1x1，输出128，还有一个bias；
输入为7*7*832，对于每个filter，每一步有832*1*1个权重，1个bias，即共（832+7*7）个参数，共832次乘法和加法，共要进行7*7步，即832*7*7次乘、加法，共有128个filter，共（832+7*7）*128=112,768个参数，则需要832*7*7*128=5,218,304次乘、加法，输出为7*7*128
ReLU：做7*7*128=6,272次的max(0,x)比较操作，输出依然为7*7*128
Concatenation
将1x1 convolution的7*7*384，3x3 convolution的7*7*384，5x5 convolution的7*7*128，pool_projection（1x1 convolution）的7*7*128级联在一起，形成7*7*1024的特征图集

Layer 19 7x7 average pooling
7x7的核，stride为1，无padding
输入为17*7*1024， 1024次的9个数取均值操作，共48*1024=49,152次加法操作，1024次除法操作，输出为1*1*1024
Layer 20 dropout
40%参数舍去，贝叶斯，进行1024次乘法

Layer 21 classifer
全链接网络，输入为1*1*1024， bias为0，输出为1*1*1000,每个输出都有1024个参数，进行1024次乘、加法，共1,024,000个参数，1,024,000次乘、加法，输出为1*1*1000

Layer 22 softmax
在这里，k=1000,首先经过999次比较，在经过1000次减法，之后经过1000次的ej运算，再进行999次加法，最后1000次除法
edit