summary.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: summary.proto

package tensorflow

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

// Metadata associated with a series of Summary data
type SummaryDescription struct {
	// Hint on how plugins should process the data in this series.
	// Supported values include "scalar", "histogram", "image", "audio"
	TypeHint string `protobuf:"bytes,1,opt,name=type_hint,json=typeHint,proto3" json:"type_hint,omitempty"`
}

func (m *SummaryDescription) Reset()         { *m = SummaryDescription{} }
func (m *SummaryDescription) String() string { return proto.CompactTextString(m) }
func (*SummaryDescription) ProtoMessage()    {}
func (*SummaryDescription) Descriptor() ([]byte, []int) {
	return fileDescriptor_f7168d0e3f3f5589, []int{0}
}
func (m *SummaryDescription) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SummaryDescription) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SummaryDescription.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SummaryDescription) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SummaryDescription.Merge(m, src)
}
func (m *SummaryDescription) XXX_Size() int {
	return m.Size()
}
func (m *SummaryDescription) XXX_DiscardUnknown() {
	xxx_messageInfo_SummaryDescription.DiscardUnknown(m)
}

var xxx_messageInfo_SummaryDescription proto.InternalMessageInfo

func (m *SummaryDescription) GetTypeHint() string {
	if m != nil {
		return m.TypeHint
	}
	return ""
}

// Serialization format for histogram module in
// core/lib/histogram/histogram.h
type HistogramProto struct {
	Min        float64 `protobuf:"fixed64,1,opt,name=min,proto3" json:"min,omitempty"`
	Max        float64 `protobuf:"fixed64,2,opt,name=max,proto3" json:"max,omitempty"`
	Num        float64 `protobuf:"fixed64,3,opt,name=num,proto3" json:"num,omitempty"`
	Sum        float64 `protobuf:"fixed64,4,opt,name=sum,proto3" json:"sum,omitempty"`
	SumSquares float64 `protobuf:"fixed64,5,opt,name=sum_squares,json=sumSquares,proto3" json:"sum_squares,omitempty"`
	// Parallel arrays encoding the bucket boundaries and the bucket values.
	// bucket(i) is the count for the bucket i.  The range for
	// a bucket is:
	//   i == 0:  -DBL_MAX .. bucket_limit(0)
	//   i != 0:  bucket_limit(i-1) .. bucket_limit(i)
	BucketLimit []float64 `protobuf:"fixed64,6,rep,packed,name=bucket_limit,json=bucketLimit,proto3" json:"bucket_limit,omitempty"`
	Bucket      []float64 `protobuf:"fixed64,7,rep,packed,name=bucket,proto3" json:"bucket,omitempty"`
}

func (m *HistogramProto) Reset()         { *m = HistogramProto{} }
func (m *HistogramProto) String() string { return proto.CompactTextString(m) }
func (*HistogramProto) ProtoMessage()    {}
func (*HistogramProto) Descriptor() ([]byte, []int) {
	return fileDescriptor_f7168d0e3f3f5589, []int{1}
}
func (m *HistogramProto) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HistogramProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HistogramProto.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *HistogramProto) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HistogramProto.Merge(m, src)
}
func (m *HistogramProto) XXX_Size() int {
	return m.Size()
}
func (m *HistogramProto) XXX_DiscardUnknown() {
	xxx_messageInfo_HistogramProto.DiscardUnknown(m)
}

var xxx_messageInfo_HistogramProto proto.InternalMessageInfo

func (m *HistogramProto) GetMin() float64 {
	if m != nil {
		return m.Min
	}
	return 0
}

func (m *HistogramProto) GetMax() float64 {
	if m != nil {
		return m.Max
	}
	return 0
}

func (m *HistogramProto) GetNum() float64 {
	if m != nil {
		return m.Num
	}
	return 0
}

func (m *HistogramProto) GetSum() float64 {
	if m != nil {
		return m.Sum
	}
	return 0
}

func (m *HistogramProto) GetSumSquares() float64 {
	if m != nil {
		return m.SumSquares
	}
	return 0
}

func (m *HistogramProto) GetBucketLimit() []float64 {
	if m != nil {
		return m.BucketLimit
	}
	return nil
}

func (m *HistogramProto) GetBucket() []float64 {
	if m != nil {
		return m.Bucket
	}
	return nil
}

// A SummaryMetadata encapsulates information on which plugins are able to make
// use of a certain summary value.
type SummaryMetadata struct {
	// Data that associates a summary with a certain plugin.
	PluginData *SummaryMetadata_PluginData `protobuf:"bytes,1,opt,name=plugin_data,json=pluginData,proto3" json:"plugin_data,omitempty"`
	// Display name for viewing in TensorBoard.
	DisplayName string `protobuf:"bytes,2,opt,name=display_name,json=displayName,proto3" json:"display_name,omitempty"`
	// Longform readable description of the summary sequence. Markdown supported.
	SummaryDescription string `protobuf:"bytes,3,opt,name=summary_description,json=summaryDescription,proto3" json:"summary_description,omitempty"`
}

