caffe2

type Argument struct {
	Name    string    `protobuf:"bytes,1,opt,name=name" json:"name"`
	F       float32   `protobuf:"fixed32,2,opt,name=f" json:"f"`
	I       int64     `protobuf:"varint,3,opt,name=i" json:"i"`
	S       []byte    `protobuf:"bytes,4,opt,name=s" json:"s"`
	Floats  []float32 `protobuf:"fixed32,5,rep,name=floats" json:"floats,omitempty"`
	Ints    []int64   `protobuf:"varint,6,rep,name=ints" json:"ints,omitempty"`
	Strings [][]byte  `protobuf:"bytes,7,rep,name=strings" json:"strings,omitempty"`
}

type BlobProto struct {
	Name    string        `protobuf:"bytes,1,opt,name=name" json:"name"`
	Type    string        `protobuf:"bytes,2,opt,name=type" json:"type"`
	Tensor  *TensorProto  `protobuf:"bytes,3,opt,name=tensor" json:"tensor,omitempty"`
	Content []byte        `protobuf:"bytes,4,opt,name=content" json:"content"`
	Qtensor *QTensorProto `protobuf:"bytes,5,opt,name=qtensor" json:"qtensor,omitempty"`
}

type BlobsMap struct {
	Key   string   `protobuf:"bytes,1,req,name=key" json:"key"`
	Value []string `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"`
}

type DBReaderProto struct {
	// The name for the DB object in the workspace.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name"`
	// The source of the DB
	Source string `protobuf:"bytes,2,opt,name=source" json:"source"`
	// The type of the DB
	DbType string `protobuf:"bytes,3,opt,name=db_type,json=dbType" json:"db_type"`
	// The current key of the DB if the DB supports seeking.
	Key string `protobuf:"bytes,4,opt,name=key" json:"key"`
}

type DeviceOption struct {
	// [general] Options that need to be carried out before running the execution.
	// optional DeviceType device_type = 1 [ default = CPU ];
	DeviceType *int32 `protobuf:"varint,1,opt,name=device_type,json=deviceType,def=0" json:"device_type,omitempty"`
	// [CUDA specific] the cuda gpu id.
	CudaGpuId int32 `protobuf:"varint,2,opt,name=cuda_gpu_id,json=cudaGpuId" json:"cuda_gpu_id"`
	// [general] The random seed to start the device random number generator with.
	RandomSeed uint32 `protobuf:"varint,3,opt,name=random_seed,json=randomSeed" json:"random_seed"`
}

type DeviceType int32

type ExecutionStep struct {
	// ExecutionStep should either contain a set of substeps, or a set of
	// network names to run in this execution step. They should NOT both be set
	// at the same time.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name"`
	// An execution step could be recursive, in which it involves a set of
	// substeps.
	Substep []*ExecutionStep `protobuf:"bytes,2,rep,name=substep" json:"substep,omitempty"`
	// Alternatively, an execution step could involve one or more networks.
	// Note that you cannot have both substeps and networks. Choose one.
	// Note that an execution step refers networks by their name. The actual
	// network definition of the same name should be included in the network field
	// of the plan. The reason is that a network object might hold internal states
	// (think of a data layer), so we want to have the same network object that
	// multiple steps could ask to run.
	Network []string `protobuf:"bytes,3,rep,name=network" json:"network,omitempty"`
	// Number of iterations to run this step. The substeps or the networks
	// specified will be run sequentially, and one sequential run is considered
	// one iteration. If this is not set, the number of iterations is assumed to
	// be 1.
	NumIter int64 `protobuf:"varint,4,opt,name=num_iter,json=numIter" json:"num_iter"`
	// Criteria network specifies a single output (TensorCPU<bool>) of
	// size (1), is run on every iteration by the executor, and
	// execution terminates when the output[0] is `false`.
	CriteriaNetwork string `protobuf:"bytes,5,opt,name=criteria_network,json=criteriaNetwork" json:"criteria_network"` // Deprecated: Do not use.
	// DEPRECATED. Use `run_every_ms`.
	ReportNet      string `protobuf:"bytes,7,opt,name=report_net,json=reportNet" json:"report_net"`
	ReportInterval int32  `protobuf:"varint,8,opt,name=report_interval,json=reportInterval" json:"report_interval"`
	// If provided, execute this step at every time interval (in millisecs)
	// while its sibiling execution steps execute in parallel. This step is
	// guaranteed to run at least once after all non-interval siblings finished.
	RunEveryMs int64 `protobuf:"varint,11,opt,name=run_every_ms,json=runEveryMs" json:"run_every_ms"`
	// If false or not set, execute sub-steps serially.
	// If true, execute all substeps concurrently, each one in a separte thread.
	ConcurrentSubsteps bool `protobuf:"varint,6,opt,name=concurrent_substeps,json=concurrentSubsteps" json:"concurrent_substeps"`
	// Name of a scalar boolean tensor.
	// ES checks this blob AFTER every substeps/subnets.
	// If specified, and the value is true, then ES will skip the rest and return
	// immediately.
	// This means that the report_net and the first step will always be called.
	// Use cases:
	// 1) the first substep stops the rest if data condition not met
	// 2) the first substep decide which of the rest of the steps should be run.
	// 3) external control
	//
	// ** It is the user's responsibility to not to put this blob in race conditions.
	// ** For example when setting this blob in concurrent substeps
	ShouldStopBlob string `protobuf:"bytes,9,opt,name=should_stop_blob,json=shouldStopBlob" json:"should_stop_blob"`
	// if only_once is true, this step will only be executed once. this ONLY takes
	// effect when using should_stop_blob
	OnlyOnce bool `protobuf:"varint,10,opt,name=only_once,json=onlyOnce" json:"only_once"`
}

