package caffe2

Get desktop application:
View/edit binary Protocol Buffers messages

A named argument containing either singular float, integer and string values, or repeated float, int and string arrays.

Used in: NetDef, OperatorDef

• optional string name = 1

• optional float f = 2

• optional int64 i = 3

• optional bytes s = 4

• optional NetDef n = 8

• repeated float floats = 5

• repeated int64 ints = 6

• repeated bytes strings = 7

• repeated NetDef nets = 9

Protobuf format for blobs that are not Tensors. We use a key to store the type of the blob. For example for a serialized DBProto, the type should be "DBReader" and the content should be a serialized DBProto object.

• optional string name = 1

• optional string type = 2

• optional TensorProto tensor = 3

• optional bytes content = 4

• optional QTensorProto qtensor = 5

• optional int32 content_num_chunks = 6

  If blob is not Tensor and is divided into chunks, content_num_chunks contains number of chunks, into which blob was divided.

• optional int32 content_chunk_id = 7

Used in: MetaNetDef

• required string key = 1

• repeated string value = 2

Protobuf format to serialize DBReader.

• optional string name = 1

  The name for the DB object in the workspace.

• optional string source = 2

  The source of the DB

• optional string db_type = 3

  The type of the DB

• optional string key = 4

  The current key of the DB if the DB supports seeking.

Device-specific options. We do not distinguish DeviceOption protos for different DeviceTypes, so currently all devices share the same DeviceOption proto. Fields that are specific to a device type is ignored if the type does not match. Note: if you add fields to the DeviceOption, make sure you add the corresponding changes to IsSameDevice() function in utils/proto_utils.{h,cc}.

Used in: NetDef, OperatorDef, TensorProto

• optional int32 device_type = 1

  [general] Options that need to be carried out before running the execution. optional DeviceType device_type = 1 [ default = CPU ];

  0 is CPU.

• optional int32 cuda_gpu_id = 2

  [CUDA specific] the cuda gpu id.

• optional uint32 random_seed = 3

  [general] The random seed to start the device random number generator with.

• optional string node_name = 4

  [general] What node this op should execute on. Used for net transformation purposes. Must be empty at execution time.

DeviceType that Caffe2 currently supports. Note: if you add a device type, make sure you add the corresponding device line in core/blob_serialization.cc.

• CPU = 0

  In default, we will use CPU.

• CUDA = 1

  CUDA.

• MKLDNN = 2

  Reserved for explicit MKLDNN

• OPENGL = 3

  OpenGL

• COMPILE_TIME_MAX_DEVICE_TYPES = 4

  Change the following number if you add more devices in the code.

• ONLY_FOR_TEST = 20901701

  This device type is only for test.

ExecutionStep is actually a sort-of-hacky way we simulate iteration right now.

Used in: PlanDef

• optional string name = 1

  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.

• repeated ExecutionStep substep = 2

  An execution step could be recursive, in which it involves a set of substeps.

• repeated string network = 3

  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.

• optional int64 num_iter = 4

  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.