func (m *SummaryMetadata) Reset()         { *m = SummaryMetadata{} }
func (m *SummaryMetadata) String() string { return proto.CompactTextString(m) }
func (*SummaryMetadata) ProtoMessage()    {}
func (*SummaryMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_f7168d0e3f3f5589, []int{2}
}
func (m *SummaryMetadata) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SummaryMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SummaryMetadata.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SummaryMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SummaryMetadata.Merge(m, src)
}
func (m *SummaryMetadata) XXX_Size() int {
	return m.Size()
}
func (m *SummaryMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_SummaryMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_SummaryMetadata proto.InternalMessageInfo

func (m *SummaryMetadata) GetPluginData() *SummaryMetadata_PluginData {
	if m != nil {
		return m.PluginData
	}
	return nil
}

func (m *SummaryMetadata) GetDisplayName() string {
	if m != nil {
		return m.DisplayName
	}
	return ""
}

func (m *SummaryMetadata) GetSummaryDescription() string {
	if m != nil {
		return m.SummaryDescription
	}
	return ""
}

type SummaryMetadata_PluginData struct {
	// The name of the plugin this data pertains to.
	PluginName string `protobuf:"bytes,1,opt,name=plugin_name,json=pluginName,proto3" json:"plugin_name,omitempty"`
	// The content to store for the plugin. The best practice is for this to be
	// a binary serialized protocol buffer.
	Content []byte `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`
}

func (m *SummaryMetadata_PluginData) Reset()         { *m = SummaryMetadata_PluginData{} }
func (m *SummaryMetadata_PluginData) String() string { return proto.CompactTextString(m) }
func (*SummaryMetadata_PluginData) ProtoMessage()    {}
func (*SummaryMetadata_PluginData) Descriptor() ([]byte, []int) {
	return fileDescriptor_f7168d0e3f3f5589, []int{2, 0}
}
func (m *SummaryMetadata_PluginData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SummaryMetadata_PluginData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SummaryMetadata_PluginData.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SummaryMetadata_PluginData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SummaryMetadata_PluginData.Merge(m, src)
}
func (m *SummaryMetadata_PluginData) XXX_Size() int {
	return m.Size()
}
func (m *SummaryMetadata_PluginData) XXX_DiscardUnknown() {
	xxx_messageInfo_SummaryMetadata_PluginData.DiscardUnknown(m)
}

var xxx_messageInfo_SummaryMetadata_PluginData proto.InternalMessageInfo

func (m *SummaryMetadata_PluginData) GetPluginName() string {
	if m != nil {
		return m.PluginName
	}
	return ""
}

func (m *SummaryMetadata_PluginData) GetContent() []byte {
	if m != nil {
		return m.Content
	}
	return nil
}

// A Summary is a set of named values to be displayed by the
// visualizer.
//
// Summaries are produced regularly during training, as controlled by
// the "summary_interval_secs" attribute of the training operation.
// Summaries are also produced at the end of an evaluation.
type Summary struct {
	// Set of values for the summary.
	Value []*Summary_Value `protobuf:"bytes,1,rep,name=value,proto3" json:"value,omitempty"`
}

func (m *Summary) Reset()         { *m = Summary{} }
func (m *Summary) String() string { return proto.CompactTextString(m) }
func (*Summary) ProtoMessage()    {}
func (*Summary) Descriptor() ([]byte, []int) {
	return fileDescriptor_f7168d0e3f3f5589, []int{3}
}
func (m *Summary) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Summary) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Summary.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Summary) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Summary.Merge(m, src)
}
func (m *Summary) XXX_Size() int {
	return m.Size()
}
func (m *Summary) XXX_DiscardUnknown() {
	xxx_messageInfo_Summary.DiscardUnknown(m)
}

var xxx_messageInfo_Summary proto.InternalMessageInfo

func (m *Summary) GetValue() []*Summary_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

type Summary_Image struct {
	// Dimensions of the image.
	Height int32 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
	Width  int32 `protobuf:"varint,2,opt,name=width,proto3" json:"width,omitempty"`
	// Valid colorspace values are
	//   1 - grayscale
	//   2 - grayscale + alpha
	//   3 - RGB
	//   4 - RGBA
	//   5 - DIGITAL_YUV
	//   6 - BGRA
	Colorspace int32 `protobuf:"varint,3,opt,name=colorspace,proto3" json:"colorspace,omitempty"`
	// Image data in encoded format.  All image formats supported by
	// image_codec::CoderUtil can be stored here.
	EncodedImageString []byte `protobuf:"bytes,4,opt,name=encoded_image_string,json=encodedImageString,proto3" json:"encoded_image_string,omitempty"`
}

func (m *Summary_Image) Reset()         { *m = Summary_Image{} }
func (m *Summary_Image) String() string { return proto.CompactTextString(m) }
func (*Summary_Image) ProtoMessage()    {}
func (*Summary_Image) Descriptor() ([]byte, []int) {
	return fileDescriptor_f7168d0e3f3f5589, []int{3, 0}
}
func (m *Summary_Image) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Summary_Image) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Summary_Image.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Summary_Image) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Summary_Image.Merge(m, src)
}
func (m *Summary_Image) XXX_Size() int {
	return m.Size()
}
func (m *Summary_Image) XXX_DiscardUnknown() {
	xxx_messageInfo_Summary_Image.DiscardUnknown(m)
}

var xxx_messageInfo_Summary_Image proto.InternalMessageInfo

func (m *Summary_Image) GetHeight() int32 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *Summary_Image) GetWidth() int32 {
	if m != nil {
		return m.Width
	}
	return 0
}

func (m *Summary_Image) GetColorspace() int32 {
	if m != nil {
		return m.Colorspace
	}
	return 0
}

func (m *Summary_Image) GetEncodedImageString() []byte {
	if m != nil {
		return m.EncodedImageString
	}
	return nil
}

type Summary_Audio struct {
	// Sample rate of the audio in Hz.
	SampleRate float32 `protobuf:"fixed32,1,opt,name=sample_rate,json=sampleRate,proto3" json:"sample_rate,omitempty"`
	// Number of channels of audio.
	NumChannels int64 `protobuf:"varint,2,opt,name=num_channels,json=numChannels,proto3" json:"num_channels,omitempty"`
	// Length of the audio in frames (samples per channel).
	LengthFrames int64 `protobuf:"varint,3,opt,name=length_frames,json=lengthFrames,proto3" json:"length_frames,omitempty"`
	// Encoded audio data and its associated RFC 2045 content type (e.g.
	// "audio/wav").
	EncodedAudioString []byte `protobuf:"bytes,4,opt,name=encoded_audio_string,json=encodedAudioString,proto3" json:"encoded_audio_string,omitempty"`
	ContentType        string `protobuf:"bytes,5,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"`
}

