U ‰d»ã@sdZddlZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z ddl mZd d lmZd d lmZmZmZmZmZd d lmZd d lmZd dlmZd dlmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*Gdd„de+ƒZ,Gdd„de+ƒZ-dS)zlProvides an API for writing protocol buffers to event files to be consumed by TensorBoard for visualization.éN)Útf)Ú SessionLog)ÚEvent)Ú event_pb2)ÚProjectorConfig)ÚEventFileWriteré)Úmake_np)Úmake_matÚ make_spriteÚmake_tsvÚ write_pbtxtÚget_embedding_info)Úload_onnx_graph)Úgraph)Úfigure_to_image) ÚscalarÚ histogramÚ histogram_rawÚimageÚaudioÚtextÚpr_curveÚ pr_curve_rawÚvideoÚcustom_scalarsÚ image_boxesÚmeshÚhparamsc@sbeZdZdZddd„Zdd„Zdd d „Zdd d „Zddd„Zddd„Z dd„Z dd„Z dd„Z d S)Ú FileWritera—Writes protocol buffers to event files to be consumed by TensorBoard. 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. é éxÚcCst|ƒ}t||||ƒ|_dS)agCreates a `FileWriter` and an event file. On construction the writer creates a new event file in `log_dir`. The other arguments to the constructor control the asynchronous writes to the event file. Args: log_dir: A string. Directory where event file will be written. max_queue: Integer. Size of the queue for pending events and summaries before one of the 'add' calls forces a flush to disk. Default is ten items. flush_secs: Number. How often, in seconds, to flush the pending events and summaries to disk. Default is every two minutes. filename_suffix: A string. Suffix added to all event filenames in the log_dir directory. More details on filename construction in tensorboard.summary.writer.event_file_writer.EventFileWriter. N)ÚstrrÚ event_writer)ÚselfÚlog_dirÚ max_queueÚ flush_secsÚfilename_suffix©r*úB/tmp/pip-unpacked-wheel-ua33x9lu/torch/utils/tensorboard/writer.pyÚ__init__5sÿzFileWriter.__init__cCs |j ¡S)z7Returns the directory where event file will be written.)r$Ú get_logdir©r%r*r*r+r-OszFileWriter.get_logdirNcCs8|dkrt ¡n||_|dk r(t|ƒ|_|j |¡dS)a]Adds an event to the event file. Args: event: An `Event` protocol buffer. step: Number. Optional global step value for training process to record with the event. walltime: float. Optional walltime to override the default (current) walltime (from time.time()) seconds after epoch N)ÚtimeZ wall_timeÚintÚstepr$Ú add_event)r%Úeventr1Úwalltimer*r*r+r2Ss  zFileWriter.add_eventcCstj|d}| |||¡dS)añAdds 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. Args: summary: A `Summary` protocol buffer. global_step: Number. Optional global step value for training process to record with the summary. walltime: float. Optional walltime to override the default (current) walltime (from time.time()) seconds after epoch )ÚsummaryN)rrr2)r%r5Ú global_stepr4r3r*r*r+Ú add_summarycs zFileWriter.add_summarycCs^|d}|d}tj| ¡d}| |d|¡tjd| ¡d}tj|d}| |d|¡dS)a&Adds a `Graph` and step stats protocol buffer to the event file. Args: graph_profile: A `Graph` and step stats protocol buffer. walltime: float. Optional walltime to override the default (current) walltime (from time.time()) seconds after epoch rr©Z graph_defNZstep1)ÚtagZ run_metadata)Ztagged_run_metadata)rrÚSerializeToStringr2ZTaggedRunMetadata)r%Z graph_profiler4rZ stepstatsr3Ztrmr*r*r+Ú add_graphrsÿ zFileWriter.add_graphcCs"tj| ¡d}| |d|¡dS)zòAdds a `Graph` protocol buffer to the event file. Args: graph: A `Graph` protocol buffer. walltime: float. Optional walltime to override the default (current) _get_file_writerfrom time.time()) r8N)rrr:r2)r%rr4r3r*r*r+Úadd_onnx_graph…szFileWriter.add_onnx_graphcCs|j ¡dS©z‰Flushes the event file to disk. Call this method to make sure that all pending events have been written to disk. N)r$Úflushr.r*r*r+r>szFileWriter.flushcCs|j ¡dS)z…Flushes the event file to disk and close the file. Call this method when you do not need the summary writer anymore. N)r$Úcloser.r*r*r+r?—szFileWriter.closecCs|j ¡dS)zäReopens 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. N)r$Úreopenr.r*r*r+r@szFileWriter.reopen)r r!r")NN)NN)N)N) Ú__name__Ú __module__Ú __qualname__Ú__doc__r,r-r2r7r;r<r>r?r@r*r*r*r+r+s     rc@s,eZdZdZdMdd„Zdd „Zd d „Zd d „ZdNdd„ZdOdd„Z dPdd„Z dQdd„Z dRdd„Z dSdd„Z dTdd„ZdUd!d"„ZdVd$d%„ZdWd'd(„ZdXd*d+„ZdYd,d-„Zd.d/„ZdZd0d1„Zed2d3„ƒZd[d5d6„Zd\d8d9„Zd]d:d;„Zd^d=d>„Zd_d?d@„ZdAdB„Zd`dCdD„ZdEdF„ZdGdH„Z dIdJ„Z!dKdL„Z"dS)aÚ SummaryWritera²Writes entries directly to event files in the log_dir to be consumed by TensorBoard. The `SummaryWriter` class provides a high-level API 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. Nr"r r!c CsÔtj d¡|sPddl}ddlm}| ¡ d¡} tj  d| d|  ¡|¡}||_ ||_ ||_ ||_||_d|_|_| ¡d} g} g} | d kr¶|  | ¡|  | ¡| d 9} qŽ| ddd …dg| |_dS) a‚Creates a `SummaryWriter` that will write out events and summaries to the event file. Args: log_dir (string): Save directory location. Default is runs/**CURRENT_DATETIME_HOSTNAME**, which changes after each run. Use hierarchical folder structure to compare between runs easily. e.g. pass in 'runs/exp1', 'runs/exp2', etc. for each new experiment to compare across them. comment (string): Comment log_dir suffix appended to the default ``log_dir``. If ``log_dir`` is assigned, this argument has no effect. purge_step (int): When logging crashes at step :math:`T+X` and restarts at step :math:`T`, any events whose global_step larger or equal to :math:`T` will be purged and hidden from TensorBoard. Note that crashed and resumed experiments should have the same ``log_dir``. max_queue (int): Size of the queue for pending events and summaries before one of the 'add' calls forces a flush to disk. Default is ten items. flush_secs (int): How often, in seconds, to flush the pending events and summaries to disk. Default is every two minutes. filename_suffix (string): Suffix added to all event filenames in the log_dir directory. More details on filename construction in tensorboard.summary.writer.event_file_writer.EventFileWriter. Examples:: from torch.utils.tensorboard import SummaryWriter # create a summary writer with automatically generated folder name. writer = SummaryWriter() # folder location: runs/May04_22-14-54_s-MacBook-Pro.local/ # create a summary writer using the specified folder name. writer = SummaryWriter("my_experiment") # folder location: my_experiment # create a summary writer with comment appended. writer = SummaryWriter(comment="LR_0.1_BATCH_16") # folder location: runs/May04_22-14-54_s-MacBook-Pro.localLR_0.1_BATCH_16/ z tensorboard.create.summarywriterrN)Údatetimez %b%d_%H-%M-%SÚrunsÚ_gê-™—q=g@Œµx¯Dgš™™™™™ñ?éÿÿÿÿ)ÚtorchÚ_CÚ_log_api_usage_onceÚsocketrFÚnowÚstrftimeÚosÚpathÚjoinÚ gethostnamer&Ú purge_stepr'r(r)Ú file_writerÚ all_writersÚ_get_file_writerÚappendÚ default_bins) r%r&ÚcommentrTr'r(r)rMrFÚ current_timeÚvZbucketsZ neg_bucketsr*r*r+r,±s03  ÿ    zSummaryWriter.__init__cCs t|tƒS)ag Caffe2 users have the option of passing a string representing the name of a blob in the workspace instead of passing the actual Tensor/array containing the numeric values. Thus, we need to check if we received a string as input instead of an actual Tensor/array, and if so, we need to fetch the Blob from the workspace corresponding to that name. Fetching can be done with the following: from caffe2.python import workspace (if not already imported) workspace.FetchBlob(blob_name) workspace.FetchBlobs([blob_name1, blob_name2, ...]) )Ú isinstancer#)r%Úitemr*r*r+Ú_check_caffe2_blobs z SummaryWriter._check_caffe2_blobcCsŠ|jdks|jdkr„t|j|j|j|jƒ|_|j ¡|ji|_|jdk r„|j}|j  t |dd¡|j  t |t t j dd¡d|_|jS)z@Returns the default FileWriter instance. Recreates it if closed.Nz brain.Event:2)r1Z file_version)Ústatus)r1Z session_log) rVrUrr&r'r(r)r-rTr2rrÚSTART)r%Zmost_recent_stepr*r*r+rWs*ÿ  ÿ þÿzSummaryWriter._get_file_writercCs|jS)z8Returns the directory where event files will be written.©r&r.r*r*r+r-&szSummaryWriter.get_logdirc CsÀtj d¡t|ƒtk s$t|ƒtk r,tdƒ‚t|||ƒ\}}}|sNtt ¡ƒ}t j   |  ¡  ¡|¡}t|dH} | j |¡| j |¡| j |¡| ¡D]\} } |  | | ¡qœW5QRXdS)a Add a set of hyperparameters to be compared in TensorBoard. Args: hparam_dict (dict): Each key-value pair in the dictionary is the name of the hyper parameter and it's corresponding value. The type of the value can be one of `bool`, `string`, `float`, `int`, or `None`. metric_dict (dict): Each key-value pair in the dictionary is the name of the metric and it's corresponding value. Note that the key used here should be unique in the tensorboard record. Otherwise the value you added by ``add_scalar`` will be displayed in hparam plugin. In most cases, this is unwanted. hparam_domain_discrete: (Optional[Dict[str, List[Any]]]) A dictionary that contains names of the hyperparameters and all discrete values they can hold run_name (str): Name of the run, to be included as part of the logdir. If unspecified, will use current timestamp. Examples:: from torch.utils.tensorboard import SummaryWriter with SummaryWriter() as w: for i in range(5): w.add_hparams({'lr': 0.1*i, 'bsize': i}, {'hparam/accuracy': 10*i, 'hparam/loss': 10*i}) Expected result: .. image:: _static/img/tensorboard/add_hparam.png :scale: 50 % ztensorboard.logging.add_hparamsz1hparam_dict and metric_dict should be dictionary.rbN)rJrKrLÚtypeÚdictÚ TypeErrorrr#r/rPrQrRrWr-rErUr7ÚitemsÚ add_scalar) r%Z hparam_dictZ metric_dictZhparam_domain_discreteZrun_nameÚexpZssiZseiZlogdirZw_hpÚkr\r*r*r+Ú add_hparams*s"      zSummaryWriter.add_hparamsFc CsRtj d¡| |¡r,ddlm}| |¡}t||||d}| ¡  |||¡dS)ahAdd scalar data to summary. Args: tag (string): Data identifier scalar_value (float or string/blobname): Value to save global_step (int): Global step value to record walltime (float): Optional override default walltime (time.time()) with seconds after epoch of event new_style (boolean): Whether to use new style (tensor field) or old style (simple_value field). New style could lead to faster data loading. Examples:: from torch.utils.tensorboard import SummaryWriter writer = SummaryWriter() x = range(100) for i in x: writer.add_scalar('y=2x', i * 2, i) writer.close() Expected result: .. image:: _static/img/tensorboard/add_scalar.png :scale: 50 % ztensorboard.logging.add_scalarr©Ú workspace)Ú new_styleÚdouble_precisionN) rJrKrLr_Ú caffe2.pythonrlÚ FetchBlobrrWr7) r%r9Ú scalar_valuer6r4rmrnrlr5r*r*r+rg[s"    ÿzSummaryWriter.add_scalarc CsØtj d¡|dkrt ¡n|}| ¡ ¡}| ¡D]ž\}}|d| dd¡d|}|jdk sft ‚||j  ¡kr€|j|} nt ||j |j |jƒ} | |j|<| |¡r¾ddlm} |  |¡}|  t||ƒ||¡q4dS)aAdds many scalar data to summary. Args: main_tag (string): The parent name for the tags tag_scalar_dict (dict): Key-value pair storing the tag and corresponding values global_step (int): Global step value to record walltime (float): Optional override default walltime (time.time()) seconds after epoch of event Examples:: from torch.utils.tensorboard import SummaryWriter writer = SummaryWriter() r = 5 for i in range(100): writer.add_scalars('run_14h', {'xsinx':i*np.sin(i/r), 'xcosx':i*np.cos(i/r), 'tanx': np.tan(i/r)}, i) writer.close() # This call adds three values to the same scalar plot with the tag # 'run_14h' in TensorBoard's scalar section. Expected result: .. image:: _static/img/tensorboard/add_scalars.png :scale: 50 % ztensorboard.logging.add_scalarsNú/rHrrk)rJrKrLr/rWr-rfÚreplacerVÚAssertionErrorÚkeysrr'r(r)r_rorlrpr7r) r%Zmain_tagZtag_scalar_dictr6r4Z fw_logdirr9rqZfw_tagÚfwrlr*r*r+Ú add_scalarsˆs&   ÿ    zSummaryWriter.add_scalarsÚ tensorflowcCsftj d¡| |¡r,ddlm}| |¡}t|tƒrD|dkrD|j }|  ¡  t ||||d||¡dS)aAdd histogram to summary. Args: tag (string): Data identifier values (torch.Tensor, numpy.array, or string/blobname): Values to build histogram global_step (int): Global step value to record bins (string): One of {'tensorflow','auto', 'fd', ...}. This determines how the bins are made. You can find other options in: https://docs.scipy.org/doc/numpy/reference/generated/numpy.histogram.html walltime (float): Optional override default walltime (time.time()) seconds after epoch of event Examples:: from torch.utils.tensorboard import SummaryWriter import numpy as np writer = SummaryWriter() for i in range(10): x = np.random.random(1000) writer.add_histogram('distribution centers', x + i, i) writer.close() Expected result: .. image:: _static/img/tensorboard/add_histogram.png :scale: 50 % z!tensorboard.logging.add_histogramrrkrx)Úmax_binsN) rJrKrLr_rorlrpr]r#rYrWr7r)r%r9Úvaluesr6Zbinsr4ryrlr*r*r+Ú add_histogram¸s$    ÿzSummaryWriter.add_histogramc CsLtj d¡t|ƒt|ƒkr$tdƒ‚| ¡ t||||||||ƒ| | ¡dS)aˆAdds histogram with raw data. Args: tag (string): Data identifier min (float or int): Min value max (float or int): Max value num (int): Number of values sum (float or int): Sum of all values sum_squares (float or int): Sum of squares for all values bucket_limits (torch.Tensor, numpy.array): Upper value per bucket. The number of elements of it should be the same as `bucket_counts`. bucket_counts (torch.Tensor, numpy.array): Number of values per bucket global_step (int): Global step value to record walltime (float): Optional override default walltime (time.time()) seconds after epoch of event see: https://github.com/tensorflow/tensorboard/blob/master/tensorboard/plugins/histogram/README.md Examples:: from torch.utils.tensorboard import SummaryWriter import numpy as np writer = SummaryWriter() dummy_data = [] for idx, value in enumerate(range(50)): dummy_data += [idx + 0.001] * value bins = list(range(50+2)) bins = np.array(bins) values = np.array(dummy_data).astype(float).reshape(-1) counts, limits = np.histogram(values, bins=bins) sum_sq = values.dot(values) writer.add_histogram_raw( tag='histogram_with_raw_data', min=values.min(), max=values.max(), num=len(values), sum=values.sum(), sum_squares=sum_sq, bucket_limits=limits[1:].tolist(), bucket_counts=counts.tolist(), global_step=0) writer.close() Expected result: .. image:: _static/img/tensorboard/add_histogram_raw.png :scale: 50 % z%tensorboard.logging.add_histogram_rawz;len(bucket_limits) != len(bucket_counts), see the document.N)rJrKrLÚlenÚ ValueErrorrWr7r) r%r9ÚminÚmaxÚnumÚsumZ sum_squaresZ bucket_limitsZ bucket_countsr6r4r*r*r+Úadd_histogram_rawçs&> ÿÿûzSummaryWriter.add_histogram_rawÚCHWcCsLtj d¡| |¡r,ddlm}| |¡}| ¡ t |||d||¡dS)a(Add image data to summary. Note that this requires the ``pillow`` package. Args: tag (string): Data identifier img_tensor (torch.Tensor, numpy.array, or string/blobname): Image data global_step (int): Global step value to record walltime (float): Optional override default walltime (time.time()) seconds after epoch of event dataformats (string): Image data format specification of the form CHW, HWC, HW, WH, etc. Shape: img_tensor: Default is :math:`(3, H, W)`. You can use ``torchvision.utils.make_grid()`` to convert a batch of tensor into 3xHxW format or call ``add_images`` and let us do the job. Tensor with :math:`(1, H, W)`, :math:`(H, W)`, :math:`(H, W, 3)` is also suitable as long as corresponding ``dataformats`` argument is passed, e.g. ``CHW``, ``HWC``, ``HW``. Examples:: from torch.utils.tensorboard import SummaryWriter import numpy as np img = np.zeros((3, 100, 100)) img[0] = np.arange(0, 10000).reshape(100, 100) / 10000 img[1] = 1 - np.arange(0, 10000).reshape(100, 100) / 10000 img_HWC = np.zeros((100, 100, 3)) img_HWC[:, :, 0] = np.arange(0, 10000).reshape(100, 100) / 10000 img_HWC[:, :, 1] = 1 - np.arange(0, 10000).reshape(100, 100) / 10000 writer = SummaryWriter() writer.add_image('my_image', img, 0) # If you have non-default dimension setting, set the dataformats argument. writer.add_image('my_image_HWC', img_HWC, 0, dataformats='HWC') writer.close() Expected result: .. image:: _static/img/tensorboard/add_image.png :scale: 50 % ztensorboard.logging.add_imagerrk©Ú dataformatsN© rJrKrLr_rorlrprWr7r©r%r9Ú img_tensorr6r4r…rlr*r*r+Ú add_image2s.     ÿzSummaryWriter.add_imageÚNCHWcCsLtj d¡| |¡r,ddlm}| |¡}| ¡ t |||d||¡dS)a6Add batched image data to summary. Note that this requires the ``pillow`` package. Args: tag (string): Data identifier img_tensor (torch.Tensor, numpy.array, or string/blobname): Image data global_step (int): Global step value to record walltime (float): Optional override default walltime (time.time()) seconds after epoch of event dataformats (string): Image data format specification of the form NCHW, NHWC, CHW, HWC, HW, WH, etc. Shape: img_tensor: Default is :math:`(N, 3, H, W)`. If ``dataformats`` is specified, other shape will be accepted. e.g. NCHW or NHWC. Examples:: from torch.utils.tensorboard import SummaryWriter import numpy as np img_batch = np.zeros((16, 3, 100, 100)) for i in range(16): img_batch[i, 0] = np.arange(0, 10000).reshape(100, 100) / 10000 / 16 * i img_batch[i, 1] = (1 - np.arange(0, 10000).reshape(100, 100) / 10000) / 16 * i writer = SummaryWriter() writer.add_images('my_image_batch', img_batch, 0) writer.close() Expected result: .. image:: _static/img/tensorboard/add_images.png :scale: 30 % ztensorboard.logging.add_imagesrrkr„Nr†r‡r*r*r+Ú add_imagesis'     ÿzSummaryWriter.add_imagesrc Cs tj d¡| |¡r,ddlm} |  |¡}| |¡rLddlm} |  |¡}|dk rzt|tƒrd|g}t |ƒ|j dkrzd}|  ¡  t ||||||d||¡dS)auAdd image and draw bounding boxes on the image. Args: tag (string): Data identifier img_tensor (torch.Tensor, numpy.array, or string/blobname): Image data box_tensor (torch.Tensor, numpy.array, or string/blobname): Box data (for detected objects) box should be represented as [x1, y1, x2, y2]. global_step (int): Global step value to record walltime (float): Optional override default walltime (time.time()) seconds after epoch of event rescale (float): Optional scale override dataformats (string): Image data format specification of the form NCHW, NHWC, CHW, HWC, HW, WH, etc. labels (list of string): The label to be shown for each bounding box. Shape: img_tensor: Default is :math:`(3, H, W)`. It can be specified with ``dataformats`` argument. e.g. CHW or HWC box_tensor: (torch.Tensor, numpy.array, or string/blobname): NX4, where N is the number of boxes and each 4 elements in a row represents (xmin, ymin, xmax, ymax). z(tensorboard.logging.add_image_with_boxesrrkN)Úrescaler…Úlabels)rJrKrLr_rorlrpr]r#r|ÚshaperWr7r) r%r9rˆZ box_tensorr6r4rŒr…rrlr*r*r+Úadd_image_with_boxes™s0        úöz"SummaryWriter.add_image_with_boxesTcCsPtj d¡t|tƒr2|j|t||ƒ||ddn|j|t||ƒ||dddS)aRender matplotlib figure into an image and add it to summary. Note that this requires the ``matplotlib`` package. Args: tag (string): Data identifier figure (matplotlib.pyplot.figure) or list of figures: Figure or a list of figures global_step (int): Global step value to record close (bool): Flag to automatically close the figure walltime (float): Optional override default walltime (time.time()) seconds after epoch of event ztensorboard.logging.add_figurerŠr„rƒN)rJrKrLr]Úlistr‰r)r%r9Úfigurer6r?r4r*r*r+Ú add_figureÔs  ûûzSummaryWriter.add_figureécCs*tj d¡| ¡ t|||ƒ||¡dS)a>Add video data to summary. Note that this requires the ``moviepy`` package. Args: tag (string): Data identifier vid_tensor (torch.Tensor): Video data global_step (int): Global step value to record fps (float or int): Frames per second walltime (float): Optional override default walltime (time.time()) seconds after epoch of event Shape: vid_tensor: :math:`(N, T, C, H, W)`. The values should lie in [0, 255] for type `uint8` or [0, 1] for type `float`. ztensorboard.logging.add_videoN)rJrKrLrWr7r)r%r9Z vid_tensorr6Zfpsr4r*r*r+Ú add_videoós   ÿzSummaryWriter.add_videoéD¬cCsLtj d¡| |¡r,ddlm}| |¡}| ¡ t |||d||¡dS)aÒAdd audio data to summary. Args: tag (string): Data identifier snd_tensor (torch.Tensor): Sound data global_step (int): Global step value to record sample_rate (int): sample rate in Hz walltime (float): Optional override default walltime (time.time()) seconds after epoch of event Shape: snd_tensor: :math:`(1, L)`. The values should lie between [-1, 1]. ztensorboard.logging.add_audiorrk)Ú sample_rateN) rJrKrLr_rorlrprWr7r)r%r9Z snd_tensorr6r–r4rlr*r*r+Ú add_audios     ÿzSummaryWriter.add_audiocCs(tj d¡| ¡ t||ƒ||¡dS)aÈAdd text data to summary. Args: tag (string): Data identifier text_string (string): String to save global_step (int): Global step value to record walltime (float): Optional override default walltime (time.time()) seconds after epoch of event Examples:: writer.add_text('lstm', 'This is an lstm', 0) writer.add_text('rnn', 'This is an rnn', 10) ztensorboard.logging.add_textN)rJrKrLrWr7r)r%r9Z text_stringr6r4r*r*r+Úadd_texts  ÿzSummaryWriter.add_textcCs"tj d¡| ¡ t|ƒ¡dS)Nz"tensorboard.logging.add_onnx_graph)rJrKrLrWr<r)r%Zprototxtr*r*r+r<2s zSummaryWriter.add_onnx_graphc CsÄtj d¡t|dƒr0| ¡ t||||ƒ¡nddlm}ddl m }ddl m }m }m} t|tƒršt|d|jƒr€||ƒ} q¢t|d|jƒr¢| |ƒ} n||ƒ} tj|  ¡d} | ¡ | ¡d S) a Add graph data to summary. Args: model (torch.nn.Module): Model to draw. input_to_model (torch.Tensor or list of torch.Tensor): A variable or a tuple of variables to be fed. verbose (bool): Whether to print graph structure in console. use_strict_trace (bool): Whether to pass keyword argument `strict` to `torch.jit.trace`. Pass False when you want the tracer to record your mutable container types (list, dict) ztensorboard.logging.add_graphZforwardr)Ú caffe2_pb2)Úcorer)Úmodel_to_graph_defÚnets_to_graph_defÚprotos_to_graph_defr8N)rJrKrLÚhasattrrWr;rZ caffe2.protor™roršZ _caffe2_graphr›rœrr]rZNetZNetDefrrr:r2) r%ÚmodelZinput_to_modelÚverboseZuse_strict_tracer™ršr›rœrZ current_graphr3r*r*r+r;6s    ÿ     zSummaryWriter.add_graphcCsD|}| ddtdƒ¡}| ddtdƒ¡}| ddtdƒ¡}|S)Nú%z%%%02xrrú\)rsÚord)ZrawstrÚretvalr*r*r+Ú_encode_s zSummaryWriter._encodeÚdefaultc Csvtj d¡t|ƒ}|dkr d}dt|ƒ d¡| |¡f}tj  |  ¡  ¡|¡}t j j |¡} |  |¡rŒ|  |¡r~tdƒq–td|ƒ‚n |  |¡|dk rÆ|jdt|ƒks¸tdƒ‚t|||d |dk rô|jd|jdksêtd ƒ‚t||ƒ|jd kstd ƒ‚t||ƒt|d ƒs&tƒ|_t||| |||ƒ} |jj  !| g¡ddl"m#} |  $|j¡} t%|  ¡  ¡| ƒdS)aÝAdd embedding projector data to summary. Args: mat (torch.Tensor or numpy.array): A matrix which each row is the feature vector of the data point metadata (list): A list of labels, each element will be convert to string label_img (torch.Tensor): Images correspond to each data point global_step (int): Global step value to record tag (string): Name for the embedding Shape: mat: :math:`(N, D)`, where N is number of data and D is feature dimension label_img: :math:`(N, C, H, W)` Examples:: import keyword import torch meta = [] while len(meta)<100: meta = meta+keyword.kwlist # get some strings meta = meta[:100] for i, v in enumerate(meta): meta[i] = v+str(i) label_img = torch.rand(100, 3, 10, 32) for i in range(100): label_img[i]*=i/100.0 writer.add_embedding(torch.randn(100, 5), metadata=meta, label_img=label_img) writer.add_embedding(torch.randn(100, 5), label_img=label_img) writer.add_embedding(torch.randn(100, 5), metadata=meta) z!tensorboard.logging.add_embeddingNrz%s/%sézKwarning: Embedding dir exists, did you set global_step for add_embedding()?z1Path: `%s` exists, but is a file. Cannot proceed.z&#labels should equal with #data points)Úmetadata_headerz&#images should equal with #data pointséz@mat should be 2D, where mat.size(0) is the number of data pointsÚ_projector_config)Ú text_format)&rJrKrLr r#Úzfillr¥rPrQrRrWr-rÚioZgfileZget_filesystemÚexistsÚisdirÚprintÚ ExceptionÚmakedirsrŽr|rtr r Úndimr ržrrªrZ embeddingsÚextendZgoogle.protobufr«ZMessageToStringr ) r%ÚmatÚmetadataZ label_imgr6r9r¨ÚsubdirZ save_pathÚfsZembedding_infor«Z config_pbtxtr*r*r+Ú add_embeddinghs`*   ÿÿ  ÿþÿþ ÿþ  ÿ  zSummaryWriter.add_embeddingécCs@tj d¡t|ƒt|ƒ}}| ¡ t|||||ƒ||¡dS)arAdds precision recall curve. Plotting a precision-recall curve lets you understand your model's performance under different threshold settings. With this function, you provide the ground truth labeling (T/F) and prediction confidence (usually the output of your model) for each target. The TensorBoard UI will let you choose the threshold interactively. Args: tag (string): Data identifier labels (torch.Tensor, numpy.array, or string/blobname): Ground truth data. Binary label for each element. predictions (torch.Tensor, numpy.array, or string/blobname): The probability that an element be classified as true. Value should be in [0, 1] global_step (int): Global step value to record num_thresholds (int): Number of thresholds used to draw the curve. walltime (float): Optional override default walltime (time.time()) seconds after epoch of event Examples:: from torch.utils.tensorboard import SummaryWriter import numpy as np labels = np.random.randint(2, size=100) # binary label predictions = np.random.rand(100) writer = SummaryWriter() writer.add_pr_curve('pr_curve', labels, predictions, 0) writer.close() z tensorboard.logging.add_pr_curveN)rJrKrLr rWr7r)r%r9rZ predictionsr6Únum_thresholdsÚweightsr4r*r*r+Ú add_pr_curveÊs( ýzSummaryWriter.add_pr_curvec Cs6tj d¡| ¡ t|||||||| | ƒ || ¡dS)aAdds precision recall curve with raw data. Args: tag (string): Data identifier true_positive_counts (torch.Tensor, numpy.array, or string/blobname): true positive counts false_positive_counts (torch.Tensor, numpy.array, or string/blobname): false positive counts true_negative_counts (torch.Tensor, numpy.array, or string/blobname): true negative counts false_negative_counts (torch.Tensor, numpy.array, or string/blobname): false negative counts precision (torch.Tensor, numpy.array, or string/blobname): precision recall (torch.Tensor, numpy.array, or string/blobname): recall global_step (int): Global step value to record num_thresholds (int): Number of thresholds used to draw the curve. walltime (float): Optional override default walltime (time.time()) seconds after epoch of event see: https://github.com/tensorflow/tensorboard/blob/master/tensorboard/plugins/pr_curve/README.md z$tensorboard.logging.add_pr_curve_rawN)rJrKrLrWr7r) r%r9Ztrue_positive_countsZfalse_positive_countsZtrue_negative_countsZfalse_negative_countsZ precisionZrecallr6r»r¼r4r*r*r+Úadd_pr_curve_rawús  ÷ ózSummaryWriter.add_pr_curve_rawÚuntitledcCs2tj d¡||d|gii}| ¡ t|ƒ¡dS)aJShorthand for creating multilinechart. Similar to ``add_custom_scalars()``, but the only necessary argument is *tags*. Args: tags (list): list of tags that have been used in ``add_scalar()`` Examples:: writer.add_custom_scalars_multilinechart(['twse/0050', 'twse/2330']) z5tensorboard.logging.add_custom_scalars_multilinechartZ MultilineN©rJrKrLrWr7r©r%ÚtagsÚcategoryÚtitleÚlayoutr*r*r+Ú!add_custom_scalars_multilinechart)s ÿz/SummaryWriter.add_custom_scalars_multilinechartcCsBtj d¡t|ƒdkst‚||d|gii}| ¡ t|ƒ¡dS)awShorthand for creating marginchart. Similar to ``add_custom_scalars()``, but the only necessary argument is *tags*, which should have exactly 3 elements. Args: tags (list): list of tags that have been used in ``add_scalar()`` Examples:: writer.add_custom_scalars_marginchart(['twse/0050', 'twse/2330', 'twse/2006']) z2tensorboard.logging.add_custom_scalars_marginchartéZMarginN)rJrKrLr|rtrWr7rrÁr*r*r+Úadd_custom_scalars_marginchart<s ÿz,SummaryWriter.add_custom_scalars_marginchartcCs"tj d¡| ¡ t|ƒ¡dS)aCreate special chart by collecting charts tags in 'scalars'. Note that this function can only be called once for each SummaryWriter() object. Because it only provides metadata to tensorboard, the function can be called before or after the training loop. Args: layout (dict): {categoryName: *charts*}, where *charts* is also a dictionary {chartName: *ListOfProperties*}. The first element in *ListOfProperties* is the chart's type (one of **Multiline** or **Margin**) and the second element should be a list containing the tags you have used in add_scalar function, which will be collected into the new chart. Examples:: layout = {'Taiwan':{'twse':['Multiline',['twse/0050', 'twse/2330']]}, 'USA':{ 'dow':['Margin', ['dow/aaa', 'dow/bbb', 'dow/ccc']], 'nasdaq':['Margin', ['nasdaq/aaa', 'nasdaq/bbb', 'nasdaq/ccc']]}} writer.add_custom_scalars(layout) z&tensorboard.logging.add_custom_scalarsNrÀ)r%rÅr*r*r+Úadd_custom_scalarsPs z SummaryWriter.add_custom_scalarscCs.tj d¡| ¡ t|||||ƒ||¡dS)afAdd meshes or 3D point clouds to TensorBoard. The visualization is based on Three.js, so it allows users to interact with the rendered object. Besides the basic definitions such as vertices, faces, users can further provide camera parameter, lighting condition, etc. Please check https://threejs.org/docs/index.html#manual/en/introduction/Creating-a-scene for advanced usage. Args: tag (string): Data identifier vertices (torch.Tensor): List of the 3D coordinates of vertices. colors (torch.Tensor): Colors for each vertex faces (torch.Tensor): Indices of vertices within each triangle. (Optional) config_dict: Dictionary with ThreeJS classes names and configuration. global_step (int): Global step value to record walltime (float): Optional override default walltime (time.time()) seconds after epoch of event Shape: vertices: :math:`(B, N, 3)`. (batch, number_of_vertices, channels) colors: :math:`(B, N, 3)`. The values should lie in [0, 255] for type `uint8` or [0, 1] for type `float`. faces: :math:`(B, N, 3)`. The values should lie in [0, number_of_vertices] for type `uint8`. Examples:: from torch.utils.tensorboard import SummaryWriter vertices_tensor = torch.as_tensor([ [1, 1, 1], [-1, -1, 1], [1, -1, -1], [-1, 1, -1], ], dtype=torch.float).unsqueeze(0) colors_tensor = torch.as_tensor([ [255, 0, 0], [0, 255, 0], [0, 0, 255], [255, 0, 255], ], dtype=torch.int).unsqueeze(0) faces_tensor = torch.as_tensor([ [0, 2, 3], [0, 3, 1], [0, 1, 2], [1, 3, 2], ], dtype=torch.int).unsqueeze(0) writer = SummaryWriter() writer.add_mesh('my_mesh', vertices=vertices_tensor, colors=colors_tensor, faces=faces_tensor) writer.close() ztensorboard.logging.add_meshN)rJrKrLrWr7r)r%r9ZverticesÚcolorsZfacesZ config_dictr6r4r*r*r+Úadd_meshfs < ÿzSummaryWriter.add_meshcCs*|jdkrdS|j ¡D] }| ¡qdSr=)rVrzr>©r%Úwriterr*r*r+r>§s zSummaryWriter.flushcCs>|jdkrdS|j ¡D]}| ¡| ¡qd|_|_dS©N)rVrzr>r?rUrÌr*r*r+r?±s   zSummaryWriter.closecCs|SrÎr*r.r*r*r+Ú __enter__¹szSummaryWriter.__enter__cCs | ¡dSrÎ)r?)r%Úexc_typeÚexc_valÚexc_tbr*r*r+Ú__exit__¼szSummaryWriter.__exit__)Nr"Nr r!r")NN)NNFF)NN)NrxNN)NN)NNrƒ)NNrŠ)NNrrƒN)NTN)Nr“N)Nr•N)NN)NFT)NNNr¦N)NrºNN)NrºNN)r¦r¿)r¦r¿)NNNNN)#rArBrCrDr,r_rWr-rjrgrwr{r‚r‰r‹rr’r”r—r˜r<r;Ú staticmethodr¥r¹r½r¾rÆrÈrÉrËr>r?rÏrÓr*r*r*r+rE¦s² ù Qÿ 5ù - 4ù 9õ Lÿ 8ÿ 5÷ ;  ÿ  ÿ ) ù gø 9ô 0ÿ ÿ ø A rE).rDrPr/rJZtensorboard.compatrZ"tensorboard.compat.proto.event_pb2rrZtensorboard.compat.protorZ2tensorboard.plugins.projector.projector_config_pb2rZ,tensorboard.summary.writer.event_file_writerrZ _convert_npr Z _embeddingr r r r rZ _onnx_graphrZ_pytorch_graphrÚ_utilsrr5rrrrrrrrrrrrrÚobjectrrEr*r*r*r+Ús"          <{