├── LICENSE ├── README.md ├── build-charm.bash ├── build-protoc.sh ├── client.go ├── cmd ├── tfclient │ └── main.go └── tfwebapp │ └── main.go ├── interfaces └── tf-inception-api │ ├── interface.yaml │ ├── provides.py │ └── requires.py ├── layers └── tfdemo │ ├── .gitignore │ ├── icon.svg │ ├── layer.yaml │ ├── metadata.yaml │ ├── reactive │ └── tfdemo.py │ └── templates │ └── tfdemo.service ├── samples ├── bobcat.jpg ├── catfish.jpg ├── cheetah.jpg ├── ferret.jpg ├── fluffy.jpg ├── fox.jpg ├── jaguar.jpg ├── mountain_lion.jpg ├── ringtail.jpg ├── tabby.jpg └── tiger.jpg └── vendor ├── tensorflow └── core │ ├── example │ ├── example.pb.go │ ├── example.proto │ ├── feature.pb.go │ └── feature.proto │ ├── framework │ ├── allocation_description.pb.go │ ├── allocation_description.proto │ ├── attr_value.pb.go │ ├── attr_value.proto │ ├── cost_graph.pb.go │ ├── cost_graph.proto │ ├── device_attributes.pb.go │ ├── device_attributes.proto │ ├── function.pb.go │ ├── function.proto │ ├── graph.pb.go │ ├── graph.proto │ ├── kernel_def.pb.go │ ├── kernel_def.proto │ ├── log_memory.pb.go │ ├── log_memory.proto │ ├── node_def.pb.go │ ├── node_def.proto │ ├── op_def.pb.go │ ├── op_def.proto │ ├── resource_handle.pb.go │ ├── resource_handle.proto │ ├── step_stats.pb.go │ ├── step_stats.proto │ ├── summary.pb.go │ ├── summary.proto │ ├── tensor.pb.go │ ├── tensor.proto │ ├── tensor_description.pb.go │ ├── tensor_description.proto │ ├── tensor_shape.pb.go │ ├── tensor_shape.proto │ ├── tensor_slice.pb.go │ ├── tensor_slice.proto │ ├── types.pb.go │ ├── types.proto │ ├── variable.pb.go │ ├── variable.proto │ ├── versions.pb.go │ └── versions.proto │ └── protobuf │ ├── meta_graph.pb.go │ ├── meta_graph.proto │ ├── saver.pb.go │ └── saver.proto └── tensorflow_serving └── apis ├── classification.pb.go ├── classification.proto ├── get_model_metadata.pb.go ├── get_model_metadata.proto ├── input.pb.go ├── input.proto ├── model.pb.go ├── model.proto ├── predict.pb.go ├── predict.proto ├── prediction_service.pb.go ├── prediction_service.proto ├── regression.pb.go └── regression.proto /README.md: -------------------------------------------------------------------------------- 1 | # tfclient 2 | 3 | A [Tensorflow Serving](https://tensorflow.github.io/serving/) client. 4 | 5 | This client can request remote predictions from the inception server described 6 | here: https://tensorflow.github.io/serving/serving_inception 7 | 8 | Copyright 2016 Casey Marshall. See [LICENSE](LICENSE) for more information. 9 | 10 | -------------------------------------------------------------------------------- /build-charm.bash: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | set -ex 4 | 5 | HERE=$(cd $(dirname $0); pwd) 6 | 7 | mkdir -p ${HERE}/layers/tfdemo/bin ${HERE}/layers/tfdemo/samples 8 | 9 | GOBIN=${HERE}/layers/tfdemo/bin go install ./cmd/tfwebapp 10 | cp -r samples/* ${HERE}/layers/tfdemo/samples 11 | 12 | JUJU_REPOSITORY=${HERE} LAYER_PATH=${HERE}/layers INTERFACE_PATH=${HERE}/interfaces \ 13 | charm build ${HERE}/layers/tfdemo 14 | 15 | -------------------------------------------------------------------------------- /build-protoc.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | mkdir -p vendor/tensorflow/core/framework 4 | cd vendor/tensorflow/core/framework 5 | wget -N https://raw.githubusercontent.com/tensorflow/tensorflow/master/tensorflow/core/framework/{allocation_description,attr_value,cost_graph,device_attributes,function,graph,kernel_def,log_memory,node_def,op_def,resource_handle,step_stats,summary,tensor_description,tensor,tensor_shape,tensor_slice,types,variable,versions}.proto 6 | cd .. 7 | 8 | mkdir -p protobuf 9 | cd protobuf 10 | wget -N https://raw.githubusercontent.com/tensorflow/tensorflow/master/tensorflow/core/protobuf/{meta_graph,saver}.proto 11 | cd .. 12 | 13 | mkdir -p example 14 | cd example 15 | wget -N https://raw.githubusercontent.com/tensorflow/tensorflow/master/tensorflow/core/example/{example,feature}.proto 16 | cd ../../.. 17 | 18 | mkdir -p tensorflow_serving/apis 19 | cd tensorflow_serving/apis 20 | wget -N https://raw.githubusercontent.com/tensorflow/serving/master/tensorflow_serving/apis/{classification,get_model_metadata,input,model,prediction_service,predict,regression}.proto 21 | cd ../.. 22 | 23 | protoc --go_out=. tensorflow/core/framework/*.proto 24 | protoc --go_out=. tensorflow/core/protobuf/*.proto 25 | protoc --go_out=. tensorflow/core/example/*.proto 26 | protoc --go_out=plugins=grpc:. tensorflow_serving/apis/*.proto 27 | -------------------------------------------------------------------------------- /client.go: -------------------------------------------------------------------------------- 1 | package tfclient 2 | 3 | import ( 4 | "errors" 5 | "sync" 6 | 7 | tfcore "tensorflow/core/framework" 8 | tf "tensorflow_serving/apis" 9 | 10 | "golang.org/x/net/context" 11 | "google.golang.org/grpc" 12 | ) 13 | 14 | type PredictionClient struct { 15 | mu sync.RWMutex 16 | rpcConn *grpc.ClientConn 17 | svcConn tf.PredictionServiceClient 18 | } 19 | 20 | type Prediction struct { 21 | Class string `json:"class"` 22 | Score float32 `json:"score"` 23 | } 24 | 25 | func NewClient(addr string) (*PredictionClient, error) { 26 | conn, err := grpc.Dial(addr, grpc.WithInsecure()) 27 | if err != nil { 28 | return nil, err 29 | } 30 | c := tf.NewPredictionServiceClient(conn) 31 | return &PredictionClient{rpcConn: conn, svcConn: c}, nil 32 | } 33 | 34 | func (c *PredictionClient) Predict(modelName string, imgdata []byte) ([]Prediction, error) { 35 | resp, err := c.svcConn.Predict(context.Background(), &tf.PredictRequest{ 36 | ModelSpec: &tf.ModelSpec{ 37 | Name: modelName, 38 | }, 39 | Inputs: map[string]*tfcore.TensorProto{ 40 | "images": &tfcore.TensorProto{ 41 | Dtype: tfcore.DataType_DT_STRING, 42 | StringVal: [][]byte{imgdata}, 43 | TensorShape: &tfcore.TensorShapeProto{ 44 | Dim: []*tfcore.TensorShapeProto_Dim{{Size: 1}}, 45 | }, 46 | }, 47 | }, 48 | }) 49 | if err != nil { 50 | return nil, err 51 | } 52 | 53 | classesTensor, scoresTensor := resp.Outputs["classes"], resp.Outputs["scores"] 54 | if classesTensor == nil || scoresTensor == nil { 55 | return nil, errors.New("missing expected tensors in response") 56 | } 57 | 58 | classes := classesTensor.StringVal 59 | scores := scoresTensor.FloatVal 60 | var result []Prediction 61 | for i := 0; i < len(classes) && i < len(scores); i++ { 62 | result = append(result, Prediction{Class: string(classes[i]), Score: scores[i]}) 63 | } 64 | return result, nil 65 | } 66 | 67 | func (c *PredictionClient) Close() error { 68 | c.mu.Lock() 69 | defer c.mu.Unlock() 70 | c.svcConn = nil 71 | return c.rpcConn.Close() 72 | } 73 | -------------------------------------------------------------------------------- /cmd/tfclient/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | _ "encoding/base64" 5 | "flag" 6 | "fmt" 7 | "io/ioutil" 8 | "log" 9 | "os" 10 | 11 | "github.com/cmars/tfclient" 12 | ) 13 | 14 | var image = flag.String("image", "", "image file to classify") 15 | var addr = flag.String("addr", "", "remote address") 16 | 17 | func main() { 18 | flag.Parse() 19 | if *image == "" || *addr == "" { 20 | flag.PrintDefaults() 21 | os.Exit(1) 22 | } 23 | 24 | client, err := tfclient.NewClient(*addr) 25 | if err != nil { 26 | log.Fatalf("failed to create client: %v", err) 27 | } 28 | defer client.Close() 29 | 30 | imgdata, err := ioutil.ReadFile(*image) 31 | if err != nil { 32 | log.Fatalf("cannot read %q: %v", *image, err) 33 | } 34 | 35 | predictions, err := client.Predict("inception", imgdata) 36 | if err != nil { 37 | log.Fatalf("predict failed: %v", err) 38 | } 39 | for _, prediction := range predictions { 40 | fmt.Printf("%-30s %f\n", prediction.Class, prediction.Score) 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /cmd/tfwebapp/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "flag" 5 | "fmt" 6 | "html/template" 7 | "io/ioutil" 8 | "log" 9 | "math/rand" 10 | "net/http" 11 | "os" 12 | "path/filepath" 13 | "strings" 14 | 15 | "github.com/cmars/tfclient" 16 | ) 17 | 18 | var addr = flag.String("addr", "", "remote address") 19 | var samples = flag.String("samples", "", "Directory containing samples") 20 | 21 | var addrs []string 22 | var samplesHandler http.Handler 23 | var sampleFiles []string 24 | 25 | func main() { 26 | flag.Parse() 27 | if *addr == "" { 28 | flag.PrintDefaults() 29 | os.Exit(1) 30 | } 31 | 32 | addrs = strings.Split(*addr, ",") 33 | 34 | if *samples != "" { 35 | files, err := ioutil.ReadDir(*samples) 36 | if err != nil { 37 | log.Printf("failed to read samples: %v", err) 38 | } else { 39 | for _, fi := range files { 40 | if strings.HasSuffix(strings.ToLower(fi.Name()), ".jpg") { 41 | sampleFiles = append(sampleFiles, fi.Name()) 42 | } 43 | } 44 | samplesHandler = http.StripPrefix("/samples/", http.FileServer(http.Dir(*samples))) 45 | } 46 | } 47 | 48 | http.HandleFunc("/", page) 49 | http.ListenAndServe(":8080", nil) 50 | } 51 | 52 | func chooseAddr() string { 53 | return addrs[rand.Intn(len(addrs))] 54 | } 55 | 56 | type response struct { 57 | Predictions []tfclient.Prediction 58 | ImageLocation string 59 | Samples []string 60 | Error error 61 | } 62 | 63 | var pageTemplate = template.Must(template.New("page").Parse(` 64 | Image Classifier 65 | 86 | 87 | 88 |

Image Classifier

89 |
90 | 91 | 92 |
93 | {{ if .ImageLocation -}} 94 |

Samples:{{ range .Samples -}} | {{.}}{{ end -}}

95 |
96 |

This?

97 |
98 | 99 | {{ else -}} 100 |
101 |

Paste a URL to a jpg image, and click the button.

102 |

Samples:{{ range .Samples -}} | {{.}}{{ end -}}

103 |
104 | {{ end -}} 105 | {{ if .Predictions }}
106 |

I think it's a...