func (m *Summary_Audio) Reset()         { *m = Summary_Audio{} }
func (m *Summary_Audio) String() string { return proto.CompactTextString(m) }
func (*Summary_Audio) ProtoMessage()    {}
func (*Summary_Audio) Descriptor() ([]byte, []int) {
	return fileDescriptor_f7168d0e3f3f5589, []int{3, 1}
}
func (m *Summary_Audio) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Summary_Audio) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Summary_Audio.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Summary_Audio) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Summary_Audio.Merge(m, src)
}
func (m *Summary_Audio) XXX_Size() int {
	return m.Size()
}
func (m *Summary_Audio) XXX_DiscardUnknown() {
	xxx_messageInfo_Summary_Audio.DiscardUnknown(m)
}

var xxx_messageInfo_Summary_Audio proto.InternalMessageInfo

func (m *Summary_Audio) GetSampleRate() float32 {
	if m != nil {
		return m.SampleRate
	}
	return 0
}

func (m *Summary_Audio) GetNumChannels() int64 {
	if m != nil {
		return m.NumChannels
	}
	return 0
}

func (m *Summary_Audio) GetLengthFrames() int64 {
	if m != nil {
		return m.LengthFrames
	}
	return 0
}

func (m *Summary_Audio) GetEncodedAudioString() []byte {
	if m != nil {
		return m.EncodedAudioString
	}
	return nil
}

func (m *Summary_Audio) GetContentType() string {
	if m != nil {
		return m.ContentType
	}
	return ""
}

type Summary_Value struct {
	// This field is deprecated and will not be set.
	NodeName string `protobuf:"bytes,7,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
	// Tag name for the data. Used by TensorBoard plugins to organize data. Tags
	// are often organized by scope (which contains slashes to convey
	// hierarchy). For example: foo/bar/0
	Tag string `protobuf:"bytes,1,opt,name=tag,proto3" json:"tag,omitempty"`
	// Contains metadata on the summary value such as which plugins may use it.
	// Take note that many summary values may lack a metadata field. This is
	// because the FileWriter only keeps a metadata object on the first summary
	// value with a certain tag for each tag. TensorBoard then remembers which
	// tags are associated with which plugins. This saves space.
	Metadata *SummaryMetadata `protobuf:"bytes,9,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// Value associated with the tag.
	//
	// Types that are valid to be assigned to Value:
	//	*Summary_Value_SimpleValue
	//	*Summary_Value_ObsoleteOldStyleHistogram
	//	*Summary_Value_Image
	//	*Summary_Value_Histo
	//	*Summary_Value_Audio
	//	*Summary_Value_Tensor
	Value isSummary_Value_Value `protobuf_oneof:"value"`
}

func (m *Summary_Value) Reset()         { *m = Summary_Value{} }
func (m *Summary_Value) String() string { return proto.CompactTextString(m) }
func (*Summary_Value) ProtoMessage()    {}
func (*Summary_Value) Descriptor() ([]byte, []int) {
	return fileDescriptor_f7168d0e3f3f5589, []int{3, 2}
}
func (m *Summary_Value) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Summary_Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Summary_Value.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Summary_Value) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Summary_Value.Merge(m, src)
}
func (m *Summary_Value) XXX_Size() int {
	return m.Size()
}
func (m *Summary_Value) XXX_DiscardUnknown() {
	xxx_messageInfo_Summary_Value.DiscardUnknown(m)
}

var xxx_messageInfo_Summary_Value proto.InternalMessageInfo

type isSummary_Value_Value interface {
	isSummary_Value_Value()
	MarshalTo([]byte) (int, error)
	Size() int
}

type Summary_Value_SimpleValue struct {
	SimpleValue float32 `protobuf:"fixed32,2,opt,name=simple_value,json=simpleValue,proto3,oneof"`
}
type Summary_Value_ObsoleteOldStyleHistogram struct {
	ObsoleteOldStyleHistogram []byte `protobuf:"bytes,3,opt,name=obsolete_old_style_histogram,json=obsoleteOldStyleHistogram,proto3,oneof"`
}
type Summary_Value_Image struct {
	Image *Summary_Image `protobuf:"bytes,4,opt,name=image,proto3,oneof"`
}
type Summary_Value_Histo struct {
	Histo *HistogramProto `protobuf:"bytes,5,opt,name=histo,proto3,oneof"`
}
type Summary_Value_Audio struct {
	Audio *Summary_Audio `protobuf:"bytes,6,opt,name=audio,proto3,oneof"`
}
type Summary_Value_Tensor struct {
	Tensor *TensorProto `protobuf:"bytes,8,opt,name=tensor,proto3,oneof"`
}

func (*Summary_Value_SimpleValue) isSummary_Value_Value()               {}
func (*Summary_Value_ObsoleteOldStyleHistogram) isSummary_Value_Value() {}
func (*Summary_Value_Image) isSummary_Value_Value()                     {}
func (*Summary_Value_Histo) isSummary_Value_Value()                     {}
func (*Summary_Value_Audio) isSummary_Value_Value()                     {}
func (*Summary_Value_Tensor) isSummary_Value_Value()                    {}

func (m *Summary_Value) GetValue() isSummary_Value_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *Summary_Value) GetNodeName() string {
	if m != nil {
		return m.NodeName
	}
	return ""
}

func (m *Summary_Value) GetTag() string {
	if m != nil {
		return m.Tag
	}
	return ""
}

func (m *Summary_Value) GetMetadata() *SummaryMetadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *Summary_Value) GetSimpleValue() float32 {
	if x, ok := m.GetValue().(*Summary_Value_SimpleValue); ok {
		return x.SimpleValue
	}
	return 0
}

func (m *Summary_Value) GetObsoleteOldStyleHistogram() []byte {
	if x, ok := m.GetValue().(*Summary_Value_ObsoleteOldStyleHistogram); ok {
		return x.ObsoleteOldStyleHistogram
	}
	return nil
}

func (m *Summary_Value) GetImage() *Summary_Image {
	if x, ok := m.GetValue().(*Summary_Value_Image); ok {
		return x.Image
	}
	return nil
}

func (m *Summary_Value) GetHisto() *HistogramProto {
	if x, ok := m.GetValue().(*Summary_Value_Histo); ok {
		return x.Histo
	}
	return nil
}

func (m *Summary_Value) GetAudio() *Summary_Audio {
	if x, ok := m.GetValue().(*Summary_Value_Audio); ok {
		return x.Audio
	}
	return nil
}