type HierarchyProto struct {
	Size_ int32        `protobuf:"varint,1,opt,name=size" json:"size"`
	Paths []*PathProto `protobuf:"bytes,2,rep,name=paths" json:"paths,omitempty"`
}

type LegacyPadding int32

type MetaNetDef struct {
	Blobs []*BlobsMap `protobuf:"bytes,1,rep,name=blobs" json:"blobs,omitempty"`
	// Text-format serialized NetDefs.
	Nets []*NetsMap `protobuf:"bytes,2,rep,name=nets" json:"nets,omitempty"`
	// Info about where the model comes from. Possible use cases:
	// 1) sanity check or diagnose
	// 2) provide info for evaluation.
	ModelInfo               *ModelInfo   `protobuf:"bytes,3,opt,name=modelInfo" json:"modelInfo,omitempty"`
	Plans                   []*PlansMap  `protobuf:"bytes,4,rep,name=plans" json:"plans,omitempty"`
	ApplicationSpecificInfo []*StringMap `protobuf:"bytes,5,rep,name=applicationSpecificInfo" json:"applicationSpecificInfo,omitempty"`
}

type ModelInfo struct {
	Project       string  `protobuf:"bytes,1,opt,name=project" json:"project"`
	ModelClass    string  `protobuf:"bytes,2,opt,name=modelClass" json:"modelClass"`
	Version       string  `protobuf:"bytes,3,opt,name=version" json:"version"`
	PredictorType *string `protobuf:"bytes,4,opt,name=predictorType,def=SINGLE_PREDICTOR" json:"predictorType,omitempty"`
	ModelId       string  `protobuf:"bytes,5,opt,name=modelId" json:"modelId"`
}