• optional string criteria_network = 5

  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`.

• optional string report_net = 7

  DEPRECATED. Use `run_every_ms`.

• optional int32 report_interval = 8

• optional int64 run_every_ms = 11

  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.

• optional bool concurrent_substeps = 6

  If false or not set, execute sub-steps serially. If true, execute all substeps concurrently, each one in a separte thread.

• optional string should_stop_blob = 9

  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

• optional bool only_once = 10

  if only_once is true, this step will only be executed once. this ONLY takes effect when using should_stop_blob

• optional bool create_workspace = 12

  Whether to create a child workspace for this step. If yes, the workflow and nets are re-created every time this step is run.

• optional int32 num_concurrent_instances = 13

  How many copies of the children execution steps to run concurrently.

Internal Protobuf format which represents the path in the tree hierarchy for each word in the vocabulary.

• optional int32 size = 1

• repeated PathProto paths = 2

• NOTSET = 0

  Do not use old-stype padding strategies.

• VALID = 1

  VALID and SAME are two strategies adopted in Google DistBelief: it forces the input shape as follows. For SAME, the output is: R_out = ceil(float(R) / float(S)) C_out = ceil(float(C) / float(S)) where R and C are row and column, S is the stride, and K is the kernel. The number of padded pixels is then computed as Pr = ((R_out - 1) * S + K - R) Pc = ((C_out - 1) * S + K - C) When Pr and Pc are even numbers, both sides (left and right, or top and bottom) get half each. When Pr and Pc are odd numbers, the right and the bottom gets the one additional padding pixel. For VALID, padding values of 0 are always used.

• SAME = 2

• CAFFE_LEGACY_POOLING = 3

  CAFFE_LEGACY_POOLING is a flag that notifies the code to use the old Caffe padding strategy. Basically, in caffe2, after padding the convolution and pooling use the same computation strategy: half-windows at the right and bottom are discarded. In Caffe, convolution follows this strategy but if there are some pixels in the half-windows, the pooling layer will actually put one additional output. If you set LegacyPadding to this, we will compute the equivalent padding strategy in caffe2 so that the output size is backward compatible with Caffe. THIS IS NOW DEPRECATED. ANY non-conventional use has to be manually converted.

• repeated BlobsMap blobs = 1

• repeated NetsMap nets = 2

  Text-format serialized NetDefs.

• optional ModelInfo modelInfo = 3

  Info about where the model comes from. Possible use cases: 1) sanity check or diagnose 2) provide info for evaluation.

• repeated PlansMap plans = 4

• repeated StringMap applicationSpecificInfo = 5

Used in: MetaNetDef

• optional string project = 1

• optional string modelClass = 2

• optional string version = 3

• optional string predictorType = 4

• optional string modelId = 5

Network definition.

Used in: Argument, NetsMap, PlanDef

• optional string name = 1

  the network's name

• repeated OperatorDef op = 2

  Operators that the network contains. Note: this is not named "operator" because that is a reserved word in C++.

• optional string type = 3

  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.

• optional int32 num_workers = 4

  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.

• optional DeviceOption device_option = 5

  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.

• repeated Argument arg = 6

• repeated string external_input = 7

  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.

• repeated string external_output = 8

Used in: MetaNetDef

• required string key = 1

• required NetDef value = 2

Each node in the hierarchy contains links to either leaf nodes or more non-terminal nodes

Used in: TreeProto

• repeated NodeProto children = 1

  Links to non-terminal children nodes

• repeated int32 word_ids = 2

  Links to terminal (leaf) nodes

• optional int32 offset = 3

• optional string name = 4

• repeated float scores = 5

Operator Definition.

Used in: NetDef

• repeated string input = 1

  the name of the input blobs

• repeated string output = 2

  the name of output top blobs

• optional string name = 3

  the operator name. This is optional.

• optional string type = 4

  the operator type. This is needed to create the object from the operator registry.

• repeated Argument arg = 5

• optional DeviceOption device_option = 6

  The device option that the operator should run under.

• optional string engine = 7

  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.

• repeated string control_input = 8

  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.

• optional bool is_gradient_op = 9

  is_gradient_op argument is only used as a hint in shape inference and has no runtime significance

Represents a node in the path from the root node all the way down to the word (leaf).

Used in: PathProto

• optional int32 index = 1

  Parameter matrix offset for this node

• optional int32 length = 2

  Number of children

• optional int32 target = 3

  Index of the next node in the path

Each PathProto belongs to a word and is an array of nodes in the path from the root to the leaf (which is the word itself) in the tree.

Used in: HierarchyProto

• optional int32 word_id = 1

• repeated PathNodeProto path_nodes = 2

Used in: PlansMap

• optional string name = 1

  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.

• repeated NetDef network = 2

  The networks that are going to be used in this plan.

• repeated ExecutionStep execution_step = 3

Used in: MetaNetDef

• required string key = 1

• required PlanDef value = 2

• optional string META_NET_DEF = 1

  Important - to ensure ordered traversal of the DB, these must be set in the given (lexicographic) order in the input DBReader.

• optional string PREDICTOR_DBREADER = 2

• optional string PARAMETERS_BLOB_TYPE = 3

  Blob types used in MetaNetDef blobs

• optional string INPUTS_BLOB_TYPE = 4

• optional string OUTPUTS_BLOB_TYPE = 5

• optional string GLOBAL_INIT_NET_TYPE = 6

  Net types used in MetaNetDef nets

• optional string PREDICT_INIT_NET_TYPE = 7

• optional string PREDICT_NET_TYPE = 8

• optional string SINGLE_PREDICTOR = 9

• optional string MULTI_PREDICTOR = 10

• optional string TRAIN_INIT_PLAN_TYPE = 11

• optional string TRAIN_PLAN_TYPE = 12

Protobuf format to serialize profiler data

Used in: ProfDAGProtos

• required string name = 1

  The name for the operator

• required float mean = 2

  The mean execution time

• required float stddev = 3

  The standard deviation

• repeated ProfDAGProto stats = 1

Used in: BlobProto

• repeated int64 dims = 1

• required int32 precision = 2

• required double scale = 3

• required double bias = 4

• required bool is_signed = 5

• repeated int32 data = 6

• optional string name = 7

Used in: MetaNetDef

• required string key = 1

• required string value = 2

TensorProto stores serialized Tensor objects.

Used in: BlobProto, TensorProtos

• repeated int64 dims = 1

  The dimensions in the tensor.

• optional TensorProto.DataType data_type = 2

• repeated float float_data = 3

  For float

• repeated int32 int32_data = 4

  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.

• optional bytes byte_data = 5

  For bytes

• repeated bytes string_data = 6

  For strings

• repeated double double_data = 9

  For double

• repeated int64 int64_data = 10

  For int64

• optional string name = 7

  Optionally, a name for the tensor.

• optional DeviceOption device_detail = 8

  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.

• optional TensorProto.Segment segment = 11

Used in: TensorProto, TensorShape

• UNDEFINED = 0

• FLOAT = 1

  float

• INT32 = 2

  int

• BYTE = 3

  BYTE, when deserialized, is going to be restored as uint8.

• STRING = 4

  string

• BOOL = 5

  Less-commonly used data types.

  bool

• UINT8 = 6

  uint8_t

• INT8 = 7

  int8_t

• UINT16 = 8

  uint16_t

• INT16 = 9

  int16_t

• INT64 = 10

  int64_t

• FLOAT16 = 12

  caffe2::__f16, caffe2::float16

• DOUBLE = 13

  double

When loading from chunks this is going to indicate where to put data in the full array. When not used full data have to be present

Used in: TensorProto

• required int64 begin = 1

• required int64 end = 2

TensorProtos stores multiple TensorProto objects in one single proto. This is useful for small tensors; For anything big, consider using a DB for storage.

• repeated TensorProto protos = 1

Used in: TensorShapes

• repeated int64 dims = 1

• optional TensorProto.DataType data_type = 2

• repeated int32 unknown_dims = 3

• optional bool unknown_shape = 4

• optional string name = 5

• repeated TensorShape shapes = 1

Protobuf format to accept hierarchy for hierarchical softmax operator. TreeProto points to the root node.

• optional NodeProto root_node = 1