func (m *Summary_Value) GetTensor() *TensorProto {
	if x, ok := m.GetValue().(*Summary_Value_Tensor); ok {
		return x.Tensor
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Summary_Value) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Summary_Value_OneofMarshaler, _Summary_Value_OneofUnmarshaler, _Summary_Value_OneofSizer, []interface{}{
		(*Summary_Value_SimpleValue)(nil),
		(*Summary_Value_ObsoleteOldStyleHistogram)(nil),
		(*Summary_Value_Image)(nil),
		(*Summary_Value_Histo)(nil),
		(*Summary_Value_Audio)(nil),
		(*Summary_Value_Tensor)(nil),
	}
}

func _Summary_Value_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Summary_Value)
	// value
	switch x := m.Value.(type) {
	case *Summary_Value_SimpleValue:
		_ = b.EncodeVarint(2<<3 | proto.WireFixed32)
		_ = b.EncodeFixed32(uint64(math.Float32bits(x.SimpleValue)))
	case *Summary_Value_ObsoleteOldStyleHistogram:
		_ = b.EncodeVarint(3<<3 | proto.WireBytes)
		_ = b.EncodeRawBytes(x.ObsoleteOldStyleHistogram)
	case *Summary_Value_Image:
		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Image); err != nil {
			return err
		}
	case *Summary_Value_Histo:
		_ = b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Histo); err != nil {
			return err
		}
	case *Summary_Value_Audio:
		_ = b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Audio); err != nil {
			return err
		}
	case *Summary_Value_Tensor:
		_ = b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Tensor); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Summary_Value.Value has unexpected type %T", x)
	}
	return nil
}

func _Summary_Value_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Summary_Value)
	switch tag {
	case 2: // value.simple_value
		if wire != proto.WireFixed32 {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeFixed32()
		m.Value = &Summary_Value_SimpleValue{math.Float32frombits(uint32(x))}
		return true, err
	case 3: // value.obsolete_old_style_histogram
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		m.Value = &Summary_Value_ObsoleteOldStyleHistogram{x}
		return true, err
	case 4: // value.image
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Summary_Image)
		err := b.DecodeMessage(msg)
		m.Value = &Summary_Value_Image{msg}
		return true, err
	case 5: // value.histo
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(HistogramProto)
		err := b.DecodeMessage(msg)
		m.Value = &Summary_Value_Histo{msg}
		return true, err
	case 6: // value.audio
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Summary_Audio)
		err := b.DecodeMessage(msg)
		m.Value = &Summary_Value_Audio{msg}
		return true, err
	case 8: // value.tensor
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(TensorProto)
		err := b.DecodeMessage(msg)
		m.Value = &Summary_Value_Tensor{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Summary_Value_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Summary_Value)
	// value
	switch x := m.Value.(type) {
	case *Summary_Value_SimpleValue:
		n += 1 // tag and wire
		n += 4
	case *Summary_Value_ObsoleteOldStyleHistogram:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.ObsoleteOldStyleHistogram)))
		n += len(x.ObsoleteOldStyleHistogram)
	case *Summary_Value_Image:
		s := proto.Size(x.Image)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Summary_Value_Histo:
		s := proto.Size(x.Histo)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Summary_Value_Audio:
		s := proto.Size(x.Audio)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Summary_Value_Tensor:
		s := proto.Size(x.Tensor)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

func init() {
	proto.RegisterType((*SummaryDescription)(nil), "tensorflow.SummaryDescription")
	proto.RegisterType((*HistogramProto)(nil), "tensorflow.HistogramProto")
	proto.RegisterType((*SummaryMetadata)(nil), "tensorflow.SummaryMetadata")
	proto.RegisterType((*SummaryMetadata_PluginData)(nil), "tensorflow.SummaryMetadata.PluginData")
	proto.RegisterType((*Summary)(nil), "tensorflow.Summary")
	proto.RegisterType((*Summary_Image)(nil), "tensorflow.Summary.Image")
	proto.RegisterType((*Summary_Audio)(nil), "tensorflow.Summary.Audio")
	proto.RegisterType((*Summary_Value)(nil), "tensorflow.Summary.Value")
}

func init() { proto.RegisterFile("summary.proto", fileDescriptor_f7168d0e3f3f5589) }

