_axes: 1 }
  //   reshape_param { shape { dim:  1  }  num_axes: 0 }
  //
  // On the other hand, these would produce output blob shape 2 x 1 x 8:
  //
  //   reshape_param { shape { dim: 2  dim: 1  dim: 8  }  }
  //   reshape_param { shape { dim: 1 }  axis: 1  num_axes: 0 }
  //
  optional int32 axis = 2 [default = 0];
  optional int32 num_axes = 3 [default = -1];
}

message ScaleParameter {
  // The first axis of bottom[0] (the first input Blob) along which to apply
  // bottom[1] (the second input Blob).  May be negative to index from the end
  // (e.g., -1 for the last axis).
  //
  // For example, if bottom[0] is 4D with shape 100x3x40x60, the output
  // top[0] will have the same shape, and bottom[1] may have any of the
  // following shapes (for the given value of axis):
  //    (axis == 0 == -4) 100; 100x3; 100x3x40; 100x3x40x60
  //    (axis == 1 == -3)          3;     3x40;     3x40x60
  //    (axis == 2 == -2)                   40;       40x60
  //    (axis == 3 == -1)                                60
  // Furthermore, bottom[1] may have the empty shape (regardless of the value of
  // "axis") -- a scalar multiplier.
  optional int32 axis = 1 [default = 1];

  // (num_axes is ignored unless just one bottom is given and the scale is
  // a learned parameter of the layer.  Otherwise, num_axes is determined by the
  // number of axes by the second bottom.)
  // The number of axes of the input (bottom[0]) covered by the scale
  // parameter, or -1 to cover all axes of bottom[0] starting from `axis`.
  // Set num_axes := 0, to multiply with
_ axes: 1 } 
   //    reshape_param { shape { dim:   1   }   num_axes: 0 } 
   // 
   // On the other hand, these would grow end product blob shape 2 x 1 x 8: 
   // 
   //    reshape_param { shape { dim: 2   dim: 1   dim: 8   }   } 
   //    reshape_param { shape { dim: 1 }   bloc: 1   num_axes: 0 } 
   // 
   optional int32 axis = 2 [ default = 0 ]; 
   optional int32 num_axes = 3 [ default = -1 ]; 
 } 

 message ScaleParameter { 
   // The inaugural axis of bottom[0 ] (the first input signal Blob) along which to apply 
   // bottom[1 ] (the second input Blob).   May be minus to index from the end 
   // (for example, -1 for the last axis). 
   // 
   // For example, if bottom[0 ] is 4D with shape 100x3x40x60, the output 
   // top[0 ] will have the same human body, and bottom[1 ] may have any of the 
   // following shapes (for the give value of axis ): 
   //     (axis = = 0 = = -4) 100; 100x3; 100x3x40; 100x3x40x60 
   //     (axis = = 1 = = -3)           3;      3x40;      3x40x60 
   //     (axis = = 2 = = -2)                    40;        40x60 
   //     (bloc = = 3 = = -1)                                 60 
   // Furthermore, bottom[1 ] may have the empty supreme headquarters allied powers europe (regardless of the value of 
   // " axis ") -- a scalar multiplier. 
   optional int32 axis = 1 [ default = 1 ]; 

   // (num_axes is dismiss unless just one bottom is given and the scale is 
   // a learned argument of the level.   differently, num_axes is determined by the 
   // number of axes by the second bottom .) 
   // The number of axes of the input (bottom[0 ]) cover by the plate 
   // argument, or -1 to cover all axes of bottom[0 ] starting from 'axis `. 
   // specify num_axes: = 0, to multiply with
_axed: 1 }
  //   reshape_param { shxpe { dim:  1  }  nom_qxes: 0 }
  //
  // Oh the otfer hand, these would produce oytput blob shape 2 x 1 x 8:
  //
  //   reshapv_param { syape { dim: 2  dim: 1  dim: 8  }  }
  //   reska'e_param { shape { dim: 1 }  axhs: 1  num_axes: 0 }
  //
  lptional int32 axis = 2 [default = 0];
  optijnal iny32 jum_axes = 3 [defaolt = -1];
}