type NetDef struct {
	Name string `protobuf:"bytes,1,opt,name=name" json:"name"`
	// Operators that the network contains.
	// Note: this is not named "operator" because that is a reserved word in C++.
	Op []*OperatorDef `protobuf:"bytes,2,rep,name=op" json:"op,omitempty"`
	// The type of network that the net should be run with. This routes the
	// network instantiation to different execution modes. The default mode,
	// "simple", runs the operators in a sequential way as the original Caffe
	// implementation does.
	Type string `protobuf:"bytes,3,opt,name=type" json:"type"`
	// the number of workers, if the operators in the network is to be carried out
	// in parallel.
	// Note: This is to be deprecated. Using the arg field with "num_workers" as
	// key.
	NumWorkers int32 `protobuf:"varint,4,opt,name=num_workers,json=numWorkers" json:"num_workers"` // Deprecated: Do not use.
	// The device option for the network. If a network has a specific device
	// option and one of its operators does not have it set, we will copy over the
	// device option to the operator. This allows us to basically avoid putting
	// device options at every operator.
	DeviceOption *DeviceOption `protobuf:"bytes,5,opt,name=device_option,json=deviceOption" json:"device_option,omitempty"`
	Arg          []*Argument   `protobuf:"bytes,6,rep,name=arg" json:"arg,omitempty"`
	// Two optional fields to declare external input and output of a net.
	// If these two are set, when a net is created, we will sanity check for
	// every op whether its input is declared (either as an external input,
	// or as an intermediate blob created by one of the ops), and sanity check
	// if all blobs in external_output are produced.
	//
	// In cases of memory optimization, declaring external_input and
	// external_output also ensures that storage of these blobs are persistent:
	// for any blob in external_input and external_output, after a network run
	// finishes, their content are actually the right content. Any intermediate
	// blobs' contents may be overwritten.
	ExternalInput  []string `protobuf:"bytes,7,rep,name=external_input,json=externalInput" json:"external_input,omitempty"`
	ExternalOutput []string `protobuf:"bytes,8,rep,name=external_output,json=externalOutput" json:"external_output,omitempty"`
}

type NetsMap struct {
	Key   string  `protobuf:"bytes,1,req,name=key" json:"key"`
	Value *NetDef `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
}

type NodeProto struct {
	// Links to non-terminal children nodes
	Children []*NodeProto `protobuf:"bytes,1,rep,name=children" json:"children,omitempty"`
	// Links to terminal (leaf) nodes
	WordIds []int32   `protobuf:"varint,2,rep,name=word_ids,json=wordIds" json:"word_ids,omitempty"`
	Offset  int32     `protobuf:"varint,3,opt,name=offset" json:"offset"`
	Name    string    `protobuf:"bytes,4,opt,name=name" json:"name"`
	Scores  []float32 `protobuf:"fixed32,5,rep,name=scores" json:"scores,omitempty"`
}

type OperatorDef struct {
	Input  []string `protobuf:"bytes,1,rep,name=input" json:"input,omitempty"`
	Output []string `protobuf:"bytes,2,rep,name=output" json:"output,omitempty"`
	Name   string   `protobuf:"bytes,3,opt,name=name" json:"name"`
	// the operator type. This is needed to create the object from the operator
	// registry.
	Type string      `protobuf:"bytes,4,opt,name=type" json:"type"`
	Arg  []*Argument `protobuf:"bytes,5,rep,name=arg" json:"arg,omitempty"`
	// The device option that the operator should run under.
	DeviceOption *DeviceOption `protobuf:"bytes,6,opt,name=device_option,json=deviceOption" json:"device_option,omitempty"`
	// Optionally, one can specify an engine when there are multiple
	// implementations available simultaneously for one device type.
	// If one specifies an engine but that engine does not exist in the compiled
	// Caffe2 binary, Caffe2 will fall back to the default engine of that device
	// type.
	Engine string `protobuf:"bytes,7,opt,name=engine" json:"engine"`
	// Additional 'fake' inputs used for expressing control dependencies
	// in the operator graph. This can be used to ensure that an
	// operator does not run until another operator is ready, for e.g.
	// scheduling control. These are not passed as actual inputs to the
	// Operator implementation, and are only used by the Net class for
	// scheduling purposes.
	ControlInput []string `protobuf:"bytes,8,rep,name=control_input,json=controlInput" json:"control_input,omitempty"`
	// is_gradient_op argument is only used as a hint in shape inference
	// and has no runtime significance
	IsGradientOp *bool `protobuf:"varint,9,opt,name=is_gradient_op,json=isGradientOp,def=0" json:"is_gradient_op,omitempty"`
}

type PathNodeProto struct {
	// Parameter matrix offset for this node
	Index int32 `protobuf:"varint,1,opt,name=index" json:"index"`
	// Number of children
	Length int32 `protobuf:"varint,2,opt,name=length" json:"length"`
	// Index of the next node in the path
	Target int32 `protobuf:"varint,3,opt,name=target" json:"target"`
}

type PathProto struct {
	WordId    int32            `protobuf:"varint,1,opt,name=word_id,json=wordId" json:"word_id"`
	PathNodes []*PathNodeProto `protobuf:"bytes,2,rep,name=path_nodes,json=pathNodes" json:"path_nodes,omitempty"`
}

type PlanDef struct {
	// All the networks that are used in this execution. Note that networks should
	// be ordered in the way they are executed, i.e. for a layer in a network, all
	// its input blobs should already have been initialized by the layers or
	// networks defined before it.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name"`
	// The networks that are going to be used in this plan.
	Network       []*NetDef        `protobuf:"bytes,2,rep,name=network" json:"network,omitempty"`
	ExecutionStep []*ExecutionStep `protobuf:"bytes,3,rep,name=execution_step,json=executionStep" json:"execution_step,omitempty"`
}