var fileDescriptor_f7168d0e3f3f5589 = []byte{
	// 793 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x54, 0xcd, 0x72, 0x1c, 0x35,
	0x10, 0xde, 0xf1, 0x30, 0xbb, 0xde, 0x9e, 0x31, 0xb8, 0x44, 0x0a, 0x26, 0x1b, 0x6a, 0x49, 0x9c,
	0x82, 0xf2, 0x85, 0x35, 0x36, 0x07, 0xce, 0x31, 0x29, 0xb2, 0x54, 0xf1, 0xe3, 0xd2, 0xa6, 0x38,
	0x70, 0x99, 0xd2, 0xce, 0x28, 0xb3, 0x22, 0x23, 0x69, 0x18, 0x69, 0x70, 0xf6, 0x09, 0xb8, 0xf2,
	0x22, 0xbc, 0x41, 0xae, 0x54, 0x71, 0xcc, 0x91, 0x23, 0x65, 0x3f, 0x04, 0x1c, 0x29, 0xb5, 0xe4,
	0xdd, 0x05, 0x62, 0x6e, 0xd2, 0xa7, 0xaf, 0xd5, 0xdd, 0xdf, 0xd7, 0x12, 0x1c, 0x98, 0x5e, 0x4a,
	0xd6, 0xad, 0x67, 0x6d, 0xa7, 0xad, 0x26, 0x60, 0xb9, 0x32, 0xba, 0x7b, 0xd6, 0xe8, 0xcb, 0x49,
	0xe6, 0xd7, 0xfe, 0xe4, 0xe8, 0x14, 0xc8, 0xc2, 0x53, 0x1f, 0x73, 0x53, 0x76, 0xa2, 0xb5, 0x42,
	0x2b, 0x72, 0x0f, 0xc6, 0x76, 0xdd, 0xf2, 0x62, 0x25, 0x94, 0xcd, 0xa3, 0xfb, 0xd1, 0xf1, 0x98,
	0xee, 0x3b, 0x60, 0x2e, 0x94, 0x3d, 0x7a, 0x19, 0xc1, 0x9b, 0x73, 0x61, 0xac, 0xae, 0x3b, 0x26,
	0x2f, 0xf0, 0xfe, 0x43, 0x88, 0xa5, 0x50, 0xc8, 0x8c, 0xa8, 0x5b, 0x22, 0xc2, 0x5e, 0xe4, 0x7b,
	0x01, 0x61, 0x2f, 0x1c, 0xa2, 0x7a, 0x99, 0xc7, 0x1e, 0x51, 0xbd, 0x74, 0x88, 0xe9, 0x65, 0xfe,
	0x86, 0x47, 0x4c, 0x2f, 0xc9, 0xfb, 0x90, 0x9a, 0x5e, 0x16, 0xe6, 0x87, 0x9e, 0x75, 0xdc, 0xe4,
	0x09, 0x9e, 0x80, 0xe9, 0xe5, 0xc2, 0x23, 0xe4, 0x03, 0xc8, 0x96, 0x7d, 0xf9, 0x9c, 0xdb, 0xa2,
	0x11, 0x52, 0xd8, 0x7c, 0x78, 0x3f, 0x3e, 0x8e, 0xce, 0xf7, 0x0e, 0x23, 0x9a, 0x7a, 0xfc, 0x4b,
	0x07, 0x93, 0x09, 0x0c, 0xfd, 0x36, 0x1f, 0x6d, 0x08, 0x01, 0x39, 0xfa, 0x33, 0x82, 0xb7, 0x42,
	0xcb, 0x5f, 0x71, 0xcb, 0x2a, 0x66, 0x19, 0x79, 0x02, 0x69, 0xdb, 0xf4, 0xb5, 0x50, 0x85, 0xdb,
	0x62, 0x1f, 0xe9, 0xd9, 0x87, 0xb3, 0xad, 0x6a, 0xb3, 0x7f, 0x45, 0xcc, 0x2e, 0x90, 0xfe, 0x98,
	0x59, 0x46, 0xa1, 0xdd, 0xac, 0xc9, 0x03, 0xc8, 0x2a, 0x61, 0xda, 0x86, 0xad, 0x0b, 0xc5, 0x24,
	0xc7, 0xfe, 0xc7, 0x34, 0x0d, 0xd8, 0xd7, 0x4c, 0x72, 0x72, 0x02, 0x6f, 0x07, 0x73, 0x8a, 0x6a,
	0x2b, 0x39, 0xea, 0x32, 0xa6, 0xc4, 0xfc, 0xc7, 0x8c, 0xc9, 0x13, 0x80, 0x6d, 0x36, 0x27, 0x51,
	0x28, 0x15, 0x13, 0x78, 0x73, 0x42, 0x09, 0x78, 0x7f, 0x0e, 0xa3, 0x52, 0x2b, 0xcb, 0x95, 0xc5,
	0xec, 0x19, 0xbd, 0xd9, 0x1e, 0xbd, 0x1c, 0xc2, 0x28, 0xf4, 0x41, 0x4e, 0x20, 0xf9, 0x91, 0x35,
	0xbd, 0xbb, 0x20, 0x3e, 0x4e, 0xcf, 0xee, 0xbe, 0xa6, 0xd7, 0xd9, 0xb7, 0x8e, 0x40, 0x3d, 0x6f,
	0xf2, 0x53, 0x04, 0xc9, 0x17, 0x92, 0xd5, 0x9c, 0xbc, 0x03, 0xc3, 0x15, 0x17, 0xf5, 0xca, 0x4f,
	0x46, 0x42, 0xc3, 0x8e, 0xdc, 0x81, 0xe4, 0x52, 0x54, 0x76, 0x85, 0x69, 0x13, 0xea, 0x37, 0x64,
	0x0a, 0x50, 0xea, 0x46, 0x77, 0xa6, 0x65, 0x25, 0xc7, 0x2e, 0x13, 0xba, 0x83, 0x90, 0x8f, 0xe1,
	0x0e, 0x57, 0xa5, 0xae, 0x78, 0x55, 0x08, 0x77, 0x7d, 0x61, 0x6c, 0x27, 0x54, 0x8d, 0x53, 0x91,
	0x51, 0x12, 0xce, 0x30, 0xf3, 0x02, 0x4f, 0x26, 0xbf, 0x46, 0x90, 0x3c, 0xea, 0x2b, 0xa1, 0x71,
	0x5c, 0x98, 0x6c, 0x1b, 0x5e, 0x74, 0xcc, 0x7a, 0x2d, 0xf6, 0x28, 0x78, 0x88, 0x32, 0xcb, 0x9d,
	0x1d, 0xaa, 0x97, 0x45, 0xb9, 0x62, 0x4a, 0xf1, 0xc6, 0x60, 0x65, 0x31, 0x4d, 0x55, 0x2f, 0x3f,
	0x0b, 0x10, 0x79, 0x08, 0x07, 0x0d, 0x57, 0xb5, 0x5d, 0x15, 0xcf, 0x3a, 0x26, 0xb9, 0xc1, 0x12,
	0x63, 0x9a, 0x79, 0xf0, 0x73, 0xc4, 0x76, 0x8b, 0x64, 0x2e, 0xf3, 0xeb, 0x8b, 0xc4, 0xa2, 0x7c,
	0x91, 0x2e, 0x73, 0x90, 0xbd, 0x70, 0x0f, 0x07, 0x47, 0x79, 0x4c, 0xd3, 0x80, 0x3d, 0x5d, 0xb7,
	0x7c, 0xf2, 0x4b, 0x0c, 0x09, 0x4a, 0xec, 0x9e, 0x9b, 0xd2, 0x15, 0xf7, 0x8e, 0x8e, 0xfc, 0x73,
	0x73, 0x00, 0xfa, 0x79, 0x08, 0xb1, 0x65, 0x75, 0x30, 0xda, 0x2d, 0xc9, 0xa7, 0xb0, 0x2f, 0xc3,
	0x1c, 0xe6, 0x63, 0x1c, 0xd5, 0x7b, 0xff, 0x33, 0xaa, 0x74, 0x43, 0x26, 0x0f, 0x21, 0x33, 0x02,
	0xf5, 0xf2, 0xde, 0x3b, 0x39, 0xf6, 0xe6, 0x03, 0x9a, 0x7a, 0xd4, 0x17, 0xf3, 0x08, 0xde, 0xd3,
	0x4b, 0xa3, 0x1b, 0x6e, 0x79, 0xa1, 0x9b, 0xaa, 0x30, 0x76, 0xdd, 0xb8, 0x9f, 0x20, 0x3c, 0x78,
	0xd4, 0x27, 0x9b, 0x0f, 0xe8, 0xdd, 0x1b, 0xd6, 0x37, 0x4d, 0xb5, 0x70, 0x9c, 0xcd, 0x9f, 0x40,
	0x4e, 0x21, 0x41, 0x2f, 0x51, 0x9f, 0x5b, 0x86, 0x0b, 0x1d, 0x9d, 0x0f, 0xa8, 0x67, 0x92, 0x33,
	0x48, 0x30, 0x05, 0x0a, 0x95, 0x9e, 0x4d, 0x76, 0x43, 0xfe, 0xf9, 0xd9, 0xb8, 0x18, 0xa4, 0xba,
	0x34, 0xe8, 0x46, 0x3e, 0xbc, 0x3d, 0x0d, 0x7a, 0xe2, 0x42, 0x90, 0x49, 0x4e, 0x61, 0xe8, 0x49,
	0xf9, 0x3e, 0xc6, 0xbc, 0xbb, 0x1b, 0xf3, 0x14, 0x97, 0x37, 0x49, 0x02, 0xf1, 0x7c, 0x14, 0x5e,
	0xca, 0xb9, 0xf8, 0xed, 0x6a, 0x1a, 0xbd, 0xba, 0x9a, 0x46, 0x7f, 0x5c, 0x4d, 0xa3, 0x9f, 0xaf,
	0xa7, 0x83, 0x57, 0xd7, 0xd3, 0xc1, 0xef, 0xd7, 0xd3, 0x01, 0xe4, 0xba, 0xab, 0x77, 0x2f, 0xc2,
	0x49, 0xba, 0xd4, 0xdd, 0xf3, 0xf3, 0x83, 0x50, 0x07, 0x5e, 0x6a, 0x2e, 0xa2, 0xef, 0x1e, 0xd4,
	0xc2, 0xae, 0xfa, 0xe5, 0xac, 0xd4, 0xf2, 0xa4, 0x63, 0xe2, 0xa3, 0xb6, 0xd3, 0xdf, 0xf3, 0xd2,
	0x9e, 0x6c, 0xa3, 0xff, 0x8a, 0xa2, 0xe5, 0x10, 0x3f, 0xe7, 0x4f, 0xfe, 0x0e, 0x00, 0x00, 0xff,
	0xff, 0xa4, 0x4f, 0x7a, 0x27, 0xc7, 0x05, 0x00, 0x00,
}

