Skip to content
Permalink
master
Switch branches/tags
Go to file
 
 
Cannot retrieve contributors at this time
syntax = "proto3";
// Align with Numpy at https://docs.scipy.org/doc/numpy/user/basics.types.html.
// No TensorFlow quantized data types.
enum DataType {
DT_UNDEFINED = 0;
DT_INT8 = 1;
DT_INT16 = 2;
DT_INT32 = 3;
DT_INT64 = 4;
DT_UINT8 = 5;
DT_UINT16 = 6;
DT_UINT32 = 7;
DT_UINT64 = 8;
DT_FLOAT16 = 9;
DT_FLOAT32 = 10;
DT_FLOAT64 = 11;
DT_COMPLEX64 = 12;
DT_COMPLEX128 = 13;
DT_BOOL = 14;
DT_STRING = 15;
}
message GraphDef {
repeated NodeDef node = 1;
int32 version = 2;
}
message NodeDef {
// The name given to this operator. Used for naming inputs,
// logging, visualization, etc. Unique within a single GraphDef.
// Must match the regexp "[A-Za-z0-9.][A-Za-z0-9_./]*".
string name = 1;
// The operation name. There may be custom parameters in attrs.
// Op names starting with an underscore are reserved for internal use.
string op = 2;
// Each input is "node:src_output" with "node" being a string name and
// "src_output" indicating which output tensor to use from "node".
// Regular inputs may optionally be followed by control inputs that
// have the format "node".
repeated string input = 3;
// Operation-specific graph-construction-time configuration.
// Note that this should include all attrs defined in the
// corresponding OpDef, including those with a value matching
// the default -- this allows the default to change and makes
// NodeDefs easier to interpret on their own. However, if an
// attr with a default is not specified in this list, the
// default will be used.
// The "names" (keys) must match the regexp "[a-z][a-z0-9_]+" (and
// one of the names from the corresponding OpDef's attr field).
// The values must have a type matching the corresponding OpDef
// attr's type field.
// TODO(josh11b): Add some examples here showing best practices.
map<string, AttrValue> attr = 4;
};
// Protocol buffer representing the value for an attr used to configure an Op.
// Comment indicates the corresponding attr type. Only the field matching the
// attr type may be filled.
message AttrValue {
message ListValue {
repeated bytes s = 2; // "list(string)"
repeated int64 i = 3 [packed = true]; // "list(int)"
repeated float f = 4 [packed = true]; // "list(float)"
repeated bool b = 5 [packed = true]; // "list(bool)"
repeated DataType type = 6 [packed = true]; // "list(type)"
repeated TensorShape shape = 7; // "list(shape)"
repeated LiteralTensor tensor = 8; // "list(tensor)"
}
oneof value {
ListValue list = 1; // any "list(...)"
bytes s = 2; // "string"
int64 i = 3; // "int"
float f = 4; // "float"
bool b = 5; // "bool"
DataType type = 6; // "type"
TensorShape shape = 7; // "shape"
LiteralTensor tensor = 8; // "tensor"
}
}
// Dimensions of a tensor.
message TensorShape {
// One dimension of the tensor.
message Dim {
// Size of the tensor in that dimension.
// This value must be >= -1, but values of -1 are reserved for "unknown"
// shapes (values of -1 mean "unknown" dimension). Certain wrappers
// that work with TensorShape may fail at runtime when deserializing
// a TensorShape containing a dim value of -1.
int64 size = 1;
// Optional name of the tensor dimension.
string name = 2;
};
// Dimensions of the tensor, such as {"input", 30}, {"output", 40}
// for a 30 x 40 2D tensor. If an entry has size-1, this
// corresponds to a dimension of unknown size. The names are
// optional.
//
// The order of entries in "dim" matters: It indicates the layout of the
// values in the tensor in-memory representation.
//
// The first entry in "dim" is the outermost dimension used to layout the
// values, the last entry is the innermost dimension. This matches the
// in-memory layout of RowMajor Eigen tensors.
//
// If "dim.size()" > 0, "unknown_rank" must be false.
repeated Dim dim = 2;
// If true, the number of dimensions in the shape is unknown.
// If true, "dim.size()" must be 0.
bool unknown_rank = 3;
};
// Protocol buffer representing a literal tensor value.
// As data types cross languages and toolkits differ, we can only cover the shared ones.
// Then each toolkit converts literal values to final ones according to type.
message LiteralTensor {
DataType dtype = 1;
// Shape of the tensor.
TensorShape tensor_shape = 2;
// Only one of the representations below is set, one of "tensor_contents" and
// the "xxx_val" attributes. We are not using oneof because as oneofs cannot
// contain repeated fields it would require another extra set of messages.
// Version number.
//
// In version 0, if the "repeated xxx" representations contain only one
// element, that element is repeated to fill the shape. This makes it easy
// to represent a constant Tensor with a single value.
int32 version_number = 3;
// Serialized raw tensor content from either Tensor::AsProtoTensorContent or
// memcpy in tensorflow::grpc::EncodeTensorToByteBuffer. This representation
// can be used for all tensor types. The purpose of this representation is to
// reduce serialization overhead during RPC call by avoiding serialization of
// many repeated small items.
bytes tensor_content = 4;
// DT_INT32, DT_INT16, DT_INT8.
repeated int32 int_val = 5 [packed = true];
// DT_UINT32, DT_UINT16, DT_UINT8.
repeated int32 uint_val = 6 [packed = true];
// DT_INT64
repeated int64 int64_val = 7 [packed = true];
// DT_UINT64
repeated int64 uint64_val = 8 [packed = true];
// DT_FLOAT16, DT_FLOAT32.
repeated float float_val = 9 [packed = true];
// DT_FLOAT64, DT_COMPLEX64, DT_COMPLEX128 (may be truncated)
repeated double double_val = 10 [packed = true];
// DT_BOOL
repeated bool bool_val = 11 [packed = true];
// DT_STRING
repeated bytes string_val = 12;
};