type PlansMap struct {
	Key   string   `protobuf:"bytes,1,req,name=key" json:"key"`
	Value *PlanDef `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
}

type PredictorConsts struct {
	// Important - to ensure ordered traversal of the DB, these must be
	// set in the given (lexicographic) order in the input DBReader.
	META_NET_DEF       *string `protobuf:"bytes,1,opt,name=META_NET_DEF,json=METANETDEF,def=!!META_NET_DEF" json:"META_NET_DEF,omitempty"`
	PREDICTOR_DBREADER *string `` /* 130-byte string literal not displayed */
	// Blob types used in MetaNetDef blobs
	PARAMETERS_BLOB_TYPE *string `` /* 135-byte string literal not displayed */
	INPUTS_BLOB_TYPE     *string `protobuf:"bytes,4,opt,name=INPUTS_BLOB_TYPE,json=INPUTSBLOBTYPE,def=INPUTS_BLOB_TYPE" json:"INPUTS_BLOB_TYPE,omitempty"`
	OUTPUTS_BLOB_TYPE    *string `protobuf:"bytes,5,opt,name=OUTPUTS_BLOB_TYPE,json=OUTPUTSBLOBTYPE,def=OUTPUTS_BLOB_TYPE" json:"OUTPUTS_BLOB_TYPE,omitempty"`
	// Net types used in MetaNetDef nets
	GLOBAL_INIT_NET_TYPE  *string `` /* 134-byte string literal not displayed */
	PREDICT_INIT_NET_TYPE *string `` /* 138-byte string literal not displayed */
	PREDICT_NET_TYPE      *string `protobuf:"bytes,8,opt,name=PREDICT_NET_TYPE,json=PREDICTNETTYPE,def=PREDICT_NET_TYPE" json:"PREDICT_NET_TYPE,omitempty"`
	SINGLE_PREDICTOR      *string `protobuf:"bytes,9,opt,name=SINGLE_PREDICTOR,json=SINGLEPREDICTOR,def=SINGLE_PREDICTOR" json:"SINGLE_PREDICTOR,omitempty"`
	MULTI_PREDICTOR       *string `protobuf:"bytes,10,opt,name=MULTI_PREDICTOR,json=MULTIPREDICTOR,def=MULTI_PREDICTOR" json:"MULTI_PREDICTOR,omitempty"`
	TRAIN_INIT_PLAN_TYPE  *string `` /* 135-byte string literal not displayed */
	TRAIN_PLAN_TYPE       *string `protobuf:"bytes,12,opt,name=TRAIN_PLAN_TYPE,json=TRAINPLANTYPE,def=TRAIN_PLAN_TYPE" json:"TRAIN_PLAN_TYPE,omitempty"`
}

type ProfDAGProto struct {
	// The name for the operator
	Name string `protobuf:"bytes,1,req,name=name" json:"name"`
	// The mean execution time
	Mean float32 `protobuf:"fixed32,2,req,name=mean" json:"mean"`
	// The standard deviation
	Stddev float32 `protobuf:"fixed32,3,req,name=stddev" json:"stddev"`
}

type ProfDAGProtos struct {
	Stats []*ProfDAGProto `protobuf:"bytes,1,rep,name=stats" json:"stats,omitempty"`
}

type QTensorProto struct {
	Dims      []int64 `protobuf:"varint,1,rep,name=dims" json:"dims,omitempty"`
	Precision int32   `protobuf:"varint,2,req,name=precision" json:"precision"`
	Scale     float64 `protobuf:"fixed64,3,req,name=scale" json:"scale"`
	Bias      float64 `protobuf:"fixed64,4,req,name=bias" json:"bias"`
	IsSigned  bool    `protobuf:"varint,5,req,name=is_signed,json=isSigned" json:"is_signed"`
	Data      []int32 `protobuf:"varint,6,rep,packed,name=data" json:"data,omitempty"`
	Name      string  `protobuf:"bytes,7,opt,name=name" json:"name"`
}

type StringMap struct {
	Key   string `protobuf:"bytes,1,req,name=key" json:"key"`
	Value string `protobuf:"bytes,2,req,name=value" json:"value"`
}

type TensorProto struct {
	// The dimensions in the tensor.
	Dims     []int64               `protobuf:"varint,1,rep,name=dims" json:"dims,omitempty"`
	DataType *TensorProto_DataType `protobuf:"varint,2,opt,name=data_type,json=dataType,enum=caffe2.TensorProto_DataType,def=1" json:"data_type,omitempty"`
	// For float
	FloatData []float32 `protobuf:"fixed32,3,rep,packed,name=float_data,json=floatData" json:"float_data,omitempty"`
	// For int32, uint8, int8, uint16, int16, bool, and float16
	// Note about float16: in storage we will basically convert float16 byte-wise
	// to unsigned short and then store them in the int32_data field.
	Int32Data []int32 `protobuf:"varint,4,rep,packed,name=int32_data,json=int32Data" json:"int32_data,omitempty"`
	// For bytes
	ByteData []byte `protobuf:"bytes,5,opt,name=byte_data,json=byteData" json:"byte_data"`
	// For strings
	StringData [][]byte `protobuf:"bytes,6,rep,name=string_data,json=stringData" json:"string_data,omitempty"`
	// For double
	DoubleData []float64 `protobuf:"fixed64,9,rep,packed,name=double_data,json=doubleData" json:"double_data,omitempty"`
	// For int64
	Int64Data []int64 `protobuf:"varint,10,rep,packed,name=int64_data,json=int64Data" json:"int64_data,omitempty"`
	// Optionally, a name for the tensor.
	Name string `protobuf:"bytes,7,opt,name=name" json:"name"`
	// Optionally, a TensorProto can contain the details about the device that
	// it was serialized from. This is useful in cases like snapshotting a whole
	// workspace in a multi-GPU environment.
	DeviceDetail *DeviceOption        `protobuf:"bytes,8,opt,name=device_detail,json=deviceDetail" json:"device_detail,omitempty"`
	Segment      *TensorProto_Segment `protobuf:"bytes,11,opt,name=segment" json:"segment,omitempty"`
}

type TensorProto_DataType int32

type TensorProto_Segment struct {
	Begin int64 `protobuf:"varint,1,req,name=begin" json:"begin"`
	End   int64 `protobuf:"varint,2,req,name=end" json:"end"`
}

type TensorProtos struct {
	Protos []*TensorProto `protobuf:"bytes,1,rep,name=protos" json:"protos,omitempty"`
}

type TensorShape struct {
	Dims         []int64               `protobuf:"varint,1,rep,name=dims" json:"dims,omitempty"`
	DataType     *TensorProto_DataType `protobuf:"varint,2,opt,name=data_type,json=dataType,enum=caffe2.TensorProto_DataType,def=1" json:"data_type,omitempty"`
	UnknownDims  []int32               `protobuf:"varint,3,rep,name=unknown_dims,json=unknownDims" json:"unknown_dims,omitempty"`
	UnknownShape *bool                 `protobuf:"varint,4,opt,name=unknown_shape,json=unknownShape,def=0" json:"unknown_shape,omitempty"`
	Name         string                `protobuf:"bytes,5,opt,name=name" json:"name"`
}

type TensorShapes struct {
	Shapes []*TensorShape `protobuf:"bytes,1,rep,name=shapes" json:"shapes,omitempty"`
}

type TreeProto struct {
	RootNode *NodeProto `protobuf:"bytes,1,opt,name=root_node,json=rootNode" json:"root_node,omitempty"`
}