func (m *SummaryDescription) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SummaryDescription) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.TypeHint) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintSummary(dAtA, i, uint64(len(m.TypeHint)))
		i += copy(dAtA[i:], m.TypeHint)
	}
	return i, nil
}

func (m *HistogramProto) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HistogramProto) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Min != 0 {
		dAtA[i] = 0x9
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Min))))
		i += 8
	}
	if m.Max != 0 {
		dAtA[i] = 0x11
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Max))))
		i += 8
	}
	if m.Num != 0 {
		dAtA[i] = 0x19
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Num))))
		i += 8
	}
	if m.Sum != 0 {
		dAtA[i] = 0x21
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Sum))))
		i += 8
	}
	if m.SumSquares != 0 {
		dAtA[i] = 0x29
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.SumSquares))))
		i += 8
	}
	if len(m.BucketLimit) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintSummary(dAtA, i, uint64(len(m.BucketLimit)*8))
		for _, num := range m.BucketLimit {
			f1 := math.Float64bits(float64(num))
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f1))
			i += 8
		}
	}
	if len(m.Bucket) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintSummary(dAtA, i, uint64(len(m.Bucket)*8))
		for _, num := range m.Bucket {
			f2 := math.Float64bits(float64(num))
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f2))
			i += 8
		}
	}
	return i, nil
}

func (m *SummaryMetadata) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SummaryMetadata) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.PluginData != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintSummary(dAtA, i, uint64(m.PluginData.Size()))
		n3, err3 := m.PluginData.MarshalTo(dAtA[i:])
		if err3 != nil {
			return 0, err3
		}
		i += n3
	}
	if len(m.DisplayName) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintSummary(dAtA, i, uint64(len(m.DisplayName)))
		i += copy(dAtA[i:], m.DisplayName)
	}
	if len(m.SummaryDescription) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintSummary(dAtA, i, uint64(len(m.SummaryDescription)))
		i += copy(dAtA[i:], m.SummaryDescription)
	}
	return i, nil
}

func (m *SummaryMetadata_PluginData) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SummaryMetadata_PluginData) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.PluginName) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintSummary(dAtA, i, uint64(len(m.PluginName)))
		i += copy(dAtA[i:], m.PluginName)
	}
	if len(m.Content) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintSummary(dAtA, i, uint64(len(m.Content)))
		i += copy(dAtA[i:], m.Content)
	}
	return i, nil
}

func (m *Summary) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Summary) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		for _, msg := range m.Value {
			dAtA[i] = 0xa
			i++
			i = encodeVarintSummary(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *Summary_Image) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Summary_Image) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Height != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintSummary(dAtA, i, uint64(m.Height))
	}
	if m.Width != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintSummary(dAtA, i, uint64(m.Width))
	}
	if m.Colorspace != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintSummary(dAtA, i, uint64(m.Colorspace))
	}
	if len(m.EncodedImageString) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintSummary(dAtA, i, uint64(len(m.EncodedImageString)))
		i += copy(dAtA[i:], m.EncodedImageString)
	}
	return i, nil
}