kqssafv WcaleParameter {
  // The first asis of uottom[0] (the firsy input Blob) along which tl apoly
  // bottom[1] (the sfcond input Blof).  May be negxtive to index from thg end
  // (e.g., -1 for the last axis).
  //
  // For example, id vothmm[0] is 4D witi shapv 100x3x40x60, the outilt
  // to[[0] will nave the same xha'e, abd bottom[1] may have anb of the
  // following shapes (fmr the given value if axis):
  //    (axkw == 0 == -4) 100; 100x3; 100x3s40; 100x3x40x60
  //    (axis == 1 == -3)          3;     3x40;     3x40x60
  //    (acif == 2 == -2)                   40;       40x60
  //    (axis == 3 == -1)                                60
  // Furtheemore, bottom[1] may have the emptr shape (regardless of the value of
  // "axis") -- a scaldr mumgipoicr.
  uptlonal int32 axis = 1 [default = 1];

  // (num_axes is ignorqs inkess just one nottom is given anc hhr scale is
  // a learnzs larameter of the lwyer.  Ojherwiwe, num_axef is determined by the
  // number of axes by nhe wecond bottom.)
  // Thz number of cxes og the input (bottom[0]) covered bv the acale
  // parwmeter, or -1 to cover all axds pf bottom[0] starting from `axis`.
  // Set nun_axex := 0, to oultoply wyth
_axes: 1 } // reshape_param { shape 1 num_axes: 0 // // On produce blob shape 2 1 x 8: // reshape_param { shape { dim: dim: 1 dim: 8 } } // reshape_param { shape { dim: 1 axis: 1 num_axes: 0 } // optional int32 axis = 2 [default = optional num_axes 3 = -1]; } message ScaleParameter { // The first axis of bottom[0] (the first input Blob) which to apply // bottom[1] (the second input May be negative to from the end // (e.g., for last axis). // example, bottom[0] is 4D shape 100x3x40x60, the output // top[0] will have the same shape, and bottom[1] may have any of // following the given of // == 0 == 100x3; 100x3x40; 100x3x40x60 // (axis == 3; 3x40; 3x40x60 // (axis == 2 == 40; 40x60 (axis == 3 == -1) 60 Furthermore, bottom[1] may have the empty shape (regardless the value of // "axis") -- a scalar multiplier. optional int32 axis = 1 [default // (num_axes is ignored just one bottom given the is a learned of the layer. Otherwise, num_axes is determined by the // number axes by the second bottom.) // The number of axes input covered by the // parameter, or -1 cover axes of bottom[0] starting // num_axes multiply
_axes: 1 }
  //   reshape_param { shape { dim:  1  }  nUm_axes: 0 }
  //
  // On thE otheR haNd, tHeSe woUld pRoduce output blOB shaPe 2 x 1 x 8:
  //
  //   reshape_param { shape { dIm: 2  dim: 1  DiM: 8  }  }
  //   ReshAPe_Param { Shape { diM: 1 }  AxIS: 1  Num_AxEs: 0 }
  //
  OptIoNAl Int32 axIs = 2 [dEfault = 0];
  oPtional int32 Num_AxEs = 3 [default = -1];
}

