a .Sicc@sdZddlmZddlmZddlmZddlmZddlmZddl m Z ddl m Z dd l mZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlm Z ddl!m"Z"ddl#m$Z$ddl#m%Z%ddl&Tddl'm(Z)ddl*Tddl+m,Z,ddl+m-Z-ddl+m.Z.ddl+m/Z/ddl+m0Z0ddl+m1Z1ddl+m2Z2ddl+m3Z3dd l+m4Z4dd!l+m5Z5dd"l+m6Z6dd#l+m7Z7dd$l+m8Z8dd%l+m9Z9dd&l:m;Z;dd'lm?Z?dd)l@mAZAdd*l@mBZBdd+l@mCZCdd,l@mDZDdd-lEmFZFdd.lGmHZHdd/lGmIZIdd0lGmJZJdd1lGmKZKdd2lGmLZLdd3lGmMZMdd4lGmNZNdd5lOmPZPdd6lQmRZRdd7lQmSZSdd8lQmTZTdd9lQmUZUdd:lQmVZVdd;lQmWZWddlZm[Z[dd?l\m]Z]dd@l\m^Z^ddAl\m_Z_ddBl\m`Z`ddClambZbddDlcmdZdddElemfZfddFlgmhZhddGlgmiZiddHlgmjZjddIlgmkZkddJlgmlZlddKlgmmZmddLlnmoZoddMlnmpZpddNlqmrZrddOlsmtZtddluTddlvTddlwTddlxTddPlymzZzddQlym{Z{ddRl|m}Z}ddSl~mZddTl~mZetdUeetdVezetdWeetdXeetdYeetdZeetd[eetd\eetd]eetd^e{etd_gd`eetdaeetdbe}dce_dde_dee_dfe_dge_dhe_die_dje_dke_dlS)mzhSupport for training models. See the [Training](https://tensorflow.org/api_guides/python/train) guide. )sdca_optimizer) sdca_fprint)sdca_shrink_l1)AdadeltaOptimizer)AdagradOptimizer)AdagradDAOptimizer)ProximalAdagradOptimizer) AdamOptimizer) FtrlOptimizer) MixedPrecisionLossScaleOptimizer)'enable_mixed_precision_graph_rewrite_v1)MomentumOptimizer)ExponentialMovingAverage) Optimizer)RMSPropOptimizer)GradientDescentOptimizer) ProximalGradientDescentOptimizer)SyncReplicasOptimizer) Coordinator) LooperThread)*)input)$get_or_create_steps_per_run_variable)SecondOrStepTimer)LoggingTensorHook)StopAtStepHook)CheckpointSaverHook)CheckpointSaverListener)StepCounterHook)NanLossDuringTrainingError) NanTensorHook)SummarySaverHook)GlobalStepWaiterHook) FinalOpsHook) FeedFnHook) ProfilerHook)basic_train_loop) PythonState) Checkpoint)init_from_checkpoint)list_variables)load_checkpoint) load_variable)replica_device_setter)Scaffold)MonitoredTrainingSession)SessionCreator)ChiefSessionCreator)WorkerSessionCreator)MonitoredSession)SingularMonitoredSession)Saver)checkpoint_exists)generate_checkpoint_state_proto)get_checkpoint_mtimes)get_checkpoint_state)latest_checkpoint)update_checkpoint_state)export_meta_graph)import_meta_graph)saveable_object_util)SessionRunHook)SessionRunArgs)SessionRunContext)SessionRunValues)SessionManager)summary_iterator) Supervisor) write_graph) global_step)get_global_step)assert_global_step)create_global_step)get_or_create_global_step) VocabInfo) warm_start)NewCheckpointReader) tf_export) ClusterDef)JobDef) ServerDef) ClusterSpec)Serverztrain.BytesListztrain.ClusterDefz train.Examplez train.Featureztrain.Featuresztrain.FeatureListztrain.FeatureListsztrain.FloatListztrain.Int64Listz train.JobDefztrain.SaverDef)v1ztrain.SequenceExampleztrain.ServerDefa*Used in `tf.train.Example` protos. Holds a list of byte-strings. An `Example` proto is a representation of the following python type: ``` Dict[str, Union[List[bytes], List[int64], List[float]]] ``` This proto implements the `List[bytes]` portion. >>> from google.protobuf import text_format >>> example = text_format.Parse(''' ... features { ... feature {key: "my_feature" ... value {bytes_list {value: ['abc', '12345' ]}}} ... }''', ... tf.train.Example()) >>> >>> example.features.feature['my_feature'].bytes_list.value ["abc", "12345"] Use `tf.io.parse_example` to extract tensors from a serialized `Example` proto: >>> tf.io.parse_example( ... example.SerializeToString(), ... features = {'my_feature': tf.io.RaggedFeature(dtype=tf.string)}) {'my_feature': } See the [`tf.train.Example`](https://www.tensorflow.org/tutorials/load_data/tfrecord#tftrainexample) guide for usage details. a(Used in `tf.train.Example` protos. Holds a list of floats. An `Example` proto is a representation of the following python type: ``` Dict[str, Union[List[bytes], List[int64], List[float]]] ``` This proto implements the `List[float]` portion. >>> from google.protobuf import text_format >>> example = text_format.Parse(''' ... features { ... feature {key: "my_feature" ... value {float_list {value: [1., 2., 3., 4. ]}}} ... }''', ... tf.train.Example()) >>> >>> example.features.feature['my_feature'].float_list.value [1.0, 2.0, 3.0, 4.0] Use `tf.io.parse_example` to extract tensors from a serialized `Example` proto: >>> tf.io.parse_example( ... example.SerializeToString(), ... features = {'my_feature': tf.io.RaggedFeature(dtype=tf.float32)}) {'my_feature': } See the [`tf.train.Example`](https://www.tensorflow.org/tutorials/load_data/tfrecord#tftrainexample) guide for usage details. aUsed in `tf.train.Example` protos. Holds a list of Int64s. An `Example` proto is a representation of the following python type: ``` Dict[str, Union[List[bytes], List[int64], List[float]]] ``` This proto implements the `List[int64]` portion. >>> from google.protobuf import text_format >>> example = text_format.Parse(''' ... features { ... feature {key: "my_feature" ... value {int64_list {value: [1, 2, 3, 4]}}} ... }''', ... tf.train.Example()) >>> >>> example.features.feature['my_feature'].int64_list.value [1, 2, 3, 4] Use `tf.io.parse_example` to extract tensors from a serialized `Example` proto: >>> tf.io.parse_example( ... example.SerializeToString(), ... features = {'my_feature': tf.io.RaggedFeature(dtype=tf.int64)}) {'my_feature': } See the [`tf.train.Example`](https://www.tensorflow.org/tutorials/load_data/tfrecord#tftrainexample) guide for usage details. a9Used in `tf.train.Example` protos. Contains a list of values. An `Example` proto is a representation of the following python type: ``` Dict[str, Union[List[bytes], List[int64], List[float]]] ``` This proto implements the `Union`. The contained list can be one of three types: - `tf.train.BytesList` - `tf.train.FloatList` - `tf.train.Int64List` >>> int_feature = tf.train.Feature( ... int64_list=tf.train.Int64List(value=[1, 2, 3, 4])) >>> float_feature = tf.train.Feature( ... float_list=tf.train.FloatList(value=[1., 2., 3., 4.])) >>> bytes_feature = tf.train.Feature( ... bytes_list=tf.train.BytesList(value=[b"abc", b"1234"])) >>> >>> example = tf.train.Example( ... features=tf.train.Features(feature={ ... 'my_ints': int_feature, ... 'my_floats': float_feature, ... 'my_bytes': bytes_feature, ... })) Use `tf.io.parse_example` to extract tensors from a serialized `Example` proto: >>> tf.io.parse_example( ... example.SerializeToString(), ... features = { ... 'my_ints': tf.io.RaggedFeature(dtype=tf.int64), ... 'my_floats': tf.io.RaggedFeature(dtype=tf.float32), ... 'my_bytes': tf.io.RaggedFeature(dtype=tf.string)}) {'my_bytes': , 'my_floats': , 'my_ints': } aUsed in `tf.train.Example` protos. Contains the mapping from keys to `Feature`. An `Example` proto is a representation of the following python type: ``` Dict[str, Union[List[bytes], List[int64], List[float]]] ``` This proto implements the `Dict`. >>> int_feature = tf.train.Feature( ... int64_list=tf.train.Int64List(value=[1, 2, 3, 4])) >>> float_feature = tf.train.Feature( ... float_list=tf.train.FloatList(value=[1., 2., 3., 4.])) >>> bytes_feature = tf.train.Feature( ... bytes_list=tf.train.BytesList(value=[b"abc", b"1234"])) >>> >>> example = tf.train.Example( ... features=tf.train.Features(feature={ ... 'my_ints': int_feature, ... 'my_floats': float_feature, ... 'my_bytes': bytes_feature, ... })) Use `tf.io.parse_example` to extract tensors from a serialized `Example` proto: >>> tf.io.parse_example( ... example.SerializeToString(), ... features = { ... 'my_ints': tf.io.RaggedFeature(dtype=tf.int64), ... 'my_floats': tf.io.RaggedFeature(dtype=tf.float32), ... 'my_bytes': tf.io.RaggedFeature(dtype=tf.string)}) {'my_bytes': , 'my_floats': , 'my_ints': } aPMainly used as part of a `tf.train.SequenceExample`. Contains a list of `tf.train.Feature`s. The `tf.train.SequenceExample` proto can be thought of as a proto implementation of the following python type: ``` # tf.train.Feature Feature = Union[List[bytes], List[int64], List[float]] # tf.train.FeatureList FeatureList = List[Feature] # tf.train.FeatureLists FeatureLists = Dict[str, FeatureList] class SequenceExample(typing.NamedTuple): context: Dict[str, Feature] feature_lists: FeatureLists ``` This proto implements the `List[Feature]` portion. aXMainly used as part of a `tf.train.SequenceExample`. Contains a list of `tf.train.Feature`s. The `tf.train.SequenceExample` proto can be thought of as a proto implementation of the following python type: ``` # tf.train.Feature Feature = Union[List[bytes], List[int64], List[float]] # tf.train.FeatureList FeatureList = List[Feature] # tf.train.FeatureLists FeatureLists = Dict[str, FeatureList] class SequenceExample(typing.NamedTuple): context: Dict[str, Feature] feature_lists: FeatureLists ``` This proto implements the `Dict[str, FeatureList]` portion. aAn `Example` is a standard proto storing data for training and inference. An `Example` proto is a representation of the following python type: ``` Dict[str, Union[List[bytes], List[int64], List[float]]] ``` It contains a key-value store `Example.features` where each key (string) maps to a `tf.train.Feature` message which contains a fixed-type list. This flexible and compact format allows the storage of large amounts of typed data, but requires that the data shape and use be determined by the configuration files and parsers that are used to read and write this format (refer to `tf.io.parse_example` for details). >>> from google.protobuf import text_format >>> example = text_format.Parse(''' ... features { ... feature {key: "my_feature" ... value {int64_list {value: [1, 2, 3, 4]}}} ... }''', ... tf.train.Example()) Use `tf.io.parse_example` to extract tensors from a serialized `Example` proto: >>> tf.io.parse_example( ... example.SerializeToString(), ... features = {'my_feature': tf.io.RaggedFeature(dtype=tf.int64)}) {'my_feature': } While the list of keys, and the contents of each key _could_ be different for every `Example`, TensorFlow expects a fixed list of keys, each with a fixed `tf.dtype`. A conformant `Example` dataset obeys the following conventions: - If a Feature `K` exists in one example with data type `T`, it must be of type `T` in all other examples when present. It may be omitted. - The number of instances of Feature `K` list data may vary across examples, depending on the requirements of the model. - If a Feature `K` doesn't exist in an example, a `K`-specific default will be used, if configured. - If a Feature `K` exists in an example but contains no items, the intent is considered to be an empty tensor and no default will be used. a[A `SequenceExample` represents a sequence of features and some context. It can be thought of as a proto-implementation of the following python type: ``` Feature = Union[List[bytes], List[int64], List[float]] class SequenceExample(typing.NamedTuple): context: Dict[str, Feature] feature_lists: Dict[str, List[Feature]] ``` To implement this as protos it's broken up into sub-messages as follows: ``` # tf.train.Feature Feature = Union[List[bytes], List[int64], List[float]] # tf.train.FeatureList FeatureList = List[Feature] # tf.train.FeatureLists FeatureLists = Dict[str, FeatureList] # tf.train.SequenceExample class SequenceExample(typing.NamedTuple): context: Dict[str, Feature] feature_lists: FeatureLists ``` To parse a `SequenceExample` in TensorFlow refer to the `tf.io.parse_sequence_example` function. The `context` contains features which apply to the entire example. The `feature_lists` contain a key, value map where each key is associated with a repeated set of `tf.train.Features` (a `tf.train.FeatureList`). A `FeatureList` represents the values of a feature identified by its key over time / frames. Below is a `SequenceExample` for a movie recommendation application recording a sequence of ratings by a user. The time-independent features ("locale", "age", "favorites") describing the user are part of the context. The sequence of movies the user rated are part of the feature_lists. For each movie in the sequence we have information on its name and actors and the user's rating. This information is recorded in three separate `feature_list`s. In the example below there are only two movies. All three `feature_list`s, namely "movie_ratings", "movie_names", and "actors" have a feature value for both movies. Note, that "actors" is itself a `bytes_list` with multiple strings per movie. ``` context: { feature: { key : "locale" value: { bytes_list: { value: [ "pt_BR" ] } } } feature: { key : "age" value: { float_list: { value: [ 19.0 ] } } } feature: { key : "favorites" value: { bytes_list: { value: [ "Majesty Rose", "Savannah Outen", "One Direction" ] } } } } feature_lists: { feature_list: { key : "movie_ratings" value: { feature: { float_list: { value: [ 4.5 ] } } feature: { float_list: { value: [ 5.0 ] } } } } feature_list: { key : "movie_names" value: { feature: { bytes_list: { value: [ "The Shawshank Redemption" ] } } feature: { bytes_list: { value: [ "Fight Club" ] } } } } feature_list: { key : "actors" value: { feature: { bytes_list: { value: [ "Tim Robbins", "Morgan Freeman" ] } } feature: { bytes_list: { value: [ "Brad Pitt", "Edward Norton", "Helena Bonham Carter" ] } } } } } ``` A conformant `SequenceExample` data set obeys the following conventions: `context`: - All conformant context features `K` must obey the same conventions as a conformant Example's features (see above). `feature_lists`: - A `FeatureList L` may be missing in an example; it is up to the parser configuration to determine if this is allowed or considered an empty list (zero length). - If a `FeatureList L` exists, it may be empty (zero length). - If a `FeatureList L` is non-empty, all features within the `FeatureList` must have the same data type `T`. Even across `SequenceExample`s, the type `T` of the `FeatureList` identified by the same key must be the same. An entry without any values may serve as an empty feature. - If a `FeatureList L` is non-empty, it is up to the parser configuration to determine if all features within the `FeatureList` must have the same size. The same holds for this `FeatureList` across multiple examples. - For sequence modeling ([example](https://github.com/tensorflow/nmt)), the feature lists represent a sequence of frames. In this scenario, all `FeatureList`s in a `SequenceExample` have the same number of `Feature` messages, so that the i-th element in each `FeatureList` is part of the i-th frame (or time step). **Examples of conformant and non-conformant examples' `FeatureLists`:** Conformant `FeatureLists`: ``` feature_lists: { feature_list: { key: "movie_ratings" value: { feature: { float_list: { value: [ 4.5 ] } } feature: { float_list: { value: [ 5.0 ] } } } } } ``` Non-conformant `FeatureLists` (mismatched types): ``` feature_lists: { feature_list: { key: "movie_ratings" value: { feature: { float_list: { value: [ 4.5 ] } } feature: { int64_list: { value: [ 5 ] } } } } } ``` Conditionally conformant `FeatureLists`, the parser configuration determines if the feature sizes must match: ``` feature_lists: { feature_list: { key: "movie_ratings" value: { feature: { float_list: { value: [ 4.5 ] } } feature: { float_list: { value: [ 5.0, 6.0 ] } } } } } ``` **Examples of conformant and non-conformant `SequenceExample`s:** Conformant pair of SequenceExample: ``` feature_lists: { feature_list: { key: "movie_ratings" value: { feature: { float_list: { value: [ 4.5 ] } } feature: { float_list: { value: [ 5.0 ] } } } } } feature_lists: { feature_list: { key: "movie_ratings" value: { feature: { float_list: { value: [ 4.5 ] } } feature: { float_list: { value: [ 5.0 ] } } feature: { float_list: { value: [ 2.0 ] } } } } } ``` Conformant pair of `SequenceExample`s: ``` feature_lists: { feature_list: { key: "movie_ratings" value: { feature: { float_list: { value: [ 4.5 ] } } feature: { float_list: { value: [ 5.0 ] } } } } } feature_lists: { feature_list: { key: "movie_ratings" value: { } } } ``` Conditionally conformant pair of `SequenceExample`s, the parser configuration determines if the second `feature_lists` is consistent (zero-length) or invalid (missing "movie_ratings"): ``` feature_lists: { feature_list: { key: "movie_ratings" value: { feature: { float_list: { value: [ 4.5 ] } } feature: { float_list: { value: [ 5.0 ] } } } } } feature_lists: { } ``` Non-conformant pair of `SequenceExample`s (mismatched types): ``` feature_lists: { feature_list: { key: "movie_ratings" value: { feature: { float_list: { value: [ 4.5 ] } } feature: { float_list: { value: [ 5.0 ] } } } } } feature_lists: { feature_list: { key: "movie_ratings" value: { feature: { int64_list: { value: [ 4 ] } } feature: { int64_list: { value: [ 5 ] } } feature: { int64_list: { value: [ 2 ] } } } } } ``` Conditionally conformant pair of `SequenceExample`s; the parser configuration determines if the feature sizes must match: ``` feature_lists: { feature_list: { key: "movie_ratings" value: { feature: { float_list: { value: [ 4.5 ] } } feature: { float_list: { value: [ 5.0 ] } } } } } feature_lists: { feature_list: { key: "movie_ratings" value: { feature: { float_list: { value: [ 4.0 ] } } feature: { float_list: { value: [ 5.0, 3.0 ] } } } } ``` N)__doc__Ztensorflow.python.ops.sdca_opsrrrZ#tensorflow.python.training.adadeltarZ"tensorflow.python.training.adagradrZ%tensorflow.python.training.adagrad_darZ+tensorflow.python.training.proximal_adagradrZtensorflow.python.training.adamr Ztensorflow.python.training.ftrlr ZZ+tensorflow.python.training.session_run_hookr?r@rArBZ*tensorflow.python.training.session_managerrC%tensorflow.python.training.summary_iorDZ%tensorflow.python.training.supervisorrEZ(tensorflow.python.training.training_utilrFrGrHrIrJrKZ-tensorflow.python.training.warm_starting_utilrLrMZ/tensorflow.python.training.py_checkpoint_readerrN tensorflow.python.util.tf_exportrOZ#tensorflow.core.example.example_pb2Z#tensorflow.core.example.feature_pb2Z"tensorflow.core.protobuf.saver_pb2Z.tensorflow.python.training.learning_rate_decayZ$tensorflow.core.protobuf.cluster_pb2rPrQZ.tensorflow.core.protobuf.tensorflow_server_pb2rRZ%tensorflow.python.training.server_librSrT BytesListZExampleFeatureZFeaturesZ FeatureListZ FeatureLists FloatList Int64ListSaverDefZSequenceExamplerbrb_/var/www/html/django/DPS/env/lib/python3.9/site-packages/tensorflow/python/training/training.pys                                                                                              &%%3-2