func (m *Summary_Audio) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Summary_Audio) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.SampleRate != 0 {
		dAtA[i] = 0xd
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.SampleRate))))
		i += 4
	}
	if m.NumChannels != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintSummary(dAtA, i, uint64(m.NumChannels))
	}
	if m.LengthFrames != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintSummary(dAtA, i, uint64(m.LengthFrames))
	}
	if len(m.EncodedAudioString) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintSummary(dAtA, i, uint64(len(m.EncodedAudioString)))
		i += copy(dAtA[i:], m.EncodedAudioString)
	}
	if len(m.ContentType) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintSummary(dAtA, i, uint64(len(m.ContentType)))
		i += copy(dAtA[i:], m.ContentType)
	}
	return i, nil
}

func (m *Summary_Value) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Summary_Value) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Tag) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintSummary(dAtA, i, uint64(len(m.Tag)))
		i += copy(dAtA[i:], m.Tag)
	}
	if m.Value != nil {
		nn4, err4 := m.Value.MarshalTo(dAtA[i:])
		if err4 != nil {
			return 0, err4
		}
		i += nn4
	}
	if len(m.NodeName) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintSummary(dAtA, i, uint64(len(m.NodeName)))
		i += copy(dAtA[i:], m.NodeName)
	}
	if m.Metadata != nil {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintSummary(dAtA, i, uint64(m.Metadata.Size()))
		n5, err5 := m.Metadata.MarshalTo(dAtA[i:])
		if err5 != nil {
			return 0, err5
		}
		i += n5
	}
	return i, nil
}

func (m *Summary_Value_SimpleValue) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	dAtA[i] = 0x15
	i++
	encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.SimpleValue))))
	i += 4
	return i, nil
}
func (m *Summary_Value_ObsoleteOldStyleHistogram) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ObsoleteOldStyleHistogram != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintSummary(dAtA, i, uint64(len(m.ObsoleteOldStyleHistogram)))
		i += copy(dAtA[i:], m.ObsoleteOldStyleHistogram)
	}
	return i, nil
}
func (m *Summary_Value_Image) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Image != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintSummary(dAtA, i, uint64(m.Image.Size()))
		n6, err6 := m.Image.MarshalTo(dAtA[i:])
		if err6 != nil {
			return 0, err6
		}
		i += n6
	}
	return i, nil
}
func (m *Summary_Value_Histo) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Histo != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintSummary(dAtA, i, uint64(m.Histo.Size()))
		n7, err7 := m.Histo.MarshalTo(dAtA[i:])
		if err7 != nil {
			return 0, err7
		}
		i += n7
	}
	return i, nil
}
func (m *Summary_Value_Audio) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Audio != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintSummary(dAtA, i, uint64(m.Audio.Size()))
		n8, err8 := m.Audio.MarshalTo(dAtA[i:])
		if err8 != nil {
			return 0, err8
		}
		i += n8
	}
	return i, nil
}
func (m *Summary_Value_Tensor) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Tensor != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintSummary(dAtA, i, uint64(m.Tensor.Size()))
		n9, err9 := m.Tensor.MarshalTo(dAtA[i:])
		if err9 != nil {
			return 0, err9
		}
		i += n9
	}
	return i, nil
}
func encodeVarintSummary(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *SummaryDescription) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TypeHint)
	if l > 0 {
		n += 1 + l + sovSummary(uint64(l))
	}
	return n
}

func (m *HistogramProto) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Min != 0 {
		n += 9
	}
	if m.Max != 0 {
		n += 9
	}
	if m.Num != 0 {
		n += 9
	}
	if m.Sum != 0 {
		n += 9
	}
	if m.SumSquares != 0 {
		n += 9
	}
	if len(m.BucketLimit) > 0 {
		n += 1 + sovSummary(uint64(len(m.BucketLimit)*8)) + len(m.BucketLimit)*8
	}
	if len(m.Bucket) > 0 {
		n += 1 + sovSummary(uint64(len(m.Bucket)*8)) + len(m.Bucket)*8
	}
	return n
}

func (m *SummaryMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PluginData != nil {
		l = m.PluginData.Size()
		n += 1 + l + sovSummary(uint64(l))
	}
	l = len(m.DisplayName)
	if l > 0 {
		n += 1 + l + sovSummary(uint64(l))
	}
	l = len(m.SummaryDescription)
	if l > 0 {
		n += 1 + l + sovSummary(uint64(l))
	}
	return n
}

func (m *SummaryMetadata_PluginData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PluginName)
	if l > 0 {
		n += 1 + l + sovSummary(uint64(l))
	}
	l = len(m.Content)
	if l > 0 {
		n += 1 + l + sovSummary(uint64(l))
	}
	return n
}

func (m *Summary) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Value) > 0 {
		for _, e := range m.Value {
			l = e.Size()
			n += 1 + l + sovSummary(uint64(l))
		}
	}
	return n
}

func (m *Summary_Image) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovSummary(uint64(m.Height))
	}
	if m.Width != 0 {
		n += 1 + sovSummary(uint64(m.Width))
	}
	if m.Colorspace != 0 {
		n += 1 + sovSummary(uint64(m.Colorspace))
	}
	l = len(m.EncodedImageString)
	if l > 0 {
		n += 1 + l + sovSummary(uint64(l))
	}
	return n
}

func (m *Summary_Audio) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SampleRate != 0 {
		n += 5
	}
	if m.NumChannels != 0 {
		n += 1 + sovSummary(uint64(m.NumChannels))
	}
	if m.LengthFrames != 0 {
		n += 1 + sovSummary(uint64(m.LengthFrames))
	}
	l = len(m.EncodedAudioString)
	if l > 0 {
		n += 1 + l + sovSummary(uint64(l))
	}
	l = len(m.ContentType)
	if l > 0 {
		n += 1 + l + sovSummary(uint64(l))
	}
	return n
}