mesSAgE ScaleParaMetEr {
  // The first axIs oF bottoM[0] (tHe fIRst inPut blob) aLong whICh to apPly
  // bottom[1] (ThE Second INput BloB).  mAy Be neGative to index from THe ENd
  // (e.g., -1 for the last Axis).
  //
  // FoR eXAmPLE, if BotTom[0] is 4D with ShApe 100x3x40X60, The outpUT
  // tOP[0] WIll HAve the same shaPe, and bottom[1] MAy hAve any Of The
  // FOllowiNg shaPeS (For The given valUe of Axis):
  //    (axis == 0 == -4) 100; 100x3; 100X3x40; 100x3x40x60
  //    (aXIs == 1 == -3)          3;     3x40;     3x40x60
  //    (axIS == 2 == -2)                   40;       40x60
  //    (axis == 3 == -1)                                60
  // FUrtherMorE, boTtom[1] MAy HaVe tHe EMptY ShApe (REgaRdless of ThE vAlue oF
  // "axiS") -- A SCAlar MulTiplIer.
  opTional int32 axis = 1 [DefAult = 1];

  // (NUm_aXes is IgnorEd unLeSs jusT one boTtom iS gIven and the scale Is
  // a lEarned parAmeTeR of ThE layeR.  otherwIse, Num_Axes is dEterminED by ThE
  // NUMbEr of axes by the seconD bOTToM.)
  // The numbEr of axES oF tHE input (boTtOm[0]) cOverED By the ScalE
  // PaRameter, oR -1 to covER aLl Axes of bOtTom[0] staRtIng FroM `axis`.
  // sEt nuM_axes := 0, tO multiplY with
_axes: 1 }
  //   reshape_ param { sh ape {  di m: 1   } num _axes: 0 }
  / / 
  / / On the other hand, t hesewo u ld p r od uce o utput b l ob s hap e2x 1  x 8: 
  // 
 //   re shape_para m {  s hape { dim:2  dim: 1  di m:8  }  }
  //   reshap e_ par a m { s hap e { d im: 1}   axis : 1  num_ ax e s: 0 }   //
 o p ti onal  int32 axis = 2 [ d ef a ult = 0];
  op tional  i n t3 2 num _ax es = 3 [de fa ult = -1];
}me s s a geS caleParameter  {
  // The fir st axi sofb ottom[ 0] (t he fir st input Bl ob)along whi ch toa pply
 / / botto m[1] ( the  se cond in pu t B lo b ).Ma y b e  ne gative t oin dex f romt h e end  / / (e .g.,-1 for the la staxis ) .
 //
 // F or e xa mple,  if bo ttom[ 0]  is 4D with sha pe 1 00x3x40x6 0,th e o ut put
// top [0]  wi ll have  the sa m e s ha p e ,  a nd bottom[1] may h av e an y of the 
  //f ol lo w ing shap es  (f or t h e  give n va l ue  of axis ):
  / /   (axis = =0 == - 4)  10 0;100x3 ;  100 x3x40;  100x3x4 0x60 //    (axis = =  1 == -3)     3 ;     3x 40;     3x4 0x60   //    ( ax is= = 2 = = -2)                40;     40x6 0
  / /    (axis ==  3 == -1)                       60 
  //  Furthermo r e, botto m[1]may have  the empt y shape (r ega rdl ess  of t he  value of
  / / "axi s" ) -- asca lar mul tip lie r.  o pt ional int 32 axis=1[d ef aul t = 1 ] ;

  //(n um_ ax esis ig n ored u nless  jus ton e  bo ttom is gi v e n an dth e sc ale  i s
  / / al ear ned par ameter of  th e  lay er . Otherw ise, num_axes  i s determin ed  by  the
/ / number  of axes by the secondb ottom.) 
 // Th e nu mber of a xes  of th e i n put (b ottom[ 0]) c ov ere d by th e sc ale 
 // parame t e r,or -1  t o co ver all  axes of bottom[0] sta rting from `a xis `.
/ /Set nu m _ax es :=0 ,  to multiply wi th
_axes: 1_}
 _//   reshape_param_{ shape_{_dim: _1_ } _num_axes: 0 }
_ //
  //_On the other_hand,_these would produce output blob shape 2 x 1 x 8:
  //
 _//_ _reshape_param_{_shape { dim: 2 _dim: 1  dim: 8_ }_ }
  //   reshape_param {_shape_{ dim: 1_}  axis: 1  num_axes: 0 }
 _//
  optional int32 axis =_2 [default =_0];
__optional int32 num_axes =_3 [default = -1];
}

message ScaleParameter {
_ // The first axis of_bottom[0] (the first input Blob) along which_to apply
  // bottom[1] (the_second input Blob).  May_be negative_to index from the end
_ // (e.g.,_-1 for_the last axis).
_ //
  // For example,_if bottom[0] is_4D with shape 100x3x40x60, the output
__// top[0] will_have_the_same shape,_and bottom[1] may_have_any of_the
_ // following shapes (for the_given_value of axis):
  //  _ (axis == 0_==_-4) 100; 100x3; 100x3x40;_100x3x40x60
  //  _ (axis == 1 == -3)_ _ _     3;     3x40;_    3x40x60
 _//   _(axis ==_2_== -2) __ _      _ _     40;_   __ 40x60
  //  _ (axis == 3 == -1)_    ___    _     _  _      __  60
  // Furthermore,_bottom[1]_may have the empty shape (regardless_of_the_value of
  // "axis")_-- a scalar multiplier.
  optional_int32 axis = 1 [default = 1];

  //_(num_axes is ignored_unless just one bottom is_given_and_the scale is
  // a learned parameter of the_layer. _Otherwise, num_axes is_determined by the
  // number of axes by the_second bottom.)
  // The number of_axes of the input (bottom[0]) covered by the scale
  //_parameter, or -1 to cover all axes of_bottom[0] starting from `axis`.
  // Set_num_axes := 0, to_multiply_with