107 | 108 | {{ range .Predictions -}} 109 | 110 | {{ end -}} 111 |
ClassScore
{{ .Class }}{{ .Score }}
{{ end -}} 112 | {{ if .Error -}} 113 |
114 | An error occurred when trying to classify this image:
115 | {{ . }} 116 |
117 | {{ end -}} 118 | 119 | 120 | `)) 121 | 122 | func page(w http.ResponseWriter, r *http.Request) { 123 | log.Println(r.URL.Path) 124 | hasSamples := samplesHandler != nil 125 | if hasSamples && strings.HasPrefix(r.URL.Path, "/samples") { 126 | samplesHandler.ServeHTTP(w, r) 127 | return 128 | } 129 | 130 | fail := func(err error) { 131 | log.Println(err) 132 | w.WriteHeader(http.StatusInternalServerError) 133 | err = pageTemplate.Execute(w, response{Error: err}) 134 | if err != nil { 135 | log.Println(err) 136 | } 137 | } 138 | err := r.ParseForm() 139 | if err != nil { 140 | fail(err) 141 | return 142 | } 143 | imgdata, imageLocation, err := getImage(r, hasSamples) 144 | if err != nil { 145 | fail(err) 146 | return 147 | } 148 | if imgdata == nil { 149 | err := pageTemplate.Execute(w, response{Samples: sampleFiles}) 150 | if err != nil { 151 | log.Println(err) 152 | } 153 | return 154 | } 155 | 156 | client, err := tfclient.NewClient(chooseAddr()) 157 | if err != nil { 158 | fail(err) 159 | return 160 | } 161 | predictions, err := client.Predict("inception", imgdata) 162 | if err != nil { 163 | fail(err) 164 | return 165 | } 166 | err = pageTemplate.Execute(w, response{ 167 | Predictions: predictions, 168 | ImageLocation: imageLocation, 169 | Samples: sampleFiles, 170 | }) 171 | if err != nil { 172 | log.Println(err) 173 | return 174 | } 175 | } 176 | 177 | func getImage(r *http.Request, hasSamples bool) ([]byte, string, error) { 178 | fail := func(err error) ([]byte, string, error) { 179 | return nil, "", err 180 | } 181 | 182 | sampleLocation := r.Form.Get("sample") 183 | if sampleLocation != "" && hasSamples { 184 | imageLocation := "/samples/" + sampleLocation 185 | log.Println("open", imageLocation, sampleLocation) 186 | sampleFile, err := os.Open(filepath.Join(*samples, sampleLocation)) 187 | if err != nil { 188 | return fail(err) 189 | } 190 | defer sampleFile.Close() 191 | imgdata, err := ioutil.ReadAll(sampleFile) 192 | if err != nil { 193 | return fail(err) 194 | } 195 | return imgdata, imageLocation, nil 196 | } 197 | 198 | imageLocation := r.Form.Get("image") 199 | if imageLocation == "" { 200 | return nil, "", nil 201 | } 202 | 203 | httpClient := &http.Client{} 204 | resp, err := httpClient.Get(imageLocation) 205 | if err != nil { 206 | return fail(err) 207 | } 208 | defer resp.Body.Close() 209 | if resp.StatusCode != http.StatusOK { 210 | return fail(fmt.Errorf("request failed")) 211 | } 212 | imgdata, err := ioutil.ReadAll(resp.Body) 213 | if err != nil { 214 | return fail(err) 215 | } 216 | return imgdata, imageLocation, nil 217 | } 218 | -------------------------------------------------------------------------------- /interfaces/tf-inception-api/interface.yaml: -------------------------------------------------------------------------------- 1 | name: tf-inception-api 2 | version: 1 3 | -------------------------------------------------------------------------------- /interfaces/tf-inception-api/provides.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from charms.reactive import RelationBase, scopes, hook 4 | from charmhelpers.core import hookenv 5 | 6 | 7 | class TfInceptionProvides(RelationBase): 8 | scope = scopes.UNIT 9 | 10 | @hook('{provides:tf-inception-api}-relation-{joined,changed}') 11 | def changed(self): 12 | conv = self._maybe_conversation() 13 | if conv: 14 | self.set_state('{relation_name}.available') 15 | 16 | @hook('{provides:tf-inception-api}-relation-{departed,broken}') 17 | def departed(self): 18 | conv = self._maybe_conversation() 19 | if conv: 20 | self.remove_state('{relation_name}.available') 21 | 22 | def _maybe_conversation(self): 23 | conv = None 24 | try: 25 | conv = self.conversation() 26 | except: 27 | pass 28 | return conv 29 | 30 | def configure(self, port): 31 | relation_info = { 32 | 'host': hookenv.unit_get('private-address'), 33 | 'port': port, 34 | } 35 | self.set_remote(**relation_info) 36 | -------------------------------------------------------------------------------- /interfaces/tf-inception-api/requires.py: -------------------------------------------------------------------------------- 1 | import os 2 | import tempfile 3 | 4 | from charms.reactive import RelationBase, scopes, hook 5 | 6 | 7 | class TfInceptionRequires(RelationBase): 8 | scope = scopes.UNIT 9 | 10 | @hook('{requires:tf-inception-api}-relation-{joined,changed}') 11 | def joined(self): 12 | conv = self._maybe_conversation() 13 | if conv: 14 | conv.set_state('{relation_name}.available') 15 | 16 | @hook('{requires:tf-inception-api}-relation-{departed,broken}') 17 | def departed(self): 18 | conv = self._maybe_conversation() 19 | if conv: 20 | conv.remove_state('{relation_name}.available') 21 | 22 | def _maybe_conversation(self): 23 | conv = None 24 | try: 25 | conv = self.conversation() 26 | except: 27 | pass 28 | return conv 29 | 30 | def _maybe_conversations(self): 31 | convs = [] 32 | try: 33 | convs = self.conversations() 34 | except: 35 | pass 36 | return convs 37 | 38 | def addrs(self): 39 | addrs = set() 40 | for conv in self.conversations(): 41 | host = conv.get_remote('host') 42 | port = conv.get_remote('port') 43 | if host and port: 44 | addr = '%s:%s' % (host, port) 45 | addrs.add(addr) 46 | return list(addrs) 47 | -------------------------------------------------------------------------------- /layers/tfdemo/.gitignore: -------------------------------------------------------------------------------- 1 | bin 2 | samples 3 | -------------------------------------------------------------------------------- /layers/tfdemo/layer.yaml: -------------------------------------------------------------------------------- 1 | includes: 2 | - layer:basic 3 | - interface:tf-inception-api 4 | - interface:http 5 | -------------------------------------------------------------------------------- /layers/tfdemo/metadata.yaml: -------------------------------------------------------------------------------- 1 | name: tfdemo 2 | summary: Demo image classification with remote Tensorflow model 3 | maintainer: Casey Marshall 4 | description: | 5 | This demo web application displays a form where you can paste in the 6 | URL to an image to be classified by a remote Tensorflow model. 7 | tags: 8 | # Replace "misc" with one or more whitelisted tags from this list: 9 | # https://jujucharms.com/docs/stable/authors-charm-metadata 10 | - misc 11 | subordinate: false 12 | provides: 13 | website: 14 | interface: http 15 | requires: 16 | client: 17 | interface: tf-inception-api 18 | series: 19 | - xenial 20 | -------------------------------------------------------------------------------- /layers/tfdemo/reactive/tfdemo.py: -------------------------------------------------------------------------------- 1 | import os 2 | import shutil 3 | from subprocess import check_call 4 | 5 | from charms.reactive import when, when_not, set_state, remove_state, hook 6 | from charms.reactive.helpers import data_changed 7 | 8 | from charmhelpers.core.templating import render 9 | from charmhelpers.core import hookenv, host 10 | 11 | 12 | @hook('upgrade-charm') 13 | def upgrade_charm(): 14 | install_tfdemo() 15 | 16 | 17 | @when_not('tfdemo.installed') 18 | def install_tfdemo(): 19 | shutil.copyfile("bin/tfwebapp", "/usr/bin/tfwebapp") 20 | os.chmod("/usr/bin/tfwebapp", 0o755) 21 | if host.service_available('tfdemo') and host.service_running('tfdemo'): 22 | host.service_restart('tfdemo') 23 | set_state('tfdemo.installed') 24 | 25 | 26 | @when('client.available', 'tfdemo.installed') 27 | def tensorflow_available(tf): 28 | addrs = tf.addrs() 29 | if not addrs: 30 | if host.service_running('tfdemo'): 31 | host.service_stop('tfdemo') 32 | return 33 | hookenv.open_port(8080) 34 | ctx = { 35 | 'addr': ','.join(addrs), 36 | } 37 | samples_dir = os.path.join(hookenv.charm_dir(), "samples") 38 | if os.path.exists(samples_dir): 39 | ctx['samples'] = samples_dir 40 | render(source="tfdemo.service", 41 | target="/etc/systemd/system/tfdemo.service", 42 | owner="root", 43 | perms=0o644, 44 | context=ctx, 45 | ) 46 | check_call(['systemctl', 'daemon-reload']) 47 | if host.service_running('tfdemo'): 48 | host.service_restart('tfdemo') 49 | else: 50 | host.service_start('tfdemo') 51 | remove_state('client.available') 52 | 53 | 54 | @when('website.available') 55 | def website_available(w): 56 | w.configure(8080) 57 | remove_state('website.available') 58 | -------------------------------------------------------------------------------- /layers/tfdemo/templates/tfdemo.service: -------------------------------------------------------------------------------- 1 | [Unit] 2 | Description=Demo image classification with remote Tensorflow model 3 | After=syslog.target network.target 4 | 5 | [Service] 6 | Type=simple 7 | ExecStart=/usr/bin/tfwebapp -addr {{ addr }} -samples {{ samples }} 8 | Restart=always 9 | RestartSec=1 10 | 11 | [Install] 12 | WantedBy=multi-user.target 13 | -------------------------------------------------------------------------------- /samples/bobcat.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cmars/tfclient/2c05252f1730e6974c166b850b4751e359144555/samples/bobcat.jpg -------------------------------------------------------------------------------- /samples/catfish.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cmars/tfclient/2c05252f1730e6974c166b850b4751e359144555/samples/catfish.jpg -------------------------------------------------------------------------------- /samples/cheetah.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cmars/tfclient/2c05252f1730e6974c166b850b4751e359144555/samples/cheetah.jpg -------------------------------------------------------------------------------- /samples/ferret.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cmars/tfclient/2c05252f1730e6974c166b850b4751e359144555/samples/ferret.jpg -------------------------------------------------------------------------------- /samples/fluffy.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cmars/tfclient/2c05252f1730e6974c166b850b4751e359144555/samples/fluffy.jpg -------------------------------------------------------------------------------- /samples/fox.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cmars/tfclient/2c05252f1730e6974c166b850b4751e359144555/samples/fox.jpg -------------------------------------------------------------------------------- /samples/jaguar.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cmars/tfclient/2c05252f1730e6974c166b850b4751e359144555/samples/jaguar.jpg -------------------------------------------------------------------------------- /samples/mountain_lion.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cmars/tfclient/2c05252f1730e6974c166b850b4751e359144555/samples/mountain_lion.jpg -------------------------------------------------------------------------------- /samples/ringtail.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cmars/tfclient/2c05252f1730e6974c166b850b4751e359144555/samples/ringtail.jpg -------------------------------------------------------------------------------- /samples/tabby.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cmars/tfclient/2c05252f1730e6974c166b850b4751e359144555/samples/tabby.jpg -------------------------------------------------------------------------------- /samples/tiger.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cmars/tfclient/2c05252f1730e6974c166b850b4751e359144555/samples/tiger.jpg -------------------------------------------------------------------------------- /vendor/tensorflow/core/example/example.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow/core/example/example.proto 3 | // DO NOT EDIT! 4 | 5 | /* 6 | Package tensorflow is a generated protocol buffer package. 7 | 8 | It is generated from these files: 9 | tensorflow/core/example/example.proto 10 | tensorflow/core/example/feature.proto 11 | 12 | It has these top-level messages: 13 | Example 14 | SequenceExample 15 | BytesList 16 | FloatList 17 | Int64List 18 | Feature 19 | Features 20 | FeatureList 21 | FeatureLists 22 | */ 23 | package tensorflow 24 | 25 | import proto "github.com/golang/protobuf/proto" 26 | import fmt "fmt" 27 | import math "math" 28 | 29 | // Reference imports to suppress errors if they are not otherwise used. 30 | var _ = proto.Marshal 31 | var _ = fmt.Errorf 32 | var _ = math.Inf 33 | 34 | // This is a compile-time assertion to ensure that this generated file 35 | // is compatible with the proto package it is being compiled against. 36 | // A compilation error at this line likely means your copy of the 37 | // proto package needs to be updated. 38 | const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package 39 | 40 | type Example struct { 41 | Features *Features `protobuf:"bytes,1,opt,name=features" json:"features,omitempty"` 42 | } 43 | 44 | func (m *Example) Reset() { *m = Example{} } 45 | func (m *Example) String() string { return proto.CompactTextString(m) } 46 | func (*Example) ProtoMessage() {} 47 | func (*Example) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } 48 | 49 | func (m *Example) GetFeatures() *Features { 50 | if m != nil { 51 | return m.Features 52 | } 53 | return nil 54 | } 55 | 56 | type SequenceExample struct { 57 | Context *Features `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` 58 | FeatureLists *FeatureLists `protobuf:"bytes,2,opt,name=feature_lists,json=featureLists" json:"feature_lists,omitempty"` 59 | } 60 | 61 | func (m *SequenceExample) Reset() { *m = SequenceExample{} } 62 | func (m *SequenceExample) String() string { return proto.CompactTextString(m) } 63 | func (*SequenceExample) ProtoMessage() {} 64 | func (*SequenceExample) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } 65 | 66 | func (m *SequenceExample) GetContext() *Features { 67 | if m != nil { 68 | return m.Context 69 | } 70 | return nil 71 | } 72 | 73 | func (m *SequenceExample) GetFeatureLists() *FeatureLists { 74 | if m != nil { 75 | return m.FeatureLists 76 | } 77 | return nil 78 | } 79 | 80 | func init() { 81 | proto.RegisterType((*Example)(nil), "tensorflow.Example") 82 | proto.RegisterType((*SequenceExample)(nil), "tensorflow.SequenceExample") 83 | } 84 | 85 | func init() { proto.RegisterFile("tensorflow/core/example/example.proto", fileDescriptor0) } 86 | 87 | var fileDescriptor0 = []byte{ 88 | // 190 bytes of a gzipped FileDescriptorProto 89 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x52, 0x2d, 0x49, 0xcd, 0x2b, 90 | 0xce, 0x2f, 0x4a, 0xcb, 0xc9, 0x2f, 0xd7, 0x4f, 0xce, 0x2f, 0x4a, 0xd5, 0x4f, 0xad, 0x48, 0xcc, 91 | 0x2d, 0xc8, 0x81, 0xd3, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0x5c, 0x08, 0x65, 0x52, 0x38, 92 | 0xb5, 0xa4, 0xa5, 0x26, 0x96, 0x94, 0x16, 0x41, 0xb5, 0x28, 0x59, 0x73, 0xb1, 0xbb, 0x42, 0x24, 93 | 0x84, 0x0c, 0xb8, 0x38, 0xa0, 0x72, 0xc5, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0xdc, 0x46, 0x22, 0x7a, 94 | 0x08, 0x43, 0xf4, 0xdc, 0xa0, 0x72, 0x41, 0x70, 0x55, 0x4a, 0x0d, 0x8c, 0x5c, 0xfc, 0xc1, 0xa9, 95 | 0x85, 0xa5, 0xa9, 0x79, 0xc9, 0xa9, 0x30, 0x53, 0xf4, 0xb8, 0xd8, 0x93, 0xf3, 0xf3, 0x4a, 0x52, 96 | 0x2b, 0x4a, 0xf0, 0x1a, 0x02, 0x53, 0x24, 0x64, 0xcb, 0xc5, 0x0b, 0x35, 0x2f, 0x3e, 0x27, 0xb3, 97 | 0xb8, 0xa4, 0x58, 0x82, 0x09, 0xac, 0x4b, 0x02, 0x8b, 0x2e, 0x1f, 0x90, 0x7c, 0x10, 0x4f, 0x1a, 98 | 0x12, 0xcf, 0x49, 0x87, 0x4b, 0x2c, 0xbf, 0x28, 0x1d, 0x59, 0x31, 0xd4, 0x9f, 0x4e, 0xbc, 0x50, 99 | 0x17, 0x05, 0x80, 0xfc, 0x59, 0x1c, 0xc0, 0xf8, 0x83, 0x91, 0x31, 0x89, 0x0d, 0xec, 0x69, 0x63, 100 | 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x98, 0x79, 0xef, 0x4a, 0x50, 0x01, 0x00, 0x00, 101 | } 102 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/example/feature.proto: -------------------------------------------------------------------------------- 1 | // Protocol messages for describing features for machine learning model 2 | // training or inference. 3 | // 4 | // There are three base Feature types: 5 | // - bytes 6 | // - float 7 | // - int64 8 | // 9 | // A Feature contains Lists which may hold zero or more values. These 10 | // lists are the base values BytesList, FloatList, Int64List. 11 | // 12 | // Features are organized into categories by name. The Features message 13 | // contains the mapping from name to Feature. 14 | // 15 | // Example Features for a movie recommendation application: 16 | // feature { 17 | // key: "age" 18 | // value { float_list { 19 | // value: 29.0 20 | // }} 21 | // } 22 | // feature { 23 | // key: "movie" 24 | // value { bytes_list { 25 | // value: "The Shawshank Redemption" 26 | // value: "Fight Club" 27 | // }} 28 | // } 29 | // feature { 30 | // key: "movie_ratings" 31 | // value { float_list { 32 | // value: 9.0 33 | // value: 9.7 34 | // }} 35 | // } 36 | // feature { 37 | // key: "suggestion" 38 | // value { bytes_list { 39 | // value: "Inception" 40 | // }} 41 | // } 42 | // feature { 43 | // key: "suggestion_purchased" 44 | // value { int64_list { 45 | // value: 1 46 | // }} 47 | // } 48 | // feature { 49 | // key: "purchase_price" 50 | // value { float_list { 51 | // value: 9.99 52 | // }} 53 | // } 54 | // 55 | 56 | syntax = "proto3"; 57 | option cc_enable_arenas = true; 58 | option java_outer_classname = "FeatureProtos"; 59 | option java_multiple_files = true; 60 | option java_package = "org.tensorflow.example"; 61 | 62 | package tensorflow; 63 | 64 | // Containers to hold repeated fundamental values. 65 | message BytesList { 66 | repeated bytes value = 1; 67 | } 68 | message FloatList { 69 | repeated float value = 1 [packed = true]; 70 | } 71 | message Int64List { 72 | repeated int64 value = 1 [packed = true]; 73 | } 74 | 75 | // Containers for non-sequential data. 76 | message Feature { 77 | // Each feature can be exactly one kind. 78 | oneof kind { 79 | BytesList bytes_list = 1; 80 | FloatList float_list = 2; 81 | Int64List int64_list = 3; 82 | } 83 | }; 84 | 85 | message Features { 86 | // Map from feature name to feature. 87 | map feature = 1; 88 | }; 89 | 90 | // Containers for sequential data. 91 | // 92 | // A FeatureList contains lists of Features. These may hold zero or more 93 | // Feature values. 94 | // 95 | // FeatureLists are organized into categories by name. The FeatureLists message 96 | // contains the mapping from name to FeatureList. 97 | // 98 | message FeatureList { 99 | repeated Feature feature = 1; 100 | }; 101 | 102 | message FeatureLists { 103 | // Map from feature name to feature list. 104 | map feature_list = 1; 105 | }; 106 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/allocation_description.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow/core/framework/allocation_description.proto 3 | // DO NOT EDIT! 4 | 5 | /* 6 | Package tensorflow is a generated protocol buffer package. 7 | 8 | It is generated from these files: 9 | tensorflow/core/framework/allocation_description.proto 10 | tensorflow/core/framework/attr_value.proto 11 | tensorflow/core/framework/cost_graph.proto 12 | tensorflow/core/framework/device_attributes.proto 13 | tensorflow/core/framework/function.proto 14 | tensorflow/core/framework/graph.proto 15 | tensorflow/core/framework/kernel_def.proto 16 | tensorflow/core/framework/log_memory.proto 17 | tensorflow/core/framework/node_def.proto 18 | tensorflow/core/framework/op_def.proto 19 | tensorflow/core/framework/resource_handle.proto 20 | tensorflow/core/framework/step_stats.proto 21 | tensorflow/core/framework/summary.proto 22 | tensorflow/core/framework/tensor_description.proto 23 | tensorflow/core/framework/tensor.proto 24 | tensorflow/core/framework/tensor_shape.proto 25 | tensorflow/core/framework/tensor_slice.proto 26 | tensorflow/core/framework/types.proto 27 | tensorflow/core/framework/variable.proto 28 | tensorflow/core/framework/versions.proto 29 | 30 | It has these top-level messages: 31 | AllocationDescription 32 | AttrValue 33 | NameAttrList 34 | CostGraphDef 35 | DeviceLocality 36 | DeviceAttributes 37 | FunctionDefLibrary 38 | FunctionDef 39 | GradientDef 40 | GraphDef 41 | KernelDef 42 | MemoryLogStep 43 | MemoryLogTensorAllocation 44 | MemoryLogTensorDeallocation 45 | MemoryLogTensorOutput 46 | MemoryLogRawAllocation 47 | MemoryLogRawDeallocation 48 | NodeDef 49 | OpDef 50 | OpDeprecation 51 | OpList 52 | ResourceHandle 53 | AllocatorMemoryUsed 54 | NodeOutput 55 | NodeExecStats 56 | DeviceStepStats 57 | StepStats 58 | SummaryDescription 59 | HistogramProto 60 | Summary 61 | TensorDescription 62 | TensorProto 63 | TensorShapeProto 64 | TensorSliceProto 65 | VariableDef 66 | SaveSliceInfoDef 67 | VersionDef 68 | */ 69 | package tensorflow 70 | 71 | import proto "github.com/golang/protobuf/proto" 72 | import fmt "fmt" 73 | import math "math" 74 | 75 | // Reference imports to suppress errors if they are not otherwise used. 76 | var _ = proto.Marshal 77 | var _ = fmt.Errorf 78 | var _ = math.Inf 79 | 80 | // This is a compile-time assertion to ensure that this generated file 81 | // is compatible with the proto package it is being compiled against. 82 | // A compilation error at this line likely means your copy of the 83 | // proto package needs to be updated. 84 | const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package 85 | 86 | type AllocationDescription struct { 87 | // Total number of bytes requested 88 | RequestedBytes int64 `protobuf:"varint,1,opt,name=requested_bytes,json=requestedBytes" json:"requested_bytes,omitempty"` 89 | // Total number of bytes allocated if known 90 | AllocatedBytes int64 `protobuf:"varint,2,opt,name=allocated_bytes,json=allocatedBytes" json:"allocated_bytes,omitempty"` 91 | // Name of the allocator used 92 | AllocatorName string `protobuf:"bytes,3,opt,name=allocator_name,json=allocatorName" json:"allocator_name,omitempty"` 93 | // Identifier of the allocated buffer if known 94 | AllocationId int64 `protobuf:"varint,4,opt,name=allocation_id,json=allocationId" json:"allocation_id,omitempty"` 95 | // Set if this tensor only has one remaining reference 96 | HasSingleReference bool `protobuf:"varint,5,opt,name=has_single_reference,json=hasSingleReference" json:"has_single_reference,omitempty"` 97 | // Address of the allocation. 98 | Ptr uint64 `protobuf:"varint,6,opt,name=ptr" json:"ptr,omitempty"` 99 | } 100 | 101 | func (m *AllocationDescription) Reset() { *m = AllocationDescription{} } 102 | func (m *AllocationDescription) String() string { return proto.CompactTextString(m) } 103 | func (*AllocationDescription) ProtoMessage() {} 104 | func (*AllocationDescription) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } 105 | 106 | func (m *AllocationDescription) GetRequestedBytes() int64 { 107 | if m != nil { 108 | return m.RequestedBytes 109 | } 110 | return 0 111 | } 112 | 113 | func (m *AllocationDescription) GetAllocatedBytes() int64 { 114 | if m != nil { 115 | return m.AllocatedBytes 116 | } 117 | return 0 118 | } 119 | 120 | func (m *AllocationDescription) GetAllocatorName() string { 121 | if m != nil { 122 | return m.AllocatorName 123 | } 124 | return "" 125 | } 126 | 127 | func (m *AllocationDescription) GetAllocationId() int64 { 128 | if m != nil { 129 | return m.AllocationId 130 | } 131 | return 0 132 | } 133 | 134 | func (m *AllocationDescription) GetHasSingleReference() bool { 135 | if m != nil { 136 | return m.HasSingleReference 137 | } 138 | return false 139 | } 140 | 141 | func (m *AllocationDescription) GetPtr() uint64 { 142 | if m != nil { 143 | return m.Ptr 144 | } 145 | return 0 146 | } 147 | 148 | func init() { 149 | proto.RegisterType((*AllocationDescription)(nil), "tensorflow.AllocationDescription") 150 | } 151 | 152 | func init() { 153 | proto.RegisterFile("tensorflow/core/framework/allocation_description.proto", fileDescriptor0) 154 | } 155 | 156 | var fileDescriptor0 = []byte{ 157 | // 255 bytes of a gzipped FileDescriptorProto 158 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x90, 0xc1, 0x4a, 0xc4, 0x30, 159 | 0x10, 0x86, 0x89, 0x5d, 0x17, 0x1d, 0x5c, 0x95, 0xa0, 0x10, 0xf0, 0x22, 0x8a, 0xe8, 0xa9, 0x15, 160 | 0x04, 0x4f, 0x5e, 0x2c, 0x5e, 0xbc, 0xc8, 0x52, 0x1f, 0x20, 0x74, 0xdb, 0xe9, 0x5a, 0xac, 0x99, 161 | 0x3a, 0x89, 0x2c, 0xbe, 0xb9, 0xde, 0x4c, 0xba, 0x6e, 0xea, 0xc1, 0xdb, 0xf0, 0xfd, 0x5f, 0x32, 162 | 0xc3, 0x0f, 0xb7, 0x0e, 0x8d, 0x25, 0x6e, 0x3a, 0x5a, 0x65, 0x15, 0x31, 0x66, 0x0d, 0x97, 0x6f, 163 | 0xb8, 0x22, 0x7e, 0xcd, 0xca, 0xae, 0xa3, 0xaa, 0x74, 0x2d, 0x19, 0x5d, 0xa3, 0xad, 0xb8, 0xed, 164 | 0xc3, 0x9c, 0xf6, 0x4c, 0x8e, 0x24, 0x8c, 0xef, 0xce, 0xbe, 0x05, 0x1c, 0xdf, 0x47, 0xf9, 0x61, 165 | 0x74, 0xe5, 0x25, 0x1c, 0x30, 0xbe, 0x7f, 0xa0, 0x75, 0x58, 0xeb, 0xc5, 0xa7, 0x43, 0xab, 0xc4, 166 | 0xa9, 0xb8, 0x4a, 0x8a, 0xfd, 0x88, 0xf3, 0x40, 0x83, 0xf8, 0xbb, 0x2e, 0x8a, 0x5b, 0x6b, 0x31, 167 | 0xe2, 0xb5, 0x78, 0x01, 0x1b, 0x42, 0xac, 0x8d, 0x3f, 0x55, 0x25, 0xde, 0xdb, 0x2d, 0x66, 0x91, 168 | 0x3e, 0x79, 0x28, 0xcf, 0x61, 0xf6, 0xe7, 0xfc, 0xb6, 0x56, 0x93, 0xe1, 0xb7, 0xbd, 0x11, 0x3e, 169 | 0xd6, 0xf2, 0x1a, 0x8e, 0x5e, 0x4a, 0xab, 0x6d, 0x6b, 0x96, 0x1d, 0x6a, 0xc6, 0x06, 0x19, 0x4d, 170 | 0x85, 0x6a, 0xdb, 0xbb, 0x3b, 0x85, 0xf4, 0xd9, 0xf3, 0x10, 0x15, 0x9b, 0x44, 0x1e, 0x42, 0xd2, 171 | 0x3b, 0x56, 0x53, 0x2f, 0x4c, 0x8a, 0x30, 0xe6, 0x77, 0xa0, 0x88, 0x97, 0xe9, 0xd8, 0x46, 0x1a, 172 | 0x0b, 0xcc, 0x4f, 0xfe, 0x2d, 0x65, 0x1e, 0xfa, 0xb3, 0x73, 0xf1, 0x25, 0xc4, 0x62, 0x3a, 0x94, 173 | 0x79, 0xf3, 0x13, 0x00, 0x00, 0xff, 0xff, 0x2e, 0xb7, 0xe1, 0x85, 0x86, 0x01, 0x00, 0x00, 174 | } 175 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/allocation_description.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow; 4 | option cc_enable_arenas = true; 5 | option java_outer_classname = "AllocationDescriptionProtos"; 6 | option java_multiple_files = true; 7 | option java_package = "org.tensorflow.framework"; 8 | 9 | message AllocationDescription { 10 | // Total number of bytes requested 11 | int64 requested_bytes = 1; 12 | 13 | // Total number of bytes allocated if known 14 | int64 allocated_bytes = 2; 15 | 16 | // Name of the allocator used 17 | string allocator_name = 3; 18 | 19 | // Identifier of the allocated buffer if known 20 | int64 allocation_id = 4; 21 | 22 | // Set if this tensor only has one remaining reference 23 | bool has_single_reference = 5; 24 | 25 | // Address of the allocation. 26 | uint64 ptr = 6; 27 | }; 28 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/attr_value.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow; 4 | option cc_enable_arenas = true; 5 | option java_outer_classname = "AttrValueProtos"; 6 | option java_multiple_files = true; 7 | option java_package = "org.tensorflow.framework"; 8 | 9 | import "tensorflow/core/framework/tensor.proto"; 10 | import "tensorflow/core/framework/tensor_shape.proto"; 11 | import "tensorflow/core/framework/types.proto"; 12 | 13 | // Protocol buffer representing the value for an attr used to configure an Op. 14 | // Comment indicates the corresponding attr type. Only the field matching the 15 | // attr type may be filled. 16 | message AttrValue { 17 | // LINT.IfChange 18 | message ListValue { 19 | repeated bytes s = 2; // "list(string)" 20 | repeated int64 i = 3 [packed = true]; // "list(int)" 21 | repeated float f = 4 [packed = true]; // "list(float)" 22 | repeated bool b = 5 [packed = true]; // "list(bool)" 23 | repeated DataType type = 6 [packed = true]; // "list(type)" 24 | repeated TensorShapeProto shape = 7; // "list(shape)" 25 | repeated TensorProto tensor = 8; // "list(tensor)" 26 | repeated NameAttrList func = 9; // "list(attr)" 27 | } 28 | // LINT.ThenChange(https://www.tensorflow.org/code/tensorflow/c/c_api.cc) 29 | 30 | oneof value { 31 | bytes s = 2; // "string" 32 | int64 i = 3; // "int" 33 | float f = 4; // "float" 34 | bool b = 5; // "bool" 35 | DataType type = 6; // "type" 36 | TensorShapeProto shape = 7; // "shape" 37 | TensorProto tensor = 8; // "tensor" 38 | ListValue list = 1; // any "list(...)" 39 | 40 | // "func" represents a function. func.name is a function's name or 41 | // a primitive op's name. func.attr.first is the name of an attr 42 | // defined for that function. func.attr.second is the value for 43 | // that attr in the instantiation. 44 | NameAttrList func = 10; 45 | 46 | // This is a placeholder only used in nodes defined inside a 47 | // function. It indicates the attr value will be supplied when 48 | // the function is instantiated. For example, let us suppose a 49 | // node "N" in function "FN". "N" has an attr "A" with value 50 | // placeholder = "foo". When FN is instantiated with attr "foo" 51 | // set to "bar", the instantiated node N's attr A will have been 52 | // given the value "bar". 53 | string placeholder = 9; 54 | } 55 | } 56 | 57 | // A list of attr names and their values. The whole list is attached 58 | // with a string name. E.g., MatMul[T=float]. 59 | message NameAttrList { 60 | string name = 1; 61 | map attr = 2; 62 | } 63 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/cost_graph.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow; 4 | option cc_enable_arenas = true; 5 | option java_outer_classname = "CostGraphProtos"; 6 | option java_multiple_files = true; 7 | option java_package = "org.tensorflow.framework"; 8 | 9 | import "tensorflow/core/framework/tensor_shape.proto"; 10 | import "tensorflow/core/framework/types.proto"; 11 | 12 | message CostGraphDef { 13 | message Node { 14 | // The name of the node. Names are globally unique. 15 | string name = 1; 16 | 17 | // The device of the node. Can be empty if the node is mapped to the 18 | // default partition or partitioning hasn't been run yet. 19 | string device = 2; 20 | 21 | // The id of the node. Node ids are only unique inside a partition. 22 | int32 id = 3; 23 | 24 | // Inputs of this node. They must be executed before this node can be 25 | // executed. An input is a particular output of another node, specified 26 | // by the node id and the output index. 27 | message InputInfo { 28 | int32 preceding_node = 1; 29 | int32 preceding_port = 2; 30 | } 31 | repeated InputInfo input_info = 4; 32 | 33 | // Outputs of this node. 34 | message OutputInfo { 35 | int64 size = 1; 36 | // If >= 0, the output is an alias of an input. Note that an alias input 37 | // may itself be an alias. The algorithm will therefore need to follow 38 | // those pointers. 39 | int64 alias_input_port = 2; 40 | TensorShapeProto shape = 3; 41 | DataType dtype = 4; 42 | } 43 | repeated OutputInfo output_info = 5; 44 | 45 | // Temporary memory used by this node. 46 | int64 temporary_memory_size = 6; 47 | 48 | int64 host_peak_memory_size = 10; 49 | int64 device_peak_memory_size = 11; 50 | int64 persisted_memory_size = 12; 51 | int64 auxiliary_memory_size = 13; 52 | 53 | // Estimate of the computational cost of this node, in microseconds. 54 | int64 compute_cost = 9; 55 | 56 | // If true, the output is permanent: it can't be discarded, because this 57 | // node is part of the "final output". Nodes may depend on final nodes. 58 | bool is_final = 7; 59 | 60 | // Ids of the control inputs for this node. 61 | repeated int32 control_input = 8; 62 | } 63 | repeated Node node = 1; 64 | } 65 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/device_attributes.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow/core/framework/device_attributes.proto 3 | // DO NOT EDIT! 4 | 5 | package tensorflow 6 | 7 | import proto "github.com/golang/protobuf/proto" 8 | import fmt "fmt" 9 | import math "math" 10 | 11 | // Reference imports to suppress errors if they are not otherwise used. 12 | var _ = proto.Marshal 13 | var _ = fmt.Errorf 14 | var _ = math.Inf 15 | 16 | type DeviceLocality struct { 17 | // Optional bus locality of device. Default value of 0 means 18 | // no specific locality. Specific localities are indexed from 1. 19 | BusId int32 `protobuf:"varint,1,opt,name=bus_id,json=busId" json:"bus_id,omitempty"` 20 | } 21 | 22 | func (m *DeviceLocality) Reset() { *m = DeviceLocality{} } 23 | func (m *DeviceLocality) String() string { return proto.CompactTextString(m) } 24 | func (*DeviceLocality) ProtoMessage() {} 25 | func (*DeviceLocality) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} } 26 | 27 | func (m *DeviceLocality) GetBusId() int32 { 28 | if m != nil { 29 | return m.BusId 30 | } 31 | return 0 32 | } 33 | 34 | type DeviceAttributes struct { 35 | // Fully specified name of the device within a cluster. 36 | Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` 37 | // String representation of device_type. 38 | DeviceType string `protobuf:"bytes,2,opt,name=device_type,json=deviceType" json:"device_type,omitempty"` 39 | // Memory capacity of device in bytes. 40 | MemoryLimit int64 `protobuf:"varint,4,opt,name=memory_limit,json=memoryLimit" json:"memory_limit,omitempty"` 41 | // Platform-specific data about device that may be useful 42 | // for supporting efficient data transfers. 43 | Locality *DeviceLocality `protobuf:"bytes,5,opt,name=locality" json:"locality,omitempty"` 44 | // A device is assigned a global unique number each time it is 45 | // initialized. "incarnation" should never be 0. 46 | Incarnation uint64 `protobuf:"fixed64,6,opt,name=incarnation" json:"incarnation,omitempty"` 47 | // String representation of the physical device that this device maps to. 48 | PhysicalDeviceDesc string `protobuf:"bytes,7,opt,name=physical_device_desc,json=physicalDeviceDesc" json:"physical_device_desc,omitempty"` 49 | } 50 | 51 | func (m *DeviceAttributes) Reset() { *m = DeviceAttributes{} } 52 | func (m *DeviceAttributes) String() string { return proto.CompactTextString(m) } 53 | func (*DeviceAttributes) ProtoMessage() {} 54 | func (*DeviceAttributes) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{1} } 55 | 56 | func (m *DeviceAttributes) GetName() string { 57 | if m != nil { 58 | return m.Name 59 | } 60 | return "" 61 | } 62 | 63 | func (m *DeviceAttributes) GetDeviceType() string { 64 | if m != nil { 65 | return m.DeviceType 66 | } 67 | return "" 68 | } 69 | 70 | func (m *DeviceAttributes) GetMemoryLimit() int64 { 71 | if m != nil { 72 | return m.MemoryLimit 73 | } 74 | return 0 75 | } 76 | 77 | func (m *DeviceAttributes) GetLocality() *DeviceLocality { 78 | if m != nil { 79 | return m.Locality 80 | } 81 | return nil 82 | } 83 | 84 | func (m *DeviceAttributes) GetIncarnation() uint64 { 85 | if m != nil { 86 | return m.Incarnation 87 | } 88 | return 0 89 | } 90 | 91 | func (m *DeviceAttributes) GetPhysicalDeviceDesc() string { 92 | if m != nil { 93 | return m.PhysicalDeviceDesc 94 | } 95 | return "" 96 | } 97 | 98 | func init() { 99 | proto.RegisterType((*DeviceLocality)(nil), "tensorflow.DeviceLocality") 100 | proto.RegisterType((*DeviceAttributes)(nil), "tensorflow.DeviceAttributes") 101 | } 102 | 103 | func init() { proto.RegisterFile("tensorflow/core/framework/device_attributes.proto", fileDescriptor3) } 104 | 105 | var fileDescriptor3 = []byte{ 106 | // 282 bytes of a gzipped FileDescriptorProto 107 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x5c, 0x50, 0x4b, 0x4b, 0xf3, 0x40, 108 | 0x14, 0x65, 0xbe, 0xaf, 0x89, 0x7a, 0x23, 0x22, 0x17, 0x95, 0xc1, 0x8d, 0xb5, 0x1b, 0x5d, 0x25, 109 | 0x3e, 0x40, 0xd7, 0x96, 0x6e, 0x84, 0x2e, 0x4a, 0x70, 0x1f, 0xf2, 0x98, 0xea, 0x60, 0x92, 0x1b, 110 | 0x66, 0xa6, 0x96, 0xfc, 0x71, 0x71, 0xe9, 0x74, 0x12, 0xd3, 0xea, 0x6e, 0xe6, 0x3c, 0xee, 0x39, 111 | 0x1c, 0xb8, 0x35, 0xa2, 0xd6, 0xa4, 0x96, 0x25, 0xad, 0xa3, 0x9c, 0x94, 0x88, 0x96, 0x2a, 0xad, 112 | 0xc4, 0x9a, 0xd4, 0x7b, 0x54, 0x88, 0x0f, 0x99, 0x8b, 0x24, 0x35, 0x46, 0xc9, 0x6c, 0x65, 0x84, 113 | 0x0e, 0x1b, 0x45, 0x86, 0x10, 0xb6, 0x96, 0xc9, 0x15, 0x1c, 0xcd, 0x9c, 0x6c, 0x4e, 0x79, 0x5a, 114 | 0x4a, 0xd3, 0xe2, 0x29, 0xf8, 0xd9, 0x4a, 0x27, 0xb2, 0xe0, 0x6c, 0xcc, 0xae, 0xbd, 0xd8, 0xb3, 115 | 0xbf, 0xe7, 0x62, 0xf2, 0xc9, 0xe0, 0xb8, 0x53, 0x3e, 0x0d, 0xf7, 0x10, 0x61, 0x54, 0xdb, 0x34, 116 | 0xa7, 0x3c, 0x88, 0xdd, 0x1b, 0x2f, 0x20, 0xe8, 0x83, 0x4d, 0xdb, 0x08, 0xfe, 0xcf, 0x51, 0xd0, 117 | 0x41, 0x2f, 0x16, 0xc1, 0x4b, 0x38, 0xac, 0x44, 0x45, 0xaa, 0x4d, 0x4a, 0x59, 0x49, 0xc3, 0x47, 118 | 0x56, 0xf1, 0x3f, 0x0e, 0x3a, 0x6c, 0xbe, 0x81, 0xf0, 0x01, 0xf6, 0xcb, 0xbe, 0x0f, 0xf7, 0x2c, 119 | 0x1d, 0xdc, 0x9d, 0x87, 0xdb, 0xd2, 0xe1, 0xef, 0xc6, 0xf1, 0xa0, 0xc5, 0x31, 0x04, 0xb2, 0xce, 120 | 0x53, 0x55, 0xa7, 0x46, 0x52, 0xcd, 0x7d, 0x6b, 0xf5, 0xe3, 0x5d, 0x08, 0x6f, 0xe0, 0xa4, 0x79, 121 | 0x6b, 0xb5, 0xb4, 0x86, 0xa4, 0xaf, 0x59, 0x08, 0x9d, 0xf3, 0x3d, 0x57, 0x13, 0x7f, 0xb8, 0x2e, 122 | 0x61, 0x66, 0x99, 0xe9, 0x23, 0x70, 0x52, 0xaf, 0xbb, 0xf1, 0xc3, 0xc2, 0xd3, 0xb3, 0xbf, 0x8b, 123 | 0x2c, 0x36, 0x03, 0xeb, 0x05, 0xfb, 0x62, 0x2c, 0xf3, 0xdd, 0xda, 0xf7, 0xdf, 0x01, 0x00, 0x00, 124 | 0xff, 0xff, 0x1f, 0xb1, 0x4d, 0x88, 0xa2, 0x01, 0x00, 0x00, 125 | } 126 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/device_attributes.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow; 4 | option cc_enable_arenas = true; 5 | option java_outer_classname = "DeviceAttributesProtos"; 6 | option java_multiple_files = true; 7 | option java_package = "org.tensorflow.framework"; 8 | 9 | message DeviceLocality { 10 | // Optional bus locality of device. Default value of 0 means 11 | // no specific locality. Specific localities are indexed from 1. 12 | int32 bus_id = 1; 13 | }; 14 | 15 | message DeviceAttributes { 16 | // Fully specified name of the device within a cluster. 17 | string name = 1; 18 | 19 | // String representation of device_type. 20 | string device_type = 2; 21 | 22 | // Memory capacity of device in bytes. 23 | int64 memory_limit = 4; 24 | 25 | // Platform-specific data about device that may be useful 26 | // for supporting efficient data transfers. 27 | DeviceLocality locality = 5; 28 | 29 | // A device is assigned a global unique number each time it is 30 | // initialized. "incarnation" should never be 0. 31 | fixed64 incarnation = 6; 32 | 33 | // String representation of the physical device that this device maps to. 34 | string physical_device_desc = 7; 35 | } 36 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/function.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow/core/framework/function.proto 3 | // DO NOT EDIT! 4 | 5 | package tensorflow 6 | 7 | import proto "github.com/golang/protobuf/proto" 8 | import fmt "fmt" 9 | import math "math" 10 | 11 | // Reference imports to suppress errors if they are not otherwise used. 12 | var _ = proto.Marshal 13 | var _ = fmt.Errorf 14 | var _ = math.Inf 15 | 16 | // A library is a set of named functions. 17 | type FunctionDefLibrary struct { 18 | Function []*FunctionDef `protobuf:"bytes,1,rep,name=function" json:"function,omitempty"` 19 | Gradient []*GradientDef `protobuf:"bytes,2,rep,name=gradient" json:"gradient,omitempty"` 20 | } 21 | 22 | func (m *FunctionDefLibrary) Reset() { *m = FunctionDefLibrary{} } 23 | func (m *FunctionDefLibrary) String() string { return proto.CompactTextString(m) } 24 | func (*FunctionDefLibrary) ProtoMessage() {} 25 | func (*FunctionDefLibrary) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} } 26 | 27 | func (m *FunctionDefLibrary) GetFunction() []*FunctionDef { 28 | if m != nil { 29 | return m.Function 30 | } 31 | return nil 32 | } 33 | 34 | func (m *FunctionDefLibrary) GetGradient() []*GradientDef { 35 | if m != nil { 36 | return m.Gradient 37 | } 38 | return nil 39 | } 40 | 41 | // A function can be instantiated when the runtime can bind every attr 42 | // with a value. When a GraphDef has a call to a function, it must 43 | // have binding for every attr defined in the signature. 44 | // 45 | // TODO(zhifengc): 46 | // * device spec, etc. 47 | type FunctionDef struct { 48 | // The definition of the function's name, arguments, return values, 49 | // attrs etc. 50 | Signature *OpDef `protobuf:"bytes,1,opt,name=signature" json:"signature,omitempty"` 51 | // Attributes specific to this function definition. 52 | Attr map[string]*AttrValue `protobuf:"bytes,5,rep,name=attr" json:"attr,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` 53 | // By convention, "op" in node_def is resolved by consulting with a 54 | // user-defined library first. If not resolved, "func" is assumed to 55 | // be a builtin op. 56 | NodeDef []*NodeDef `protobuf:"bytes,3,rep,name=node_def,json=nodeDef" json:"node_def,omitempty"` 57 | // A mapping from the output arg names from `signature` to the 58 | // outputs from `node_def` that should be returned by the function. 59 | Ret map[string]string `protobuf:"bytes,4,rep,name=ret" json:"ret,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` 60 | } 61 | 62 | func (m *FunctionDef) Reset() { *m = FunctionDef{} } 63 | func (m *FunctionDef) String() string { return proto.CompactTextString(m) } 64 | func (*FunctionDef) ProtoMessage() {} 65 | func (*FunctionDef) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{1} } 66 | 67 | func (m *FunctionDef) GetSignature() *OpDef { 68 | if m != nil { 69 | return m.Signature 70 | } 71 | return nil 72 | } 73 | 74 | func (m *FunctionDef) GetAttr() map[string]*AttrValue { 75 | if m != nil { 76 | return m.Attr 77 | } 78 | return nil 79 | } 80 | 81 | func (m *FunctionDef) GetNodeDef() []*NodeDef { 82 | if m != nil { 83 | return m.NodeDef 84 | } 85 | return nil 86 | } 87 | 88 | func (m *FunctionDef) GetRet() map[string]string { 89 | if m != nil { 90 | return m.Ret 91 | } 92 | return nil 93 | } 94 | 95 | // GradientDef defines the gradient function of a function defined in 96 | // a function library. 97 | // 98 | // A gradient function g (specified by gradient_func) for a function f 99 | // (specified by function_name) must follow the following: 100 | // 101 | // The function 'f' must be a numerical function which takes N inputs 102 | // and produces M outputs. Its gradient function 'g', which is a 103 | // function taking N + M inputs and produces N outputs. 104 | // 105 | // I.e. if we have 106 | // (y1, y2, ..., y_M) = f(x1, x2, ..., x_N), 107 | // then, g is 108 | // (dL/dx1, dL/dx2, ..., dL/dx_N) = g(x1, x2, ..., x_N, 109 | // dL/dy1, dL/dy2, ..., dL/dy_M), 110 | // where L is a scalar-value function of (x1, x2, ..., xN) (e.g., the 111 | // loss function). dL/dx_i is the partial derivative of L with respect 112 | // to x_i. 113 | type GradientDef struct { 114 | FunctionName string `protobuf:"bytes,1,opt,name=function_name,json=functionName" json:"function_name,omitempty"` 115 | GradientFunc string `protobuf:"bytes,2,opt,name=gradient_func,json=gradientFunc" json:"gradient_func,omitempty"` 116 | } 117 | 118 | func (m *GradientDef) Reset() { *m = GradientDef{} } 119 | func (m *GradientDef) String() string { return proto.CompactTextString(m) } 120 | func (*GradientDef) ProtoMessage() {} 121 | func (*GradientDef) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{2} } 122 | 123 | func (m *GradientDef) GetFunctionName() string { 124 | if m != nil { 125 | return m.FunctionName 126 | } 127 | return "" 128 | } 129 | 130 | func (m *GradientDef) GetGradientFunc() string { 131 | if m != nil { 132 | return m.GradientFunc 133 | } 134 | return "" 135 | } 136 | 137 | func init() { 138 | proto.RegisterType((*FunctionDefLibrary)(nil), "tensorflow.FunctionDefLibrary") 139 | proto.RegisterType((*FunctionDef)(nil), "tensorflow.FunctionDef") 140 | proto.RegisterType((*GradientDef)(nil), "tensorflow.GradientDef") 141 | } 142 | 143 | func init() { proto.RegisterFile("tensorflow/core/framework/function.proto", fileDescriptor4) } 144 | 145 | var fileDescriptor4 = []byte{ 146 | // 387 bytes of a gzipped FileDescriptorProto 147 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x7c, 0x92, 0x5f, 0x4f, 0xf2, 0x30, 148 | 0x14, 0xc6, 0x33, 0x06, 0xef, 0xcb, 0x0e, 0x68, 0xb4, 0x6a, 0x5c, 0x76, 0x85, 0x98, 0x18, 0xa2, 149 | 0xc9, 0x96, 0x40, 0x34, 0xc6, 0x3b, 0x89, 0x7f, 0x6e, 0x0c, 0x92, 0x5d, 0xe8, 0xe5, 0x32, 0xa0, 150 | 0x23, 0x0b, 0xd8, 0x92, 0x52, 0x24, 0xdc, 0xf8, 0x5d, 0xfd, 0x16, 0x5e, 0xda, 0x76, 0x2b, 0x6b, 151 | 0xa2, 0xf3, 0xae, 0xe9, 0xf9, 0x3d, 0xcf, 0x73, 0x7a, 0x7a, 0xa0, 0xc3, 0x31, 0x59, 0x52, 0x96, 152 | 0xcc, 0xe9, 0x3a, 0x18, 0x53, 0x86, 0x83, 0x84, 0xc5, 0x6f, 0x78, 0x4d, 0xd9, 0x2c, 0x48, 0x56, 153 | 0x64, 0xcc, 0x53, 0x4a, 0xfc, 0x05, 0xa3, 0x9c, 0x22, 0x28, 0x48, 0xef, 0xbc, 0x5c, 0x15, 0x73, 154 | 0xce, 0xa2, 0xf7, 0x78, 0xbe, 0xc2, 0x99, 0xce, 0xfb, 0x23, 0x81, 0xd0, 0x09, 0x8e, 0x26, 0x38, 155 | 0xc9, 0xc9, 0xb3, 0x72, 0x92, 0x2e, 0x0a, 0xae, 0xfd, 0x01, 0xe8, 0x21, 0xef, 0xed, 0x0e, 0x27, 156 | 0x4f, 0xe9, 0x88, 0xc5, 0x6c, 0x83, 0x7a, 0x50, 0xd7, 0x1d, 0xbb, 0x56, 0xcb, 0xee, 0x34, 0xba, 157 | 0xc7, 0x7e, 0x61, 0xe8, 0x1b, 0x8a, 0x70, 0x0b, 0x4a, 0xd1, 0x94, 0xc5, 0x93, 0x14, 0x13, 0xee, 158 | 0x56, 0x7e, 0x8a, 0x1e, 0xf3, 0x9a, 0x12, 0x69, 0xb0, 0xfd, 0x59, 0x81, 0x86, 0x61, 0x87, 0x02, 159 | 0x70, 0x96, 0xe9, 0x94, 0xc4, 0x7c, 0xc5, 0xb0, 0x88, 0xb6, 0x84, 0xcb, 0xbe, 0xe9, 0xf2, 0xbc, 160 | 0x90, 0xfa, 0x82, 0x41, 0x97, 0x50, 0x95, 0x63, 0x72, 0x6b, 0x2a, 0xf1, 0xa4, 0xa4, 0x4d, 0xff, 161 | 0x56, 0x30, 0xf7, 0x84, 0xb3, 0x4d, 0xa8, 0x70, 0xe4, 0x43, 0x5d, 0x4f, 0xcc, 0xb5, 0x95, 0xf4, 162 | 0xc0, 0x94, 0x0e, 0x44, 0x4d, 0x06, 0xfd, 0x27, 0xd9, 0x01, 0x75, 0xc1, 0x66, 0x98, 0xbb, 0x55, 163 | 0x85, 0xb6, 0xca, 0x52, 0x42, 0xcc, 0xb3, 0x10, 0x09, 0x7b, 0x03, 0x70, 0xb6, 0xb1, 0x68, 0x0f, 164 | 0xec, 0x19, 0xde, 0xa8, 0x27, 0x39, 0xa1, 0x3c, 0xa2, 0x0b, 0xa8, 0xa9, 0xbf, 0x15, 0xc3, 0x92, 165 | 0xcf, 0x3c, 0x32, 0x4d, 0xa5, 0xee, 0x45, 0x16, 0xc3, 0x8c, 0xb9, 0xa9, 0x5c, 0x5b, 0xde, 0x15, 166 | 0xd4, 0x75, 0xc0, 0x2f, 0x76, 0x87, 0xa6, 0x9d, 0x63, 0xe8, 0xda, 0xaf, 0xd0, 0x30, 0x86, 0x8f, 167 | 0x4e, 0x61, 0x47, 0xff, 0x59, 0x44, 0xc4, 0x52, 0xe4, 0x26, 0x4d, 0x7d, 0x39, 0x10, 0x77, 0x12, 168 | 0xd2, 0x7f, 0x14, 0xc9, 0x42, 0xee, 0xda, 0xd4, 0x97, 0xf2, 0xd5, 0xfd, 0x00, 0x5c, 0xca, 0xa6, 169 | 0x66, 0xdf, 0xdb, 0x2d, 0xeb, 0xef, 0xea, 0xb9, 0x0c, 0xe5, 0x9e, 0x2d, 0x87, 0xd6, 0x97, 0x65, 170 | 0x8d, 0xfe, 0xa9, 0xa5, 0xeb, 0x7d, 0x07, 0x00, 0x00, 0xff, 0xff, 0xa1, 0xb1, 0x76, 0x27, 0x2a, 171 | 0x03, 0x00, 0x00, 172 | } 173 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/function.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow; 4 | option cc_enable_arenas = true; 5 | option java_outer_classname = "FunctionProtos"; 6 | option java_multiple_files = true; 7 | option java_package = "org.tensorflow.framework"; 8 | 9 | import "tensorflow/core/framework/attr_value.proto"; 10 | import "tensorflow/core/framework/node_def.proto"; 11 | import "tensorflow/core/framework/op_def.proto"; 12 | 13 | // A library is a set of named functions. 14 | message FunctionDefLibrary { 15 | repeated FunctionDef function = 1; 16 | repeated GradientDef gradient = 2; 17 | } 18 | 19 | // A function can be instantiated when the runtime can bind every attr 20 | // with a value. When a GraphDef has a call to a function, it must 21 | // have binding for every attr defined in the signature. 22 | // 23 | // TODO(zhifengc): 24 | // * device spec, etc. 25 | message FunctionDef { 26 | // The definition of the function's name, arguments, return values, 27 | // attrs etc. 28 | OpDef signature = 1; 29 | 30 | // Attributes specific to this function definition. 31 | map attr = 5; 32 | 33 | // NOTE: field id 2 deleted on Jan 11, 2016, GraphDef version 21. 34 | 35 | // In both of the following fields, there is the need to specify an 36 | // output that is used as either the input to another node (in 37 | // `node_def`) or as a return value of the function (in `ret`). 38 | // Unlike the NodeDefs in GraphDef, we need to be able to specify a 39 | // list in some cases (instead of just single outputs). Also, we 40 | // need to be able to deal with lists of unknown length (so the 41 | // output index may not be known at function definition time). So 42 | // we use the following format instead: 43 | // * "fun_in" where "fun_in" is the name of a function input arg in 44 | // the `signature` field above. This represents that input, whether 45 | // it is a single tensor or a list. 46 | // * "fun_in:0" gives the first element of a function input arg (a 47 | // non-list input is considered a list of length 1 for these 48 | // purposes). 49 | // * "node:out" where "node" is the name of a node in `node_def` and 50 | // "out" is the name one of its op's output arguments (the name 51 | // comes from the OpDef of the node's op). This represents that 52 | // node's output, whether it is a single tensor or a list. 53 | // Note: We enforce that an op's output arguments are never 54 | // renamed in the backwards-compatibility test. 55 | // * "node:out:0" gives the first element of a node output arg (a 56 | // non-list output is considered a list of length 1 for these 57 | // purposes). 58 | // 59 | // NOT CURRENTLY SUPPORTED (but may be in the future): 60 | // * "node:out:-1" gives last element in a node output list 61 | // * "node:out:1:" gives a list with all but the first element in a 62 | // node output list 63 | // * "node:out::-1" gives a list with all but the last element in a 64 | // node output list 65 | 66 | // The body of the function. Unlike the NodeDefs in a GraphDef, attrs 67 | // may have values of type `placeholder` and the `input` field uses 68 | // the "output" format above. 69 | 70 | // By convention, "op" in node_def is resolved by consulting with a 71 | // user-defined library first. If not resolved, "func" is assumed to 72 | // be a builtin op. 73 | repeated NodeDef node_def = 3; 74 | 75 | // A mapping from the output arg names from `signature` to the 76 | // outputs from `node_def` that should be returned by the function. 77 | map ret = 4; 78 | } 79 | 80 | // GradientDef defines the gradient function of a function defined in 81 | // a function library. 82 | // 83 | // A gradient function g (specified by gradient_func) for a function f 84 | // (specified by function_name) must follow the following: 85 | // 86 | // The function 'f' must be a numerical function which takes N inputs 87 | // and produces M outputs. Its gradient function 'g', which is a 88 | // function taking N + M inputs and produces N outputs. 89 | // 90 | // I.e. if we have 91 | // (y1, y2, ..., y_M) = f(x1, x2, ..., x_N), 92 | // then, g is 93 | // (dL/dx1, dL/dx2, ..., dL/dx_N) = g(x1, x2, ..., x_N, 94 | // dL/dy1, dL/dy2, ..., dL/dy_M), 95 | // where L is a scalar-value function of (x1, x2, ..., xN) (e.g., the 96 | // loss function). dL/dx_i is the partial derivative of L with respect 97 | // to x_i. 98 | message GradientDef { 99 | string function_name = 1; // The function name. 100 | string gradient_func = 2; // The gradient function's name. 101 | } 102 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/graph.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow/core/framework/graph.proto 3 | // DO NOT EDIT! 4 | 5 | package tensorflow 6 | 7 | import proto "github.com/golang/protobuf/proto" 8 | import fmt "fmt" 9 | import math "math" 10 | 11 | // Reference imports to suppress errors if they are not otherwise used. 12 | var _ = proto.Marshal 13 | var _ = fmt.Errorf 14 | var _ = math.Inf 15 | 16 | // Represents the graph of operations 17 | type GraphDef struct { 18 | Node []*NodeDef `protobuf:"bytes,1,rep,name=node" json:"node,omitempty"` 19 | // Compatibility versions of the graph. See core/public/version.h for version 20 | // history. The GraphDef version is distinct from the TensorFlow version, and 21 | // each release of TensorFlow will support a range of GraphDef versions. 22 | Versions *VersionDef `protobuf:"bytes,4,opt,name=versions" json:"versions,omitempty"` 23 | // Deprecated single version field; use versions above instead. Since all 24 | // GraphDef changes before "versions" was introduced were forward 25 | // compatible, this field is entirely ignored. 26 | Version int32 `protobuf:"varint,3,opt,name=version" json:"version,omitempty"` 27 | // EXPERIMENTAL. DO NOT USE OR DEPEND ON THIS YET. 28 | // 29 | // "library" provides user-defined functions. 30 | // 31 | // Naming: 32 | // * library.function.name are in a flat namespace. 33 | // NOTE: We may need to change it to be hierarchical to support 34 | // different orgs. E.g., 35 | // { "/google/nn", { ... }}, 36 | // { "/google/vision", { ... }} 37 | // { "/org_foo/module_bar", { ... }} 38 | // map named_lib; 39 | // * If node[i].op is the name of one function in "library", 40 | // node[i] is deemed as a function call. Otherwise, node[i].op 41 | // must be a primitive operation supported by the runtime. 42 | // 43 | // 44 | // Function call semantics: 45 | // 46 | // * The callee may start execution as soon as some of its inputs 47 | // are ready. The caller may want to use Tuple() mechanism to 48 | // ensure all inputs are ready in the same time. 49 | // 50 | // * The consumer of return values may start executing as soon as 51 | // the return values the consumer depends on are ready. The 52 | // consumer may want to use Tuple() mechanism to ensure the 53 | // consumer does not start until all return values of the callee 54 | // function are ready. 55 | Library *FunctionDefLibrary `protobuf:"bytes,2,opt,name=library" json:"library,omitempty"` 56 | } 57 | 58 | func (m *GraphDef) Reset() { *m = GraphDef{} } 59 | func (m *GraphDef) String() string { return proto.CompactTextString(m) } 60 | func (*GraphDef) ProtoMessage() {} 61 | func (*GraphDef) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} } 62 | 63 | func (m *GraphDef) GetNode() []*NodeDef { 64 | if m != nil { 65 | return m.Node 66 | } 67 | return nil 68 | } 69 | 70 | func (m *GraphDef) GetVersions() *VersionDef { 71 | if m != nil { 72 | return m.Versions 73 | } 74 | return nil 75 | } 76 | 77 | func (m *GraphDef) GetVersion() int32 { 78 | if m != nil { 79 | return m.Version 80 | } 81 | return 0 82 | } 83 | 84 | func (m *GraphDef) GetLibrary() *FunctionDefLibrary { 85 | if m != nil { 86 | return m.Library 87 | } 88 | return nil 89 | } 90 | 91 | func init() { 92 | proto.RegisterType((*GraphDef)(nil), "tensorflow.GraphDef") 93 | } 94 | 95 | func init() { proto.RegisterFile("tensorflow/core/framework/graph.proto", fileDescriptor5) } 96 | 97 | var fileDescriptor5 = []byte{ 98 | // 240 bytes of a gzipped FileDescriptorProto 99 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x52, 0x2d, 0x49, 0xcd, 0x2b, 100 | 0xce, 0x2f, 0x4a, 0xcb, 0xc9, 0x2f, 0xd7, 0x4f, 0xce, 0x2f, 0x4a, 0xd5, 0x4f, 0x2b, 0x4a, 0xcc, 101 | 0x4d, 0x2d, 0xcf, 0x2f, 0xca, 0xd6, 0x4f, 0x2f, 0x4a, 0x2c, 0xc8, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 102 | 0xc9, 0x17, 0xe2, 0x42, 0x28, 0x93, 0xd2, 0xc0, 0xad, 0x25, 0x2f, 0x3f, 0x25, 0x35, 0x3e, 0x25, 103 | 0x35, 0x0d, 0xa2, 0x0b, 0x9f, 0xca, 0xb4, 0xd2, 0xbc, 0xe4, 0x92, 0xcc, 0xfc, 0x3c, 0xc2, 0x2a, 104 | 0xcb, 0x52, 0x8b, 0x8a, 0x81, 0x0a, 0x8b, 0x21, 0x2a, 0x95, 0xf6, 0x33, 0x72, 0x71, 0xb8, 0x83, 105 | 0x5c, 0xe6, 0x92, 0x9a, 0x26, 0xa4, 0xce, 0xc5, 0x02, 0xb2, 0x52, 0x82, 0x51, 0x81, 0x59, 0x83, 106 | 0xdb, 0x48, 0x58, 0x0f, 0x61, 0x8a, 0x9e, 0x1f, 0x50, 0x1c, 0xa8, 0x24, 0x08, 0xac, 0x40, 0xc8, 107 | 0x88, 0x8b, 0x03, 0x66, 0x8e, 0x04, 0x8b, 0x02, 0x23, 0x50, 0xb1, 0x18, 0xb2, 0xe2, 0x30, 0x88, 108 | 0x1c, 0x48, 0x3d, 0x5c, 0x9d, 0x90, 0x0c, 0x17, 0x3b, 0x94, 0x2d, 0xc1, 0x0c, 0xd4, 0xc2, 0xea, 109 | 0xc4, 0x24, 0xc1, 0x18, 0x04, 0x13, 0x12, 0xb2, 0xe0, 0x62, 0xcf, 0xc9, 0x4c, 0x2a, 0x4a, 0x2c, 110 | 0xaa, 0x94, 0x60, 0x02, 0x1b, 0x28, 0x87, 0x6c, 0xa0, 0x1b, 0xd4, 0x7b, 0x40, 0x13, 0x7d, 0x20, 111 | 0xaa, 0x82, 0x60, 0xca, 0x9d, 0x74, 0xb8, 0x24, 0xf2, 0x8b, 0xd2, 0x91, 0x55, 0xc3, 0x3d, 0xeb, 112 | 0xc4, 0x0d, 0xf6, 0x5a, 0x00, 0xc8, 0xa7, 0xc5, 0x01, 0x8c, 0x3f, 0x18, 0x19, 0x93, 0xd8, 0xc0, 113 | 0xde, 0x36, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x84, 0xf3, 0xe9, 0xda, 0xa9, 0x01, 0x00, 0x00, 114 | } 115 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/graph.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow; 4 | option cc_enable_arenas = true; 5 | option java_outer_classname = "GraphProtos"; 6 | option java_multiple_files = true; 7 | option java_package = "org.tensorflow.framework"; 8 | 9 | import "tensorflow/core/framework/node_def.proto"; 10 | import "tensorflow/core/framework/function.proto"; 11 | import "tensorflow/core/framework/versions.proto"; 12 | 13 | // Represents the graph of operations 14 | message GraphDef { 15 | repeated NodeDef node = 1; 16 | 17 | // Compatibility versions of the graph. See core/public/version.h for version 18 | // history. The GraphDef version is distinct from the TensorFlow version, and 19 | // each release of TensorFlow will support a range of GraphDef versions. 20 | VersionDef versions = 4; 21 | 22 | // Deprecated single version field; use versions above instead. Since all 23 | // GraphDef changes before "versions" was introduced were forward 24 | // compatible, this field is entirely ignored. 25 | int32 version = 3 [deprecated = true]; 26 | 27 | // EXPERIMENTAL. DO NOT USE OR DEPEND ON THIS YET. 28 | // 29 | // "library" provides user-defined functions. 30 | // 31 | // Naming: 32 | // * library.function.name are in a flat namespace. 33 | // NOTE: We may need to change it to be hierarchical to support 34 | // different orgs. E.g., 35 | // { "/google/nn", { ... }}, 36 | // { "/google/vision", { ... }} 37 | // { "/org_foo/module_bar", { ... }} 38 | // map named_lib; 39 | // * If node[i].op is the name of one function in "library", 40 | // node[i] is deemed as a function call. Otherwise, node[i].op 41 | // must be a primitive operation supported by the runtime. 42 | // 43 | // 44 | // Function call semantics: 45 | // 46 | // * The callee may start execution as soon as some of its inputs 47 | // are ready. The caller may want to use Tuple() mechanism to 48 | // ensure all inputs are ready in the same time. 49 | // 50 | // * The consumer of return values may start executing as soon as 51 | // the return values the consumer depends on are ready. The 52 | // consumer may want to use Tuple() mechanism to ensure the 53 | // consumer does not start until all return values of the callee 54 | // function are ready. 55 | FunctionDefLibrary library = 2; 56 | }; 57 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/kernel_def.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow/core/framework/kernel_def.proto 3 | // DO NOT EDIT! 4 | 5 | package tensorflow 6 | 7 | import proto "github.com/golang/protobuf/proto" 8 | import fmt "fmt" 9 | import math "math" 10 | 11 | // Reference imports to suppress errors if they are not otherwise used. 12 | var _ = proto.Marshal 13 | var _ = fmt.Errorf 14 | var _ = math.Inf 15 | 16 | type KernelDef struct { 17 | // Must match the name of an Op. 18 | Op string `protobuf:"bytes,1,opt,name=op" json:"op,omitempty"` 19 | // Type of device this kernel runs on. 20 | DeviceType string `protobuf:"bytes,2,opt,name=device_type,json=deviceType" json:"device_type,omitempty"` 21 | Constraint []*KernelDef_AttrConstraint `protobuf:"bytes,3,rep,name=constraint" json:"constraint,omitempty"` 22 | // Names of the Op's input_/output_args that reside in host memory 23 | // instead of device memory. 24 | HostMemoryArg []string `protobuf:"bytes,4,rep,name=host_memory_arg,json=hostMemoryArg" json:"host_memory_arg,omitempty"` 25 | // This allows experimental kernels to be registered for an op that 26 | // won't be used unless the user specifies a "_kernel" attr with 27 | // value matching this. 28 | Label string `protobuf:"bytes,5,opt,name=label" json:"label,omitempty"` 29 | } 30 | 31 | func (m *KernelDef) Reset() { *m = KernelDef{} } 32 | func (m *KernelDef) String() string { return proto.CompactTextString(m) } 33 | func (*KernelDef) ProtoMessage() {} 34 | func (*KernelDef) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0} } 35 | 36 | func (m *KernelDef) GetOp() string { 37 | if m != nil { 38 | return m.Op 39 | } 40 | return "" 41 | } 42 | 43 | func (m *KernelDef) GetDeviceType() string { 44 | if m != nil { 45 | return m.DeviceType 46 | } 47 | return "" 48 | } 49 | 50 | func (m *KernelDef) GetConstraint() []*KernelDef_AttrConstraint { 51 | if m != nil { 52 | return m.Constraint 53 | } 54 | return nil 55 | } 56 | 57 | func (m *KernelDef) GetHostMemoryArg() []string { 58 | if m != nil { 59 | return m.HostMemoryArg 60 | } 61 | return nil 62 | } 63 | 64 | func (m *KernelDef) GetLabel() string { 65 | if m != nil { 66 | return m.Label 67 | } 68 | return "" 69 | } 70 | 71 | type KernelDef_AttrConstraint struct { 72 | // Name of an attr from the Op. 73 | Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` 74 | // A list of values that this kernel supports for this attr. 75 | // Like OpDef.AttrDef.allowed_values, except for kernels instead of Ops. 76 | AllowedValues *AttrValue `protobuf:"bytes,2,opt,name=allowed_values,json=allowedValues" json:"allowed_values,omitempty"` 77 | } 78 | 79 | func (m *KernelDef_AttrConstraint) Reset() { *m = KernelDef_AttrConstraint{} } 80 | func (m *KernelDef_AttrConstraint) String() string { return proto.CompactTextString(m) } 81 | func (*KernelDef_AttrConstraint) ProtoMessage() {} 82 | func (*KernelDef_AttrConstraint) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0, 0} } 83 | 84 | func (m *KernelDef_AttrConstraint) GetName() string { 85 | if m != nil { 86 | return m.Name 87 | } 88 | return "" 89 | } 90 | 91 | func (m *KernelDef_AttrConstraint) GetAllowedValues() *AttrValue { 92 | if m != nil { 93 | return m.AllowedValues 94 | } 95 | return nil 96 | } 97 | 98 | func init() { 99 | proto.RegisterType((*KernelDef)(nil), "tensorflow.KernelDef") 100 | proto.RegisterType((*KernelDef_AttrConstraint)(nil), "tensorflow.KernelDef.AttrConstraint") 101 | } 102 | 103 | func init() { proto.RegisterFile("tensorflow/core/framework/kernel_def.proto", fileDescriptor6) } 104 | 105 | var fileDescriptor6 = []byte{ 106 | // 296 bytes of a gzipped FileDescriptorProto 107 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x7c, 0x50, 0x4f, 0x6b, 0xfa, 0x40, 108 | 0x10, 0x25, 0xfe, 0xf9, 0x81, 0x23, 0x2a, 0x2c, 0xbf, 0xc2, 0xe2, 0xa5, 0x52, 0x4a, 0x91, 0x1e, 109 | 0x62, 0xb1, 0xd7, 0x5e, 0xb4, 0xde, 0x4a, 0x41, 0x42, 0xe9, 0x35, 0x6c, 0x92, 0x49, 0x2a, 0x6e, 110 | 0xb2, 0x61, 0x76, 0xab, 0xf8, 0x7d, 0xfa, 0x21, 0x7b, 0xec, 0x66, 0x23, 0x31, 0xbd, 0xf4, 0x36, 111 | 0xf3, 0xe6, 0xcd, 0x9b, 0x79, 0x0f, 0xee, 0x0d, 0x16, 0x5a, 0x51, 0x2a, 0xd5, 0x71, 0x11, 0x2b, 112 | 0xc2, 0x45, 0x4a, 0x22, 0xc7, 0xa3, 0xa2, 0xfd, 0x62, 0x8f, 0x54, 0xa0, 0x0c, 0x13, 0x4c, 0xfd, 113 | 0x92, 0x94, 0x51, 0x0c, 0x2e, 0xdc, 0xe9, 0x1f, 0x7b, 0xc2, 0x18, 0x0a, 0x0f, 0x42, 0x7e, 0x62, 114 | 0xbd, 0x77, 0xf3, 0xd5, 0x81, 0xc1, 0x8b, 0x13, 0xdb, 0x60, 0xca, 0xc6, 0xd0, 0x51, 0x25, 0xf7, 115 | 0x66, 0xde, 0x7c, 0x10, 0xd8, 0x8a, 0x5d, 0xc3, 0x30, 0xc1, 0xc3, 0x2e, 0xc6, 0xd0, 0x9c, 0x4a, 116 | 0xe4, 0x1d, 0x37, 0x80, 0x1a, 0x7a, 0xb3, 0x08, 0xdb, 0x00, 0xc4, 0xaa, 0xd0, 0x86, 0xc4, 0xae, 117 | 0x30, 0xbc, 0x3b, 0xeb, 0xce, 0x87, 0xcb, 0x5b, 0xff, 0x72, 0xdf, 0x6f, 0xb4, 0xfd, 0x95, 0x3d, 118 | 0xfd, 0xdc, 0x70, 0x83, 0xd6, 0x1e, 0xbb, 0x83, 0xc9, 0x87, 0xd2, 0x26, 0xcc, 0x31, 0x57, 0x74, 119 | 0x0a, 0x05, 0x65, 0xbc, 0x67, 0xa5, 0x06, 0xc1, 0xa8, 0x82, 0x5f, 0x1d, 0xba, 0xa2, 0x8c, 0xfd, 120 | 0x87, 0xbe, 0x14, 0x11, 0x4a, 0xde, 0x77, 0x8f, 0xd4, 0xcd, 0x34, 0x82, 0xf1, 0x6f, 0x6d, 0xc6, 121 | 0xa0, 0x57, 0x58, 0xc7, 0x67, 0x23, 0xae, 0x66, 0x4f, 0x30, 0x16, 0xd2, 0x7e, 0x84, 0x49, 0xed, 122 | 0x5f, 0x3b, 0x37, 0xc3, 0xe5, 0x55, 0xfb, 0xdb, 0x4a, 0xe7, 0xbd, 0x9a, 0x06, 0xa3, 0x33, 0xd9, 123 | 0x75, 0x7a, 0xfd, 0x00, 0x5c, 0x51, 0xd6, 0xa6, 0x36, 0x99, 0xae, 0x27, 0x8d, 0xc7, 0x6d, 0x15, 124 | 0xa9, 0xde, 0x7a, 0xdf, 0x9e, 0x17, 0xfd, 0x73, 0xf9, 0x3e, 0xfe, 0x04, 0x00, 0x00, 0xff, 0xff, 125 | 0x4a, 0x74, 0xc9, 0xbe, 0xc5, 0x01, 0x00, 0x00, 126 | } 127 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/kernel_def.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow; 4 | option cc_enable_arenas = true; 5 | option java_outer_classname = "KernelDefProtos"; 6 | option java_multiple_files = true; 7 | option java_package = "org.tensorflow.framework"; 8 | 9 | import "tensorflow/core/framework/attr_value.proto"; 10 | 11 | message KernelDef { 12 | // Must match the name of an Op. 13 | string op = 1; 14 | 15 | // Type of device this kernel runs on. 16 | string device_type = 2; 17 | 18 | message AttrConstraint { 19 | // Name of an attr from the Op. 20 | string name = 1; 21 | 22 | // A list of values that this kernel supports for this attr. 23 | // Like OpDef.AttrDef.allowed_values, except for kernels instead of Ops. 24 | AttrValue allowed_values = 2; 25 | } 26 | repeated AttrConstraint constraint = 3; 27 | 28 | // Names of the Op's input_/output_args that reside in host memory 29 | // instead of device memory. 30 | repeated string host_memory_arg = 4; 31 | 32 | // This allows experimental kernels to be registered for an op that 33 | // won't be used unless the user specifies a "_kernel" attr with 34 | // value matching this. 35 | string label = 5; 36 | } 37 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/log_memory.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow; 4 | option cc_enable_arenas = true; 5 | option java_outer_classname = "LogMemoryProtos"; 6 | option java_multiple_files = true; 7 | option java_package = "org.tensorflow.framework"; 8 | 9 | import "tensorflow/core/framework/tensor_description.proto"; 10 | 11 | message MemoryLogStep { 12 | // Process-unique step id. 13 | int64 step_id = 1; 14 | 15 | // Handle describing the feeds and fetches of the step. 16 | string handle = 2; 17 | }; 18 | 19 | message MemoryLogTensorAllocation { 20 | // Process-unique step id. 21 | int64 step_id = 1; 22 | 23 | // Name of the kernel making the allocation as set in GraphDef, 24 | // e.g., "affine2/weights/Assign". 25 | string kernel_name = 2; 26 | 27 | // Allocated tensor details. 28 | TensorDescription tensor = 3; 29 | }; 30 | 31 | message MemoryLogTensorDeallocation { 32 | // Id of the tensor buffer being deallocated, used to match to a 33 | // corresponding allocation. 34 | int64 allocation_id = 1; 35 | 36 | // Name of the allocator used. 37 | string allocator_name = 2; 38 | }; 39 | 40 | message MemoryLogTensorOutput { 41 | // Process-unique step id. 42 | int64 step_id = 1; 43 | 44 | // Name of the kernel producing an output as set in GraphDef, e.g., 45 | // "affine2/weights/Assign". 46 | string kernel_name = 2; 47 | 48 | // Index of the output being set. 49 | int32 index = 3; 50 | 51 | // Output tensor details. 52 | TensorDescription tensor = 4; 53 | } 54 | 55 | message MemoryLogRawAllocation { 56 | // Process-unique step id. 57 | int64 step_id = 1; 58 | 59 | // Name of the operation making the allocation. 60 | string operation = 2; 61 | 62 | // Number of bytes in the allocation. 63 | int64 num_bytes = 3; 64 | 65 | // Address of the allocation. 66 | uint64 ptr = 4; 67 | 68 | // Id of the tensor buffer being allocated, used to match to a 69 | // corresponding deallocation. 70 | int64 allocation_id = 5; 71 | 72 | // Name of the allocator used. 73 | string allocator_name = 6; 74 | }; 75 | 76 | message MemoryLogRawDeallocation { 77 | // Process-unique step id. 78 | int64 step_id = 1; 79 | 80 | // Name of the operation making the deallocation. 81 | string operation = 2; 82 | 83 | // Id of the tensor buffer being deallocated, used to match to a 84 | // corresponding allocation. 85 | int64 allocation_id = 3; 86 | 87 | // Name of the allocator used. 88 | string allocator_name = 4; 89 | 90 | // True if the deallocation is queued and will be performed later, 91 | // e.g. for GPU lazy freeing of buffers. 92 | bool deferred = 5; 93 | }; 94 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/node_def.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow/core/framework/node_def.proto 3 | // DO NOT EDIT! 4 | 5 | package tensorflow 6 | 7 | import proto "github.com/golang/protobuf/proto" 8 | import fmt "fmt" 9 | import math "math" 10 | 11 | // Reference imports to suppress errors if they are not otherwise used. 12 | var _ = proto.Marshal 13 | var _ = fmt.Errorf 14 | var _ = math.Inf 15 | 16 | type NodeDef struct { 17 | // The name given to this operator. Used for naming inputs, 18 | // logging, visualization, etc. Unique within a single GraphDef. 19 | // Must match the regexp "[A-Za-z0-9.][A-Za-z0-9_./]*". 20 | Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` 21 | // The operation name. There may be custom parameters in attrs. 22 | // Op names starting with an underscore are reserved for internal use. 23 | Op string `protobuf:"bytes,2,opt,name=op" json:"op,omitempty"` 24 | // Each input is "node:src_output" with "node" being a string name and 25 | // "src_output" indicating which output tensor to use from "node". If 26 | // "src_output" is 0 the ":0" suffix can be omitted. Regular inputs 27 | // may optionally be followed by control inputs that have the format 28 | // "^node". 29 | Input []string `protobuf:"bytes,3,rep,name=input" json:"input,omitempty"` 30 | // A (possibly partial) specification for the device on which this 31 | // node should be placed. 32 | // The expected syntax for this string is as follows: 33 | // 34 | // DEVICE_SPEC ::= COLOCATED_NODE | PARTIAL_SPEC 35 | // 36 | // COLOCATED_NODE ::= "@" NODE_NAME // See NodeDef.name above. 37 | // PARTIAL_SPEC ::= ("/" CONSTRAINT) * 38 | // CONSTRAINT ::= ("job:" JOB_NAME) 39 | // | ("replica:" [1-9][0-9]*) 40 | // | ("task:" [1-9][0-9]*) 41 | // | ( ("gpu" | "cpu") ":" ([1-9][0-9]* | "*") ) 42 | // 43 | // Valid values for this string include: 44 | // * "@other/node" (colocate with "other/node") 45 | // * "/job:worker/replica:0/task:1/gpu:3" (full specification) 46 | // * "/job:worker/gpu:3" (partial specification) 47 | // * "" (no specification) 48 | // 49 | // If the constraints do not resolve to a single device (or if this 50 | // field is empty or not present), the runtime will attempt to 51 | // choose a device automatically. 52 | Device string `protobuf:"bytes,4,opt,name=device" json:"device,omitempty"` 53 | // Operation-specific graph-construction-time configuration. 54 | // Note that this should include all attrs defined in the 55 | // corresponding OpDef, including those with a value matching 56 | // the default -- this allows the default to change and makes 57 | // NodeDefs easier to interpret on their own. However, if 58 | // an attr with a default is not specified in this list, the 59 | // default will be used. 60 | // The "names" (keys) must match the regexp "[a-z][a-z0-9_]+" (and 61 | // one of the names from the corresponding OpDef's attr field). 62 | // The values must have a type matching the corresponding OpDef 63 | // attr's type field. 64 | // TODO(josh11b): Add some examples here showing best practices. 65 | Attr map[string]*AttrValue `protobuf:"bytes,5,rep,name=attr" json:"attr,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` 66 | } 67 | 68 | func (m *NodeDef) Reset() { *m = NodeDef{} } 69 | func (m *NodeDef) String() string { return proto.CompactTextString(m) } 70 | func (*NodeDef) ProtoMessage() {} 71 | func (*NodeDef) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{0} } 72 | 73 | func (m *NodeDef) GetName() string { 74 | if m != nil { 75 | return m.Name 76 | } 77 | return "" 78 | } 79 | 80 | func (m *NodeDef) GetOp() string { 81 | if m != nil { 82 | return m.Op 83 | } 84 | return "" 85 | } 86 | 87 | func (m *NodeDef) GetInput() []string { 88 | if m != nil { 89 | return m.Input 90 | } 91 | return nil 92 | } 93 | 94 | func (m *NodeDef) GetDevice() string { 95 | if m != nil { 96 | return m.Device 97 | } 98 | return "" 99 | } 100 | 101 | func (m *NodeDef) GetAttr() map[string]*AttrValue { 102 | if m != nil { 103 | return m.Attr 104 | } 105 | return nil 106 | } 107 | 108 | func init() { 109 | proto.RegisterType((*NodeDef)(nil), "tensorflow.NodeDef") 110 | } 111 | 112 | func init() { proto.RegisterFile("tensorflow/core/framework/node_def.proto", fileDescriptor8) } 113 | 114 | var fileDescriptor8 = []byte{ 115 | // 259 bytes of a gzipped FileDescriptorProto 116 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x74, 0x90, 0x4f, 0x4b, 0xc3, 0x40, 117 | 0x10, 0xc5, 0xd9, 0xfc, 0xa9, 0x64, 0x0a, 0x22, 0x83, 0xca, 0x52, 0x10, 0x8a, 0xa7, 0x52, 0x21, 118 | 0xc1, 0x7a, 0x11, 0x6f, 0x16, 0xbd, 0x96, 0x92, 0x83, 0xd7, 0x12, 0x9b, 0x89, 0x94, 0xd6, 0x9d, 119 | 0xb0, 0x6e, 0x5b, 0xfa, 0x65, 0xfd, 0x1c, 0x1e, 0xdd, 0xdd, 0x84, 0x36, 0x97, 0xde, 0xe6, 0xcf, 120 | 0xef, 0xcd, 0x3c, 0x1e, 0x8c, 0x0c, 0xa9, 0x1f, 0xd6, 0xd5, 0x86, 0xf7, 0xd9, 0x92, 0x35, 0x65, 121 | 0x95, 0x2e, 0xbe, 0x69, 0xcf, 0x7a, 0x9d, 0x29, 0x2e, 0x69, 0x51, 0x52, 0x95, 0xd6, 0x9a, 0x0d, 122 | 0x23, 0x9c, 0xc8, 0xc1, 0xf8, 0xbc, 0xaa, 0x30, 0x46, 0x2f, 0x76, 0xc5, 0x66, 0x4b, 0x8d, 0xee, 123 | 0xfe, 0x57, 0xc0, 0xc5, 0xcc, 0x9e, 0x7a, 0xa3, 0x0a, 0x11, 0x22, 0x65, 0x41, 0x29, 0x86, 0x62, 124 | 0x94, 0xe4, 0xbe, 0xc6, 0x4b, 0x08, 0xb8, 0x96, 0x81, 0x9f, 0xd8, 0x0a, 0xaf, 0x21, 0x5e, 0xa9, 125 | 0x7a, 0x6b, 0x64, 0x38, 0x0c, 0xed, 0xa8, 0x69, 0xf0, 0x16, 0x7a, 0x25, 0xed, 0x56, 0x4b, 0x92, 126 | 0x91, 0x27, 0xdb, 0x0e, 0x1f, 0x21, 0x72, 0x1f, 0x65, 0x6c, 0xe1, 0xfe, 0xe4, 0x2e, 0x3d, 0x19, 127 | 0x4b, 0xdb, 0xa7, 0xe9, 0xab, 0xdd, 0xbf, 0x2b, 0xa3, 0x0f, 0xb9, 0x47, 0x07, 0x33, 0x48, 0x8e, 128 | 0x23, 0xbc, 0x82, 0x70, 0x4d, 0x87, 0xd6, 0x90, 0x2b, 0xf1, 0x01, 0x62, 0x6f, 0xdf, 0x5b, 0xea, 129 | 0x4f, 0x6e, 0xba, 0x27, 0x9d, 0xee, 0xc3, 0x2d, 0xf3, 0x86, 0x79, 0x09, 0x9e, 0xc5, 0x74, 0x0c, 130 | 0x92, 0xf5, 0x57, 0x17, 0x3b, 0xa6, 0x31, 0x4d, 0x9c, 0x89, 0xb9, 0xcb, 0x61, 0x2e, 0xfe, 0x84, 131 | 0xf8, 0xec, 0xf9, 0x4c, 0x9e, 0xfe, 0x03, 0x00, 0x00, 0xff, 0xff, 0x56, 0x19, 0xbb, 0x7c, 0x77, 132 | 0x01, 0x00, 0x00, 133 | } 134 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/node_def.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow; 4 | option cc_enable_arenas = true; 5 | option java_outer_classname = "NodeProto"; 6 | option java_multiple_files = true; 7 | option java_package = "org.tensorflow.framework"; 8 | 9 | import "tensorflow/core/framework/attr_value.proto"; 10 | 11 | message NodeDef { 12 | // The name given to this operator. Used for naming inputs, 13 | // logging, visualization, etc. Unique within a single GraphDef. 14 | // Must match the regexp "[A-Za-z0-9.][A-Za-z0-9_./]*". 15 | string name = 1; 16 | 17 | // The operation name. There may be custom parameters in attrs. 18 | // Op names starting with an underscore are reserved for internal use. 19 | string op = 2; 20 | 21 | // Each input is "node:src_output" with "node" being a string name and 22 | // "src_output" indicating which output tensor to use from "node". If 23 | // "src_output" is 0 the ":0" suffix can be omitted. Regular inputs 24 | // may optionally be followed by control inputs that have the format 25 | // "^node". 26 | repeated string input = 3; 27 | 28 | // A (possibly partial) specification for the device on which this 29 | // node should be placed. 30 | // The expected syntax for this string is as follows: 31 | // 32 | // DEVICE_SPEC ::= COLOCATED_NODE | PARTIAL_SPEC 33 | // 34 | // COLOCATED_NODE ::= "@" NODE_NAME // See NodeDef.name above. 35 | // PARTIAL_SPEC ::= ("/" CONSTRAINT) * 36 | // CONSTRAINT ::= ("job:" JOB_NAME) 37 | // | ("replica:" [1-9][0-9]*) 38 | // | ("task:" [1-9][0-9]*) 39 | // | ( ("gpu" | "cpu") ":" ([1-9][0-9]* | "*") ) 40 | // 41 | // Valid values for this string include: 42 | // * "@other/node" (colocate with "other/node") 43 | // * "/job:worker/replica:0/task:1/gpu:3" (full specification) 44 | // * "/job:worker/gpu:3" (partial specification) 45 | // * "" (no specification) 46 | // 47 | // If the constraints do not resolve to a single device (or if this 48 | // field is empty or not present), the runtime will attempt to 49 | // choose a device automatically. 50 | string device = 4; 51 | 52 | // Operation-specific graph-construction-time configuration. 53 | // Note that this should include all attrs defined in the 54 | // corresponding OpDef, including those with a value matching 55 | // the default -- this allows the default to change and makes 56 | // NodeDefs easier to interpret on their own. However, if 57 | // an attr with a default is not specified in this list, the 58 | // default will be used. 59 | // The "names" (keys) must match the regexp "[a-z][a-z0-9_]+" (and 60 | // one of the names from the corresponding OpDef's attr field). 61 | // The values must have a type matching the corresponding OpDef 62 | // attr's type field. 63 | // TODO(josh11b): Add some examples here showing best practices. 64 | map attr = 5; 65 | }; 66 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/op_def.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow; 4 | option cc_enable_arenas = true; 5 | option java_outer_classname = "OpDefProtos"; 6 | option java_multiple_files = true; 7 | option java_package = "org.tensorflow.framework"; 8 | 9 | import "tensorflow/core/framework/attr_value.proto"; 10 | import "tensorflow/core/framework/types.proto"; 11 | 12 | // Defines an operation. A NodeDef in a GraphDef specifies an Op by 13 | // using the "op" field which should match the name of a OpDef. 14 | message OpDef { 15 | // Op names starting with an underscore are reserved for internal use. 16 | // Names should be CamelCase and match the regexp "[A-Z][a-zA-Z0-9_]*". 17 | string name = 1; 18 | 19 | // For describing inputs and outputs. 20 | message ArgDef { 21 | // Name for the input/output. Should match the regexp "[a-z][a-z0-9_]*". 22 | string name = 1; 23 | 24 | // Human readable description. 25 | string description = 2; 26 | 27 | // Describes the type of one or more tensors that are accepted/produced 28 | // by this input/output arg. The only legal combinations are: 29 | // * For a single tensor: either the "type" field is set or the 30 | // "type_attr" field is set to the name of an attr with type "type". 31 | // * For a sequence of tensors with the same type: the "number_attr" 32 | // field will be set to the name of an attr with type "int", and 33 | // either the "type" or "type_attr" field will be set as for 34 | // single tensors. 35 | // * For a sequence of tensors, the "type_list_attr" field will be set 36 | // to the name of an attr with type "list(type)". 37 | DataType type = 3; 38 | string type_attr = 4; // if specified, attr must have type "type" 39 | string number_attr = 5; // if specified, attr must have type "int" 40 | // If specified, attr must have type "list(type)", and none of 41 | // type, type_attr, and number_attr may be specified. 42 | string type_list_attr = 6; 43 | 44 | // For inputs: if true, the inputs are required to be refs. 45 | // By default, inputs can be either refs or non-refs. 46 | // For outputs: if true, outputs are refs, otherwise they are not. 47 | bool is_ref = 16; 48 | }; 49 | 50 | // Description of the input(s). 51 | repeated ArgDef input_arg = 2; 52 | 53 | // Description of the output(s). 54 | repeated ArgDef output_arg = 3; 55 | 56 | // Description of the graph-construction-time configuration of this 57 | // Op. That is to say, this describes the attr fields that will 58 | // be specified in the NodeDef. 59 | message AttrDef { 60 | // A descriptive name for the argument. May be used, e.g. by the 61 | // Python client, as a keyword argument name, and so should match 62 | // the regexp "[a-z][a-z0-9_]+". 63 | string name = 1; 64 | 65 | // One of the type names from attr_value.proto ("string", "list(string)", 66 | // "int", etc.). 67 | string type = 2; 68 | 69 | // A reasonable default for this attribute if the user does not supply 70 | // a value. If not specified, the user must supply a value. 71 | AttrValue default_value = 3; 72 | 73 | // Human-readable description. 74 | string description = 4; 75 | 76 | // TODO(josh11b): bool is_optional? 77 | 78 | // --- Constraints --- 79 | // These constraints are only in effect if specified. Default is no 80 | // constraints. 81 | 82 | // For type == "int", this is a minimum value. For "list(___)" 83 | // types, this is the minimum length. 84 | bool has_minimum = 5; 85 | int64 minimum = 6; 86 | 87 | // The set of allowed values. Has type that is the "list" version 88 | // of the "type" field above (uses the "list" field of AttrValue). 89 | // If type == "type" or "list(type)" above, then the "type" field 90 | // of "allowed_values.list" has the set of allowed DataTypes. 91 | // If type == "string" or "list(string)", then the "s" field of 92 | // "allowed_values.list" has the set of allowed strings. 93 | AttrValue allowed_values = 7; 94 | } 95 | repeated AttrDef attr = 4; 96 | 97 | // Optional deprecation based on GraphDef versions. 98 | OpDeprecation deprecation = 8; 99 | 100 | // One-line human-readable description of what the Op does. 101 | string summary = 5; 102 | 103 | // Additional, longer human-readable description of what the Op does. 104 | string description = 6; 105 | 106 | // ------------------------------------------------------------------------- 107 | // Which optimizations this operation can participate in. 108 | 109 | // True if the operation is commutative ("op(a,b) == op(b,a)" for all inputs) 110 | bool is_commutative = 18; 111 | 112 | // If is_aggregate is true, then this operation accepts N >= 2 113 | // inputs and produces 1 output all of the same type. Should be 114 | // associative and commutative, and produce output with the same 115 | // shape as the input. The optimizer may replace an aggregate op 116 | // taking input from multiple devices with a tree of aggregate ops 117 | // that aggregate locally within each device (and possibly within 118 | // groups of nearby devices) before communicating. 119 | // TODO(josh11b): Implement that optimization. 120 | bool is_aggregate = 16; // for things like add 121 | 122 | // Other optimizations go here, like 123 | // can_alias_input, rewrite_when_output_unused, partitioning_strategy, etc. 124 | 125 | // ------------------------------------------------------------------------- 126 | // Optimization constraints. 127 | 128 | // By default Ops may be moved between devices. Stateful ops should 129 | // either not be moved, or should only be moved if that state can also 130 | // be moved (e.g. via some sort of save / restore). 131 | // Stateful ops are guaranteed to never be optimized away by Common 132 | // Subexpression Elimination (CSE). 133 | bool is_stateful = 17; // for things like variables, queue 134 | 135 | // ------------------------------------------------------------------------- 136 | // Non-standard options. 137 | 138 | // By default, all inputs to an Op must be initialized Tensors. Ops 139 | // that may initialize tensors for the first time should set this 140 | // field to true, to allow the Op to take an uninitialized Tensor as 141 | // input. 142 | bool allows_uninitialized_input = 19; // for Assign, etc. 143 | }; 144 | 145 | // Information about version-dependent deprecation of an op 146 | message OpDeprecation { 147 | // First GraphDef version at which the op is disallowed. 148 | int32 version = 1; 149 | 150 | // Explanation of why it was deprecated and what to use instead. 151 | string explanation = 2; 152 | }; 153 | 154 | // A collection of OpDefs 155 | message OpList { 156 | repeated OpDef op = 1; 157 | }; 158 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/resource_handle.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow/core/framework/resource_handle.proto 3 | // DO NOT EDIT! 4 | 5 | package tensorflow 6 | 7 | import proto "github.com/golang/protobuf/proto" 8 | import fmt "fmt" 9 | import math "math" 10 | 11 | // Reference imports to suppress errors if they are not otherwise used. 12 | var _ = proto.Marshal 13 | var _ = fmt.Errorf 14 | var _ = math.Inf 15 | 16 | // Protocol buffer representing a handle to a tensorflow resource. Handles are 17 | // not valid across executions, but can be serialized back and forth from within 18 | // a single run. 19 | type ResourceHandle struct { 20 | // Unique name for the device containing the resource. 21 | Device string `protobuf:"bytes,1,opt,name=device" json:"device,omitempty"` 22 | // Container in which this resource is placed. 23 | Container string `protobuf:"bytes,2,opt,name=container" json:"container,omitempty"` 24 | // Unique name of this resource. 25 | Name string `protobuf:"bytes,3,opt,name=name" json:"name,omitempty"` 26 | // Hash code for the type of the resource. Is only valid in the same device 27 | // and in the same execution. 28 | HashCode uint64 `protobuf:"varint,4,opt,name=hash_code,json=hashCode" json:"hash_code,omitempty"` 29 | // For debug-only, the name of the type pointed to by this handle, if 30 | // available. 31 | MaybeTypeName string `protobuf:"bytes,5,opt,name=maybe_type_name,json=maybeTypeName" json:"maybe_type_name,omitempty"` 32 | } 33 | 34 | func (m *ResourceHandle) Reset() { *m = ResourceHandle{} } 35 | func (m *ResourceHandle) String() string { return proto.CompactTextString(m) } 36 | func (*ResourceHandle) ProtoMessage() {} 37 | func (*ResourceHandle) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{0} } 38 | 39 | func (m *ResourceHandle) GetDevice() string { 40 | if m != nil { 41 | return m.Device 42 | } 43 | return "" 44 | } 45 | 46 | func (m *ResourceHandle) GetContainer() string { 47 | if m != nil { 48 | return m.Container 49 | } 50 | return "" 51 | } 52 | 53 | func (m *ResourceHandle) GetName() string { 54 | if m != nil { 55 | return m.Name 56 | } 57 | return "" 58 | } 59 | 60 | func (m *ResourceHandle) GetHashCode() uint64 { 61 | if m != nil { 62 | return m.HashCode 63 | } 64 | return 0 65 | } 66 | 67 | func (m *ResourceHandle) GetMaybeTypeName() string { 68 | if m != nil { 69 | return m.MaybeTypeName 70 | } 71 | return "" 72 | } 73 | 74 | func init() { 75 | proto.RegisterType((*ResourceHandle)(nil), "tensorflow.ResourceHandle") 76 | } 77 | 78 | func init() { proto.RegisterFile("tensorflow/core/framework/resource_handle.proto", fileDescriptor10) } 79 | 80 | var fileDescriptor10 = []byte{ 81 | // 222 bytes of a gzipped FileDescriptorProto 82 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x54, 0x8f, 0x41, 0x4b, 0xc4, 0x30, 83 | 0x10, 0x85, 0x89, 0xd6, 0xc5, 0x0e, 0xa8, 0x10, 0x41, 0x02, 0x7a, 0x10, 0x0f, 0xe2, 0xa9, 0x39, 84 | 0xe8, 0x2f, 0x58, 0x2f, 0x9e, 0x64, 0x29, 0xde, 0x43, 0x36, 0x9d, 0xb5, 0x8b, 0xbb, 0x99, 0x65, 85 | 0x1a, 0x2d, 0xfd, 0x35, 0xfe, 0x4d, 0x8f, 0xa6, 0x43, 0xb1, 0x78, 0xcb, 0x7c, 0xef, 0x3d, 0xf2, 86 | 0x1e, 0xd8, 0x84, 0xb1, 0x23, 0xde, 0xec, 0xa8, 0xb7, 0x81, 0x18, 0xed, 0x86, 0xfd, 0x1e, 0x7b, 87 | 0xe2, 0x0f, 0xcb, 0xd8, 0xd1, 0x27, 0x07, 0x74, 0xad, 0x8f, 0xcd, 0x0e, 0xab, 0x03, 0x53, 0x22, 88 | 0x0d, 0x73, 0xe0, 0xee, 0x5b, 0xc1, 0x79, 0x3d, 0xb9, 0x5e, 0xc4, 0xa4, 0xaf, 0x60, 0xd1, 0xe0, 89 | 0xd7, 0x36, 0xa0, 0x51, 0xb7, 0xea, 0xa1, 0xac, 0xa7, 0x4b, 0xdf, 0x40, 0x19, 0x28, 0x26, 0xbf, 90 | 0x8d, 0xc8, 0xe6, 0x48, 0xa4, 0x19, 0x68, 0x0d, 0x45, 0xcc, 0xdf, 0x9a, 0x63, 0x11, 0xe4, 0xad, 91 | 0xaf, 0xa1, 0x6c, 0x7d, 0xd7, 0xba, 0x40, 0x0d, 0x9a, 0x22, 0x0b, 0x45, 0x7d, 0x3a, 0x82, 0xe7, 92 | 0x7c, 0xeb, 0x7b, 0xb8, 0xd8, 0xfb, 0x61, 0x8d, 0x2e, 0x0d, 0x07, 0x74, 0x92, 0x3d, 0x91, 0xec, 93 | 0x99, 0xe0, 0xb7, 0x4c, 0x5f, 0x33, 0x5c, 0x3e, 0x81, 0x21, 0x7e, 0xaf, 0xe6, 0xce, 0xd5, 0xdf, 94 | 0xbe, 0xe5, 0xe5, 0xff, 0xea, 0xab, 0x71, 0xde, 0x4a, 0xfd, 0x28, 0xb5, 0x5e, 0xc8, 0xd4, 0xc7, 95 | 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x39, 0x9f, 0x89, 0xe8, 0x1d, 0x01, 0x00, 0x00, 96 | } 97 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/resource_handle.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow; 4 | option cc_enable_arenas = true; 5 | option java_outer_classname = "ResourceHandleProto"; 6 | option java_multiple_files = true; 7 | option java_package = "org.tensorflow.framework"; 8 | 9 | // Protocol buffer representing a handle to a tensorflow resource. Handles are 10 | // not valid across executions, but can be serialized back and forth from within 11 | // a single run. 12 | message ResourceHandle { 13 | // Unique name for the device containing the resource. 14 | string device = 1; 15 | 16 | // Container in which this resource is placed. 17 | string container = 2; 18 | 19 | // Unique name of this resource. 20 | string name = 3; 21 | 22 | // Hash code for the type of the resource. Is only valid in the same device 23 | // and in the same execution. 24 | uint64 hash_code = 4; 25 | 26 | // For debug-only, the name of the type pointed to by this handle, if 27 | // available. 28 | string maybe_type_name = 5; 29 | }; 30 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/step_stats.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow; 4 | option cc_enable_arenas = true; 5 | option java_outer_classname = "StepStatsProtos"; 6 | option java_multiple_files = true; 7 | option java_package = "org.tensorflow.framework"; 8 | 9 | import "tensorflow/core/framework/allocation_description.proto"; 10 | import "tensorflow/core/framework/tensor_description.proto"; 11 | 12 | // TODO(tucker): The next 4 message defs are very similar to 13 | // the *LogEntry messages in profile.proto. They should be 14 | // unified in one place. 15 | 16 | message AllocatorMemoryUsed { 17 | string allocator_name = 1; 18 | int64 total_bytes = 2; 19 | int64 peak_bytes = 3; 20 | // The bytes that are not deallocated. 21 | int64 live_bytes = 4; 22 | } 23 | 24 | // Output sizes recorded for a single execution of a graph node. 25 | message NodeOutput { 26 | int32 slot = 1; 27 | TensorDescription tensor_description = 3; 28 | }; 29 | 30 | // Time/size stats recorded for a single execution of a graph node. 31 | message NodeExecStats { 32 | // TODO(tucker): Use some more compact form of node identity than 33 | // the full string name. Either all processes should agree on a 34 | // global id (cost_id?) for each node, or we should use a hash of 35 | // the name. 36 | string node_name = 1; 37 | int64 all_start_micros = 2; 38 | int64 op_start_rel_micros = 3; 39 | int64 op_end_rel_micros = 4; 40 | int64 all_end_rel_micros = 5; 41 | repeated AllocatorMemoryUsed memory = 6; 42 | repeated NodeOutput output = 7; 43 | string timeline_label = 8; 44 | int64 scheduled_micros = 9; 45 | uint32 thread_id = 10; 46 | repeated AllocationDescription referenced_tensor = 11; 47 | }; 48 | 49 | message DeviceStepStats { 50 | string device = 1; 51 | repeated NodeExecStats node_stats = 2; 52 | } 53 | 54 | message StepStats { 55 | repeated DeviceStepStats dev_stats = 1; 56 | }; 57 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/summary.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow; 4 | option cc_enable_arenas = true; 5 | option java_outer_classname = "SummaryProtos"; 6 | option java_multiple_files = true; 7 | option java_package = "org.tensorflow.framework"; 8 | 9 | import "tensorflow/core/framework/tensor.proto"; 10 | 11 | // Metadata associated with a series of Summary data 12 | message SummaryDescription { 13 | // Hint on how plugins should process the data in this series. 14 | // Supported values include "scalar", "histogram", "image", "audio" 15 | string type_hint = 1; 16 | } 17 | 18 | // Serialization format for histogram module in 19 | // core/lib/histogram/histogram.h 20 | message HistogramProto { 21 | double min = 1; 22 | double max = 2; 23 | double num = 3; 24 | double sum = 4; 25 | double sum_squares = 5; 26 | 27 | // Parallel arrays encoding the bucket boundaries and the bucket values. 28 | // bucket(i) is the count for the bucket i. The range for 29 | // a bucket is: 30 | // i == 0: -DBL_MAX .. bucket_limit(0) 31 | // i != 0: bucket_limit(i-1) .. bucket_limit(i) 32 | repeated double bucket_limit = 6 [packed = true]; 33 | repeated double bucket = 7 [packed = true]; 34 | }; 35 | 36 | // A Summary is a set of named values to be displayed by the 37 | // visualizer. 38 | // 39 | // Summaries are produced regularly during training, as controlled by 40 | // the "summary_interval_secs" attribute of the training operation. 41 | // Summaries are also produced at the end of an evaluation. 42 | message Summary { 43 | message Image { 44 | // Dimensions of the image. 45 | int32 height = 1; 46 | int32 width = 2; 47 | // Valid colorspace values are 48 | // 1 - grayscale 49 | // 2 - grayscale + alpha 50 | // 3 - RGB 51 | // 4 - RGBA 52 | // 5 - DIGITAL_YUV 53 | // 6 - BGRA 54 | int32 colorspace = 3; 55 | // Image data in encoded format. All image formats supported by 56 | // image_codec::CoderUtil can be stored here. 57 | bytes encoded_image_string = 4; 58 | } 59 | 60 | message Audio { 61 | // Sample rate of the audio in Hz. 62 | float sample_rate = 1; 63 | // Number of channels of audio. 64 | int64 num_channels = 2; 65 | // Length of the audio in frames (samples per channel). 66 | int64 length_frames = 3; 67 | // Encoded audio data and its associated RFC 2045 content type (e.g. 68 | // "audio/wav"). 69 | bytes encoded_audio_string = 4; 70 | string content_type = 5; 71 | } 72 | 73 | message Value { 74 | // Name of the node that output this summary; in general, the name of a 75 | // TensorSummary node. If the node in question has multiple outputs, then 76 | // a ":\d+" suffix will be appended, like "some_op:13". 77 | // Might not be set for legacy summaries (i.e. those not using the tensor 78 | // value field) 79 | string node_name = 7; 80 | 81 | // Tag name for the data. Will only be used by legacy summaries 82 | // (ie. those not using the tensor value field) 83 | // For legacy summaries, will be used as the title of the graph 84 | // in the visualizer. 85 | // 86 | // Tag is usually "op_name:value_name", where "op_name" itself can have 87 | // structure to indicate grouping. 88 | string tag = 1; 89 | 90 | // Value associated with the tag. 91 | oneof value { 92 | float simple_value = 2; 93 | bytes obsolete_old_style_histogram = 3; 94 | Image image = 4; 95 | HistogramProto histo = 5; 96 | Audio audio = 6; 97 | TensorProto tensor = 8; 98 | } 99 | } 100 | 101 | // Set of values for the summary. 102 | repeated Value value = 1; 103 | } 104 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/tensor.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow/core/framework/tensor.proto 3 | // DO NOT EDIT! 4 | 5 | package tensorflow 6 | 7 | import proto "github.com/golang/protobuf/proto" 8 | import fmt "fmt" 9 | import math "math" 10 | 11 | // Reference imports to suppress errors if they are not otherwise used. 12 | var _ = proto.Marshal 13 | var _ = fmt.Errorf 14 | var _ = math.Inf 15 | 16 | // Protocol buffer representing a tensor. 17 | type TensorProto struct { 18 | Dtype DataType `protobuf:"varint,1,opt,name=dtype,enum=tensorflow.DataType" json:"dtype,omitempty"` 19 | // Shape of the tensor. TODO(touts): sort out the 0-rank issues. 20 | TensorShape *TensorShapeProto `protobuf:"bytes,2,opt,name=tensor_shape,json=tensorShape" json:"tensor_shape,omitempty"` 21 | // Version number. 22 | // 23 | // In version 0, if the "repeated xxx" representations contain only one 24 | // element, that element is repeated to fill the shape. This makes it easy 25 | // to represent a constant Tensor with a single value. 26 | VersionNumber int32 `protobuf:"varint,3,opt,name=version_number,json=versionNumber" json:"version_number,omitempty"` 27 | // Serialized raw tensor content from either Tensor::AsProtoTensorContent or 28 | // memcpy in tensorflow::grpc::EncodeTensorToByteBuffer. This representation 29 | // can be used for all tensor types. The purpose of this representation is to 30 | // reduce serialization overhead during RPC call by avoiding serialization of 31 | // many repeated small items. 32 | TensorContent []byte `protobuf:"bytes,4,opt,name=tensor_content,json=tensorContent,proto3" json:"tensor_content,omitempty"` 33 | // DT_HALF. Note that since protobuf has no int16 type, we'll have some 34 | // pointless zero padding for each value here. 35 | HalfVal []int32 `protobuf:"varint,13,rep,packed,name=half_val,json=halfVal" json:"half_val,omitempty"` 36 | // DT_FLOAT. 37 | FloatVal []float32 `protobuf:"fixed32,5,rep,packed,name=float_val,json=floatVal" json:"float_val,omitempty"` 38 | // DT_DOUBLE. 39 | DoubleVal []float64 `protobuf:"fixed64,6,rep,packed,name=double_val,json=doubleVal" json:"double_val,omitempty"` 40 | // DT_INT32, DT_INT16, DT_INT8, DT_UINT8. 41 | IntVal []int32 `protobuf:"varint,7,rep,packed,name=int_val,json=intVal" json:"int_val,omitempty"` 42 | // DT_STRING 43 | StringVal [][]byte `protobuf:"bytes,8,rep,name=string_val,json=stringVal,proto3" json:"string_val,omitempty"` 44 | // DT_COMPLEX64. scomplex_val(2*i) and scomplex_val(2*i+1) are real 45 | // and imaginary parts of i-th single precision complex. 46 | ScomplexVal []float32 `protobuf:"fixed32,9,rep,packed,name=scomplex_val,json=scomplexVal" json:"scomplex_val,omitempty"` 47 | // DT_INT64 48 | Int64Val []int64 `protobuf:"varint,10,rep,packed,name=int64_val,json=int64Val" json:"int64_val,omitempty"` 49 | // DT_BOOL 50 | BoolVal []bool `protobuf:"varint,11,rep,packed,name=bool_val,json=boolVal" json:"bool_val,omitempty"` 51 | // DT_COMPLEX128. dcomplex_val(2*i) and dcomplex_val(2*i+1) are real 52 | // and imaginary parts of i-th double precision complex. 53 | DcomplexVal []float64 `protobuf:"fixed64,12,rep,packed,name=dcomplex_val,json=dcomplexVal" json:"dcomplex_val,omitempty"` 54 | // DT_RESOURCE 55 | ResourceHandleVal []*ResourceHandle `protobuf:"bytes,14,rep,name=resource_handle_val,json=resourceHandleVal" json:"resource_handle_val,omitempty"` 56 | } 57 | 58 | func (m *TensorProto) Reset() { *m = TensorProto{} } 59 | func (m *TensorProto) String() string { return proto.CompactTextString(m) } 60 | func (*TensorProto) ProtoMessage() {} 61 | func (*TensorProto) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{0} } 62 | 63 | func (m *TensorProto) GetDtype() DataType { 64 | if m != nil { 65 | return m.Dtype 66 | } 67 | return DataType_DT_INVALID 68 | } 69 | 70 | func (m *TensorProto) GetTensorShape() *TensorShapeProto { 71 | if m != nil { 72 | return m.TensorShape 73 | } 74 | return nil 75 | } 76 | 77 | func (m *TensorProto) GetVersionNumber() int32 { 78 | if m != nil { 79 | return m.VersionNumber 80 | } 81 | return 0 82 | } 83 | 84 | func (m *TensorProto) GetTensorContent() []byte { 85 | if m != nil { 86 | return m.TensorContent 87 | } 88 | return nil 89 | } 90 | 91 | func (m *TensorProto) GetHalfVal() []int32 { 92 | if m != nil { 93 | return m.HalfVal 94 | } 95 | return nil 96 | } 97 | 98 | func (m *TensorProto) GetFloatVal() []float32 { 99 | if m != nil { 100 | return m.FloatVal 101 | } 102 | return nil 103 | } 104 | 105 | func (m *TensorProto) GetDoubleVal() []float64 { 106 | if m != nil { 107 | return m.DoubleVal 108 | } 109 | return nil 110 | } 111 | 112 | func (m *TensorProto) GetIntVal() []int32 { 113 | if m != nil { 114 | return m.IntVal 115 | } 116 | return nil 117 | } 118 | 119 | func (m *TensorProto) GetStringVal() [][]byte { 120 | if m != nil { 121 | return m.StringVal 122 | } 123 | return nil 124 | } 125 | 126 | func (m *TensorProto) GetScomplexVal() []float32 { 127 | if m != nil { 128 | return m.ScomplexVal 129 | } 130 | return nil 131 | } 132 | 133 | func (m *TensorProto) GetInt64Val() []int64 { 134 | if m != nil { 135 | return m.Int64Val 136 | } 137 | return nil 138 | } 139 | 140 | func (m *TensorProto) GetBoolVal() []bool { 141 | if m != nil { 142 | return m.BoolVal 143 | } 144 | return nil 145 | } 146 | 147 | func (m *TensorProto) GetDcomplexVal() []float64 { 148 | if m != nil { 149 | return m.DcomplexVal 150 | } 151 | return nil 152 | } 153 | 154 | func (m *TensorProto) GetResourceHandleVal() []*ResourceHandle { 155 | if m != nil { 156 | return m.ResourceHandleVal 157 | } 158 | return nil 159 | } 160 | 161 | func init() { 162 | proto.RegisterType((*TensorProto)(nil), "tensorflow.TensorProto") 163 | } 164 | 165 | func init() { proto.RegisterFile("tensorflow/core/framework/tensor.proto", fileDescriptor14) } 166 | 167 | var fileDescriptor14 = []byte{ 168 | // 423 bytes of a gzipped FileDescriptorProto 169 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x92, 0x4f, 0xab, 0xd3, 0x40, 170 | 0x14, 0xc5, 0x49, 0xfb, 0xd2, 0x26, 0x37, 0x69, 0xd1, 0xe8, 0x22, 0x54, 0x1f, 0x3e, 0x85, 0xca, 171 | 0x43, 0xb4, 0x81, 0x2a, 0x6e, 0x85, 0xea, 0x42, 0x5c, 0x48, 0x19, 0x8b, 0xdb, 0x30, 0x49, 0xa6, 172 | 0x7f, 0x70, 0x9a, 0x09, 0x33, 0x69, 0xab, 0x1f, 0xcf, 0x6f, 0xe5, 0xd2, 0x99, 0x3b, 0x69, 0x1a, 173 | 0x05, 0x7d, 0xbb, 0xf6, 0x9c, 0xdf, 0x3d, 0xe7, 0x0e, 0xb9, 0xf0, 0xbc, 0x66, 0xa5, 0x12, 0x72, 174 | 0xcd, 0xc5, 0x29, 0xc9, 0x85, 0x64, 0xc9, 0x5a, 0xd2, 0x3d, 0x3b, 0x09, 0xf9, 0x2d, 0xb1, 0xce, 175 | 0xac, 0x92, 0xa2, 0x16, 0x11, 0x5c, 0xb8, 0x49, 0xf2, 0xef, 0x19, 0xc9, 0x94, 0x38, 0xc8, 0x9c, 176 | 0xa5, 0x5b, 0x5a, 0x16, 0x9c, 0xd9, 0xe1, 0xc9, 0xcb, 0xbb, 0x4a, 0x52, 0xb5, 0xa5, 0xd5, 0x99, 177 | 0x9e, 0xfe, 0x87, 0xfe, 0x51, 0x31, 0x65, 0xb1, 0x67, 0x3f, 0xaf, 0x20, 0x58, 0x21, 0xb9, 0xc4, 178 | 0x0d, 0x5f, 0x80, 0x5b, 0x18, 0x3f, 0x76, 0x6e, 0x9c, 0xdb, 0xf1, 0xfc, 0xe1, 0xec, 0x12, 0x33, 179 | 0xfb, 0x40, 0x6b, 0xba, 0xd2, 0x1e, 0xb1, 0x48, 0xf4, 0x0e, 0xc2, 0x6e, 0x71, 0xdc, 0xd3, 0x23, 180 | 0xc1, 0xfc, 0x71, 0x77, 0xc4, 0x46, 0x7f, 0x31, 0x36, 0xe6, 0x93, 0xa0, 0xbe, 0x28, 0xd1, 0x14, 181 | 0xc6, 0x47, 0x26, 0xd5, 0x4e, 0x94, 0x69, 0x79, 0xd8, 0x67, 0x4c, 0xc6, 0x7d, 0x1d, 0xe1, 0x92, 182 | 0x51, 0xa3, 0x7e, 0x46, 0xd1, 0x60, 0x4d, 0x4f, 0x2e, 0x4a, 0xfd, 0xab, 0x8e, 0xaf, 0x34, 0x16, 183 | 0x92, 0x91, 0x55, 0xdf, 0x5b, 0x31, 0xba, 0x06, 0x6f, 0x4b, 0xf9, 0x3a, 0x3d, 0x52, 0x1e, 0x8f, 184 | 0x6e, 0xfa, 0xb7, 0xee, 0xa2, 0x77, 0xcf, 0x21, 0x43, 0xa3, 0x7d, 0xa5, 0x3c, 0x7a, 0x02, 0xbe, 185 | 0x5e, 0x89, 0xd6, 0xe8, 0xbb, 0xda, 0xef, 0xa1, 0xef, 0xa1, 0x68, 0x80, 0xa7, 0x00, 0x85, 0x38, 186 | 0x64, 0x9c, 0x21, 0x31, 0xd0, 0x84, 0x83, 0x84, 0x6f, 0x55, 0x83, 0x3c, 0x82, 0xe1, 0xae, 0xb4, 187 | 0x09, 0xc3, 0xb6, 0x61, 0xa0, 0x25, 0x63, 0x5e, 0x03, 0xa8, 0x5a, 0xee, 0xca, 0x0d, 0xfa, 0x9e, 188 | 0xf6, 0x43, 0xe2, 0x5b, 0xc5, 0xd8, 0x53, 0x08, 0x55, 0x2e, 0xf6, 0x15, 0x67, 0xdf, 0x11, 0xf0, 189 | 0xdb, 0x15, 0x82, 0xb3, 0xde, 0xac, 0xa9, 0xf3, 0xde, 0xbe, 0x41, 0x06, 0x34, 0xd3, 0xb7, 0x6b, 190 | 0xa2, 0x68, 0x6b, 0xbc, 0x4c, 0x08, 0x8e, 0x7e, 0xa0, 0x7d, 0xcf, 0x3e, 0xd3, 0x68, 0x4d, 0x4d, 191 | 0xd1, 0xad, 0x09, 0xdb, 0x77, 0x04, 0x45, 0xa7, 0xe6, 0x13, 0x3c, 0xf8, 0xeb, 0xca, 0x90, 0x1e, 192 | 0x6b, 0x3a, 0x98, 0x4f, 0xba, 0x9f, 0x90, 0x34, 0xd8, 0x47, 0xa4, 0xc8, 0x7d, 0xf9, 0xc7, 0x7f, 193 | 0x9d, 0xb5, 0x78, 0x05, 0xb1, 0x90, 0x9b, 0xee, 0x4c, 0x7b, 0x6b, 0x8b, 0xb0, 0x73, 0x5c, 0x6a, 194 | 0xe9, 0xfc, 0x72, 0x9c, 0x6c, 0x80, 0x97, 0xf7, 0xfa, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0xec, 195 | 0x7c, 0x59, 0xcf, 0x35, 0x03, 0x00, 0x00, 196 | } 197 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/tensor.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow; 4 | option cc_enable_arenas = true; 5 | option java_outer_classname = "TensorProtos"; 6 | option java_multiple_files = true; 7 | option java_package = "org.tensorflow.framework"; 8 | 9 | import "tensorflow/core/framework/resource_handle.proto"; 10 | import "tensorflow/core/framework/tensor_shape.proto"; 11 | import "tensorflow/core/framework/types.proto"; 12 | 13 | // Protocol buffer representing a tensor. 14 | message TensorProto { 15 | DataType dtype = 1; 16 | 17 | // Shape of the tensor. TODO(touts): sort out the 0-rank issues. 18 | TensorShapeProto tensor_shape = 2; 19 | 20 | // Only one of the representations below is set, one of "tensor_contents" and 21 | // the "xxx_val" attributes. We are not using oneof because as oneofs cannot 22 | // contain repeated fields it would require another extra set of messages. 23 | 24 | // Version number. 25 | // 26 | // In version 0, if the "repeated xxx" representations contain only one 27 | // element, that element is repeated to fill the shape. This makes it easy 28 | // to represent a constant Tensor with a single value. 29 | int32 version_number = 3; 30 | 31 | // Serialized raw tensor content from either Tensor::AsProtoTensorContent or 32 | // memcpy in tensorflow::grpc::EncodeTensorToByteBuffer. This representation 33 | // can be used for all tensor types. The purpose of this representation is to 34 | // reduce serialization overhead during RPC call by avoiding serialization of 35 | // many repeated small items. 36 | bytes tensor_content = 4; 37 | 38 | // Type specific representations that make it easy to create tensor protos in 39 | // all languages. Only the representation corresponding to "dtype" can 40 | // be set. The values hold the flattened representation of the tensor in 41 | // row major order. 42 | 43 | // DT_HALF. Note that since protobuf has no int16 type, we'll have some 44 | // pointless zero padding for each value here. 45 | repeated int32 half_val = 13 [packed = true]; 46 | 47 | // DT_FLOAT. 48 | repeated float float_val = 5 [packed = true]; 49 | 50 | // DT_DOUBLE. 51 | repeated double double_val = 6 [packed = true]; 52 | 53 | // DT_INT32, DT_INT16, DT_INT8, DT_UINT8. 54 | repeated int32 int_val = 7 [packed = true]; 55 | 56 | // DT_STRING 57 | repeated bytes string_val = 8; 58 | 59 | // DT_COMPLEX64. scomplex_val(2*i) and scomplex_val(2*i+1) are real 60 | // and imaginary parts of i-th single precision complex. 61 | repeated float scomplex_val = 9 [packed = true]; 62 | 63 | // DT_INT64 64 | repeated int64 int64_val = 10 [packed = true]; 65 | 66 | // DT_BOOL 67 | repeated bool bool_val = 11 [packed = true]; 68 | 69 | // DT_COMPLEX128. dcomplex_val(2*i) and dcomplex_val(2*i+1) are real 70 | // and imaginary parts of i-th double precision complex. 71 | repeated double dcomplex_val = 12 [packed = true]; 72 | 73 | // DT_RESOURCE 74 | repeated ResourceHandle resource_handle_val = 14; 75 | }; 76 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/tensor_description.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow/core/framework/tensor_description.proto 3 | // DO NOT EDIT! 4 | 5 | package tensorflow 6 | 7 | import proto "github.com/golang/protobuf/proto" 8 | import fmt "fmt" 9 | import math "math" 10 | 11 | // Reference imports to suppress errors if they are not otherwise used. 12 | var _ = proto.Marshal 13 | var _ = fmt.Errorf 14 | var _ = math.Inf 15 | 16 | type TensorDescription struct { 17 | // Data type of tensor elements 18 | Dtype DataType `protobuf:"varint,1,opt,name=dtype,enum=tensorflow.DataType" json:"dtype,omitempty"` 19 | // Shape of the tensor. 20 | Shape *TensorShapeProto `protobuf:"bytes,2,opt,name=shape" json:"shape,omitempty"` 21 | // Information about the size and allocator used for the data 22 | AllocationDescription *AllocationDescription `protobuf:"bytes,4,opt,name=allocation_description,json=allocationDescription" json:"allocation_description,omitempty"` 23 | } 24 | 25 | func (m *TensorDescription) Reset() { *m = TensorDescription{} } 26 | func (m *TensorDescription) String() string { return proto.CompactTextString(m) } 27 | func (*TensorDescription) ProtoMessage() {} 28 | func (*TensorDescription) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{0} } 29 | 30 | func (m *TensorDescription) GetDtype() DataType { 31 | if m != nil { 32 | return m.Dtype 33 | } 34 | return DataType_DT_INVALID 35 | } 36 | 37 | func (m *TensorDescription) GetShape() *TensorShapeProto { 38 | if m != nil { 39 | return m.Shape 40 | } 41 | return nil 42 | } 43 | 44 | func (m *TensorDescription) GetAllocationDescription() *AllocationDescription { 45 | if m != nil { 46 | return m.AllocationDescription 47 | } 48 | return nil 49 | } 50 | 51 | func init() { 52 | proto.RegisterType((*TensorDescription)(nil), "tensorflow.TensorDescription") 53 | } 54 | 55 | func init() { 56 | proto.RegisterFile("tensorflow/core/framework/tensor_description.proto", fileDescriptor13) 57 | } 58 | 59 | var fileDescriptor13 = []byte{ 60 | // 232 bytes of a gzipped FileDescriptorProto 61 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x32, 0x2a, 0x49, 0xcd, 0x2b, 62 | 0xce, 0x2f, 0x4a, 0xcb, 0xc9, 0x2f, 0xd7, 0x4f, 0xce, 0x2f, 0x4a, 0xd5, 0x4f, 0x2b, 0x4a, 0xcc, 63 | 0x4d, 0x2d, 0xcf, 0x2f, 0xca, 0xd6, 0x87, 0xc8, 0xc4, 0xa7, 0xa4, 0x16, 0x27, 0x17, 0x65, 0x16, 64 | 0x94, 0x64, 0xe6, 0xe7, 0xe9, 0x15, 0x14, 0xe5, 0x97, 0xe4, 0x0b, 0x71, 0x21, 0xf4, 0x48, 0xa9, 65 | 0xe2, 0xd1, 0x5f, 0x59, 0x90, 0x5a, 0x0c, 0xd1, 0x22, 0xa5, 0x43, 0xd0, 0x9a, 0xe2, 0x8c, 0xc4, 66 | 0x82, 0x54, 0xa8, 0x6a, 0x33, 0xdc, 0xaa, 0x13, 0x73, 0x72, 0xf2, 0x93, 0x13, 0x41, 0x8e, 0xc1, 67 | 0x74, 0x98, 0xd2, 0x59, 0x46, 0x2e, 0xc1, 0x10, 0xb0, 0x56, 0x17, 0x84, 0x9c, 0x90, 0x16, 0x17, 68 | 0x6b, 0x0a, 0xc8, 0x2d, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x7c, 0x46, 0x22, 0x7a, 0x08, 0xd3, 0xf5, 69 | 0x5c, 0x12, 0x4b, 0x12, 0x43, 0x80, 0x72, 0x41, 0x10, 0x25, 0x42, 0x46, 0x5c, 0xac, 0x60, 0x87, 70 | 0x48, 0x30, 0x01, 0xd5, 0x72, 0x1b, 0xc9, 0x20, 0xab, 0x85, 0x98, 0x1c, 0x0c, 0x92, 0x0e, 0x00, 71 | 0x59, 0x17, 0x04, 0x51, 0x2a, 0x14, 0xc1, 0x25, 0x86, 0xdd, 0x55, 0x12, 0x2c, 0x60, 0x43, 0x14, 72 | 0x91, 0x0d, 0x71, 0x84, 0xab, 0x44, 0x72, 0x62, 0x90, 0x68, 0x22, 0x36, 0x61, 0x27, 0x0b, 0x2e, 73 | 0x89, 0xfc, 0xa2, 0x74, 0x64, 0xed, 0xf0, 0x80, 0x70, 0x12, 0xc7, 0xf0, 0x28, 0xd8, 0x51, 0xc5, 74 | 0x01, 0x8c, 0x3f, 0x18, 0x19, 0x93, 0xd8, 0xc0, 0x01, 0x62, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 75 | 0x26, 0xb4, 0x9a, 0xb7, 0xdf, 0x01, 0x00, 0x00, 76 | } 77 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/tensor_description.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow; 4 | option cc_enable_arenas = true; 5 | option java_outer_classname = "TensorDescriptionProtos"; 6 | option java_multiple_files = true; 7 | option java_package = "org.tensorflow.framework"; 8 | 9 | import "tensorflow/core/framework/types.proto"; 10 | import "tensorflow/core/framework/tensor_shape.proto"; 11 | import "tensorflow/core/framework/allocation_description.proto"; 12 | 13 | message TensorDescription { 14 | // Data type of tensor elements 15 | DataType dtype = 1; 16 | 17 | // Shape of the tensor. 18 | TensorShapeProto shape = 2; 19 | 20 | // Information about the size and allocator used for the data 21 | AllocationDescription allocation_description = 4; 22 | }; 23 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/tensor_shape.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow/core/framework/tensor_shape.proto 3 | // DO NOT EDIT! 4 | 5 | package tensorflow 6 | 7 | import proto "github.com/golang/protobuf/proto" 8 | import fmt "fmt" 9 | import math "math" 10 | 11 | // Reference imports to suppress errors if they are not otherwise used. 12 | var _ = proto.Marshal 13 | var _ = fmt.Errorf 14 | var _ = math.Inf 15 | 16 | // Dimensions of a tensor. 17 | type TensorShapeProto struct { 18 | // Dimensions of the tensor, such as {"input", 30}, {"output", 40} 19 | // for a 30 x 40 2D tensor. If an entry has size -1, this 20 | // corresponds to a dimension of unknown size. The names are 21 | // optional. 22 | // 23 | // The order of entries in "dim" matters: It indicates the layout of the 24 | // values in the tensor in-memory representation. 25 | // 26 | // The first entry in "dim" is the outermost dimension used to layout the 27 | // values, the last entry is the innermost dimension. This matches the 28 | // in-memory layout of RowMajor Eigen tensors. 29 | // 30 | // If "dim.size()" > 0, "unknown_rank" must be false. 31 | Dim []*TensorShapeProto_Dim `protobuf:"bytes,2,rep,name=dim" json:"dim,omitempty"` 32 | // If true, the number of dimensions in the shape is unknown. 33 | // 34 | // If true, "dim.size()" must be 0. 35 | UnknownRank bool `protobuf:"varint,3,opt,name=unknown_rank,json=unknownRank" json:"unknown_rank,omitempty"` 36 | } 37 | 38 | func (m *TensorShapeProto) Reset() { *m = TensorShapeProto{} } 39 | func (m *TensorShapeProto) String() string { return proto.CompactTextString(m) } 40 | func (*TensorShapeProto) ProtoMessage() {} 41 | func (*TensorShapeProto) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{0} } 42 | 43 | func (m *TensorShapeProto) GetDim() []*TensorShapeProto_Dim { 44 | if m != nil { 45 | return m.Dim 46 | } 47 | return nil 48 | } 49 | 50 | func (m *TensorShapeProto) GetUnknownRank() bool { 51 | if m != nil { 52 | return m.UnknownRank 53 | } 54 | return false 55 | } 56 | 57 | // One dimension of the tensor. 58 | type TensorShapeProto_Dim struct { 59 | // Size of the tensor in that dimension. 60 | // This value must be >= -1, but values of -1 are reserved for "unknown" 61 | // shapes (values of -1 mean "unknown" dimension). Certain wrappers 62 | // that work with TensorShapeProto may fail at runtime when deserializing 63 | // a TensorShapeProto containing a dim value of -1. 64 | Size int64 `protobuf:"varint,1,opt,name=size" json:"size,omitempty"` 65 | // Optional name of the tensor dimension. 66 | Name string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"` 67 | } 68 | 69 | func (m *TensorShapeProto_Dim) Reset() { *m = TensorShapeProto_Dim{} } 70 | func (m *TensorShapeProto_Dim) String() string { return proto.CompactTextString(m) } 71 | func (*TensorShapeProto_Dim) ProtoMessage() {} 72 | func (*TensorShapeProto_Dim) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{0, 0} } 73 | 74 | func (m *TensorShapeProto_Dim) GetSize() int64 { 75 | if m != nil { 76 | return m.Size 77 | } 78 | return 0 79 | } 80 | 81 | func (m *TensorShapeProto_Dim) GetName() string { 82 | if m != nil { 83 | return m.Name 84 | } 85 | return "" 86 | } 87 | 88 | func init() { 89 | proto.RegisterType((*TensorShapeProto)(nil), "tensorflow.TensorShapeProto") 90 | proto.RegisterType((*TensorShapeProto_Dim)(nil), "tensorflow.TensorShapeProto.Dim") 91 | } 92 | 93 | func init() { proto.RegisterFile("tensorflow/core/framework/tensor_shape.proto", fileDescriptor15) } 94 | 95 | var fileDescriptor15 = []byte{ 96 | // 202 bytes of a gzipped FileDescriptorProto 97 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xd2, 0x29, 0x49, 0xcd, 0x2b, 98 | 0xce, 0x2f, 0x4a, 0xcb, 0xc9, 0x2f, 0xd7, 0x4f, 0xce, 0x2f, 0x4a, 0xd5, 0x4f, 0x2b, 0x4a, 0xcc, 99 | 0x4d, 0x2d, 0xcf, 0x2f, 0xca, 0xd6, 0x87, 0xc8, 0xc4, 0x17, 0x67, 0x24, 0x16, 0xa4, 0xea, 0x15, 100 | 0x14, 0xe5, 0x97, 0xe4, 0x0b, 0x71, 0x21, 0x54, 0x2b, 0xcd, 0x60, 0xe4, 0x12, 0x08, 0x01, 0x73, 101 | 0x83, 0x41, 0x2a, 0x02, 0xc0, 0x0a, 0x8c, 0xb8, 0x98, 0x53, 0x32, 0x73, 0x25, 0x98, 0x14, 0x98, 102 | 0x35, 0xb8, 0x8d, 0x14, 0xf4, 0x10, 0xca, 0xf5, 0xd0, 0x95, 0xea, 0xb9, 0x64, 0xe6, 0x06, 0x81, 103 | 0x14, 0x0b, 0x29, 0x72, 0xf1, 0x94, 0xe6, 0x65, 0xe7, 0xe5, 0x97, 0xe7, 0xc5, 0x17, 0x25, 0xe6, 104 | 0x65, 0x4b, 0x30, 0x2b, 0x30, 0x6a, 0x70, 0x04, 0x71, 0x43, 0xc5, 0x82, 0x80, 0x42, 0x52, 0xba, 105 | 0x5c, 0xcc, 0x40, 0xe5, 0x42, 0x42, 0x5c, 0x2c, 0xc5, 0x99, 0x55, 0xa9, 0x12, 0x8c, 0x40, 0x15, 106 | 0xcc, 0x41, 0x60, 0x36, 0x48, 0x2c, 0x0f, 0xe8, 0x62, 0xa0, 0x95, 0x8c, 0x1a, 0x9c, 0x41, 0x60, 107 | 0xb6, 0x93, 0x11, 0x97, 0x44, 0x7e, 0x51, 0x3a, 0xb2, 0xed, 0x70, 0x5f, 0x39, 0x09, 0xa2, 0x3b, 108 | 0xa4, 0x38, 0x80, 0xf1, 0x07, 0x23, 0x63, 0x12, 0x1b, 0xd8, 0x87, 0xc6, 0x80, 0x00, 0x00, 0x00, 109 | 0xff, 0xff, 0x34, 0xe4, 0x72, 0x62, 0x11, 0x01, 0x00, 0x00, 110 | } 111 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/tensor_shape.proto: -------------------------------------------------------------------------------- 1 | // Protocol buffer representing the shape of tensors. 2 | 3 | syntax = "proto3"; 4 | option cc_enable_arenas = true; 5 | option java_outer_classname = "TensorShapeProtos"; 6 | option java_multiple_files = true; 7 | option java_package = "org.tensorflow.framework"; 8 | 9 | package tensorflow; 10 | 11 | // Dimensions of a tensor. 12 | message TensorShapeProto { 13 | // One dimension of the tensor. 14 | message Dim { 15 | // Size of the tensor in that dimension. 16 | // This value must be >= -1, but values of -1 are reserved for "unknown" 17 | // shapes (values of -1 mean "unknown" dimension). Certain wrappers 18 | // that work with TensorShapeProto may fail at runtime when deserializing 19 | // a TensorShapeProto containing a dim value of -1. 20 | int64 size = 1; 21 | 22 | // Optional name of the tensor dimension. 23 | string name = 2; 24 | }; 25 | 26 | // Dimensions of the tensor, such as {"input", 30}, {"output", 40} 27 | // for a 30 x 40 2D tensor. If an entry has size -1, this 28 | // corresponds to a dimension of unknown size. The names are 29 | // optional. 30 | // 31 | // The order of entries in "dim" matters: It indicates the layout of the 32 | // values in the tensor in-memory representation. 33 | // 34 | // The first entry in "dim" is the outermost dimension used to layout the 35 | // values, the last entry is the innermost dimension. This matches the 36 | // in-memory layout of RowMajor Eigen tensors. 37 | // 38 | // If "dim.size()" > 0, "unknown_rank" must be false. 39 | repeated Dim dim = 2; 40 | 41 | // If true, the number of dimensions in the shape is unknown. 42 | // 43 | // If true, "dim.size()" must be 0. 44 | bool unknown_rank = 3; 45 | }; 46 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/tensor_slice.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow/core/framework/tensor_slice.proto 3 | // DO NOT EDIT! 4 | 5 | package tensorflow 6 | 7 | import proto "github.com/golang/protobuf/proto" 8 | import fmt "fmt" 9 | import math "math" 10 | 11 | // Reference imports to suppress errors if they are not otherwise used. 12 | var _ = proto.Marshal 13 | var _ = fmt.Errorf 14 | var _ = math.Inf 15 | 16 | // Can only be interpreted if you know the corresponding TensorShape. 17 | type TensorSliceProto struct { 18 | // Extent of the slice in all tensor dimensions. 19 | // 20 | // Must have one entry for each of the dimension of the tensor that this 21 | // slice belongs to. The order of sizes is the same as the order of 22 | // dimensions in the TensorShape. 23 | Extent []*TensorSliceProto_Extent `protobuf:"bytes,1,rep,name=extent" json:"extent,omitempty"` 24 | } 25 | 26 | func (m *TensorSliceProto) Reset() { *m = TensorSliceProto{} } 27 | func (m *TensorSliceProto) String() string { return proto.CompactTextString(m) } 28 | func (*TensorSliceProto) ProtoMessage() {} 29 | func (*TensorSliceProto) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{0} } 30 | 31 | func (m *TensorSliceProto) GetExtent() []*TensorSliceProto_Extent { 32 | if m != nil { 33 | return m.Extent 34 | } 35 | return nil 36 | } 37 | 38 | // Extent of the slice in one dimension. 39 | type TensorSliceProto_Extent struct { 40 | // Start index of the slice, starting at 0. 41 | Start int64 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` 42 | // Length of the slice: if the length is missing or -1 we will 43 | // interpret this as "everything in this dimension". We use 44 | // "oneof" to preserve information about whether the length is 45 | // present without changing the serialization format from the 46 | // prior proto2 version of this proto. 47 | // 48 | // Types that are valid to be assigned to HasLength: 49 | // *TensorSliceProto_Extent_Length 50 | HasLength isTensorSliceProto_Extent_HasLength `protobuf_oneof:"has_length"` 51 | } 52 | 53 | func (m *TensorSliceProto_Extent) Reset() { *m = TensorSliceProto_Extent{} } 54 | func (m *TensorSliceProto_Extent) String() string { return proto.CompactTextString(m) } 55 | func (*TensorSliceProto_Extent) ProtoMessage() {} 56 | func (*TensorSliceProto_Extent) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{0, 0} } 57 | 58 | type isTensorSliceProto_Extent_HasLength interface { 59 | isTensorSliceProto_Extent_HasLength() 60 | } 61 | 62 | type TensorSliceProto_Extent_Length struct { 63 | Length int64 `protobuf:"varint,2,opt,name=length,oneof"` 64 | } 65 | 66 | func (*TensorSliceProto_Extent_Length) isTensorSliceProto_Extent_HasLength() {} 67 | 68 | func (m *TensorSliceProto_Extent) GetHasLength() isTensorSliceProto_Extent_HasLength { 69 | if m != nil { 70 | return m.HasLength 71 | } 72 | return nil 73 | } 74 | 75 | func (m *TensorSliceProto_Extent) GetStart() int64 { 76 | if m != nil { 77 | return m.Start 78 | } 79 | return 0 80 | } 81 | 82 | func (m *TensorSliceProto_Extent) GetLength() int64 { 83 | if x, ok := m.GetHasLength().(*TensorSliceProto_Extent_Length); ok { 84 | return x.Length 85 | } 86 | return 0 87 | } 88 | 89 | // XXX_OneofFuncs is for the internal use of the proto package. 90 | func (*TensorSliceProto_Extent) 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{}) { 91 | return _TensorSliceProto_Extent_OneofMarshaler, _TensorSliceProto_Extent_OneofUnmarshaler, _TensorSliceProto_Extent_OneofSizer, []interface{}{ 92 | (*TensorSliceProto_Extent_Length)(nil), 93 | } 94 | } 95 | 96 | func _TensorSliceProto_Extent_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { 97 | m := msg.(*TensorSliceProto_Extent) 98 | // has_length 99 | switch x := m.HasLength.(type) { 100 | case *TensorSliceProto_Extent_Length: 101 | b.EncodeVarint(2<<3 | proto.WireVarint) 102 | b.EncodeVarint(uint64(x.Length)) 103 | case nil: 104 | default: 105 | return fmt.Errorf("TensorSliceProto_Extent.HasLength has unexpected type %T", x) 106 | } 107 | return nil 108 | } 109 | 110 | func _TensorSliceProto_Extent_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { 111 | m := msg.(*TensorSliceProto_Extent) 112 | switch tag { 113 | case 2: // has_length.length 114 | if wire != proto.WireVarint { 115 | return true, proto.ErrInternalBadWireType 116 | } 117 | x, err := b.DecodeVarint() 118 | m.HasLength = &TensorSliceProto_Extent_Length{int64(x)} 119 | return true, err 120 | default: 121 | return false, nil 122 | } 123 | } 124 | 125 | func _TensorSliceProto_Extent_OneofSizer(msg proto.Message) (n int) { 126 | m := msg.(*TensorSliceProto_Extent) 127 | // has_length 128 | switch x := m.HasLength.(type) { 129 | case *TensorSliceProto_Extent_Length: 130 | n += proto.SizeVarint(2<<3 | proto.WireVarint) 131 | n += proto.SizeVarint(uint64(x.Length)) 132 | case nil: 133 | default: 134 | panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) 135 | } 136 | return n 137 | } 138 | 139 | func init() { 140 | proto.RegisterType((*TensorSliceProto)(nil), "tensorflow.TensorSliceProto") 141 | proto.RegisterType((*TensorSliceProto_Extent)(nil), "tensorflow.TensorSliceProto.Extent") 142 | } 143 | 144 | func init() { proto.RegisterFile("tensorflow/core/framework/tensor_slice.proto", fileDescriptor16) } 145 | 146 | var fileDescriptor16 = []byte{ 147 | // 189 bytes of a gzipped FileDescriptorProto 148 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xd2, 0x29, 0x49, 0xcd, 0x2b, 149 | 0xce, 0x2f, 0x4a, 0xcb, 0xc9, 0x2f, 0xd7, 0x4f, 0xce, 0x2f, 0x4a, 0xd5, 0x4f, 0x2b, 0x4a, 0xcc, 150 | 0x4d, 0x2d, 0xcf, 0x2f, 0xca, 0xd6, 0x87, 0xc8, 0xc4, 0x17, 0xe7, 0x64, 0x26, 0xa7, 0xea, 0x15, 151 | 0x14, 0xe5, 0x97, 0xe4, 0x0b, 0x71, 0x21, 0x54, 0x2b, 0x4d, 0x67, 0xe4, 0x12, 0x08, 0x01, 0x73, 152 | 0x83, 0x41, 0x2a, 0x02, 0xc0, 0x0a, 0xac, 0xb9, 0xd8, 0x52, 0x2b, 0x80, 0x8a, 0x4a, 0x24, 0x18, 153 | 0x15, 0x98, 0x35, 0xb8, 0x8d, 0x94, 0xf5, 0x10, 0x3a, 0xf4, 0xd0, 0x55, 0xeb, 0xb9, 0x82, 0x95, 154 | 0x06, 0x41, 0xb5, 0x48, 0xb9, 0x71, 0xb1, 0x41, 0x44, 0x84, 0x44, 0xb8, 0x58, 0x8b, 0x4b, 0x12, 155 | 0x8b, 0x40, 0xa6, 0x30, 0x6a, 0x30, 0x07, 0x41, 0x38, 0x42, 0x12, 0x5c, 0x6c, 0x39, 0xa9, 0x79, 156 | 0xe9, 0x25, 0x19, 0x12, 0x4c, 0x20, 0x61, 0x0f, 0x86, 0x20, 0x28, 0xdf, 0x89, 0x87, 0x8b, 0x2b, 157 | 0x23, 0xb1, 0x38, 0x1e, 0xca, 0x33, 0xe2, 0x92, 0xc8, 0x2f, 0x4a, 0x47, 0xb6, 0x19, 0xee, 0x29, 158 | 0x27, 0x41, 0x74, 0x47, 0x14, 0x07, 0x30, 0xfe, 0x60, 0x64, 0x4c, 0x62, 0x03, 0x7b, 0xd0, 0x18, 159 | 0x10, 0x00, 0x00, 0xff, 0xff, 0xf8, 0xe6, 0xc9, 0xa7, 0x10, 0x01, 0x00, 0x00, 160 | } 161 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/tensor_slice.proto: -------------------------------------------------------------------------------- 1 | // Protocol buffer representing slices of a tensor 2 | 3 | syntax = "proto3"; 4 | option cc_enable_arenas = true; 5 | option java_outer_classname = "TensorSliceProtos"; 6 | option java_multiple_files = true; 7 | option java_package = "org.tensorflow.framework"; 8 | 9 | package tensorflow; 10 | 11 | // Can only be interpreted if you know the corresponding TensorShape. 12 | message TensorSliceProto { 13 | // Extent of the slice in one dimension. 14 | message Extent { 15 | // Either both or no attributes must be set. When no attribute is set 16 | // means: All data in that dimension. 17 | 18 | // Start index of the slice, starting at 0. 19 | int64 start = 1; 20 | 21 | // Length of the slice: if the length is missing or -1 we will 22 | // interpret this as "everything in this dimension". We use 23 | // "oneof" to preserve information about whether the length is 24 | // present without changing the serialization format from the 25 | // prior proto2 version of this proto. 26 | oneof has_length { 27 | int64 length = 2; 28 | } 29 | }; 30 | 31 | // Extent of the slice in all tensor dimensions. 32 | // 33 | // Must have one entry for each of the dimension of the tensor that this 34 | // slice belongs to. The order of sizes is the same as the order of 35 | // dimensions in the TensorShape. 36 | repeated Extent extent = 1; 37 | }; 38 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/types.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow/core/framework/types.proto 3 | // DO NOT EDIT! 4 | 5 | package tensorflow 6 | 7 | import proto "github.com/golang/protobuf/proto" 8 | import fmt "fmt" 9 | import math "math" 10 | 11 | // Reference imports to suppress errors if they are not otherwise used. 12 | var _ = proto.Marshal 13 | var _ = fmt.Errorf 14 | var _ = math.Inf 15 | 16 | // LINT.IfChange 17 | type DataType int32 18 | 19 | const ( 20 | // Not a legal value for DataType. Used to indicate a DataType field 21 | // has not been set. 22 | DataType_DT_INVALID DataType = 0 23 | // Data types that all computation devices are expected to be 24 | // capable to support. 25 | DataType_DT_FLOAT DataType = 1 26 | DataType_DT_DOUBLE DataType = 2 27 | DataType_DT_INT32 DataType = 3 28 | DataType_DT_UINT8 DataType = 4 29 | DataType_DT_INT16 DataType = 5 30 | DataType_DT_INT8 DataType = 6 31 | DataType_DT_STRING DataType = 7 32 | DataType_DT_COMPLEX64 DataType = 8 33 | DataType_DT_INT64 DataType = 9 34 | DataType_DT_BOOL DataType = 10 35 | DataType_DT_QINT8 DataType = 11 36 | DataType_DT_QUINT8 DataType = 12 37 | DataType_DT_QINT32 DataType = 13 38 | DataType_DT_BFLOAT16 DataType = 14 39 | DataType_DT_QINT16 DataType = 15 40 | DataType_DT_QUINT16 DataType = 16 41 | DataType_DT_UINT16 DataType = 17 42 | DataType_DT_COMPLEX128 DataType = 18 43 | DataType_DT_HALF DataType = 19 44 | DataType_DT_RESOURCE DataType = 20 45 | // Do not use! These are only for parameters. Every enum above 46 | // should have a corresponding value below (verified by types_test). 47 | DataType_DT_FLOAT_REF DataType = 101 48 | DataType_DT_DOUBLE_REF DataType = 102 49 | DataType_DT_INT32_REF DataType = 103 50 | DataType_DT_UINT8_REF DataType = 104 51 | DataType_DT_INT16_REF DataType = 105 52 | DataType_DT_INT8_REF DataType = 106 53 | DataType_DT_STRING_REF DataType = 107 54 | DataType_DT_COMPLEX64_REF DataType = 108 55 | DataType_DT_INT64_REF DataType = 109 56 | DataType_DT_BOOL_REF DataType = 110 57 | DataType_DT_QINT8_REF DataType = 111 58 | DataType_DT_QUINT8_REF DataType = 112 59 | DataType_DT_QINT32_REF DataType = 113 60 | DataType_DT_BFLOAT16_REF DataType = 114 61 | DataType_DT_QINT16_REF DataType = 115 62 | DataType_DT_QUINT16_REF DataType = 116 63 | DataType_DT_UINT16_REF DataType = 117 64 | DataType_DT_COMPLEX128_REF DataType = 118 65 | DataType_DT_HALF_REF DataType = 119 66 | DataType_DT_RESOURCE_REF DataType = 120 67 | ) 68 | 69 | var DataType_name = map[int32]string{ 70 | 0: "DT_INVALID", 71 | 1: "DT_FLOAT", 72 | 2: "DT_DOUBLE", 73 | 3: "DT_INT32", 74 | 4: "DT_UINT8", 75 | 5: "DT_INT16", 76 | 6: "DT_INT8", 77 | 7: "DT_STRING", 78 | 8: "DT_COMPLEX64", 79 | 9: "DT_INT64", 80 | 10: "DT_BOOL", 81 | 11: "DT_QINT8", 82 | 12: "DT_QUINT8", 83 | 13: "DT_QINT32", 84 | 14: "DT_BFLOAT16", 85 | 15: "DT_QINT16", 86 | 16: "DT_QUINT16", 87 | 17: "DT_UINT16", 88 | 18: "DT_COMPLEX128", 89 | 19: "DT_HALF", 90 | 20: "DT_RESOURCE", 91 | 101: "DT_FLOAT_REF", 92 | 102: "DT_DOUBLE_REF", 93 | 103: "DT_INT32_REF", 94 | 104: "DT_UINT8_REF", 95 | 105: "DT_INT16_REF", 96 | 106: "DT_INT8_REF", 97 | 107: "DT_STRING_REF", 98 | 108: "DT_COMPLEX64_REF", 99 | 109: "DT_INT64_REF", 100 | 110: "DT_BOOL_REF", 101 | 111: "DT_QINT8_REF", 102 | 112: "DT_QUINT8_REF", 103 | 113: "DT_QINT32_REF", 104 | 114: "DT_BFLOAT16_REF", 105 | 115: "DT_QINT16_REF", 106 | 116: "DT_QUINT16_REF", 107 | 117: "DT_UINT16_REF", 108 | 118: "DT_COMPLEX128_REF", 109 | 119: "DT_HALF_REF", 110 | 120: "DT_RESOURCE_REF", 111 | } 112 | var DataType_value = map[string]int32{ 113 | "DT_INVALID": 0, 114 | "DT_FLOAT": 1, 115 | "DT_DOUBLE": 2, 116 | "DT_INT32": 3, 117 | "DT_UINT8": 4, 118 | "DT_INT16": 5, 119 | "DT_INT8": 6, 120 | "DT_STRING": 7, 121 | "DT_COMPLEX64": 8, 122 | "DT_INT64": 9, 123 | "DT_BOOL": 10, 124 | "DT_QINT8": 11, 125 | "DT_QUINT8": 12, 126 | "DT_QINT32": 13, 127 | "DT_BFLOAT16": 14, 128 | "DT_QINT16": 15, 129 | "DT_QUINT16": 16, 130 | "DT_UINT16": 17, 131 | "DT_COMPLEX128": 18, 132 | "DT_HALF": 19, 133 | "DT_RESOURCE": 20, 134 | "DT_FLOAT_REF": 101, 135 | "DT_DOUBLE_REF": 102, 136 | "DT_INT32_REF": 103, 137 | "DT_UINT8_REF": 104, 138 | "DT_INT16_REF": 105, 139 | "DT_INT8_REF": 106, 140 | "DT_STRING_REF": 107, 141 | "DT_COMPLEX64_REF": 108, 142 | "DT_INT64_REF": 109, 143 | "DT_BOOL_REF": 110, 144 | "DT_QINT8_REF": 111, 145 | "DT_QUINT8_REF": 112, 146 | "DT_QINT32_REF": 113, 147 | "DT_BFLOAT16_REF": 114, 148 | "DT_QINT16_REF": 115, 149 | "DT_QUINT16_REF": 116, 150 | "DT_UINT16_REF": 117, 151 | "DT_COMPLEX128_REF": 118, 152 | "DT_HALF_REF": 119, 153 | "DT_RESOURCE_REF": 120, 154 | } 155 | 156 | func (x DataType) String() string { 157 | return proto.EnumName(DataType_name, int32(x)) 158 | } 159 | func (DataType) EnumDescriptor() ([]byte, []int) { return fileDescriptor17, []int{0} } 160 | 161 | func init() { 162 | proto.RegisterEnum("tensorflow.DataType", DataType_name, DataType_value) 163 | } 164 | 165 | func init() { proto.RegisterFile("tensorflow/core/framework/types.proto", fileDescriptor17) } 166 | 167 | var fileDescriptor17 = []byte{ 168 | // 415 bytes of a gzipped FileDescriptorProto 169 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x54, 0x93, 0x5f, 0xaf, 0xd2, 0x40, 170 | 0x10, 0xc5, 0xad, 0x7a, 0xef, 0x85, 0x29, 0x7f, 0x86, 0x05, 0x13, 0xbf, 0x80, 0x2f, 0xc6, 0x40, 171 | 0x00, 0x43, 0x78, 0xa5, 0xb4, 0x68, 0x93, 0x4a, 0x29, 0x14, 0xe3, 0x1b, 0x41, 0x53, 0x50, 0xf9, 172 | 0xb3, 0xd8, 0x56, 0xd1, 0xaf, 0xe7, 0xa7, 0xf2, 0xd1, 0xed, 0x74, 0xca, 0xf6, 0x3e, 0x9e, 0xdf, 173 | 0xcc, 0x9e, 0x3d, 0x3d, 0xd9, 0xc2, 0xab, 0x34, 0x3a, 0x27, 0x32, 0xde, 0x1d, 0xe5, 0xb5, 0xf7, 174 | 0x45, 0xc6, 0x51, 0x6f, 0x17, 0x6f, 0x4f, 0xd1, 0x55, 0xc6, 0x87, 0x5e, 0xfa, 0xe7, 0x12, 0x25, 175 | 0xdd, 0x4b, 0x2c, 0x53, 0x29, 0x40, 0xaf, 0xbd, 0xfe, 0x7b, 0x07, 0x15, 0x7b, 0x9b, 0x6e, 0x43, 176 | 0x35, 0x17, 0x0d, 0x00, 0x3b, 0xdc, 0xb8, 0xf3, 0x8f, 0x13, 0xcf, 0xb5, 0xf1, 0x89, 0xa8, 0xa9, 177 | 0x59, 0xb8, 0x99, 0x79, 0xfe, 0x24, 0x44, 0x43, 0xd4, 0xa1, 0xaa, 0x94, 0xed, 0xaf, 0x2d, 0xcf, 178 | 0xc1, 0xa7, 0x3c, 0x74, 0xe7, 0xe1, 0x70, 0x80, 0xcf, 0x58, 0xad, 0x95, 0x1c, 0xe3, 0x73, 0x3d, 179 | 0xeb, 0x8f, 0xf0, 0x4e, 0x98, 0xf0, 0x90, 0xab, 0x31, 0xde, 0xb3, 0xcb, 0x2a, 0x5c, 0xba, 0xf3, 180 | 0x77, 0xf8, 0x20, 0x10, 0x6a, 0x4a, 0x4e, 0xfd, 0x0f, 0x0b, 0xcf, 0xf9, 0x34, 0x7a, 0x8b, 0x15, 181 | 0x7d, 0x56, 0xa9, 0x2a, 0x9f, 0xb5, 0x7c, 0xdf, 0x43, 0xe0, 0x51, 0x40, 0x4e, 0x26, 0x3b, 0x05, 182 | 0xf9, 0x9d, 0xb5, 0x42, 0xe6, 0x81, 0xea, 0xa2, 0x09, 0x66, 0x76, 0x90, 0xc2, 0xab, 0x14, 0x8d, 183 | 0xd2, 0x5c, 0xc9, 0x26, 0x7f, 0x2b, 0x9d, 0x56, 0x1a, 0x79, 0xcc, 0xb2, 0x25, 0x5a, 0x50, 0xd7, 184 | 0xb9, 0xfa, 0x83, 0x31, 0x0a, 0x8e, 0xf2, 0x7e, 0xe2, 0xcd, 0xb0, 0xcd, 0xf6, 0x4b, 0x67, 0xe5, 185 | 0xaf, 0x97, 0x53, 0x07, 0x3b, 0xfc, 0x21, 0x74, 0x9d, 0xc2, 0x33, 0x8c, 0xd8, 0x22, 0xef, 0x8b, 186 | 0xd0, 0x8e, 0x97, 0x28, 0x22, 0x91, 0x3d, 0x13, 0xfa, 0x06, 0x22, 0x5f, 0xf5, 0x4e, 0x7f, 0x44, 187 | 0xe4, 0x1b, 0xdf, 0x75, 0x5b, 0xf9, 0xce, 0xce, 0x79, 0x87, 0x84, 0x0e, 0xa2, 0x03, 0x58, 0xee, 188 | 0x91, 0xe8, 0x51, 0x7b, 0x31, 0x39, 0x15, 0xb5, 0xa8, 0x3e, 0x09, 0x9c, 0x79, 0x25, 0xb8, 0xb9, 189 | 0x4b, 0x76, 0x0f, 0x74, 0xa6, 0x4b, 0x81, 0x74, 0xf0, 0x1f, 0xa2, 0x0d, 0xcd, 0x52, 0xbf, 0x04, 190 | 0xe3, 0xd2, 0x1e, 0xa3, 0x44, 0x08, 0x68, 0xe8, 0x9e, 0x89, 0xa5, 0xbc, 0x56, 0x42, 0x3f, 0xc5, 191 | 0x0b, 0x68, 0x3d, 0xea, 0x9b, 0xf0, 0x2f, 0x8e, 0x9b, 0x75, 0x4e, 0xe0, 0xca, 0xd7, 0x16, 0xbd, 192 | 0x13, 0xfc, 0x6d, 0xbd, 0x81, 0x97, 0x32, 0xde, 0x77, 0xf5, 0xb3, 0xee, 0xde, 0x1e, 0xbe, 0x65, 193 | 0x66, 0x2f, 0x3b, 0x59, 0x64, 0x0f, 0x3f, 0x59, 0x18, 0xff, 0x0c, 0xe3, 0xf3, 0x3d, 0xfd, 0x05, 194 | 0xc3, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0x14, 0x03, 0xf4, 0x32, 0x2e, 0x03, 0x00, 0x00, 195 | } 196 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/types.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow; 4 | option cc_enable_arenas = true; 5 | option java_outer_classname = "TypesProtos"; 6 | option java_multiple_files = true; 7 | option java_package = "org.tensorflow.framework"; 8 | 9 | // LINT.IfChange 10 | enum DataType { 11 | // Not a legal value for DataType. Used to indicate a DataType field 12 | // has not been set. 13 | DT_INVALID = 0; 14 | 15 | // Data types that all computation devices are expected to be 16 | // capable to support. 17 | DT_FLOAT = 1; 18 | DT_DOUBLE = 2; 19 | DT_INT32 = 3; 20 | DT_UINT8 = 4; 21 | DT_INT16 = 5; 22 | DT_INT8 = 6; 23 | DT_STRING = 7; 24 | DT_COMPLEX64 = 8; // Single-precision complex 25 | DT_INT64 = 9; 26 | DT_BOOL = 10; 27 | DT_QINT8 = 11; // Quantized int8 28 | DT_QUINT8 = 12; // Quantized uint8 29 | DT_QINT32 = 13; // Quantized int32 30 | DT_BFLOAT16 = 14; // Float32 truncated to 16 bits. Only for cast ops. 31 | DT_QINT16 = 15; // Quantized int16 32 | DT_QUINT16 = 16; // Quantized uint16 33 | DT_UINT16 = 17; 34 | DT_COMPLEX128 = 18; // Double-precision complex 35 | DT_HALF = 19; 36 | DT_RESOURCE = 20; 37 | 38 | // TODO(josh11b): DT_GENERIC_PROTO = ??; 39 | // TODO(jeff,josh11b): DT_UINT64? DT_UINT32? 40 | 41 | // Do not use! These are only for parameters. Every enum above 42 | // should have a corresponding value below (verified by types_test). 43 | DT_FLOAT_REF = 101; 44 | DT_DOUBLE_REF = 102; 45 | DT_INT32_REF = 103; 46 | DT_UINT8_REF = 104; 47 | DT_INT16_REF = 105; 48 | DT_INT8_REF = 106; 49 | DT_STRING_REF = 107; 50 | DT_COMPLEX64_REF = 108; 51 | DT_INT64_REF = 109; 52 | DT_BOOL_REF = 110; 53 | DT_QINT8_REF = 111; 54 | DT_QUINT8_REF = 112; 55 | DT_QINT32_REF = 113; 56 | DT_BFLOAT16_REF = 114; 57 | DT_QINT16_REF = 115; 58 | DT_QUINT16_REF = 116; 59 | DT_UINT16_REF = 117; 60 | DT_COMPLEX128_REF = 118; 61 | DT_HALF_REF = 119; 62 | DT_RESOURCE_REF = 120; 63 | } 64 | // LINT.ThenChange(https://www.tensorflow.org/code/tensorflow/c/c_api.h,https://www.tensorflow.org/code/tensorflow/go/tensor.go) 65 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/variable.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow/core/framework/variable.proto 3 | // DO NOT EDIT! 4 | 5 | package tensorflow 6 | 7 | import proto "github.com/golang/protobuf/proto" 8 | import fmt "fmt" 9 | import math "math" 10 | 11 | // Reference imports to suppress errors if they are not otherwise used. 12 | var _ = proto.Marshal 13 | var _ = fmt.Errorf 14 | var _ = math.Inf 15 | 16 | // Protocol buffer representing a Variable. 17 | type VariableDef struct { 18 | // Name of the variable tensor. 19 | VariableName string `protobuf:"bytes,1,opt,name=variable_name,json=variableName" json:"variable_name,omitempty"` 20 | // Name of the initializer op. 21 | InitializerName string `protobuf:"bytes,2,opt,name=initializer_name,json=initializerName" json:"initializer_name,omitempty"` 22 | // Name of the snapshot tensor. 23 | SnapshotName string `protobuf:"bytes,3,opt,name=snapshot_name,json=snapshotName" json:"snapshot_name,omitempty"` 24 | // Support for saving variables as slices of a larger variable. 25 | SaveSliceInfoDef *SaveSliceInfoDef `protobuf:"bytes,4,opt,name=save_slice_info_def,json=saveSliceInfoDef" json:"save_slice_info_def,omitempty"` 26 | // Whether to represent this as a ResourceVariable. 27 | IsResource bool `protobuf:"varint,5,opt,name=is_resource,json=isResource" json:"is_resource,omitempty"` 28 | } 29 | 30 | func (m *VariableDef) Reset() { *m = VariableDef{} } 31 | func (m *VariableDef) String() string { return proto.CompactTextString(m) } 32 | func (*VariableDef) ProtoMessage() {} 33 | func (*VariableDef) Descriptor() ([]byte, []int) { return fileDescriptor18, []int{0} } 34 | 35 | func (m *VariableDef) GetVariableName() string { 36 | if m != nil { 37 | return m.VariableName 38 | } 39 | return "" 40 | } 41 | 42 | func (m *VariableDef) GetInitializerName() string { 43 | if m != nil { 44 | return m.InitializerName 45 | } 46 | return "" 47 | } 48 | 49 | func (m *VariableDef) GetSnapshotName() string { 50 | if m != nil { 51 | return m.SnapshotName 52 | } 53 | return "" 54 | } 55 | 56 | func (m *VariableDef) GetSaveSliceInfoDef() *SaveSliceInfoDef { 57 | if m != nil { 58 | return m.SaveSliceInfoDef 59 | } 60 | return nil 61 | } 62 | 63 | func (m *VariableDef) GetIsResource() bool { 64 | if m != nil { 65 | return m.IsResource 66 | } 67 | return false 68 | } 69 | 70 | type SaveSliceInfoDef struct { 71 | // Name of the full variable of which this is a slice. 72 | FullName string `protobuf:"bytes,1,opt,name=full_name,json=fullName" json:"full_name,omitempty"` 73 | // Shape of the full variable. 74 | FullShape []int64 `protobuf:"varint,2,rep,packed,name=full_shape,json=fullShape" json:"full_shape,omitempty"` 75 | // Offset of this variable into the full variable. 76 | VarOffset []int64 `protobuf:"varint,3,rep,packed,name=var_offset,json=varOffset" json:"var_offset,omitempty"` 77 | // Shape of this variable. 78 | VarShape []int64 `protobuf:"varint,4,rep,packed,name=var_shape,json=varShape" json:"var_shape,omitempty"` 79 | } 80 | 81 | func (m *SaveSliceInfoDef) Reset() { *m = SaveSliceInfoDef{} } 82 | func (m *SaveSliceInfoDef) String() string { return proto.CompactTextString(m) } 83 | func (*SaveSliceInfoDef) ProtoMessage() {} 84 | func (*SaveSliceInfoDef) Descriptor() ([]byte, []int) { return fileDescriptor18, []int{1} } 85 | 86 | func (m *SaveSliceInfoDef) GetFullName() string { 87 | if m != nil { 88 | return m.FullName 89 | } 90 | return "" 91 | } 92 | 93 | func (m *SaveSliceInfoDef) GetFullShape() []int64 { 94 | if m != nil { 95 | return m.FullShape 96 | } 97 | return nil 98 | } 99 | 100 | func (m *SaveSliceInfoDef) GetVarOffset() []int64 { 101 | if m != nil { 102 | return m.VarOffset 103 | } 104 | return nil 105 | } 106 | 107 | func (m *SaveSliceInfoDef) GetVarShape() []int64 { 108 | if m != nil { 109 | return m.VarShape 110 | } 111 | return nil 112 | } 113 | 114 | func init() { 115 | proto.RegisterType((*VariableDef)(nil), "tensorflow.VariableDef") 116 | proto.RegisterType((*SaveSliceInfoDef)(nil), "tensorflow.SaveSliceInfoDef") 117 | } 118 | 119 | func init() { proto.RegisterFile("tensorflow/core/framework/variable.proto", fileDescriptor18) } 120 | 121 | var fileDescriptor18 = []byte{ 122 | // 313 bytes of a gzipped FileDescriptorProto 123 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x5c, 0x91, 0x4f, 0x4b, 0x33, 0x31, 124 | 0x10, 0xc6, 0xc9, 0xdb, 0xbe, 0xd2, 0x4e, 0xfd, 0x53, 0xd6, 0xcb, 0x82, 0x8a, 0x52, 0x2f, 0xf5, 125 | 0xd2, 0x05, 0xfd, 0x06, 0xc5, 0x8b, 0x08, 0x5a, 0xb6, 0xe0, 0x35, 0xa4, 0x75, 0x62, 0x83, 0x71, 126 | 0x53, 0x32, 0xdb, 0x16, 0xfc, 0x08, 0x7e, 0x5a, 0x8f, 0x1e, 0x9d, 0x64, 0xbb, 0x76, 0xe9, 0xf5, 127 | 0xf7, 0xfc, 0xf2, 0x30, 0x93, 0x81, 0x61, 0x89, 0x05, 0x39, 0xaf, 0xad, 0xdb, 0x64, 0x73, 0xe7, 128 | 0x31, 0xd3, 0x5e, 0x7d, 0xe0, 0xc6, 0xf9, 0xf7, 0x6c, 0xad, 0xbc, 0x51, 0x33, 0x8b, 0xa3, 0xa5, 129 | 0x77, 0xa5, 0x4b, 0x60, 0x67, 0x0e, 0xbe, 0x05, 0xf4, 0x5e, 0xb6, 0xf1, 0x3d, 0xea, 0xe4, 0x1a, 130 | 0x8e, 0x6a, 0x5b, 0x16, 0xfc, 0x3e, 0x15, 0x57, 0x62, 0xd8, 0xcd, 0x0f, 0x6b, 0xf8, 0xc4, 0x2c, 131 | 0xb9, 0x81, 0xbe, 0x29, 0x4c, 0x69, 0x94, 0x35, 0x9f, 0xe8, 0x2b, 0xef, 0x5f, 0xf4, 0x4e, 0x1a, 132 | 0x3c, 0xaa, 0xdc, 0x47, 0x85, 0x5a, 0xd2, 0xc2, 0x95, 0x95, 0xd7, 0xaa, 0xfa, 0x6a, 0x18, 0xa5, 133 | 0x47, 0x38, 0x25, 0xb5, 0x46, 0x49, 0xd6, 0xcc, 0x51, 0x9a, 0x42, 0x3b, 0xf9, 0x8a, 0x3a, 0x6d, 134 | 0xb3, 0xda, 0xbb, 0x3d, 0x1f, 0xed, 0xc6, 0x1d, 0x4d, 0x59, 0x9b, 0x06, 0xeb, 0x81, 0x25, 0x9e, 135 | 0x37, 0xef, 0xd3, 0x1e, 0x49, 0x2e, 0xa1, 0x67, 0x48, 0x7a, 0x24, 0xb7, 0xf2, 0x73, 0x4c, 0xff, 136 | 0x73, 0x49, 0x27, 0x07, 0x43, 0xf9, 0x96, 0x0c, 0xbe, 0x04, 0xf4, 0xf7, 0x7b, 0x92, 0x33, 0xe8, 137 | 0xea, 0x95, 0xb5, 0xcd, 0x9d, 0x3b, 0x01, 0xc4, 0xf9, 0x2e, 0x00, 0x62, 0x48, 0x0b, 0xb5, 0x0c, 138 | 0x9b, 0xb6, 0x86, 0xad, 0x3c, 0xea, 0xd3, 0x00, 0x42, 0xcc, 0xdf, 0x23, 0x9d, 0xd6, 0x84, 0x25, 139 | 0x2f, 0x18, 0x63, 0x26, 0xcf, 0x11, 0x84, 0xea, 0x10, 0x57, 0x8f, 0xdb, 0x31, 0xed, 0x30, 0x88, 140 | 0x6f, 0xc7, 0x19, 0xa4, 0xce, 0xbf, 0x35, 0x57, 0xfc, 0x3b, 0xdb, 0xf8, 0xb8, 0x3e, 0xcc, 0x24, 141 | 0x9c, 0x8d, 0x26, 0xe2, 0x47, 0x88, 0xd9, 0x41, 0xbc, 0xe1, 0xdd, 0x6f, 0x00, 0x00, 0x00, 0xff, 142 | 0xff, 0x29, 0x78, 0x7d, 0xd2, 0xef, 0x01, 0x00, 0x00, 143 | } 144 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/variable.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow; 4 | option cc_enable_arenas = true; 5 | option java_outer_classname = "VariableProtos"; 6 | option java_multiple_files = true; 7 | option java_package = "org.tensorflow.framework"; 8 | 9 | // Protocol buffer representing a Variable. 10 | message VariableDef { 11 | // Name of the variable tensor. 12 | string variable_name = 1; 13 | 14 | // Name of the initializer op. 15 | string initializer_name = 2; 16 | 17 | // Name of the snapshot tensor. 18 | string snapshot_name = 3; 19 | 20 | // Support for saving variables as slices of a larger variable. 21 | SaveSliceInfoDef save_slice_info_def = 4; 22 | 23 | // Whether to represent this as a ResourceVariable. 24 | bool is_resource = 5; 25 | } 26 | 27 | message SaveSliceInfoDef { 28 | // Name of the full variable of which this is a slice. 29 | string full_name = 1; 30 | // Shape of the full variable. 31 | repeated int64 full_shape = 2; 32 | // Offset of this variable into the full variable. 33 | repeated int64 var_offset = 3; 34 | // Shape of this variable. 35 | repeated int64 var_shape = 4; 36 | } 37 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/versions.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow/core/framework/versions.proto 3 | // DO NOT EDIT! 4 | 5 | package tensorflow 6 | 7 | import proto "github.com/golang/protobuf/proto" 8 | import fmt "fmt" 9 | import math "math" 10 | 11 | // Reference imports to suppress errors if they are not otherwise used. 12 | var _ = proto.Marshal 13 | var _ = fmt.Errorf 14 | var _ = math.Inf 15 | 16 | // Version information for a piece of serialized data 17 | // 18 | // There are different types of versions for each type of data 19 | // (GraphDef, etc.), but they all have the same common shape 20 | // described here. 21 | // 22 | // Each consumer has "consumer" and "min_producer" versions (specified 23 | // elsewhere). A consumer is allowed to consume this data if 24 | // 25 | // producer >= min_producer 26 | // consumer >= min_consumer 27 | // consumer not in bad_consumers 28 | // 29 | type VersionDef struct { 30 | // The version of the code that produced this data. 31 | Producer int32 `protobuf:"varint,1,opt,name=producer" json:"producer,omitempty"` 32 | // Any consumer below this version is not allowed to consume this data. 33 | MinConsumer int32 `protobuf:"varint,2,opt,name=min_consumer,json=minConsumer" json:"min_consumer,omitempty"` 34 | // Specific consumer versions which are disallowed (e.g. due to bugs). 35 | BadConsumers []int32 `protobuf:"varint,3,rep,packed,name=bad_consumers,json=badConsumers" json:"bad_consumers,omitempty"` 36 | } 37 | 38 | func (m *VersionDef) Reset() { *m = VersionDef{} } 39 | func (m *VersionDef) String() string { return proto.CompactTextString(m) } 40 | func (*VersionDef) ProtoMessage() {} 41 | func (*VersionDef) Descriptor() ([]byte, []int) { return fileDescriptor19, []int{0} } 42 | 43 | func (m *VersionDef) GetProducer() int32 { 44 | if m != nil { 45 | return m.Producer 46 | } 47 | return 0 48 | } 49 | 50 | func (m *VersionDef) GetMinConsumer() int32 { 51 | if m != nil { 52 | return m.MinConsumer 53 | } 54 | return 0 55 | } 56 | 57 | func (m *VersionDef) GetBadConsumers() []int32 { 58 | if m != nil { 59 | return m.BadConsumers 60 | } 61 | return nil 62 | } 63 | 64 | func init() { 65 | proto.RegisterType((*VersionDef)(nil), "tensorflow.VersionDef") 66 | } 67 | 68 | func init() { proto.RegisterFile("tensorflow/core/framework/versions.proto", fileDescriptor19) } 69 | 70 | var fileDescriptor19 = []byte{ 71 | // 178 bytes of a gzipped FileDescriptorProto 72 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x44, 0x8e, 0x3d, 0x0e, 0x82, 0x40, 73 | 0x10, 0x46, 0xb3, 0x12, 0x8d, 0x19, 0xd1, 0x62, 0x2b, 0x62, 0x85, 0xda, 0x50, 0xb1, 0x85, 0x37, 74 | 0x40, 0x0f, 0x40, 0x2c, 0x6c, 0x0d, 0x3f, 0x8b, 0x21, 0x0a, 0x43, 0x66, 0x40, 0xae, 0x6e, 0xe9, 75 | 0x8a, 0xb8, 0x94, 0xf3, 0xbd, 0x97, 0xc9, 0x83, 0xa0, 0xd5, 0x35, 0x23, 0x15, 0x4f, 0xec, 0x55, 76 | 0x86, 0xa4, 0x55, 0x41, 0x49, 0xa5, 0x7b, 0xa4, 0x87, 0x7a, 0x69, 0xe2, 0x12, 0x6b, 0x0e, 0x1b, 77 | 0xc2, 0x16, 0x25, 0x4c, 0xe6, 0xbe, 0x01, 0xb8, 0xfe, 0xe8, 0x59, 0x17, 0x72, 0x0b, 0x4b, 0xa3, 78 | 0xe4, 0x5d, 0xa6, 0xc9, 0x13, 0xbe, 0x08, 0xe6, 0x17, 0x7b, 0xcb, 0x1d, 0xb8, 0x55, 0x59, 0xdf, 79 | 0x32, 0xf3, 0xa7, 0xab, 0x0c, 0x9f, 0x0d, 0x7c, 0x65, 0xb6, 0xd3, 0x38, 0xc9, 0x03, 0xac, 0xd3, 80 | 0x24, 0xb7, 0x0a, 0x7b, 0x8e, 0xef, 0x18, 0xc7, 0x35, 0xe3, 0xdf, 0xe1, 0x48, 0x81, 0x87, 0x74, 81 | 0x0f, 0xa7, 0x86, 0xd0, 0x86, 0x46, 0x9b, 0xb1, 0x85, 0xe3, 0x6f, 0x28, 0xc7, 0xe2, 0x2d, 0x44, 82 | 0xba, 0x18, 0xaa, 0x8f, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa2, 0xca, 0xc7, 0x87, 0xe1, 0x00, 83 | 0x00, 0x00, 84 | } 85 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/framework/versions.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow; 4 | option cc_enable_arenas = true; 5 | option java_outer_classname = "VersionsProtos"; 6 | option java_multiple_files = true; 7 | option java_package = "org.tensorflow.framework"; 8 | 9 | // Version information for a piece of serialized data 10 | // 11 | // There are different types of versions for each type of data 12 | // (GraphDef, etc.), but they all have the same common shape 13 | // described here. 14 | // 15 | // Each consumer has "consumer" and "min_producer" versions (specified 16 | // elsewhere). A consumer is allowed to consume this data if 17 | // 18 | // producer >= min_producer 19 | // consumer >= min_consumer 20 | // consumer not in bad_consumers 21 | // 22 | message VersionDef { 23 | // The version of the code that produced this data. 24 | int32 producer = 1; 25 | 26 | // Any consumer below this version is not allowed to consume this data. 27 | int32 min_consumer = 2; 28 | 29 | // Specific consumer versions which are disallowed (e.g. due to bugs). 30 | repeated int32 bad_consumers = 3; 31 | }; 32 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/protobuf/saver.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow/core/protobuf/saver.proto 3 | // DO NOT EDIT! 4 | 5 | package tensorflow 6 | 7 | import proto "github.com/golang/protobuf/proto" 8 | import fmt "fmt" 9 | import math "math" 10 | 11 | // Reference imports to suppress errors if they are not otherwise used. 12 | var _ = proto.Marshal 13 | var _ = fmt.Errorf 14 | var _ = math.Inf 15 | 16 | // A version number that identifies a different on-disk checkpoint format. 17 | // Usually, each subclass of BaseSaverBuilder works with a particular 18 | // version/format. However, it is possible that the same builder may be 19 | // upgraded to support a newer checkpoint format in the future. 20 | type SaverDef_CheckpointFormatVersion int32 21 | 22 | const ( 23 | // Internal legacy format. 24 | SaverDef_LEGACY SaverDef_CheckpointFormatVersion = 0 25 | // Current format: tf.Saver() which works with tensorflow::table::Table. 26 | SaverDef_V1 SaverDef_CheckpointFormatVersion = 1 27 | // Experimental format under development. 28 | SaverDef_V2 SaverDef_CheckpointFormatVersion = 2 29 | ) 30 | 31 | var SaverDef_CheckpointFormatVersion_name = map[int32]string{ 32 | 0: "LEGACY", 33 | 1: "V1", 34 | 2: "V2", 35 | } 36 | var SaverDef_CheckpointFormatVersion_value = map[string]int32{ 37 | "LEGACY": 0, 38 | "V1": 1, 39 | "V2": 2, 40 | } 41 | 42 | func (x SaverDef_CheckpointFormatVersion) String() string { 43 | return proto.EnumName(SaverDef_CheckpointFormatVersion_name, int32(x)) 44 | } 45 | func (SaverDef_CheckpointFormatVersion) EnumDescriptor() ([]byte, []int) { 46 | return fileDescriptor1, []int{0, 0} 47 | } 48 | 49 | // Protocol buffer representing the configuration of a Saver. 50 | type SaverDef struct { 51 | // The name of the tensor in which to specify the filename when saving or 52 | // restoring a model checkpoint. 53 | FilenameTensorName string `protobuf:"bytes,1,opt,name=filename_tensor_name,json=filenameTensorName" json:"filename_tensor_name,omitempty"` 54 | // The operation to run when saving a model checkpoint. 55 | SaveTensorName string `protobuf:"bytes,2,opt,name=save_tensor_name,json=saveTensorName" json:"save_tensor_name,omitempty"` 56 | // The operation to run when restoring a model checkpoint. 57 | RestoreOpName string `protobuf:"bytes,3,opt,name=restore_op_name,json=restoreOpName" json:"restore_op_name,omitempty"` 58 | // Maximum number of checkpoints to keep. If 0, no checkpoints are deleted. 59 | MaxToKeep int32 `protobuf:"varint,4,opt,name=max_to_keep,json=maxToKeep" json:"max_to_keep,omitempty"` 60 | // Shard the save files, one per device that has Variable nodes. 61 | Sharded bool `protobuf:"varint,5,opt,name=sharded" json:"sharded,omitempty"` 62 | // How often to keep an additional checkpoint. If not specified, only the last 63 | // "max_to_keep" checkpoints are kept; if specified, in addition to keeping 64 | // the last "max_to_keep" checkpoints, an additional checkpoint will be kept 65 | // for every n hours of training. 66 | KeepCheckpointEveryNHours float32 `protobuf:"fixed32,6,opt,name=keep_checkpoint_every_n_hours,json=keepCheckpointEveryNHours" json:"keep_checkpoint_every_n_hours,omitempty"` 67 | Version SaverDef_CheckpointFormatVersion `protobuf:"varint,7,opt,name=version,enum=tensorflow.SaverDef_CheckpointFormatVersion" json:"version,omitempty"` 68 | } 69 | 70 | func (m *SaverDef) Reset() { *m = SaverDef{} } 71 | func (m *SaverDef) String() string { return proto.CompactTextString(m) } 72 | func (*SaverDef) ProtoMessage() {} 73 | func (*SaverDef) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} } 74 | 75 | func (m *SaverDef) GetFilenameTensorName() string { 76 | if m != nil { 77 | return m.FilenameTensorName 78 | } 79 | return "" 80 | } 81 | 82 | func (m *SaverDef) GetSaveTensorName() string { 83 | if m != nil { 84 | return m.SaveTensorName 85 | } 86 | return "" 87 | } 88 | 89 | func (m *SaverDef) GetRestoreOpName() string { 90 | if m != nil { 91 | return m.RestoreOpName 92 | } 93 | return "" 94 | } 95 | 96 | func (m *SaverDef) GetMaxToKeep() int32 { 97 | if m != nil { 98 | return m.MaxToKeep 99 | } 100 | return 0 101 | } 102 | 103 | func (m *SaverDef) GetSharded() bool { 104 | if m != nil { 105 | return m.Sharded 106 | } 107 | return false 108 | } 109 | 110 | func (m *SaverDef) GetKeepCheckpointEveryNHours() float32 { 111 | if m != nil { 112 | return m.KeepCheckpointEveryNHours 113 | } 114 | return 0 115 | } 116 | 117 | func (m *SaverDef) GetVersion() SaverDef_CheckpointFormatVersion { 118 | if m != nil { 119 | return m.Version 120 | } 121 | return SaverDef_LEGACY 122 | } 123 | 124 | func init() { 125 | proto.RegisterType((*SaverDef)(nil), "tensorflow.SaverDef") 126 | proto.RegisterEnum("tensorflow.SaverDef_CheckpointFormatVersion", SaverDef_CheckpointFormatVersion_name, SaverDef_CheckpointFormatVersion_value) 127 | } 128 | 129 | func init() { proto.RegisterFile("tensorflow/core/protobuf/saver.proto", fileDescriptor1) } 130 | 131 | var fileDescriptor1 = []byte{ 132 | // 334 bytes of a gzipped FileDescriptorProto 133 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x74, 0xd1, 0x5d, 0x4f, 0xf2, 0x30, 134 | 0x14, 0x07, 0xf0, 0x67, 0xe3, 0x61, 0xc0, 0x21, 0xe2, 0x52, 0x4d, 0x9c, 0x17, 0x1a, 0x43, 0x8c, 135 | 0x72, 0x61, 0x86, 0x62, 0xbc, 0x57, 0x10, 0x34, 0xd1, 0x20, 0x99, 0x84, 0xc4, 0xab, 0x66, 0x40, 136 | 0x27, 0x0b, 0xb0, 0xb3, 0xb4, 0xc5, 0x97, 0x8f, 0xe0, 0x37, 0xf6, 0xd2, 0xb6, 0x38, 0xc1, 0x0b, 137 | 0xaf, 0xd6, 0x73, 0xce, 0xef, 0xbf, 0x6e, 0x2d, 0x1c, 0x4a, 0x96, 0x08, 0xe4, 0xd1, 0x0c, 0x5f, 138 | 0xeb, 0x23, 0xe4, 0xac, 0x9e, 0x72, 0x94, 0x38, 0x5c, 0x44, 0x75, 0x11, 0xbe, 0x30, 0xee, 0x9b, 139 | 0x92, 0xc0, 0x4a, 0x55, 0x3f, 0x72, 0x50, 0x7c, 0xd4, 0xb3, 0x6b, 0x16, 0x91, 0x53, 0xd8, 0x8e, 140 | 0xe2, 0x19, 0x4b, 0xc2, 0x39, 0xa3, 0x4b, 0x43, 0xf5, 0xda, 0xb3, 0x0e, 0xac, 0x5a, 0x29, 0x20, 141 | 0xd9, 0xac, 0x6f, 0x46, 0x5d, 0xb5, 0x22, 0x35, 0x70, 0xf5, 0x9b, 0x7f, 0x69, 0xdb, 0xe8, 0x8a, 142 | 0xee, 0xaf, 0xc9, 0x23, 0xd8, 0xe4, 0x4c, 0x48, 0xf5, 0x51, 0x14, 0xd3, 0x25, 0xcc, 0x19, 0xb8, 143 | 0xf1, 0xdd, 0x7e, 0x48, 0x8d, 0xdb, 0x87, 0xf2, 0x3c, 0x7c, 0xa3, 0x12, 0xe9, 0x94, 0xb1, 0xd4, 144 | 0xfb, 0xaf, 0x4c, 0x3e, 0x28, 0xa9, 0x56, 0x1f, 0xef, 0x54, 0x83, 0x78, 0x50, 0x10, 0x93, 0x90, 145 | 0x8f, 0xd9, 0xd8, 0xcb, 0xab, 0x59, 0x31, 0xc8, 0x4a, 0x72, 0x09, 0x7b, 0x3a, 0x42, 0x47, 0x13, 146 | 0x36, 0x9a, 0xa6, 0x18, 0x27, 0x92, 0x32, 0xf5, 0x63, 0xef, 0x34, 0xa1, 0x13, 0x5c, 0x70, 0xe1, 147 | 0x39, 0xca, 0xdb, 0xc1, 0xae, 0x46, 0xad, 0x1f, 0xd3, 0xd6, 0xa4, 0x7b, 0xab, 0x01, 0xe9, 0x40, 148 | 0x41, 0x55, 0x22, 0xc6, 0xc4, 0x2b, 0x28, 0x5b, 0x69, 0x9c, 0xf8, 0xab, 0xa3, 0xf2, 0xb3, 0x63, 149 | 0xf2, 0x57, 0xe1, 0x0e, 0xf2, 0x79, 0x28, 0x07, 0xcb, 0x4c, 0x90, 0x85, 0xab, 0x17, 0xb0, 0xf3, 150 | 0x87, 0x21, 0x00, 0xce, 0x7d, 0xfb, 0xe6, 0xaa, 0xf5, 0xe4, 0xfe, 0x23, 0x0e, 0xd8, 0x83, 0x33, 151 | 0xd7, 0x32, 0xcf, 0x86, 0x6b, 0x37, 0x8f, 0x61, 0x0b, 0xf9, 0xf3, 0xfa, 0x96, 0x0b, 0x19, 0xcf, 152 | 0x9a, 0x65, 0xb3, 0x71, 0x4f, 0x5f, 0x9d, 0xe8, 0x59, 0x9f, 0x96, 0x35, 0x74, 0xcc, 0x3d, 0x9e, 153 | 0x7f, 0x05, 0x00, 0x00, 0xff, 0xff, 0xe0, 0xa1, 0x8e, 0x12, 0xef, 0x01, 0x00, 0x00, 154 | } 155 | -------------------------------------------------------------------------------- /vendor/tensorflow/core/protobuf/saver.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow; 4 | option cc_enable_arenas = true; 5 | option java_outer_classname = "SaverProtos"; 6 | option java_multiple_files = true; 7 | option java_package = "org.tensorflow.util"; 8 | 9 | // Protocol buffer representing the configuration of a Saver. 10 | message SaverDef { 11 | // The name of the tensor in which to specify the filename when saving or 12 | // restoring a model checkpoint. 13 | string filename_tensor_name = 1; 14 | 15 | // The operation to run when saving a model checkpoint. 16 | string save_tensor_name = 2; 17 | 18 | // The operation to run when restoring a model checkpoint. 19 | string restore_op_name = 3; 20 | 21 | // Maximum number of checkpoints to keep. If 0, no checkpoints are deleted. 22 | int32 max_to_keep = 4; 23 | 24 | // Shard the save files, one per device that has Variable nodes. 25 | bool sharded = 5; 26 | 27 | // How often to keep an additional checkpoint. If not specified, only the last 28 | // "max_to_keep" checkpoints are kept; if specified, in addition to keeping 29 | // the last "max_to_keep" checkpoints, an additional checkpoint will be kept 30 | // for every n hours of training. 31 | float keep_checkpoint_every_n_hours = 6; 32 | 33 | // A version number that identifies a different on-disk checkpoint format. 34 | // Usually, each subclass of BaseSaverBuilder works with a particular 35 | // version/format. However, it is possible that the same builder may be 36 | // upgraded to support a newer checkpoint format in the future. 37 | enum CheckpointFormatVersion { 38 | // Internal legacy format. 39 | LEGACY = 0; 40 | // Current format: tf.Saver() which works with tensorflow::table::Table. 41 | V1 = 1; 42 | // Experimental format under development. 43 | V2 = 2; 44 | } 45 | CheckpointFormatVersion version = 7; 46 | } 47 | -------------------------------------------------------------------------------- /vendor/tensorflow_serving/apis/classification.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow_serving/apis/classification.proto 3 | // DO NOT EDIT! 4 | 5 | /* 6 | Package tensorflow_serving is a generated protocol buffer package. 7 | 8 | It is generated from these files: 9 | tensorflow_serving/apis/classification.proto 10 | tensorflow_serving/apis/get_model_metadata.proto 11 | tensorflow_serving/apis/input.proto 12 | tensorflow_serving/apis/model.proto 13 | tensorflow_serving/apis/prediction_service.proto 14 | tensorflow_serving/apis/predict.proto 15 | tensorflow_serving/apis/regression.proto 16 | 17 | It has these top-level messages: 18 | Class 19 | Classifications 20 | ClassificationResult 21 | ClassificationRequest 22 | ClassificationResponse 23 | SignatureDefMap 24 | GetModelMetadataRequest 25 | GetModelMetadataResponse 26 | ExampleList 27 | ExampleListWithContext 28 | Input 29 | ModelSpec 30 | PredictRequest 31 | PredictResponse 32 | Regression 33 | RegressionResult 34 | RegressionRequest 35 | RegressionResponse 36 | */ 37 | package tensorflow_serving 38 | 39 | import proto "github.com/golang/protobuf/proto" 40 | import fmt "fmt" 41 | import math "math" 42 | 43 | // Reference imports to suppress errors if they are not otherwise used. 44 | var _ = proto.Marshal 45 | var _ = fmt.Errorf 46 | var _ = math.Inf 47 | 48 | // This is a compile-time assertion to ensure that this generated file 49 | // is compatible with the proto package it is being compiled against. 50 | // A compilation error at this line likely means your copy of the 51 | // proto package needs to be updated. 52 | const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package 53 | 54 | // A single class. 55 | type Class struct { 56 | // Label or name of the class. 57 | Label string `protobuf:"bytes,1,opt,name=label" json:"label,omitempty"` 58 | // Score for this class (e.g., the probability the item belongs to this 59 | // class). 60 | Score float32 `protobuf:"fixed32,2,opt,name=score" json:"score,omitempty"` 61 | } 62 | 63 | func (m *Class) Reset() { *m = Class{} } 64 | func (m *Class) String() string { return proto.CompactTextString(m) } 65 | func (*Class) ProtoMessage() {} 66 | func (*Class) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } 67 | 68 | func (m *Class) GetLabel() string { 69 | if m != nil { 70 | return m.Label 71 | } 72 | return "" 73 | } 74 | 75 | func (m *Class) GetScore() float32 { 76 | if m != nil { 77 | return m.Score 78 | } 79 | return 0 80 | } 81 | 82 | // List of classes for a single item 83 | // (tensorflow.Example or tensorflow.InferenceExample.features). 84 | type Classifications struct { 85 | // List of Classifications for an item sorted by decreasing score. 86 | Classes []*Class `protobuf:"bytes,1,rep,name=classes" json:"classes,omitempty"` 87 | } 88 | 89 | func (m *Classifications) Reset() { *m = Classifications{} } 90 | func (m *Classifications) String() string { return proto.CompactTextString(m) } 91 | func (*Classifications) ProtoMessage() {} 92 | func (*Classifications) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } 93 | 94 | func (m *Classifications) GetClasses() []*Class { 95 | if m != nil { 96 | return m.Classes 97 | } 98 | return nil 99 | } 100 | 101 | // For tensorflow.Example this will contain one result. 102 | // For tensorflow.InferenceExample this will contain one result for each 103 | // InferenceExample::features and in the same order as the features. 104 | type ClassificationResult struct { 105 | Classifications []*Classifications `protobuf:"bytes,1,rep,name=classifications" json:"classifications,omitempty"` 106 | } 107 | 108 | func (m *ClassificationResult) Reset() { *m = ClassificationResult{} } 109 | func (m *ClassificationResult) String() string { return proto.CompactTextString(m) } 110 | func (*ClassificationResult) ProtoMessage() {} 111 | func (*ClassificationResult) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } 112 | 113 | func (m *ClassificationResult) GetClassifications() []*Classifications { 114 | if m != nil { 115 | return m.Classifications 116 | } 117 | return nil 118 | } 119 | 120 | type ClassificationRequest struct { 121 | // Model Specification. 122 | ModelSpec *ModelSpec `protobuf:"bytes,1,opt,name=model_spec,json=modelSpec" json:"model_spec,omitempty"` 123 | // Input data. 124 | Input *Input `protobuf:"bytes,2,opt,name=input" json:"input,omitempty"` 125 | } 126 | 127 | func (m *ClassificationRequest) Reset() { *m = ClassificationRequest{} } 128 | func (m *ClassificationRequest) String() string { return proto.CompactTextString(m) } 129 | func (*ClassificationRequest) ProtoMessage() {} 130 | func (*ClassificationRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } 131 | 132 | func (m *ClassificationRequest) GetModelSpec() *ModelSpec { 133 | if m != nil { 134 | return m.ModelSpec 135 | } 136 | return nil 137 | } 138 | 139 | func (m *ClassificationRequest) GetInput() *Input { 140 | if m != nil { 141 | return m.Input 142 | } 143 | return nil 144 | } 145 | 146 | type ClassificationResponse struct { 147 | // Result of the classification. 148 | Result *ClassificationResult `protobuf:"bytes,1,opt,name=result" json:"result,omitempty"` 149 | } 150 | 151 | func (m *ClassificationResponse) Reset() { *m = ClassificationResponse{} } 152 | func (m *ClassificationResponse) String() string { return proto.CompactTextString(m) } 153 | func (*ClassificationResponse) ProtoMessage() {} 154 | func (*ClassificationResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} } 155 | 156 | func (m *ClassificationResponse) GetResult() *ClassificationResult { 157 | if m != nil { 158 | return m.Result 159 | } 160 | return nil 161 | } 162 | 163 | func init() { 164 | proto.RegisterType((*Class)(nil), "tensorflow.serving.Class") 165 | proto.RegisterType((*Classifications)(nil), "tensorflow.serving.Classifications") 166 | proto.RegisterType((*ClassificationResult)(nil), "tensorflow.serving.ClassificationResult") 167 | proto.RegisterType((*ClassificationRequest)(nil), "tensorflow.serving.ClassificationRequest") 168 | proto.RegisterType((*ClassificationResponse)(nil), "tensorflow.serving.ClassificationResponse") 169 | } 170 | 171 | func init() { proto.RegisterFile("tensorflow_serving/apis/classification.proto", fileDescriptor0) } 172 | 173 | var fileDescriptor0 = []byte{ 174 | // 292 bytes of a gzipped FileDescriptorProto 175 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x91, 0x41, 0x4b, 0xc3, 0x40, 176 | 0x10, 0x85, 0x49, 0x4b, 0x2a, 0x9d, 0x1e, 0x0a, 0x4b, 0x95, 0x2a, 0x08, 0x92, 0x5e, 0x72, 0x90, 177 | 0x04, 0x9a, 0xab, 0x07, 0xb1, 0x20, 0x78, 0xe8, 0x65, 0xbd, 0x79, 0x29, 0x69, 0x9c, 0xca, 0xc2, 178 | 0x36, 0x1b, 0x77, 0x36, 0xfa, 0x0f, 0xfc, 0xcd, 0x1e, 0x4d, 0x76, 0x13, 0x4a, 0x5a, 0x43, 0x6f, 179 | 0xd9, 0xe1, 0x9b, 0x37, 0xef, 0xbd, 0xc0, 0xbd, 0xc1, 0x9c, 0x94, 0xde, 0x49, 0xf5, 0xbd, 0x21, 180 | 0xd4, 0x5f, 0x22, 0xff, 0x88, 0xd3, 0x42, 0x50, 0x9c, 0xc9, 0x94, 0x48, 0xec, 0x44, 0x96, 0x1a, 181 | 0xa1, 0xf2, 0xa8, 0xd0, 0xca, 0x28, 0xc6, 0x0e, 0x74, 0xd4, 0xd0, 0x37, 0x8b, 0x3e, 0x05, 0x91, 182 | 0x17, 0xa5, 0x71, 0x8b, 0xfd, 0xd0, 0x5e, 0xbd, 0xa3, 0x74, 0x50, 0x90, 0x80, 0xbf, 0xaa, 0xaf, 183 | 0xb2, 0x19, 0xf8, 0x32, 0xdd, 0xa2, 0x9c, 0x7b, 0x77, 0x5e, 0x38, 0xe6, 0xee, 0x51, 0x4f, 0x29, 184 | 0x53, 0x1a, 0xe7, 0x83, 0x6a, 0x3a, 0xe0, 0xee, 0x11, 0x3c, 0xc3, 0x74, 0xd5, 0xb1, 0x4a, 0x2c, 185 | 0x81, 0x0b, 0xeb, 0x1e, 0xa9, 0x12, 0x18, 0x86, 0x93, 0xe5, 0x75, 0x74, 0xea, 0x3b, 0xb2, 0x5b, 186 | 0xbc, 0x25, 0x03, 0x84, 0x59, 0x57, 0x87, 0x23, 0x95, 0xd2, 0xb0, 0x35, 0x4c, 0xbb, 0x55, 0xb4, 187 | 0xa2, 0x8b, 0x5e, 0xd1, 0x03, 0xca, 0x8f, 0x77, 0x83, 0x1f, 0x0f, 0x2e, 0x8f, 0xef, 0x7c, 0x96, 188 | 0x48, 0x86, 0x3d, 0x00, 0xd8, 0x32, 0x36, 0x54, 0x60, 0x66, 0x93, 0x4f, 0x96, 0xb7, 0xff, 0xdd, 189 | 0x58, 0xd7, 0xd4, 0x6b, 0x05, 0xf1, 0xf1, 0xbe, 0xfd, 0x64, 0x31, 0xf8, 0xb6, 0x6f, 0x5b, 0x4e, 190 | 0x4f, 0xe2, 0x97, 0x1a, 0xe0, 0x8e, 0x0b, 0xde, 0xe0, 0xea, 0x24, 0x6f, 0x51, 0x39, 0x44, 0xf6, 191 | 0x08, 0x23, 0x6d, 0xb3, 0x37, 0x26, 0xc2, 0xf3, 0x41, 0x5d, 0x57, 0xbc, 0xd9, 0x7b, 0x1a, 0xfe, 192 | 0x7a, 0xde, 0x76, 0x64, 0x7f, 0x6a, 0xf2, 0x17, 0x00, 0x00, 0xff, 0xff, 0xc8, 0x91, 0xd1, 0xa7, 193 | 0x62, 0x02, 0x00, 0x00, 194 | } 195 | -------------------------------------------------------------------------------- /vendor/tensorflow_serving/apis/classification.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | option cc_enable_arenas = true; 4 | 5 | import "tensorflow_serving/apis/input.proto"; 6 | import "tensorflow_serving/apis/model.proto"; 7 | 8 | package tensorflow.serving; 9 | 10 | // A single class. 11 | message Class { 12 | // Label or name of the class. 13 | string label = 1; 14 | // Score for this class (e.g., the probability the item belongs to this 15 | // class). 16 | float score = 2; 17 | } 18 | 19 | // List of classes for a single item 20 | // (tensorflow.Example or tensorflow.InferenceExample.features). 21 | message Classifications { 22 | // List of Classifications for an item sorted by decreasing score. 23 | repeated Class classes = 1; 24 | } 25 | 26 | // For tensorflow.Example this will contain one result. 27 | // For tensorflow.InferenceExample this will contain one result for each 28 | // InferenceExample::features and in the same order as the features. 29 | message ClassificationResult { 30 | repeated Classifications classifications = 1; 31 | } 32 | 33 | // RPC Interfaces 34 | 35 | message ClassificationRequest { 36 | // Model Specification. 37 | ModelSpec model_spec = 1; 38 | 39 | // Input data. 40 | tensorflow.serving.Input input = 2; 41 | } 42 | 43 | message ClassificationResponse { 44 | // Result of the classification. 45 | ClassificationResult result = 1; 46 | } 47 | -------------------------------------------------------------------------------- /vendor/tensorflow_serving/apis/get_model_metadata.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow_serving/apis/get_model_metadata.proto 3 | // DO NOT EDIT! 4 | 5 | package tensorflow_serving 6 | 7 | import proto "github.com/golang/protobuf/proto" 8 | import fmt "fmt" 9 | import math "math" 10 | import google_protobuf1 "github.com/golang/protobuf/ptypes/any" 11 | import tensorflow13 "tensorflow/core/protobuf" 12 | 13 | // Reference imports to suppress errors if they are not otherwise used. 14 | var _ = proto.Marshal 15 | var _ = fmt.Errorf 16 | var _ = math.Inf 17 | 18 | // Message returned for "signature_def" field. 19 | type SignatureDefMap struct { 20 | SignatureDef map[string]*tensorflow13.SignatureDef `protobuf:"bytes,1,rep,name=signature_def,json=signatureDef" json:"signature_def,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` 21 | } 22 | 23 | func (m *SignatureDefMap) Reset() { *m = SignatureDefMap{} } 24 | func (m *SignatureDefMap) String() string { return proto.CompactTextString(m) } 25 | func (*SignatureDefMap) ProtoMessage() {} 26 | func (*SignatureDefMap) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} } 27 | 28 | func (m *SignatureDefMap) GetSignatureDef() map[string]*tensorflow13.SignatureDef { 29 | if m != nil { 30 | return m.SignatureDef 31 | } 32 | return nil 33 | } 34 | 35 | type GetModelMetadataRequest struct { 36 | // Model Specification indicating which model we are querying for metadata. 37 | ModelSpec *ModelSpec `protobuf:"bytes,1,opt,name=model_spec,json=modelSpec" json:"model_spec,omitempty"` 38 | // Metadata fields to get. Currently supported: "signature_def". 39 | MetadataField []string `protobuf:"bytes,2,rep,name=metadata_field,json=metadataField" json:"metadata_field,omitempty"` 40 | } 41 | 42 | func (m *GetModelMetadataRequest) Reset() { *m = GetModelMetadataRequest{} } 43 | func (m *GetModelMetadataRequest) String() string { return proto.CompactTextString(m) } 44 | func (*GetModelMetadataRequest) ProtoMessage() {} 45 | func (*GetModelMetadataRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} } 46 | 47 | func (m *GetModelMetadataRequest) GetModelSpec() *ModelSpec { 48 | if m != nil { 49 | return m.ModelSpec 50 | } 51 | return nil 52 | } 53 | 54 | func (m *GetModelMetadataRequest) GetMetadataField() []string { 55 | if m != nil { 56 | return m.MetadataField 57 | } 58 | return nil 59 | } 60 | 61 | type GetModelMetadataResponse struct { 62 | // Model Specification indicating which model this metadata belongs to. 63 | ModelSpec *ModelSpec `protobuf:"bytes,1,opt,name=model_spec,json=modelSpec" json:"model_spec,omitempty"` 64 | // Map of metadata field name to metadata field. The options for metadata 65 | // field name are listed in GetModelMetadataRequest. Currently supported: 66 | // "signature_def". 67 | Metadata map[string]*google_protobuf1.Any `protobuf:"bytes,2,rep,name=metadata" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` 68 | } 69 | 70 | func (m *GetModelMetadataResponse) Reset() { *m = GetModelMetadataResponse{} } 71 | func (m *GetModelMetadataResponse) String() string { return proto.CompactTextString(m) } 72 | func (*GetModelMetadataResponse) ProtoMessage() {} 73 | func (*GetModelMetadataResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{2} } 74 | 75 | func (m *GetModelMetadataResponse) GetModelSpec() *ModelSpec { 76 | if m != nil { 77 | return m.ModelSpec 78 | } 79 | return nil 80 | } 81 | 82 | func (m *GetModelMetadataResponse) GetMetadata() map[string]*google_protobuf1.Any { 83 | if m != nil { 84 | return m.Metadata 85 | } 86 | return nil 87 | } 88 | 89 | func init() { 90 | proto.RegisterType((*SignatureDefMap)(nil), "tensorflow.serving.SignatureDefMap") 91 | proto.RegisterType((*GetModelMetadataRequest)(nil), "tensorflow.serving.GetModelMetadataRequest") 92 | proto.RegisterType((*GetModelMetadataResponse)(nil), "tensorflow.serving.GetModelMetadataResponse") 93 | } 94 | 95 | func init() { proto.RegisterFile("tensorflow_serving/apis/get_model_metadata.proto", fileDescriptor1) } 96 | 97 | var fileDescriptor1 = []byte{ 98 | // 371 bytes of a gzipped FileDescriptorProto 99 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xa4, 0x52, 0xcd, 0x4b, 0xc3, 0x30, 100 | 0x1c, 0xa5, 0x2b, 0x8a, 0x4b, 0x9d, 0x1f, 0x45, 0xb0, 0x16, 0x04, 0x99, 0x08, 0xd3, 0x43, 0x2a, 101 | 0x15, 0x41, 0x86, 0x17, 0xc5, 0x8f, 0xd3, 0x0e, 0x76, 0x20, 0xe8, 0xa5, 0x64, 0xeb, 0xaf, 0xb5, 102 | 0xd8, 0x35, 0x35, 0x49, 0x27, 0xbd, 0x78, 0xf1, 0x9f, 0xf3, 0x4f, 0xf2, 0x68, 0x3f, 0x16, 0xd7, 103 | 0xb9, 0xed, 0xe4, 0x2d, 0x79, 0x79, 0x2f, 0xef, 0x25, 0xef, 0x87, 0x4e, 0x05, 0xc4, 0x9c, 0x32, 104 | 0x3f, 0xa2, 0xef, 0x2e, 0x07, 0x36, 0x0e, 0xe3, 0xc0, 0x22, 0x49, 0xc8, 0xad, 0x00, 0x84, 0x3b, 105 | 0xa2, 0x1e, 0x44, 0xee, 0x08, 0x04, 0xf1, 0x88, 0x20, 0x38, 0x61, 0x54, 0x50, 0x5d, 0x9f, 0x2a, 106 | 0xf0, 0x44, 0x61, 0xee, 0x05, 0x94, 0x06, 0x11, 0x58, 0x25, 0x63, 0x90, 0xfa, 0x16, 0x89, 0xb3, 107 | 0x8a, 0x6e, 0x1e, 0x4f, 0xe9, 0xd6, 0x90, 0xb2, 0x1a, 0xa7, 0xb8, 0xd7, 0x0d, 0x18, 0x49, 0x5e, 108 | 0x26, 0xd4, 0xc3, 0x65, 0x59, 0xca, 0x1c, 0x15, 0xa9, 0xfd, 0xa5, 0xa0, 0xcd, 0x7e, 0x18, 0xc4, 109 | 0x44, 0xa4, 0x0c, 0x6e, 0xc0, 0xef, 0x91, 0x44, 0x7f, 0x46, 0x2d, 0x2e, 0x21, 0xd7, 0x03, 0xdf, 110 | 0x50, 0x0e, 0xd4, 0x8e, 0x66, 0x9f, 0xe3, 0xf9, 0xa8, 0xf8, 0x8f, 0x76, 0x66, 0x7f, 0x1b, 0x0b, 111 | 0x96, 0x39, 0xeb, 0xbc, 0x06, 0x99, 0x4f, 0x68, 0x7b, 0x8e, 0xa2, 0x6f, 0x21, 0xf5, 0x15, 0xb2, 112 | 0xdc, 0x46, 0xe9, 0x34, 0x9d, 0x62, 0xa9, 0x63, 0xb4, 0x32, 0x26, 0x51, 0x0a, 0x46, 0x23, 0xc7, 113 | 0x34, 0xdb, 0xa8, 0x5b, 0xd7, 0xf5, 0x4e, 0x45, 0xeb, 0x36, 0x2e, 0x94, 0xf6, 0x07, 0xda, 0xbd, 114 | 0x07, 0xd1, 0x2b, 0x1e, 0xd7, 0x9b, 0xfc, 0xb1, 0x03, 0x6f, 0x29, 0x70, 0xa1, 0x5f, 0x22, 0x54, 115 | 0x7d, 0x3e, 0x4f, 0x60, 0x58, 0xfa, 0x68, 0xf6, 0xfe, 0xa2, 0xe7, 0x94, 0xea, 0x7e, 0x4e, 0x72, 116 | 0x9a, 0x23, 0xb9, 0xd4, 0x8f, 0xd0, 0x86, 0x2c, 0xcd, 0xf5, 0x43, 0x88, 0xbc, 0x3c, 0x95, 0x9a, 117 | 0x27, 0x6d, 0x49, 0xf4, 0xae, 0x00, 0xdb, 0x9f, 0x0d, 0x64, 0xcc, 0x07, 0xe0, 0x09, 0x8d, 0x39, 118 | 0xfc, 0x33, 0xc1, 0x23, 0x5a, 0x93, 0x5e, 0xa5, 0xb7, 0x66, 0x77, 0x17, 0x69, 0x97, 0xb9, 0x63, 119 | 0x09, 0x54, 0x8d, 0xfc, 0xde, 0x65, 0x3e, 0xa0, 0xd6, 0xcc, 0xd1, 0x82, 0x26, 0x4e, 0x66, 0x9b, 120 | 0xd8, 0xc1, 0xd5, 0x6c, 0x62, 0x39, 0x77, 0xf8, 0x2a, 0xce, 0x6a, 0x2d, 0x5c, 0xab, 0xdf, 0x8a, 121 | 0x32, 0x58, 0x2d, 0x4f, 0xcf, 0x7e, 0x02, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0x12, 0x0e, 0x0f, 122 | 0x03, 0x00, 0x00, 123 | } 124 | -------------------------------------------------------------------------------- /vendor/tensorflow_serving/apis/get_model_metadata.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow.serving; 4 | option cc_enable_arenas = true; 5 | 6 | import "google/protobuf/any.proto"; 7 | import "tensorflow/core/protobuf/meta_graph.proto"; 8 | import "tensorflow_serving/apis/model.proto"; 9 | 10 | // Message returned for "signature_def" field. 11 | message SignatureDefMap { 12 | map signature_def = 1; 13 | }; 14 | 15 | message GetModelMetadataRequest { 16 | // Model Specification indicating which model we are querying for metadata. 17 | ModelSpec model_spec = 1; 18 | // Metadata fields to get. Currently supported: "signature_def". 19 | repeated string metadata_field = 2; 20 | } 21 | 22 | message GetModelMetadataResponse { 23 | // Model Specification indicating which model this metadata belongs to. 24 | ModelSpec model_spec = 1; 25 | // Map of metadata field name to metadata field. The options for metadata 26 | // field name are listed in GetModelMetadataRequest. Currently supported: 27 | // "signature_def". 28 | map metadata = 2; 29 | } 30 | -------------------------------------------------------------------------------- /vendor/tensorflow_serving/apis/input.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow_serving/apis/input.proto 3 | // DO NOT EDIT! 4 | 5 | package tensorflow_serving 6 | 7 | import proto "github.com/golang/protobuf/proto" 8 | import fmt "fmt" 9 | import math "math" 10 | import tensorflow1 "tensorflow/core/example" 11 | 12 | // Reference imports to suppress errors if they are not otherwise used. 13 | var _ = proto.Marshal 14 | var _ = fmt.Errorf 15 | var _ = math.Inf 16 | 17 | // Specifies one or more fully independent input Examples. 18 | // See examples at: 19 | // https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/example/example.proto 20 | type ExampleList struct { 21 | Examples []*tensorflow1.Example `protobuf:"bytes,1,rep,name=examples" json:"examples,omitempty"` 22 | } 23 | 24 | func (m *ExampleList) Reset() { *m = ExampleList{} } 25 | func (m *ExampleList) String() string { return proto.CompactTextString(m) } 26 | func (*ExampleList) ProtoMessage() {} 27 | func (*ExampleList) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} } 28 | 29 | func (m *ExampleList) GetExamples() []*tensorflow1.Example { 30 | if m != nil { 31 | return m.Examples 32 | } 33 | return nil 34 | } 35 | 36 | // Specifies one or more independent input Examples, with a common context 37 | // Example. 38 | // 39 | // The common use case for context is to cleanly and optimally specify some 40 | // features that are common across multiple examples. 41 | // 42 | // See example below with a search query as the context and multiple restaurants 43 | // to perform some inference on. 44 | // 45 | // context: { 46 | // feature: { 47 | // key : "query" 48 | // value: { 49 | // bytes_list: { 50 | // value: [ "pizza" ] 51 | // } 52 | // } 53 | // } 54 | // } 55 | // examples: { 56 | // feature: { 57 | // key : "cuisine" 58 | // value: { 59 | // bytes_list: { 60 | // value: [ "Pizzeria" ] 61 | // } 62 | // } 63 | // } 64 | // } 65 | // examples: { 66 | // feature: { 67 | // key : "cuisine" 68 | // value: { 69 | // bytes_list: { 70 | // value: [ "Taqueria" ] 71 | // } 72 | // } 73 | // } 74 | // } 75 | // 76 | // Implementations of ExampleListWithContext merge the context Example into each 77 | // of the Examples. Note that feature keys must not be duplicated between the 78 | // Examples and context Example, or the behavior is undefined. 79 | // 80 | // See also: 81 | // tensorflow/core/example/example.proto 82 | // https://developers.google.com/protocol-buffers/docs/proto3#maps 83 | type ExampleListWithContext struct { 84 | Examples []*tensorflow1.Example `protobuf:"bytes,1,rep,name=examples" json:"examples,omitempty"` 85 | Context *tensorflow1.Example `protobuf:"bytes,2,opt,name=context" json:"context,omitempty"` 86 | } 87 | 88 | func (m *ExampleListWithContext) Reset() { *m = ExampleListWithContext{} } 89 | func (m *ExampleListWithContext) String() string { return proto.CompactTextString(m) } 90 | func (*ExampleListWithContext) ProtoMessage() {} 91 | func (*ExampleListWithContext) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} } 92 | 93 | func (m *ExampleListWithContext) GetExamples() []*tensorflow1.Example { 94 | if m != nil { 95 | return m.Examples 96 | } 97 | return nil 98 | } 99 | 100 | func (m *ExampleListWithContext) GetContext() *tensorflow1.Example { 101 | if m != nil { 102 | return m.Context 103 | } 104 | return nil 105 | } 106 | 107 | type Input struct { 108 | // Types that are valid to be assigned to Kind: 109 | // *Input_ExampleList 110 | // *Input_ExampleListWithContext 111 | Kind isInput_Kind `protobuf_oneof:"kind"` 112 | } 113 | 114 | func (m *Input) Reset() { *m = Input{} } 115 | func (m *Input) String() string { return proto.CompactTextString(m) } 116 | func (*Input) ProtoMessage() {} 117 | func (*Input) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{2} } 118 | 119 | type isInput_Kind interface { 120 | isInput_Kind() 121 | } 122 | 123 | type Input_ExampleList struct { 124 | ExampleList *ExampleList `protobuf:"bytes,1,opt,name=example_list,json=exampleList,oneof"` 125 | } 126 | type Input_ExampleListWithContext struct { 127 | ExampleListWithContext *ExampleListWithContext `protobuf:"bytes,2,opt,name=example_list_with_context,json=exampleListWithContext,oneof"` 128 | } 129 | 130 | func (*Input_ExampleList) isInput_Kind() {} 131 | func (*Input_ExampleListWithContext) isInput_Kind() {} 132 | 133 | func (m *Input) GetKind() isInput_Kind { 134 | if m != nil { 135 | return m.Kind 136 | } 137 | return nil 138 | } 139 | 140 | func (m *Input) GetExampleList() *ExampleList { 141 | if x, ok := m.GetKind().(*Input_ExampleList); ok { 142 | return x.ExampleList 143 | } 144 | return nil 145 | } 146 | 147 | func (m *Input) GetExampleListWithContext() *ExampleListWithContext { 148 | if x, ok := m.GetKind().(*Input_ExampleListWithContext); ok { 149 | return x.ExampleListWithContext 150 | } 151 | return nil 152 | } 153 | 154 | // XXX_OneofFuncs is for the internal use of the proto package. 155 | func (*Input) 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{}) { 156 | return _Input_OneofMarshaler, _Input_OneofUnmarshaler, _Input_OneofSizer, []interface{}{ 157 | (*Input_ExampleList)(nil), 158 | (*Input_ExampleListWithContext)(nil), 159 | } 160 | } 161 | 162 | func _Input_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { 163 | m := msg.(*Input) 164 | // kind 165 | switch x := m.Kind.(type) { 166 | case *Input_ExampleList: 167 | b.EncodeVarint(1<<3 | proto.WireBytes) 168 | if err := b.EncodeMessage(x.ExampleList); err != nil { 169 | return err 170 | } 171 | case *Input_ExampleListWithContext: 172 | b.EncodeVarint(2<<3 | proto.WireBytes) 173 | if err := b.EncodeMessage(x.ExampleListWithContext); err != nil { 174 | return err 175 | } 176 | case nil: 177 | default: 178 | return fmt.Errorf("Input.Kind has unexpected type %T", x) 179 | } 180 | return nil 181 | } 182 | 183 | func _Input_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { 184 | m := msg.(*Input) 185 | switch tag { 186 | case 1: // kind.example_list 187 | if wire != proto.WireBytes { 188 | return true, proto.ErrInternalBadWireType 189 | } 190 | msg := new(ExampleList) 191 | err := b.DecodeMessage(msg) 192 | m.Kind = &Input_ExampleList{msg} 193 | return true, err 194 | case 2: // kind.example_list_with_context 195 | if wire != proto.WireBytes { 196 | return true, proto.ErrInternalBadWireType 197 | } 198 | msg := new(ExampleListWithContext) 199 | err := b.DecodeMessage(msg) 200 | m.Kind = &Input_ExampleListWithContext{msg} 201 | return true, err 202 | default: 203 | return false, nil 204 | } 205 | } 206 | 207 | func _Input_OneofSizer(msg proto.Message) (n int) { 208 | m := msg.(*Input) 209 | // kind 210 | switch x := m.Kind.(type) { 211 | case *Input_ExampleList: 212 | s := proto.Size(x.ExampleList) 213 | n += proto.SizeVarint(1<<3 | proto.WireBytes) 214 | n += proto.SizeVarint(uint64(s)) 215 | n += s 216 | case *Input_ExampleListWithContext: 217 | s := proto.Size(x.ExampleListWithContext) 218 | n += proto.SizeVarint(2<<3 | proto.WireBytes) 219 | n += proto.SizeVarint(uint64(s)) 220 | n += s 221 | case nil: 222 | default: 223 | panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) 224 | } 225 | return n 226 | } 227 | 228 | func init() { 229 | proto.RegisterType((*ExampleList)(nil), "tensorflow.serving.ExampleList") 230 | proto.RegisterType((*ExampleListWithContext)(nil), "tensorflow.serving.ExampleListWithContext") 231 | proto.RegisterType((*Input)(nil), "tensorflow.serving.Input") 232 | } 233 | 234 | func init() { proto.RegisterFile("tensorflow_serving/apis/input.proto", fileDescriptor2) } 235 | 236 | var fileDescriptor2 = []byte{ 237 | // 237 bytes of a gzipped FileDescriptorProto 238 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x52, 0x2e, 0x49, 0xcd, 0x2b, 239 | 0xce, 0x2f, 0x4a, 0xcb, 0xc9, 0x2f, 0x8f, 0x2f, 0x4e, 0x2d, 0x2a, 0xcb, 0xcc, 0x4b, 0xd7, 0x4f, 240 | 0x2c, 0xc8, 0x2c, 0xd6, 0xcf, 0xcc, 0x2b, 0x28, 0x2d, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 241 | 0x12, 0x42, 0x28, 0xd2, 0x83, 0x2a, 0x92, 0x52, 0x45, 0x88, 0xe9, 0x27, 0xe7, 0x17, 0xa5, 0xea, 242 | 0xa7, 0x56, 0x24, 0xe6, 0x16, 0xe4, 0xc0, 0x69, 0x88, 0x56, 0x25, 0x3b, 0x2e, 0x6e, 0x57, 0x88, 243 | 0x80, 0x4f, 0x66, 0x71, 0x89, 0x90, 0x3e, 0x17, 0x07, 0x54, 0xbe, 0x58, 0x82, 0x51, 0x81, 0x59, 244 | 0x83, 0xdb, 0x48, 0x58, 0x0f, 0xc9, 0x70, 0xa8, 0xd2, 0x20, 0xb8, 0x22, 0xa5, 0x0a, 0x2e, 0x31, 245 | 0x24, 0xfd, 0xe1, 0x99, 0x25, 0x19, 0xce, 0xf9, 0x79, 0x25, 0xa9, 0x15, 0xa4, 0x1b, 0x25, 0xa4, 246 | 0xcb, 0xc5, 0x9e, 0x0c, 0xd1, 0x2b, 0xc1, 0xa4, 0xc0, 0x88, 0x4b, 0x3d, 0x4c, 0x8d, 0xd2, 0x3e, 247 | 0x46, 0x2e, 0x56, 0x4f, 0x50, 0x20, 0x08, 0xb9, 0x70, 0xf1, 0x40, 0x0d, 0x89, 0xcf, 0x01, 0x3a, 248 | 0x02, 0x68, 0x1b, 0x48, 0xb7, 0xbc, 0x1e, 0x66, 0xa8, 0xe8, 0x21, 0xb9, 0xd5, 0x83, 0x21, 0x88, 249 | 0x3b, 0x15, 0xc9, 0xeb, 0xe9, 0x5c, 0x92, 0xc8, 0xa6, 0xc4, 0x97, 0x03, 0xfd, 0x12, 0x8f, 0xea, 250 | 0x20, 0x2d, 0x02, 0x46, 0x22, 0x79, 0x1f, 0x68, 0xba, 0x58, 0x2a, 0x56, 0x19, 0x27, 0x36, 0x2e, 251 | 0x96, 0xec, 0xcc, 0xbc, 0x14, 0x27, 0xe6, 0x1f, 0x8c, 0x8c, 0x49, 0x6c, 0xe0, 0x68, 0x30, 0x06, 252 | 0x04, 0x00, 0x00, 0xff, 0xff, 0x77, 0x3b, 0x7c, 0x53, 0xe8, 0x01, 0x00, 0x00, 253 | } 254 | -------------------------------------------------------------------------------- /vendor/tensorflow_serving/apis/input.proto: -------------------------------------------------------------------------------- 1 | // Input used in serving APIs. Based on the tensorflow.Example family of 2 | // feature representations. 3 | 4 | syntax = "proto3"; 5 | 6 | option cc_enable_arenas = true; 7 | 8 | import "tensorflow/core/example/example.proto"; 9 | 10 | package tensorflow.serving; 11 | 12 | // Specifies one or more fully independent input Examples. 13 | // See examples at: 14 | // https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/example/example.proto 15 | message ExampleList { 16 | repeated tensorflow.Example examples = 1; 17 | } 18 | 19 | // Specifies one or more independent input Examples, with a common context 20 | // Example. 21 | // 22 | // The common use case for context is to cleanly and optimally specify some 23 | // features that are common across multiple examples. 24 | // 25 | // See example below with a search query as the context and multiple restaurants 26 | // to perform some inference on. 27 | // 28 | // context: { 29 | // feature: { 30 | // key : "query" 31 | // value: { 32 | // bytes_list: { 33 | // value: [ "pizza" ] 34 | // } 35 | // } 36 | // } 37 | // } 38 | // examples: { 39 | // feature: { 40 | // key : "cuisine" 41 | // value: { 42 | // bytes_list: { 43 | // value: [ "Pizzeria" ] 44 | // } 45 | // } 46 | // } 47 | // } 48 | // examples: { 49 | // feature: { 50 | // key : "cuisine" 51 | // value: { 52 | // bytes_list: { 53 | // value: [ "Taqueria" ] 54 | // } 55 | // } 56 | // } 57 | // } 58 | // 59 | // Implementations of ExampleListWithContext merge the context Example into each 60 | // of the Examples. Note that feature keys must not be duplicated between the 61 | // Examples and context Example, or the behavior is undefined. 62 | // 63 | // See also: 64 | // tensorflow/core/example/example.proto 65 | // https://developers.google.com/protocol-buffers/docs/proto3#maps 66 | message ExampleListWithContext { 67 | repeated tensorflow.Example examples = 1; 68 | tensorflow.Example context = 2; 69 | } 70 | 71 | message Input { 72 | oneof kind { 73 | ExampleList example_list = 1; 74 | ExampleListWithContext example_list_with_context = 2; 75 | } 76 | } 77 | -------------------------------------------------------------------------------- /vendor/tensorflow_serving/apis/model.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow_serving/apis/model.proto 3 | // DO NOT EDIT! 4 | 5 | package tensorflow_serving 6 | 7 | import proto "github.com/golang/protobuf/proto" 8 | import fmt "fmt" 9 | import math "math" 10 | import google_protobuf "github.com/golang/protobuf/ptypes/wrappers" 11 | 12 | // Reference imports to suppress errors if they are not otherwise used. 13 | var _ = proto.Marshal 14 | var _ = fmt.Errorf 15 | var _ = math.Inf 16 | 17 | // Metadata for an inference request such as the model name and version. 18 | type ModelSpec struct { 19 | // Required servable name. 20 | Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` 21 | // Optional version. If unspecified, will use the latest (numerical) version. 22 | // Typically not needed unless coordinating across multiple models that were 23 | // co-trained and/or have inter-dependencies on the versions used at inference 24 | // time. 25 | Version *google_protobuf.Int64Value `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"` 26 | // A named signature to evaluate. If unspecified, the default signature will 27 | // be used. Note that only MultiInference will initially support this. 28 | SignatureName string `protobuf:"bytes,3,opt,name=signature_name,json=signatureName" json:"signature_name,omitempty"` 29 | } 30 | 31 | func (m *ModelSpec) Reset() { *m = ModelSpec{} } 32 | func (m *ModelSpec) String() string { return proto.CompactTextString(m) } 33 | func (*ModelSpec) ProtoMessage() {} 34 | func (*ModelSpec) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} } 35 | 36 | func (m *ModelSpec) GetName() string { 37 | if m != nil { 38 | return m.Name 39 | } 40 | return "" 41 | } 42 | 43 | func (m *ModelSpec) GetVersion() *google_protobuf.Int64Value { 44 | if m != nil { 45 | return m.Version 46 | } 47 | return nil 48 | } 49 | 50 | func (m *ModelSpec) GetSignatureName() string { 51 | if m != nil { 52 | return m.SignatureName 53 | } 54 | return "" 55 | } 56 | 57 | func init() { 58 | proto.RegisterType((*ModelSpec)(nil), "tensorflow.serving.ModelSpec") 59 | } 60 | 61 | func init() { proto.RegisterFile("tensorflow_serving/apis/model.proto", fileDescriptor3) } 62 | 63 | var fileDescriptor3 = []byte{ 64 | // 193 bytes of a gzipped FileDescriptorProto 65 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x52, 0x2e, 0x49, 0xcd, 0x2b, 66 | 0xce, 0x2f, 0x4a, 0xcb, 0xc9, 0x2f, 0x8f, 0x2f, 0x4e, 0x2d, 0x2a, 0xcb, 0xcc, 0x4b, 0xd7, 0x4f, 67 | 0x2c, 0xc8, 0x2c, 0xd6, 0xcf, 0xcd, 0x4f, 0x49, 0xcd, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 68 | 0x12, 0x42, 0x28, 0xd2, 0x83, 0x2a, 0x92, 0x92, 0x4b, 0xcf, 0xcf, 0x4f, 0xcf, 0x49, 0xd5, 0x07, 69 | 0xab, 0x48, 0x2a, 0x4d, 0xd3, 0x2f, 0x2f, 0x4a, 0x2c, 0x28, 0x48, 0x2d, 0x2a, 0x86, 0xe8, 0x51, 70 | 0xaa, 0xe5, 0xe2, 0xf4, 0x05, 0x19, 0x11, 0x5c, 0x90, 0x9a, 0x2c, 0x24, 0xc4, 0xc5, 0x92, 0x97, 71 | 0x98, 0x9b, 0x2a, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x19, 0x04, 0x66, 0x0b, 0x99, 0x72, 0xb1, 0x97, 72 | 0x01, 0x95, 0x67, 0xe6, 0xe7, 0x49, 0x30, 0x01, 0x85, 0xb9, 0x8d, 0xa4, 0xf5, 0x20, 0x46, 0xea, 73 | 0xc1, 0x8c, 0xd4, 0xf3, 0xcc, 0x2b, 0x31, 0x33, 0x09, 0x4b, 0xcc, 0x29, 0x4d, 0x0d, 0x82, 0xa9, 74 | 0x15, 0x52, 0xe5, 0xe2, 0x2b, 0xce, 0x4c, 0xcf, 0x4b, 0x2c, 0x29, 0x2d, 0x4a, 0x8d, 0x07, 0x1b, 75 | 0xca, 0x0c, 0x36, 0x94, 0x17, 0x2e, 0xea, 0x07, 0x14, 0x74, 0x62, 0xfe, 0xc1, 0xc8, 0x98, 0xc4, 76 | 0x06, 0x36, 0xc9, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x70, 0xc7, 0x1e, 0xc1, 0xe5, 0x00, 0x00, 77 | 0x00, 78 | } 79 | -------------------------------------------------------------------------------- /vendor/tensorflow_serving/apis/model.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow.serving; 4 | option cc_enable_arenas = true; 5 | 6 | import "google/protobuf/wrappers.proto"; 7 | 8 | // Metadata for an inference request such as the model name and version. 9 | message ModelSpec { 10 | // Required servable name. 11 | string name = 1; 12 | 13 | // Optional version. If unspecified, will use the latest (numerical) version. 14 | // Typically not needed unless coordinating across multiple models that were 15 | // co-trained and/or have inter-dependencies on the versions used at inference 16 | // time. 17 | google.protobuf.Int64Value version = 2; 18 | 19 | // A named signature to evaluate. If unspecified, the default signature will 20 | // be used. Note that only MultiInference will initially support this. 21 | string signature_name = 3; 22 | } 23 | -------------------------------------------------------------------------------- /vendor/tensorflow_serving/apis/predict.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow_serving/apis/predict.proto 3 | // DO NOT EDIT! 4 | 5 | package tensorflow_serving 6 | 7 | import proto "github.com/golang/protobuf/proto" 8 | import fmt "fmt" 9 | import math "math" 10 | import tensorflow5 "tensorflow/core/framework" 11 | 12 | // Reference imports to suppress errors if they are not otherwise used. 13 | var _ = proto.Marshal 14 | var _ = fmt.Errorf 15 | var _ = math.Inf 16 | 17 | // PredictRequest specifies which TensorFlow model to run, as well as 18 | // how inputs are mapped to tensors and how outputs are filtered before 19 | // returning to user. 20 | type PredictRequest struct { 21 | // Model Specification. 22 | ModelSpec *ModelSpec `protobuf:"bytes,1,opt,name=model_spec,json=modelSpec" json:"model_spec,omitempty"` 23 | // Input tensors. 24 | // Names of input tensor are alias names. The mapping from aliases to real 25 | // input tensor names is expected to be stored as named generic signature 26 | // under the key "inputs" in the model export. 27 | // Each alias listed in a generic signature named "inputs" should be provided 28 | // exactly once in order to run the prediction. 29 | Inputs map[string]*tensorflow5.TensorProto `protobuf:"bytes,2,rep,name=inputs" json:"inputs,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` 30 | // Output filter. 31 | // Names specified are alias names. The mapping from aliases to real output 32 | // tensor names is expected to be stored as named generic signature under 33 | // the key "outputs" in the model export. 34 | // Only tensors specified here will be run/fetched and returned, with the 35 | // exception that when none is specified, all tensors specified in the 36 | // named signature will be run/fetched and returned. 37 | OutputFilter []string `protobuf:"bytes,3,rep,name=output_filter,json=outputFilter" json:"output_filter,omitempty"` 38 | } 39 | 40 | func (m *PredictRequest) Reset() { *m = PredictRequest{} } 41 | func (m *PredictRequest) String() string { return proto.CompactTextString(m) } 42 | func (*PredictRequest) ProtoMessage() {} 43 | func (*PredictRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} } 44 | 45 | func (m *PredictRequest) GetModelSpec() *ModelSpec { 46 | if m != nil { 47 | return m.ModelSpec 48 | } 49 | return nil 50 | } 51 | 52 | func (m *PredictRequest) GetInputs() map[string]*tensorflow5.TensorProto { 53 | if m != nil { 54 | return m.Inputs 55 | } 56 | return nil 57 | } 58 | 59 | func (m *PredictRequest) GetOutputFilter() []string { 60 | if m != nil { 61 | return m.OutputFilter 62 | } 63 | return nil 64 | } 65 | 66 | // Response for PredictRequest on successful run. 67 | type PredictResponse struct { 68 | // Output tensors. 69 | Outputs map[string]*tensorflow5.TensorProto `protobuf:"bytes,1,rep,name=outputs" json:"outputs,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` 70 | } 71 | 72 | func (m *PredictResponse) Reset() { *m = PredictResponse{} } 73 | func (m *PredictResponse) String() string { return proto.CompactTextString(m) } 74 | func (*PredictResponse) ProtoMessage() {} 75 | func (*PredictResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{1} } 76 | 77 | func (m *PredictResponse) GetOutputs() map[string]*tensorflow5.TensorProto { 78 | if m != nil { 79 | return m.Outputs 80 | } 81 | return nil 82 | } 83 | 84 | func init() { 85 | proto.RegisterType((*PredictRequest)(nil), "tensorflow.serving.PredictRequest") 86 | proto.RegisterType((*PredictResponse)(nil), "tensorflow.serving.PredictResponse") 87 | } 88 | 89 | func init() { proto.RegisterFile("tensorflow_serving/apis/predict.proto", fileDescriptor5) } 90 | 91 | var fileDescriptor5 = []byte{ 92 | // 319 bytes of a gzipped FileDescriptorProto 93 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x91, 0xcd, 0x4a, 0xfb, 0x40, 94 | 0x14, 0xc5, 0x99, 0x86, 0x7f, 0xff, 0xf4, 0xb6, 0x7e, 0x30, 0x1b, 0x4b, 0x40, 0x28, 0x2d, 0x8a, 95 | 0x1b, 0x27, 0xa2, 0x1b, 0x11, 0x57, 0x82, 0x05, 0x05, 0xb1, 0x4c, 0xdd, 0x97, 0xda, 0xde, 0x48, 96 | 0x68, 0x92, 0x19, 0x67, 0x26, 0x2d, 0x7d, 0x0a, 0xdf, 0xc5, 0xa7, 0x73, 0xe9, 0x64, 0xa6, 0xb5, 97 | 0x11, 0x3f, 0x56, 0xee, 0x2e, 0x77, 0xce, 0xef, 0x9e, 0x73, 0x12, 0x38, 0x30, 0x98, 0x6b, 0xa1, 98 | 0xe2, 0x54, 0x2c, 0x46, 0x1a, 0xd5, 0x3c, 0xc9, 0x9f, 0xa2, 0xb1, 0x4c, 0x74, 0x24, 0x15, 0x4e, 99 | 0x93, 0x89, 0x61, 0x52, 0x09, 0x23, 0x28, 0xdd, 0xc8, 0xd8, 0x4a, 0x16, 0x1e, 0x6e, 0x76, 0xd1, 100 | 0x44, 0x28, 0x8c, 0x62, 0x35, 0xce, 0x70, 0x21, 0xd4, 0x2c, 0xf2, 0x2f, 0x9e, 0x0d, 0x7b, 0x3f, 101 | 0x59, 0x64, 0x62, 0x8a, 0xa9, 0x17, 0x75, 0x5f, 0x6a, 0xb0, 0x3d, 0xf0, 0x96, 0x1c, 0x9f, 0x0b, 102 | 0xd4, 0x86, 0x5e, 0x02, 0x38, 0xc5, 0x48, 0x4b, 0x9c, 0xb4, 0x49, 0x87, 0x1c, 0x35, 0x4f, 0xf7, 103 | 0xd9, 0xd7, 0x20, 0xec, 0xae, 0x54, 0x0d, 0xad, 0x88, 0x37, 0xb2, 0xf5, 0x48, 0xfb, 0x50, 0x4f, 104 | 0x72, 0x59, 0x18, 0xdd, 0xae, 0x75, 0x02, 0x4b, 0xb2, 0xef, 0xc8, 0xcf, 0x8e, 0xec, 0xc6, 0x01, 105 | 0xd7, 0xb9, 0x51, 0x4b, 0xbe, 0xa2, 0x69, 0x0f, 0xb6, 0x44, 0x61, 0xec, 0x38, 0x8a, 0x93, 0xd4, 106 | 0xa0, 0x6a, 0x07, 0xf6, 0x5c, 0x83, 0xb7, 0xfc, 0xb2, 0xef, 0x76, 0x21, 0x87, 0x66, 0x85, 0xa5, 107 | 0xbb, 0x10, 0xcc, 0x70, 0xe9, 0x22, 0x37, 0x78, 0x39, 0xd2, 0x63, 0xf8, 0x37, 0x1f, 0xa7, 0x05, 108 | 0xda, 0x30, 0x65, 0x8d, 0xbd, 0x6a, 0x98, 0x07, 0x37, 0x0e, 0xca, 0xcf, 0xc0, 0xbd, 0xea, 0xa2, 109 | 0x76, 0x4e, 0xba, 0xaf, 0x04, 0x76, 0x3e, 0xf2, 0x69, 0x29, 0x72, 0x8d, 0xf4, 0x16, 0xfe, 0x7b, 110 | 0x5f, 0x6d, 0x8f, 0x97, 0xad, 0x4e, 0x7e, 0x6d, 0xe5, 0x29, 0x76, 0xef, 0x11, 0xdf, 0x6b, 0x7d, 111 | 0x20, 0x1c, 0x42, 0xab, 0xfa, 0xf0, 0x27, 0xa1, 0xaf, 0x82, 0x37, 0x42, 0x1e, 0xeb, 0xee, 0x97, 112 | 0x9e, 0xbd, 0x07, 0x00, 0x00, 0xff, 0xff, 0x62, 0xc5, 0x25, 0x7c, 0x5c, 0x02, 0x00, 0x00, 113 | } 114 | -------------------------------------------------------------------------------- /vendor/tensorflow_serving/apis/predict.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow.serving; 4 | option cc_enable_arenas = true; 5 | 6 | import "tensorflow/core/framework/tensor.proto"; 7 | import "tensorflow_serving/apis/model.proto"; 8 | 9 | // PredictRequest specifies which TensorFlow model to run, as well as 10 | // how inputs are mapped to tensors and how outputs are filtered before 11 | // returning to user. 12 | message PredictRequest { 13 | // Model Specification. 14 | ModelSpec model_spec = 1; 15 | 16 | // Input tensors. 17 | // Names of input tensor are alias names. The mapping from aliases to real 18 | // input tensor names is expected to be stored as named generic signature 19 | // under the key "inputs" in the model export. 20 | // Each alias listed in a generic signature named "inputs" should be provided 21 | // exactly once in order to run the prediction. 22 | map inputs = 2; 23 | 24 | // Output filter. 25 | // Names specified are alias names. The mapping from aliases to real output 26 | // tensor names is expected to be stored as named generic signature under 27 | // the key "outputs" in the model export. 28 | // Only tensors specified here will be run/fetched and returned, with the 29 | // exception that when none is specified, all tensors specified in the 30 | // named signature will be run/fetched and returned. 31 | repeated string output_filter = 3; 32 | } 33 | 34 | // Response for PredictRequest on successful run. 35 | message PredictResponse { 36 | // Output tensors. 37 | map outputs = 1; 38 | } 39 | -------------------------------------------------------------------------------- /vendor/tensorflow_serving/apis/prediction_service.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow_serving/apis/prediction_service.proto 3 | // DO NOT EDIT! 4 | 5 | package tensorflow_serving 6 | 7 | import proto "github.com/golang/protobuf/proto" 8 | import fmt "fmt" 9 | import math "math" 10 | 11 | import ( 12 | context "golang.org/x/net/context" 13 | grpc "google.golang.org/grpc" 14 | ) 15 | 16 | // Reference imports to suppress errors if they are not otherwise used. 17 | var _ = proto.Marshal 18 | var _ = fmt.Errorf 19 | var _ = math.Inf 20 | 21 | // Reference imports to suppress errors if they are not otherwise used. 22 | var _ context.Context 23 | var _ grpc.ClientConn 24 | 25 | // This is a compile-time assertion to ensure that this generated file 26 | // is compatible with the grpc package it is being compiled against. 27 | const _ = grpc.SupportPackageIsVersion4 28 | 29 | // Client API for PredictionService service 30 | 31 | type PredictionServiceClient interface { 32 | // Classify. 33 | Classify(ctx context.Context, in *ClassificationRequest, opts ...grpc.CallOption) (*ClassificationResponse, error) 34 | // Regress. 35 | Regress(ctx context.Context, in *RegressionRequest, opts ...grpc.CallOption) (*RegressionResponse, error) 36 | // Predict -- provides access to loaded TensorFlow model. 37 | Predict(ctx context.Context, in *PredictRequest, opts ...grpc.CallOption) (*PredictResponse, error) 38 | // GetModelMetadata - provides access to metadata for loaded models. 39 | GetModelMetadata(ctx context.Context, in *GetModelMetadataRequest, opts ...grpc.CallOption) (*GetModelMetadataResponse, error) 40 | } 41 | 42 | type predictionServiceClient struct { 43 | cc *grpc.ClientConn 44 | } 45 | 46 | func NewPredictionServiceClient(cc *grpc.ClientConn) PredictionServiceClient { 47 | return &predictionServiceClient{cc} 48 | } 49 | 50 | func (c *predictionServiceClient) Classify(ctx context.Context, in *ClassificationRequest, opts ...grpc.CallOption) (*ClassificationResponse, error) { 51 | out := new(ClassificationResponse) 52 | err := grpc.Invoke(ctx, "/tensorflow.serving.PredictionService/Classify", in, out, c.cc, opts...) 53 | if err != nil { 54 | return nil, err 55 | } 56 | return out, nil 57 | } 58 | 59 | func (c *predictionServiceClient) Regress(ctx context.Context, in *RegressionRequest, opts ...grpc.CallOption) (*RegressionResponse, error) { 60 | out := new(RegressionResponse) 61 | err := grpc.Invoke(ctx, "/tensorflow.serving.PredictionService/Regress", in, out, c.cc, opts...) 62 | if err != nil { 63 | return nil, err 64 | } 65 | return out, nil 66 | } 67 | 68 | func (c *predictionServiceClient) Predict(ctx context.Context, in *PredictRequest, opts ...grpc.CallOption) (*PredictResponse, error) { 69 | out := new(PredictResponse) 70 | err := grpc.Invoke(ctx, "/tensorflow.serving.PredictionService/Predict", in, out, c.cc, opts...) 71 | if err != nil { 72 | return nil, err 73 | } 74 | return out, nil 75 | } 76 | 77 | func (c *predictionServiceClient) GetModelMetadata(ctx context.Context, in *GetModelMetadataRequest, opts ...grpc.CallOption) (*GetModelMetadataResponse, error) { 78 | out := new(GetModelMetadataResponse) 79 | err := grpc.Invoke(ctx, "/tensorflow.serving.PredictionService/GetModelMetadata", in, out, c.cc, opts...) 80 | if err != nil { 81 | return nil, err 82 | } 83 | return out, nil 84 | } 85 | 86 | // Server API for PredictionService service 87 | 88 | type PredictionServiceServer interface { 89 | // Classify. 90 | Classify(context.Context, *ClassificationRequest) (*ClassificationResponse, error) 91 | // Regress. 92 | Regress(context.Context, *RegressionRequest) (*RegressionResponse, error) 93 | // Predict -- provides access to loaded TensorFlow model. 94 | Predict(context.Context, *PredictRequest) (*PredictResponse, error) 95 | // GetModelMetadata - provides access to metadata for loaded models. 96 | GetModelMetadata(context.Context, *GetModelMetadataRequest) (*GetModelMetadataResponse, error) 97 | } 98 | 99 | func RegisterPredictionServiceServer(s *grpc.Server, srv PredictionServiceServer) { 100 | s.RegisterService(&_PredictionService_serviceDesc, srv) 101 | } 102 | 103 | func _PredictionService_Classify_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 104 | in := new(ClassificationRequest) 105 | if err := dec(in); err != nil { 106 | return nil, err 107 | } 108 | if interceptor == nil { 109 | return srv.(PredictionServiceServer).Classify(ctx, in) 110 | } 111 | info := &grpc.UnaryServerInfo{ 112 | Server: srv, 113 | FullMethod: "/tensorflow.serving.PredictionService/Classify", 114 | } 115 | handler := func(ctx context.Context, req interface{}) (interface{}, error) { 116 | return srv.(PredictionServiceServer).Classify(ctx, req.(*ClassificationRequest)) 117 | } 118 | return interceptor(ctx, in, info, handler) 119 | } 120 | 121 | func _PredictionService_Regress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 122 | in := new(RegressionRequest) 123 | if err := dec(in); err != nil { 124 | return nil, err 125 | } 126 | if interceptor == nil { 127 | return srv.(PredictionServiceServer).Regress(ctx, in) 128 | } 129 | info := &grpc.UnaryServerInfo{ 130 | Server: srv, 131 | FullMethod: "/tensorflow.serving.PredictionService/Regress", 132 | } 133 | handler := func(ctx context.Context, req interface{}) (interface{}, error) { 134 | return srv.(PredictionServiceServer).Regress(ctx, req.(*RegressionRequest)) 135 | } 136 | return interceptor(ctx, in, info, handler) 137 | } 138 | 139 | func _PredictionService_Predict_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 140 | in := new(PredictRequest) 141 | if err := dec(in); err != nil { 142 | return nil, err 143 | } 144 | if interceptor == nil { 145 | return srv.(PredictionServiceServer).Predict(ctx, in) 146 | } 147 | info := &grpc.UnaryServerInfo{ 148 | Server: srv, 149 | FullMethod: "/tensorflow.serving.PredictionService/Predict", 150 | } 151 | handler := func(ctx context.Context, req interface{}) (interface{}, error) { 152 | return srv.(PredictionServiceServer).Predict(ctx, req.(*PredictRequest)) 153 | } 154 | return interceptor(ctx, in, info, handler) 155 | } 156 | 157 | func _PredictionService_GetModelMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 158 | in := new(GetModelMetadataRequest) 159 | if err := dec(in); err != nil { 160 | return nil, err 161 | } 162 | if interceptor == nil { 163 | return srv.(PredictionServiceServer).GetModelMetadata(ctx, in) 164 | } 165 | info := &grpc.UnaryServerInfo{ 166 | Server: srv, 167 | FullMethod: "/tensorflow.serving.PredictionService/GetModelMetadata", 168 | } 169 | handler := func(ctx context.Context, req interface{}) (interface{}, error) { 170 | return srv.(PredictionServiceServer).GetModelMetadata(ctx, req.(*GetModelMetadataRequest)) 171 | } 172 | return interceptor(ctx, in, info, handler) 173 | } 174 | 175 | var _PredictionService_serviceDesc = grpc.ServiceDesc{ 176 | ServiceName: "tensorflow.serving.PredictionService", 177 | HandlerType: (*PredictionServiceServer)(nil), 178 | Methods: []grpc.MethodDesc{ 179 | { 180 | MethodName: "Classify", 181 | Handler: _PredictionService_Classify_Handler, 182 | }, 183 | { 184 | MethodName: "Regress", 185 | Handler: _PredictionService_Regress_Handler, 186 | }, 187 | { 188 | MethodName: "Predict", 189 | Handler: _PredictionService_Predict_Handler, 190 | }, 191 | { 192 | MethodName: "GetModelMetadata", 193 | Handler: _PredictionService_GetModelMetadata_Handler, 194 | }, 195 | }, 196 | Streams: []grpc.StreamDesc{}, 197 | Metadata: "tensorflow_serving/apis/prediction_service.proto", 198 | } 199 | 200 | func init() { proto.RegisterFile("tensorflow_serving/apis/prediction_service.proto", fileDescriptor4) } 201 | 202 | var fileDescriptor4 = []byte{ 203 | // 260 bytes of a gzipped FileDescriptorProto 204 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x8c, 0x91, 0xcd, 0x4e, 0xc3, 0x30, 205 | 0x10, 0x84, 0x55, 0x55, 0xa2, 0xc8, 0x27, 0xd8, 0x63, 0x8e, 0xa0, 0x22, 0x7e, 0xaa, 0x14, 0xc1, 206 | 0x1b, 0xd0, 0x03, 0xa7, 0x4a, 0x28, 0x5c, 0xb8, 0x45, 0x26, 0xd9, 0x46, 0x96, 0x92, 0xd8, 0x78, 207 | 0x17, 0x10, 0xcf, 0xc1, 0xcb, 0x72, 0x84, 0xe2, 0x75, 0x11, 0x90, 0xb4, 0xb9, 0xda, 0x33, 0xdf, 208 | 0xce, 0x68, 0xd4, 0x25, 0x63, 0x4b, 0xd6, 0xaf, 0x6a, 0xfb, 0x9a, 0x13, 0xfa, 0x17, 0xd3, 0x56, 209 | 0x73, 0xed, 0x0c, 0xcd, 0x9d, 0xc7, 0xd2, 0x14, 0x6c, 0x6c, 0x1b, 0xde, 0x0b, 0x4c, 0x9d, 0xb7, 210 | 0x6c, 0x01, 0x7e, 0x1c, 0xa9, 0x38, 0x92, 0x59, 0x1f, 0xa5, 0xa8, 0x35, 0x91, 0x59, 0x99, 0x42, 211 | 0xaf, 0x49, 0x81, 0x90, 0xf4, 0xde, 0xac, 0x90, 0xf3, 0xc6, 0x96, 0x58, 0xe7, 0x0d, 0xb2, 0x2e, 212 | 0x35, 0x6b, 0x71, 0x4c, 0x77, 0xa4, 0x14, 0xd9, 0x69, 0x9f, 0xcc, 0x63, 0xe5, 0xf1, 0x2b, 0x48, 213 | 0x8c, 0x70, 0xf5, 0x3e, 0x56, 0x87, 0x77, 0x9b, 0x86, 0xf7, 0xa1, 0x20, 0x68, 0xb5, 0xbf, 0x08, 214 | 0x81, 0xdf, 0xe0, 0x2c, 0xfd, 0xdf, 0x33, 0x5d, 0xfc, 0xaa, 0x93, 0xe1, 0xd3, 0x33, 0x12, 0x27, 215 | 0xe7, 0x43, 0xa4, 0xe4, 0x6c, 0x4b, 0x08, 0x0f, 0x6a, 0x92, 0x85, 0x30, 0x30, 0xed, 0xb2, 0x65, 216 | 0x9b, 0xa4, 0x91, 0x7e, 0xb2, 0x4b, 0x26, 0xe4, 0x4c, 0x4d, 0xa4, 0x11, 0x1c, 0x75, 0x59, 0xe4, 217 | 0x33, 0x62, 0x8f, 0xb7, 0x6a, 0x84, 0xd9, 0xa8, 0x83, 0x5b, 0xe4, 0xe5, 0x7a, 0x92, 0xa5, 0x2c, 218 | 0x02, 0x17, 0x5d, 0xc6, 0xbf, 0xaa, 0x78, 0x65, 0x36, 0x4c, 0x1c, 0xce, 0xdd, 0x8c, 0x3f, 0x46, 219 | 0xa3, 0xc7, 0xbd, 0xef, 0x85, 0xae, 0x3f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xcd, 0x3c, 0x45, 0x95, 220 | 0x9a, 0x02, 0x00, 0x00, 221 | } 222 | -------------------------------------------------------------------------------- /vendor/tensorflow_serving/apis/prediction_service.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package tensorflow.serving; 4 | option cc_enable_arenas = true; 5 | 6 | import "tensorflow_serving/apis/classification.proto"; 7 | import "tensorflow_serving/apis/get_model_metadata.proto"; 8 | import "tensorflow_serving/apis/predict.proto"; 9 | import "tensorflow_serving/apis/regression.proto"; 10 | 11 | // open source marker; do not remove 12 | // PredictionService provides access to machine-learned models loaded by 13 | // model_servers. 14 | service PredictionService { 15 | // Classify. 16 | rpc Classify(ClassificationRequest) returns (ClassificationResponse); 17 | 18 | // Regress. 19 | rpc Regress(RegressionRequest) returns (RegressionResponse); 20 | 21 | // Predict -- provides access to loaded TensorFlow model. 22 | rpc Predict(PredictRequest) returns (PredictResponse); 23 | 24 | // GetModelMetadata - provides access to metadata for loaded models. 25 | rpc GetModelMetadata(GetModelMetadataRequest) 26 | returns (GetModelMetadataResponse); 27 | } 28 | -------------------------------------------------------------------------------- /vendor/tensorflow_serving/apis/regression.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. 2 | // source: tensorflow_serving/apis/regression.proto 3 | // DO NOT EDIT! 4 | 5 | package tensorflow_serving 6 | 7 | import proto "github.com/golang/protobuf/proto" 8 | import fmt "fmt" 9 | import math "math" 10 | 11 | // Reference imports to suppress errors if they are not otherwise used. 12 | var _ = proto.Marshal 13 | var _ = fmt.Errorf 14 | var _ = math.Inf 15 | 16 | // Regression result for a single item 17 | // (tensorflow.Example or tensorflow.InferenceExample.features). 18 | type Regression struct { 19 | Value float32 `protobuf:"fixed32,1,opt,name=value" json:"value,omitempty"` 20 | } 21 | 22 | func (m *Regression) Reset() { *m = Regression{} } 23 | func (m *Regression) String() string { return proto.CompactTextString(m) } 24 | func (*Regression) ProtoMessage() {} 25 | func (*Regression) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0} } 26 | 27 | func (m *Regression) GetValue() float32 { 28 | if m != nil { 29 | return m.Value 30 | } 31 | return 0 32 | } 33 | 34 | // For tensorflow.Example this will contain one result. 35 | // For tensorflow.InferenceExample this will contain one result for each 36 | // InferenceExample::features. 37 | type RegressionResult struct { 38 | Regressions []*Regression `protobuf:"bytes,1,rep,name=regressions" json:"regressions,omitempty"` 39 | } 40 | 41 | func (m *RegressionResult) Reset() { *m = RegressionResult{} } 42 | func (m *RegressionResult) String() string { return proto.CompactTextString(m) } 43 | func (*RegressionResult) ProtoMessage() {} 44 | func (*RegressionResult) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{1} } 45 | 46 | func (m *RegressionResult) GetRegressions() []*Regression { 47 | if m != nil { 48 | return m.Regressions 49 | } 50 | return nil 51 | } 52 | 53 | type RegressionRequest struct { 54 | // Model Specification. 55 | ModelSpec *ModelSpec `protobuf:"bytes,1,opt,name=model_spec,json=modelSpec" json:"model_spec,omitempty"` 56 | // Input data. 57 | Input *Input `protobuf:"bytes,2,opt,name=input" json:"input,omitempty"` 58 | } 59 | 60 | func (m *RegressionRequest) Reset() { *m = RegressionRequest{} } 61 | func (m *RegressionRequest) String() string { return proto.CompactTextString(m) } 62 | func (*RegressionRequest) ProtoMessage() {} 63 | func (*RegressionRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{2} } 64 | 65 | func (m *RegressionRequest) GetModelSpec() *ModelSpec { 66 | if m != nil { 67 | return m.ModelSpec 68 | } 69 | return nil 70 | } 71 | 72 | func (m *RegressionRequest) GetInput() *Input { 73 | if m != nil { 74 | return m.Input 75 | } 76 | return nil 77 | } 78 | 79 | type RegressionResponse struct { 80 | Result *RegressionResult `protobuf:"bytes,1,opt,name=result" json:"result,omitempty"` 81 | } 82 | 83 | func (m *RegressionResponse) Reset() { *m = RegressionResponse{} } 84 | func (m *RegressionResponse) String() string { return proto.CompactTextString(m) } 85 | func (*RegressionResponse) ProtoMessage() {} 86 | func (*RegressionResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{3} } 87 | 88 | func (m *RegressionResponse) GetResult() *RegressionResult { 89 | if m != nil { 90 | return m.Result 91 | } 92 | return nil 93 | } 94 | 95 | func init() { 96 | proto.RegisterType((*Regression)(nil), "tensorflow.serving.Regression") 97 | proto.RegisterType((*RegressionResult)(nil), "tensorflow.serving.RegressionResult") 98 | proto.RegisterType((*RegressionRequest)(nil), "tensorflow.serving.RegressionRequest") 99 | proto.RegisterType((*RegressionResponse)(nil), "tensorflow.serving.RegressionResponse") 100 | } 101 | 102 | func init() { proto.RegisterFile("tensorflow_serving/apis/regression.proto", fileDescriptor6) } 103 | 104 | var fileDescriptor6 = []byte{ 105 | // 249 bytes of a gzipped FileDescriptorProto 106 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x90, 0xb1, 0x4e, 0xc3, 0x30, 107 | 0x10, 0x40, 0xe5, 0x56, 0xad, 0xc4, 0x65, 0x01, 0x8b, 0xa1, 0x20, 0x81, 0x90, 0x61, 0xc8, 0x94, 108 | 0x48, 0x65, 0x65, 0x40, 0x6c, 0x0c, 0x2c, 0x86, 0xbd, 0x2a, 0x70, 0x54, 0x91, 0x5c, 0xdb, 0xf8, 109 | 0xec, 0xb2, 0xf3, 0xd5, 0x8c, 0xb8, 0x76, 0x20, 0x41, 0x34, 0xea, 0x96, 0x48, 0xef, 0x9d, 0xdf, 110 | 0x1d, 0x94, 0x1e, 0x35, 0x19, 0xf7, 0xa6, 0xcc, 0xc7, 0x82, 0xd0, 0x6d, 0x1a, 0xbd, 0xaa, 0x97, 111 | 0xb6, 0xa1, 0xda, 0xe1, 0xca, 0x21, 0x51, 0x63, 0x74, 0x65, 0x9d, 0xf1, 0x86, 0xf3, 0x8e, 0xac, 112 | 0x5a, 0xf2, 0xf4, 0x72, 0xc8, 0x6e, 0xb4, 0x0d, 0x3e, 0x8b, 0xc3, 0xd0, 0xda, 0xbc, 0xa2, 0xca, 113 | 0x90, 0x10, 0x00, 0xf2, 0xf7, 0x45, 0x7e, 0x0c, 0x93, 0xcd, 0x52, 0x05, 0x9c, 0xb1, 0x0b, 0x56, 114 | 0x8e, 0x64, 0xfe, 0x11, 0x4f, 0x70, 0xd8, 0x31, 0x12, 0x29, 0x28, 0xcf, 0x6f, 0xa1, 0xe8, 0x4a, 115 | 0x29, 0xf2, 0xe3, 0xb2, 0x98, 0x9f, 0x57, 0xff, 0x5b, 0xab, 0x9e, 0xda, 0x57, 0xc4, 0x27, 0x83, 116 | 0xa3, 0xfe, 0xd8, 0xf7, 0x80, 0xe4, 0xf9, 0x0d, 0x40, 0xca, 0x5b, 0x90, 0xc5, 0x97, 0x94, 0x51, 117 | 0xcc, 0xcf, 0x76, 0x8d, 0x7d, 0xd8, 0x52, 0x8f, 0x11, 0x92, 0x07, 0xeb, 0x9f, 0x4f, 0x5e, 0xc3, 118 | 0x24, 0x5d, 0x60, 0x36, 0x4a, 0xe2, 0xc9, 0x2e, 0xf1, 0x7e, 0x0b, 0xc8, 0xcc, 0x09, 0x09, 0xfc, 119 | 0xcf, 0x6a, 0x36, 0x96, 0x61, 0x8c, 0x98, 0xba, 0xb4, 0x66, 0x1b, 0x70, 0xb5, 0x67, 0xaf, 0xc4, 120 | 0xca, 0xd6, 0xb9, 0x1b, 0x7f, 0x31, 0xf6, 0x3c, 0x4d, 0xe7, 0xbd, 0xfe, 0x0e, 0x00, 0x00, 0xff, 121 | 0xff, 0xe1, 0x57, 0x98, 0xf1, 0xe8, 0x01, 0x00, 0x00, 122 | } 123 | -------------------------------------------------------------------------------- /vendor/tensorflow_serving/apis/regression.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | option cc_enable_arenas = true; 4 | 5 | import "tensorflow_serving/apis/input.proto"; 6 | import "tensorflow_serving/apis/model.proto"; 7 | 8 | package tensorflow.serving; 9 | 10 | // Regression result for a single item 11 | // (tensorflow.Example or tensorflow.InferenceExample.features). 12 | message Regression { 13 | float value = 1; 14 | } 15 | 16 | // For tensorflow.Example this will contain one result. 17 | // For tensorflow.InferenceExample this will contain one result for each 18 | // InferenceExample::features. 19 | message RegressionResult { 20 | repeated Regression regressions = 1; 21 | } 22 | 23 | // RPC interfaces. 24 | 25 | message RegressionRequest { 26 | // Model Specification. 27 | ModelSpec model_spec = 1; 28 | 29 | // Input data. 30 | tensorflow.serving.Input input = 2; 31 | } 32 | 33 | message RegressionResponse { 34 | RegressionResult result = 1; 35 | } 36 | --------------------------------------------------------------------------------