func (m *Summary_Value) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Tag)
	if l > 0 {
		n += 1 + l + sovSummary(uint64(l))
	}
	if m.Value != nil {
		n += m.Value.Size()
	}
	l = len(m.NodeName)
	if l > 0 {
		n += 1 + l + sovSummary(uint64(l))
	}
	if m.Metadata != nil {
		l = m.Metadata.Size()
		n += 1 + l + sovSummary(uint64(l))
	}
	return n
}

func (m *Summary_Value_SimpleValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 5
	return n
}
func (m *Summary_Value_ObsoleteOldStyleHistogram) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ObsoleteOldStyleHistogram != nil {
		l = len(m.ObsoleteOldStyleHistogram)
		n += 1 + l + sovSummary(uint64(l))
	}
	return n
}
func (m *Summary_Value_Image) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Image != nil {
		l = m.Image.Size()
		n += 1 + l + sovSummary(uint64(l))
	}
	return n
}
func (m *Summary_Value_Histo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Histo != nil {
		l = m.Histo.Size()
		n += 1 + l + sovSummary(uint64(l))
	}
	return n
}
func (m *Summary_Value_Audio) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Audio != nil {
		l = m.Audio.Size()
		n += 1 + l + sovSummary(uint64(l))
	}
	return n
}
func (m *Summary_Value_Tensor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Tensor != nil {
		l = m.Tensor.Size()
		n += 1 + l + sovSummary(uint64(l))
	}
	return n
}

func sovSummary(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozSummary(x uint64) (n int) {
	return sovSummary(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *SummaryDescription) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSummary
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SummaryDescription: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SummaryDescription: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TypeHint", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSummary
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSummary
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TypeHint = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSummary(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthSummary
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthSummary
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HistogramProto) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSummary
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HistogramProto: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HistogramProto: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Min", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Min = float64(math.Float64frombits(v))
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Max = float64(math.Float64frombits(v))
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Num", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Num = float64(math.Float64frombits(v))
		case 4:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sum", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Sum = float64(math.Float64frombits(v))
		case 5:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field SumSquares", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.SumSquares = float64(math.Float64frombits(v))
		case 6:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				v2 := float64(math.Float64frombits(v))
				m.BucketLimit = append(m.BucketLimit, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSummary
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthSummary
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthSummary
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.BucketLimit) == 0 {
					m.BucketLimit = make([]float64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					v2 := float64(math.Float64frombits(v))
					m.BucketLimit = append(m.BucketLimit, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field BucketLimit", wireType)
			}
		case 7:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				v2 := float64(math.Float64frombits(v))
				m.Bucket = append(m.Bucket, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSummary
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthSummary
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthSummary
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.Bucket) == 0 {
					m.Bucket = make([]float64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					v2 := float64(math.Float64frombits(v))
					m.Bucket = append(m.Bucket, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Bucket", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipSummary(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthSummary
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthSummary
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SummaryMetadata) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSummary
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SummaryMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SummaryMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PluginData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSummary
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSummary
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PluginData == nil {
				m.PluginData = &SummaryMetadata_PluginData{}
			}
			if err := m.PluginData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DisplayName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSummary
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSummary
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DisplayName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SummaryDescription", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSummary
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSummary
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SummaryDescription = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSummary(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthSummary
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthSummary
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SummaryMetadata_PluginData) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSummary
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PluginData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PluginData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PluginName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSummary
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSummary
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PluginName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthSummary
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthSummary
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Content = append(m.Content[:0], dAtA[iNdEx:postIndex]...)
			if m.Content == nil {
				m.Content = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSummary(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthSummary
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthSummary
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Summary) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSummary
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Summary: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Summary: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSummary
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSummary
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = append(m.Value, &Summary_Value{})
			if err := m.Value[len(m.Value)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSummary(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthSummary
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthSummary
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Summary_Image) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSummary
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Image: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Image: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Width", wireType)
			}
			m.Width = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Width |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Colorspace", wireType)
			}
			m.Colorspace = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Colorspace |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EncodedImageString", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthSummary
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthSummary
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EncodedImageString = append(m.EncodedImageString[:0], dAtA[iNdEx:postIndex]...)
			if m.EncodedImageString == nil {
				m.EncodedImageString = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSummary(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthSummary
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthSummary
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Summary_Audio) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSummary
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Audio: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Audio: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field SampleRate", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.SampleRate = float32(math.Float32frombits(v))
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumChannels", wireType)
			}
			m.NumChannels = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumChannels |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LengthFrames", wireType)
			}
			m.LengthFrames = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LengthFrames |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EncodedAudioString", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthSummary
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthSummary
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EncodedAudioString = append(m.EncodedAudioString[:0], dAtA[iNdEx:postIndex]...)
			if m.EncodedAudioString == nil {
				m.EncodedAudioString = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContentType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSummary
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSummary
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContentType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSummary(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthSummary
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthSummary
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Summary_Value) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSummary
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Value: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Value: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tag", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSummary
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSummary
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tag = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field SimpleValue", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Value = &Summary_Value_SimpleValue{float32(math.Float32frombits(v))}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObsoleteOldStyleHistogram", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthSummary
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthSummary
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := make([]byte, postIndex-iNdEx)
			copy(v, dAtA[iNdEx:postIndex])
			m.Value = &Summary_Value_ObsoleteOldStyleHistogram{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSummary
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSummary
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Summary_Image{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &Summary_Value_Image{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Histo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSummary
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSummary
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &HistogramProto{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &Summary_Value_Histo{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Audio", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSummary
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSummary
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Summary_Audio{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &Summary_Value_Audio{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSummary
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSummary
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tensor", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSummary
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSummary
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &TensorProto{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &Summary_Value_Tensor{v}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSummary
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSummary
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metadata == nil {
				m.Metadata = &SummaryMetadata{}
			}
			if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSummary(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthSummary
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthSummary
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipSummary(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowSummary
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowSummary
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthSummary
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthSummary
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowSummary
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipSummary(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthSummary
				}
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthSummary = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowSummary   = fmt.Errorf("proto: integer overflow")
)