BVhJdZddlZddlZddlZddlmZddlmZddlm Z ddl m Z ddl m Z ddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZdZGddeZedgGddeZ y)z6Provides an API for generating Event protocol buffers.N) graph_pb2) summary_pb2)meta_graph_pb2) event_pb2)context) meta_graph)ops)gfile) tf_logging) plugin_asset)EventFileWriter)EventFileWriterV2) tf_exportpluginscTeZdZdZd dZd dZd dZd dZd dZdZ d d Z d d Z d Z y)SummaryToEventTransformerzAbstractly implements the SummaryWriter API. This API basically implements a number of endpoints (add_summary, add_session_log, etc). The endpoints all generate an event protobuf, which is passed to the contained event_writer. Nc||_i|_||j|j||t|tj r|j dn|}|jtj|xs|t|_ y)alCreates a `SummaryWriter` and an event file. On construction the summary writer creates a new event file in `logdir`. This event file will contain `Event` protocol buffers constructed when you call one of the following functions: `add_summary()`, `add_session_log()`, `add_event()`, or `add_graph()`. If you pass a `Graph` to the constructor it is added to the event file. (This is equivalent to calling `add_graph()` later). TensorBoard will pick the graph from the file and display it graphically so you can interactively explore the graph you built. You will usually pass the graph from the session in which you launched it: ```python ...create a graph... # Launch the graph in a session. sess = tf.compat.v1.Session() # Create a summary writer, add the 'graph' to the event file. writer = tf.compat.v1.summary.FileWriter(, sess.graph) ``` Args: event_writer: An EventWriter. Implements add_event and get_logdir. graph: A `Graph` object, such as `sess.graph`. graph_def: DEPRECATED: Use the `graph` argument instead. N)graph graph_defT add_shapesr) event_writer_session_run_tags add_graph isinstancer Graph as_graph_defadd_meta_graphrcreate_meta_graph_defset_seen_summary_tags)selfrrrmaybe_graph_as_defs W/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/summary/writer/writer.py__init__z"SummaryToEventTransformer.__init__.s:%DD I1 nn5In6 *%;"..$.?AF   * *Y6>+= ?@"eDct|tr'tj}|j ||}|j D]^}|j s|j|jvr|jd:|jj|j`tj|}|j||y)aAdds a `Summary` protocol buffer to the event file. This method wraps the provided summary in an `Event` protocol buffer and adds it to the event file. You can pass the result of evaluating any summary op, using `tf.Session.run` or `tf.Tensor.eval`, to this function. Alternatively, you can pass a `tf.compat.v1.Summary` protocol buffer that you populate with your own data. The latter is commonly done to report evaluation results in event files. Args: summary: A `Summary` protocol buffer, optionally serialized as a string. global_step: Number. Optional global step value to record with the summary. metadata)summaryN)rbytesrSummaryParseFromStringvaluer)tagr" ClearFieldaddrEvent _add_event)r#r* global_stepsummr.events r% add_summaryz%SummaryToEventTransformer.add_summaryas$'5!  "d 7#g  - ^^ d-- - $  !!%)), - OOG ,EOOE;'r'cTtj|}|j||y)a@Adds a `SessionLog` protocol buffer to the event file. This method wraps the provided session in an `Event` protocol buffer and adds it to the event file. Args: session_log: A `SessionLog` protocol buffer. global_step: Number. Optional global step value to record with the summary. ) session_logN)rr2r3)r#r9r4r6s r%add_session_logz)SummaryToEventTransformer.add_session_logs  OO 4EOOE;'r'ct|j}tj|}|j||y)Nr)SerializeToStringrr2r3)r#rr4 graph_bytesr6s r%_add_graph_defz(SummaryToEventTransformer._add_graph_defs,--/K OOk 2EOOE;'r'c@| | tdt|tjst|tjrUt|tjst j d|}|j d}|j|ntt|tjst|tjr5t j dt|tjr|}n|}n td|j||y)aAdds a `Graph` to the event file. The graph described by the protocol buffer will be displayed by TensorBoard. Most users pass a graph in the constructor instead. Args: graph: A `Graph` object, such as `sess.graph`. global_step: Number. Optional global step counter to record with the graph. graph_def: DEPRECATED. Use the `graph` parameter instead. Raises: ValueError: If both graph and graph_def are passed to the method. Nz@Please pass only graph, or graph_def (deprecated), but not both.z\When passing a `Graph` object, please use the `graph` named argument instead of `graph_def`.TrzmPassing a `GraphDef` to the SummaryWriter is deprecated. Pass a `Graph` object instead, such as `sess.graph`.zLThe passed graph must be an instance of `Graph` or the deprecated `GraphDef`) ValueErrorrr rloggingwarningr_write_plugin_assetsrGraphDef TypeErrorr>)r#rr4rtrue_graph_defs r%rz#SummaryToEventTransformer.add_graphs  Y2 ' ((%#z)SYY'G syy )B C))T):n & UI.. / Y 2 2 3 ooNO E9-- ." 5 66  4r'ctj|}|jj}|D]}|j}t j j|t|}tj||j}|jD]U\}} t j j||} tj| d5} | j| dddWy#1swYdxYw)Nw)r get_all_plugin_assetsr get_logdir plugin_nameospathjoin _PLUGINS_DIRr MakeDirsassetsitemsOpenwrite) r#r plugin_assetslogdirasset_containerrK plugin_dirrQ asset_namecontent asset_pathfs r%rCz.SummaryToEventTransformer._write_plugin_assetss 66u=M    ) ) +F(#//k77<< kBj nnZ %%'f#)<<> :wWW\\*j9 ZZ C ( A '''      s C66C? ct|tjstdt |z|j }t j|}|j||y)aAdds a `MetaGraphDef` to the event file. The `MetaGraphDef` allows running the given graph via `saver.import_meta_graph()`. Args: meta_graph_def: A `MetaGraphDef` object, often as returned by `saver.export_meta_graph()`. global_step: Number. Optional global step counter to record with the graph. Raises: TypeError: If both `meta_graph_def` is not an instance of `MetaGraphDef`. z6meta_graph_def must be type MetaGraphDef, saw type: %s)meta_graph_defN) rr MetaGraphDefrEtyper<rr2r3)r#r^r4meta_graph_bytesr6s r%rz(SummaryToEventTransformer.add_meta_graphs] nn&A&A B N>*+ ,,%779 OO+; rrCrrgr3r'r%rr&s71$f)(V (( 35j (,(0'r'rzsummary.FileWriter)v1cjeZdZdZ d fd ZdZdZdZdZfdZ dZ d Z d Z d Z xZS) FileWritera Writes `Summary` protocol buffers to event files. The `FileWriter` class provides a mechanism to create an event file in a given directory and add summaries and events to it. The class updates the file contents asynchronously. This allows a training program to call methods to add data to the file directly from the training loop, without slowing down training. When constructed with a `tf.compat.v1.Session` parameter, a `FileWriter` instead forms a compatibility layer over new graph-based summaries to facilitate the use of new summary writing with pre-existing code that expects a `FileWriter` instance. This class is not thread-safe. @compatibility(TF2) This API is not compatible with eager execution or `tf.function`. To migrate to TF2, please use `tf.summary.create_file_writer` instead for summary management. To specify the summary step, you can manage the context with `tf.summary.SummaryWriter`, which is returned by `tf.summary.create_file_writer()`. Or, you can also use the `step` argument of summary functions such as `tf.summary.histogram`. See the usage example shown below. For a comprehensive `tf.summary` migration guide, please follow [Migrating tf.summary usage to TF 2.0](https://www.tensorflow.org/tensorboard/migrate#in_tf_1x). #### How to Map Arguments | TF1 Arg Name | TF2 Arg Name | Note | | :---------------- | :---------------- | :-------------------------------- | | `logdir` | `logdir` | - | | `graph` | Not supported | - | | `max_queue` | `max_queue` | - | | `flush_secs` | `flush_millis` | The unit of time is changed | : : : from seconds to milliseconds. : | `graph_def` | Not supported | - | | `filename_suffix` | `filename_suffix` | - | | `name` | `name` | - | #### TF1 & TF2 Usage Example TF1: ```python dist = tf.compat.v1.placeholder(tf.float32, [100]) tf.compat.v1.summary.histogram(name="distribution", values=dist) writer = tf.compat.v1.summary.FileWriter("/tmp/tf1_summary_example") summaries = tf.compat.v1.summary.merge_all() sess = tf.compat.v1.Session() for step in range(100): mean_moving_normal = np.random.normal(loc=step, scale=1, size=[100]) summ = sess.run(summaries, feed_dict={dist: mean_moving_normal}) writer.add_summary(summ, global_step=step) ``` TF2: ```python writer = tf.summary.create_file_writer("/tmp/tf2_summary_example") for step in range(100): mean_moving_normal = np.random.normal(loc=step, scale=1, size=[100]) with writer.as_default(step=step): tf.summary.histogram(name='distribution', data=mean_moving_normal) ``` @end_compatibility ctjr td|t|||||}nt ||||}d|_t t|#|||y)aCreates a `FileWriter`, optionally shared within the given session. Typically, constructing a file writer creates a new event file in `logdir`. This event file will contain `Event` protocol buffers constructed when you call one of the following functions: `add_summary()`, `add_session_log()`, `add_event()`, or `add_graph()`. If you pass a `Graph` to the constructor it is added to the event file. (This is equivalent to calling `add_graph()` later). TensorBoard will pick the graph from the file and display it graphically so you can interactively explore the graph you built. You will usually pass the graph from the session in which you launched it: ```python ...create a graph... # Launch the graph in a session. sess = tf.compat.v1.Session() # Create a summary writer, add the 'graph' to the event file. writer = tf.compat.v1.summary.FileWriter(, sess.graph) ``` The `session` argument to the constructor makes the returned `FileWriter` a compatibility layer over new graph-based summaries (`tf.summary`). Crucially, this means the underlying writer resource and events file will be shared with any other `FileWriter` using the same `session` and `logdir`. In either case, ops will be added to `session.graph` to control the underlying file writer resource. Args: logdir: A string. Directory where event file will be written. graph: A `Graph` object, such as `sess.graph`. max_queue: Integer. Size of the queue for pending events and summaries. flush_secs: Number. How often, in seconds, to flush the pending events and summaries to disk. graph_def: DEPRECATED: Use the `graph` argument instead. filename_suffix: A string. Every event file's name is suffixed with `suffix`. session: A `tf.compat.v1.Session` object. See details above. Raises: RuntimeError: If called with eager execution enabled. @compatibility(eager) `v1.summary.FileWriter` is not compatible with eager execution. To write TensorBoard summaries under eager execution, use `tf.summary.create_file_writer` or a `with v1.Graph().as_default():` context. @end_compatibility zv1.summary.FileWriter is not compatible with eager execution. Use `tf.summary.create_file_writer`,or a `with v1.Graph().as_default():` contextNF) rexecuting_eagerly RuntimeErrorrr _closedsuperrvr&) r#rVr max_queue flush_secsrfilename_suffixsessionr __class__s r%r&zFileWriter.__init___sst  "  9 ::& 69j/Cl%VY %46lDL *d$\5)Dr'c|S)"Make usable with "with" statement.rsr#s r% __enter__zFileWriter.__enter__s Kr'c$|jy)rN)close)r# unused_type unused_valueunused_tracebacks r%__exit__zFileWriter.__exit__s JJLr'c6|jjS)z7Returns the directory where event file will be written.)rrJrs r%rJzFileWriter.get_logdirs    ' ' ))r'cH|jrtjdyy)NzqAttempting to use a closed FileWriter. The operation will be a noop unless the FileWriter is explicitly reopened.)rzwarningswarnrs r%_warn_if_event_writer_is_closedz*FileWriter._warn_if_event_writer_is_closeds ||mm./r'cN|jtt|||yri)rr{rvr3)r#r6rmrs r%r3zFileWriter._add_events ((* *d&ud3r'cZ|j|jj|y)zYAdds an event to the event file. Args: event: An `Event` protocol buffer. N)rrrn)r#r6s r%rnzFileWriter.add_events$  ((*&r'cX|j|jjy)z~Flushes the event file to disk. Call this method to make sure that all pending events have been written to disk. N)rrflushrs r%rzFileWriter.flushs" ((*r'cF|jjd|_y)z~Flushes the event file to disk and close the file. Call this method when you do not need the summary writer anymore. TN)rrrzrs r%rzFileWriter.closes  DLr'cF|jjd|_y)zReopens the EventFileWriter. Can be called after `close()` to add more events in the same directory. The events will go into a new events file. Does nothing if the EventFileWriter was not closed. FN)rreopenrzrs r%rzFileWriter.reopens DLr')N xNNN)rorprqrrr&rrrJrr3rnrrr __classcell__)rs@r%rvrvsSER#GER*/ 4'  r'rv)!rros.pathrLrjrtensorflow.core.frameworkrrtensorflow.core.protobufrtensorflow.core.utilrtensorflow.python.eagerrtensorflow.python.frameworkrr tensorflow.python.platformr r rAtensorflow.python.summaryr 2tensorflow.python.summary.writer.event_file_writerr 5tensorflow.python.summary.writer.event_file_writer_v2r tensorflow.python.util.tf_exportrrOobjectrrvrsr'r%rsv= /13*+2+,<2NS6 m'm'` #$%L*L&Lr'