目录
快捷键

torch.utils.tensorboard.writer 的源代码

# mypy: 允许未类型化定义
提供一个 API，用于将协议缓冲区写入事件文件，以便 TensorBoard 进行可视化

导入 操作系统
导入 时间
来自 打字 导入 可选, 类型检查, 联合

导入 火炬

如果 类型检查:
    来自 matplotlib.figure 导入 图形
来自 tensorboard.compat 导入 tf
来自 tensorboard.compat.proto 导入 event_pb2
来自 tensorboard.compat.proto.event_pb2 导入 活动, 会话日志
来自 tensorboard.plugins.projector.projector_config_pb2 导入 投影器配置
来自 tensorboard.summary.writer.event_file_writer 导入 EventFileWriter

来自 ._convert_np 导入 make_np
来自 嵌入 导入 获取嵌入信息, 创建矩阵, 创建精灵, 制作 tsv 文件, 编写 pbtxt
来自 ._onnx_graph 导入 加载 onnx_graph
来自 _pytorch_graph 导入 图
来自 _utils 导入 figure_to_image
来自 .summary 导入 (
    audio,
    自定义标量,
    直方图,
    原始直方图,
    超参数,
    图像,
    图像框,
    网格,
    PR 曲线,
    PR 曲线原始,
    标量,
    张量原型,
    文本,
    视频,
)

__all__ = [FileWriter, 摘要写入器]


类 FileWriter:
    将协议缓冲区写入事件文件，以便由 TensorBoard 消费。

`FileWriter`类提供了一个创建事件文件的机制
给定目录并添加摘要和事件到其中。该类更新
文件内容异步处理。这允许训练程序调用方法
直接从训练循环中向文件添加数据，而不会减慢训练速度
。
```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

    def 初始化(自身, 日志目录, 最大队列数=10, flush_secs=120, filename_suffix=""):
        创建一个`FileWriter`和一个事件文件。

构造时，写入器在`log_dir`中创建一个新的事件文件。
构造函数的其他参数控制异步写入
事件文件。

参数：
log_dir: 字符串。事件文件将被写入的目录。
max_queue: 整数。待处理事件队列的大小。
在进行一次 'add' 调用之前，摘要会强制刷新到磁盘。
默认为十个项目。
flush_secs: 数字。多久（以秒为单位）刷新一次
待处理事件和摘要到磁盘。默认每两分钟刷新一次。
事件文件后缀：字符串。添加到所有事件文件名中
的 log_dir 目录中。关于文件名构建的更多细节
tensorboard.summary.writer.event_file_writer.EventFileWriter。
```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
        # 有时传入 PosixPath，我们需要将其强制转换为
        # 一个字符串
        # TODO: 看看我们是否可以在未来移除这个，如果
        # 实际上是在传递一个 PosixPath
        # 日志目录 = 字符串(日志目录)
        自身.事件写入器 = 事件文件写入器(
            日志目录, 最大队列, 清空秒数, 文件名后缀
        )

    def 获取日志目录(自身):
        返回事件文件将被写入的目录。
        返回 自身.事件写入器.获取日志目录()

    def 添加事件(自身, 事件, 步长=无, 墙时=无):
        将事件添加到事件文件中。

参数：
事件：一个`Event`协议缓冲区。
步骤：数字。用于训练过程的可选全局步骤值。
以记录与事件相关的信息。
walltime: 浮点数。可选的 walltime 以覆盖默认值（当前值）
walltime（从 time.time()获取）自纪元以来的秒数
```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
        事件.wall_time = 时间.时间() 如果 walltime 是 None 否则 墙时
        如果 步骤 是 not 无:
            # 确保步骤从 numpy 或其他格式转换
            # 由于 protobuf 可能根据版本不同而无法转换
            事件.步骤 = int(步长)
        自身.事件写入器.添加事件(事件)

    def 添加摘要(自身, 摘要, 全局步数=无, 墙时=无):
        将一个`Summary`协议缓冲区添加到事件文件中。

此方法将提供的摘要封装在一个`Event`协议缓冲区中
并将其添加到事件文件中。

参数：
摘要：一个`Summary`协议缓冲区。
global_step：数字。可选的全局步长值，用于训练过程
以记录摘要。
walltime：浮点数。可选的 walltime 以覆盖默认值（当前值）
系统时间（从 time.time()获取）自纪元以来的秒数
```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
        事件 = event_pb2.活动(摘要=摘要)
        自身.添加事件(事件, 全局步数, walltime)

    def 添加图(自身, 图形配置文件, 墙时=无):
        将一个`Graph`和步骤统计协议缓冲区添加到事件文件中。

参数：
graph_profile: 一个`Graph`和步骤统计协议缓冲区。
walltime: 浮点数。可选的 walltime 以覆盖默认值（当前值）
walltime（从 time.time()获取）自纪元以来的秒数
```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
        图 = 图形配置文件[0]
        步骤统计信息 = 图形配置文件[1]
        事件 = event_pb2.活动(图形定义=图.序列化为字符串())
        自身.添加事件(事件, 无, 墙时)

        trm = event_pb2.标记运行元数据(
            标签=步骤 1, 运行元数据=步骤统计.序列化为字符串()
        )
        事件 = event_pb2.活动(标记运行元数据=trm)
        自身.添加事件(事件, 无, 墙上时间)

    def 添加_onnx_graph(自身, 图, 墙时=无):
        将`Graph`协议缓冲区添加到事件文件中。

参数：
graph: `Graph`协议缓冲区。
walltime: 浮点数。可选的 walltime 以覆盖默认值（当前值）
_get_file_writer(from time.time())
```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
        事件 = event_pb2.活动(graph_def=图.序列化为字符串())
        自身.添加事件(事件, 无, 墙时)

    def 清空(自身):
        将事件文件刷新到磁盘。

调用此方法以确保所有挂起的事件都已写入
磁盘。
```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
        自身.事件写入器.清空()

    def 关闭(自身):
        将事件文件刷新到磁盘并关闭文件。

当您不再需要摘要编写器时，调用此方法。
```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
        自身.事件编写器.关闭()

    def 重新打开(自身):
        重新打开 EventFileWriter。

在调用`close()`之后可以调用，以在相同目录下添加更多事件。
事件将进入一个新的事件文件中。
如果 EventFileWriter 没有被关闭，则不执行任何操作。
```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
        自身.事件写入器.重新打开()



[文档]类 摘要写入器:
    将条目直接写入到 log_dir 中的事件文件，以便 TensorBoard 消费。

`SummaryWriter`类提供了一个高级 API，用于在指定目录中创建事件文件
并向其中添加摘要和事件。该类异步更新文件内容。这使得训练程序可以直接从训练循环中调用方法向文件添加数据，而不会减慢训练速度
文件内容异步更新。这允许训练程序在训练循环中直接调用方法向文件添加数据，而不会减慢训练速度
文件内容异步更新。这允许训练程序在训练循环中直接调用方法向文件添加数据，而不会减慢训练速度
训练
```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```


[文档]    def 初始化(
        自身,
        日志目录=无,
        评论="",
        清理步骤=无,
        最大队列=10,
        清空秒数=120,
        文件名后缀="",
    ):
        创建一个`SummaryWriter`，该`SummaryWriter`将事件和摘要写入事件文件。

参数：
log_dir (字符串): 保存目录位置。默认为
runs/**CURRENT_DATETIME_HOSTNAME**，每次运行后都会更改。
使用分层文件夹结构来比较
运行之间的差异。例如，传入 'runs/exp1'，'runs/exp2' 等。
每进行一次新的实验，都要在它们之间进行比较。
comment（字符串）：附加到默认值的 comment_log_dir 注释日志后缀。
``log_dir``。如果 ``log_dir`` 已分配，则此参数无效。
purge_step（整数）：
当在步骤 :math:`T+X` 记录崩溃并在步骤 :math:`T` 重新启动时，
任何全局步骤大于或等于 :math:`T` 的事件将被
清除并从 TensorBoard 中隐藏。
注意，崩溃并恢复的实验应该有相同的 ``log_dir``。
max_queue (int): 待处理事件的队列大小
在一次 'add' 调用之前，如果达到 summaries 的数量，则强制将数据刷新到磁盘。默认为十个项目。
默认值为十个项目。
flush_secs (int): 多久（以秒为单位）刷新一次到磁盘。
将待处理的事件和摘要写入磁盘。默认每两分钟执行一次。
filename_suffix (str): 添加到所有事件文件名后的后缀。
在 log_dir 目录中。关于文件名构建的更多详细信息。
tensorboard.summary.writer.event_file_writer.EventFileWriter。

示例：

导入 torch.utils.tensorboard 模块

# 创建一个带有自动生成文件夹名的摘要写入器。
            writer = SummaryWriter()
# 文件夹位置：runs/May04_22-14-54_s-MacBook-Pro.local/

使用指定的文件夹名称创建一个摘要写入器。
            writer = SummaryWriter("my_experiment")
文件夹位置：my_experiment

添加注释后创建摘要写入器。
            writer = SummaryWriter(comment="LR_0.1_BATCH_16")
# 文件夹位置：runs/May04_22-14-54_s-MacBook-Pro.localLR_0.1_BATCH_16/

```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
        火炬._C._log_api_usage_once("tensorboard.create.summarywriter")
        如果 not log_dir:
            导入 套接字
            来自 datetime 导入 datetime

            当前时间 = 日期时间.现在().strftime("%b"%d_%H-%M-%S)
            日志目录 = 操作系统.路径.加入(
                运行, 当前时间 + _ + 套接字.获取主机名() + 注释
            )
        自身.日志目录 = 日志目录
        自身.清理步骤 = 清理步骤
        自身.最大队列 = 最大队列
        自身.清空秒数 = 清空秒数
        自身.文件名后缀 = 文件名后缀

        # 初始化文件写入器，但在关闭时可以清除
        # 根据需要稍后重新创建
        自身.文件写入器 = 自身.所有写入器 = None
        自身._获取文件写入器()

        # 为直方图创建默认的存储区，请参阅 tensorflow/tensorboard 中的 generate_testdata.py
        v = 1e-12
        buckets = []
        负桶 = []
        while v < 100000000000000000000:
            桶.追加(v)
            负桶.追加(-v)
            v *= 1.1
        自身.默认桶 = 否定桶[::-1] + [0] + 桶


    def 获取文件写入器(自身):
        返回默认的 FileWriter 实例。如果已关闭，则重新创建。
        如果 自身.所有写入器 是 None 或 自身.文件写入器 是 无:
            自身.文件写入器 = FileWriter(
                自身.日志目录, 自身.最大队列, 自身.flush_secs, 自身.filename_suffix
            )
            自身.all_writers = {自身.file_writer.获取日志目录(): 自身.文件写入器}
            如果 自身.清除步骤 是 not 无:
                最近步骤 = 自身.清除步骤
                自身.文件写入器.添加事件(
                    活动(步长=最近步骤, 文件版本="大脑事件：2")
                )
                自身.文件写入器.添加事件(
                    活动(
                        步长=最近一步,
                        会话日志=会话日志(状态=会话日志.开始),
                    )
                )
                自身.清理步骤 = None
        返回 自身.文件写入器

    def 获取日志目录(自身):
        返回将写入事件文件的目录。
        返回 自身.日志目录


[文档]    def 添加超参数(
        自身,
        超参数字典,
        指标字典,
        超参数域离散=无,
        运行名称=无,
        全局步数=无,
    ):
        在 TensorBoard 中添加一组要比较的超参数。

参数：
hparam_dict (dict): 每个字典中的键值对是超参数的名称及其对应的值。
超参数的名称及其对应的值。
值的类型可以是 `bool`、`string`、`float`、
`int` 或 `None`。
metric_dict (字典): 字典中的每个键值对都是指标名称及其对应的值。注意，这里的键在 tensorboard 记录中应该是唯一的。否则，您通过 ``add_scalar`` 添加的值将在 hparam 插件中显示。在大多数情况下
的情况下，这里使用的键应该是唯一的。否则，您通过 ``add_scalar`` 添加的值将在 hparam 插件中显示。
的情况下，这里使用的键应该是唯一的。否则，您通过 ``add_scalar`` 添加的值将在 hparam 插件中显示。在大多数情况下
的情况下，这里使用的键应该是唯一的。否则，您通过 ``add_scalar`` 添加的值将在 hparam 插件中显示。在大多数情况下
案例中，这是不需要的。
hparam_domain_discrete: (Optional[Dict[str, List[Any]]]) 一个字典，包含超参数的名称以及它们可以持有的所有离散值
包含超参数的名称以及它们可以持有的所有离散值
run_name (str): 运行名称，将被包含在日志目录中。
如果未指定，将使用当前时间戳。
global_step (int): 记录的全局步数值

示例：

从 torch.utils.tensorboard 导入 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})

预期结果：

.. 图片:: _static/img/tensorboard/add_hparam.png
缩放比例：50%

```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
        火炬._C._log_api_usage_once(tensorboard.logging.add_hparams)
        如果 类型(hparam_dict) 是 not 字典 或 类型(metric_dict) 是 not 字典:
            提升 类型错误("hparam_dict 和 metric_dict 应该是字典。")
        exp, ssi, 你好 = 超参数(超参数字典, 指标字典, 离散超参数域)

        如果 not 运行名称:
            运行名称 = 字符串(时间.时间())
        日志目录 = 操作系统.路径.加入(自身.获取文件写入器().获取日志目录(), 运行名称)
        与 SummaryWriter(日志目录=日志目录) 作为 w_水平方向:
            w_水平方向.文件写入器.添加摘要(exp, 全局步数)
            w_hp.文件写入器.添加摘要(ssi, 全局步数)
            w_hp.文件写入器.添加摘要(你好, 全局步数)
            为 k, v 在 指标字典.项目():
                w_hp.添加标量(k, v, 全局步数)



[文档]    def 添加标量(
self,
标签,
标量值,
global_step=None,
walltime=None,
new_style=False,
double_precision=False,
    ):
"""向摘要添加标量数据。

Args:
标签（字符串）：数据标识符
标量值（浮点数或字符串/ blob 名称）：要保存的值
全局步数（int）：记录全局步数值
墙时（浮点数）：可选覆盖默认墙时（time.time()）
使用事件纪元后的秒数
新样式（布尔值）：是否使用新样式（张量字段）或旧样式
样式（简单值字段）。新样式可能导致数据加载更快。
示例：

从 torch.utils.tensorboard 导入 SummaryWriter
writer = SummaryWriter()
x = range(100)
for i in x:
writer.add_scalar('y=2x', i * 2, i)
writer.close()

预期结果：

.. 图像:: _static/img/tensorboard/add_scalar.png
缩放比例：50%

"""
torch._C._log_api_usage_once("tensorboard.logging.add_scalar")

summary = scalar(
标签，标量值，新样式=new_style，双精度=double_precision
        )
self._get_file_writer().add_summary(summary, global_step, walltime)



[文档] def add_scalars(self, main_tag, tag_scalar_dict, global_step=None, walltime=None):
添加许多标量数据到摘要中。

参数：
main_tag (str): 标签的父名称
tag_scalar_dict (dict): 存储标签及其对应值的键值对
global_step (int): 全局步数值，用于记录
walltime (float): 可选覆盖默认 walltime (time.time())
seconds after epoch of event

示例::

从 torch.utils.tensorboard 导入 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()
# 这个调用将三个值添加到同一个带有标签的标量图中。
# 'run_14h' 在 TensorBoard 的标量部分中。

预期结果：

.. 图像:: _static/img/tensorboard/add_scalars.png
缩放比例：50%

""
torch._C._log_api_usage_once("tensorboard.logging.add_scalars")
walltime = time.time() if walltime is None else walltime
fw_logdir = self._get_file_writer().get_logdir()
for tag, scalar_value in tag_scalar_dict.items():
fw_tag = fw_logdir + "/" + main_tag.replace("/", "_") + "_" + tag
assert self.all_writers is not None
如果 fw_tag 在 self.all_writers.keys() 中：
fw = self.all_writers[fw_tag]
else:
fw = FileWriter(
fw_tag, self.max_queue, self.flush_secs, self.filename_suffix
                )
self.all_writers[fw_tag] = fw
fw.add_summary(scalar(main_tag, scalar_value), global_step, walltime)


    def 添加张量(
        自身,
        标签,
        张量,
        全局步数=无,
        墙时=无,
    ):
        将张量数据添加到摘要。

参数：
标签（str）：数据标识符
tensor (torch.Tensor): 要保存的 tensor
global_step (int): 记录的全局步数
示例：

            from torch.utils.tensorboard import SummaryWriter
            writer = SummaryWriter()
            x = torch.tensor([1,2,3])
            writer.add_scalar('x', x)
            writer.close()

预期结果：
            Summary::tensor::float_val [1,2,3]
tensor::shape [3]
tag 'x'

```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
        火炬._C._log_api_usage_once(tensorboard.logging.add_tensor)

        摘要 = 张量原型(标签, 张量)
        自身._获取文件写入器().添加摘要(摘要, 全局步数, 墙时)


[文档]    def 添加直方图(
self,
标签,
values,
global_step=None,
bins="tensorflow",
walltime=None,
max_bins=None,
    ):
添加直方图到摘要。

Args:
数据标识符
构建直方图的值（torch.Tensor、numpy.ndarray 或字符串/blobname）
记录的全局步数（int）
分箱方式（str）：可以是{'tensorflow','auto', 'fd', ...}之一。这决定了如何创建分箱。详细信息请查阅
其他选项请参考：https://docs.scipy.org/doc/numpy/reference/generated/numpy.histogram.html
walltime（浮点数）：可选覆盖默认的 walltime（time.time()）
事件自纪元以来的秒数

示例::

从 torch.utils.tensorboard 导入 SummaryWriter
导入 numpy 库
writer = SummaryWriter()
for i in range(10):
x = np.random.random(1000)
writer.add_histogram('distribution centers', x + i, i)
writer.close()

预期结果：

.. 图片:: _static/img/tensorboard/add_histogram.png
缩放: 50 %

"""
torch._C._log_api_usage_once("tensorboard.logging.add_histogram")
如果 isinstance(bins, str) 并且 bins 等于 "tensorflow":
bins = self.default_bins
self._get_file_writer().add_summary(
histogram(tag, values, bins, max_bins=max_bins), global_step, walltime
        )


    def 添加直方图原始数据(
        自身,
        标签,
        最小,
        最大值,
        数字,
        总和,
        求平方和,
        桶限制,
        桶计数,
        全局步数=无,
        墙时=无,
    ):
        添加包含原始数据的直方图。

参数：
标签（字符串）：数据标识符
最小值（浮点数或整数）
最大值（浮点数或整数）
数量（整数）
总和（浮点数或整数）
所有值的平方和（浮点数或整数）
桶限制（torch.Tensor，numpy.ndarray）：每个桶的上限值。
它的元素数量应该与 `bucket_counts` 相同。
桶计数（torch.Tensor，numpy.ndarray）：每个桶的值数量
global_step（int）：记录的全局步长值
walltime（浮点数）：可选覆盖默认 walltime（time.time()）
事件自纪元以来的秒数
查看：https://github.com/tensorflow/tensorboard/blob/master/tensorboard/plugins/histogram/README.md

示例：

从 torch.utils.tensorboard 导入 SummaryWriter
导入 numpy 库
创建 SummaryWriter 对象
创建一个空列表
遍历从 0 到 49 的数字范围
                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()

预期结果：

.. 图像 :: _static/img/tensorboard/add_histogram_raw.png
缩放比例：50%

```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
        火炬._C._log_api_usage_once(tensorboard.logging.add_histogram_raw)
        如果 长度(桶限制) != 长度(桶计数):
            提升 ValueError(
                "len(bucket_limits) != len(bucket_counts)，见文档。"
            )
        自身._get_file_writer().添加摘要(
            原始直方图(
                标签, 最小, 最大值, 数字, 总和, 平方和, 桶限制, 桶计数
            ),
            全局步数,
            墙时,
        )


[文档]    def 添加图片(
        自身, 标签, 图像张量, 全局步数=无, 墙时=无, 数据格式=CHW
    ):
        将图像数据添加到摘要中。

注意这需要 `pillow` 包。

参数：
tag (str): 数据标识符
img_tensor (torch.Tensor, numpy.ndarray, 或 string/blobname): 图像数据
global_step (int): 记录的全局步长值
walltime (浮点数): 可选覆盖默认 walltime (time.time())
事件自纪元以来的秒数
dataformats (字符串): 图像数据格式规范，形式为
CHW, HWC, HW, WH 等。
形状：
img_tensor: 默认为 :math:`(3, H, W)`。您可以使用 ``torchvision.utils.make_grid()`` 将一批张量转换为 3xHxW 格式，或者调用 ``add_images`` 让我们来做这项工作。
将一批张量转换为 3xHxW 格式或调用 ``add_images`` 让我们来做这项工作。
张量具有 :math:`(1, H, W)`、:math:`(H, W)`、:math:`(H, W, 3)` 的形状，只要传递相应的 ``dataformats`` 参数，例如 ``CHW``、``HWC``、``HW``，也是合适的。
例如，传递 ``dataformats`` 参数，例如 ``CHW``、``HWC``、``HW``。

示例：

从 torch.utils.tensorboard 导入 SummaryWriter
导入 numpy 库
            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)

# 如果你有非默认维度设置，请设置 dataformats 参数。
            writer.add_image('my_image_HWC', img_HWC, 0, dataformats='HWC')
            writer.close()

预期结果：

.. 图像 :: _static/img/tensorboard/add_image.png
缩放比例：50%

```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
        火炬._C._log_api_usage_once(tensorboard.logging.add_image)
        自身.获取文件写入器().添加摘要(
            图片(标签, 图像张量, 数据格式=数据格式), 全局步数, 墙时
        )



[文档]    def 添加图片(
self, tag, img_tensor, global_step=None, walltime=None, dataformats="NCHW"
    ):
将批量的图像数据添加到摘要中。

注意，这需要`pillow`包。

Args:
tag (str): 数据标识符
img_tensor (torch.Tensor, numpy.ndarray, or string/blobname): 图像数据
global_step (int): 全局步长值
walltime (浮点数): 可选覆盖默认 walltime (time.time())
事件自纪元以来的秒数
数据格式 (字符串)：图像数据格式规范，形式为
NCHW, NHWC, CHW, HWC, HW, WH 等
形状：
img_tensor: 默认为 :math:`(N, 3, H, W)`。如果指定了 `dataformats`，则形状将不同。
接受。例如：NCHW 或 NHWC。

示例：

从 torch.utils.tensorboard 导入 SummaryWriter
导入 numpy 库

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()

预期结果：

.. 图像 :: _static/img/tensorboard/add_images.png
缩放: 30 %

"""
torch._C._log_api_usage_once("tensorboard.logging.add_images")
self._get_file_writer().add_summary(
image(tag, img_tensor, dataformats=dataformats), global_step, walltime
        )


    def 添加带框的图片(
        自身,
        标签,
        图像张量,
        框张量,
        全局步数=无,
        墙时=无,
        缩放=1,
        数据格式="CHW",
        标签=无,
    ):
        添加图像并在图像上绘制边界框。

参数：
tag (str): 数据标识符
img_tensor (torch.Tensor, numpy.ndarray, 或 string/blobname): 图像数据
box_tensor (torch.Tensor, numpy.ndarray, 或字符串/blobname): 检测到的对象的框数据
框应以 [x1, y1, x2, y2] 的形式表示。
global_step (int): 记录的全局步长值
walltime (float): 可选覆盖默认 walltime (time.time())
事件纪元后的秒数
rescale（浮点数）：可选的缩放覆盖
dataformats（字符串）：图像数据格式规范，形式为
NCHW, NHWC, CHW, HWC, HW, WH 等。
标签列表（字符串列表）：每个边界框要显示的标签。
形状：
img_tensor：默认为 :math:`(3, H, W)`。可以通过 ``dataformats`` 参数指定。
例如 CHW 或 HWC

box_tensor：（torch.Tensor，numpy.ndarray 或字符串/ blobname）：NX4，其中 N 是数量
每行 4 个元素表示（xmin, ymin, xmax, ymax）的盒子。
```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
        火炬._C._log_api_usage_once(tensorboard.logging.add_image_with_boxes)
        如果 标签 是 not 无:
            如果 isinstance(标签, 字符串):
                标签 = [标签]
            如果 长度(标签) != 箱张量.shape[0]：
                标签 = None
        自身._获取文件写入器().添加摘要(
            图像框(
                标签,
                图像张量,
                框张量,
                调整大小=调整大小,
                数据格式=数据格式,
                标签=标签,
            ),
            全局步数,
            墙面时间,
        )


[文档]    def 添加图表(
self,
tag: 字符串类型,
figure: Union["Figure", list["Figure"]],
global_step: Optional[int] = None,
close: 布尔 = True,
walltime: 可选 [浮点数] = None,
) -> None:
"""将 matplotlib 图像渲染为图像并添加到摘要。

注意这需要 ``matplotlib`` 包。

Args:
标签：数据标识符
figure：图或图列表
global_step: 记录的全局步数值
close: 自动关闭图形的标志
walltime: 可选覆盖默认 walltime（time.time()）
event 在 epoch 之后的秒数
"""
torch._C._log_api_usage_once("tensorboard.logging.add_figure")
如果 figure 是列表类型：
self.add_image(
标签,
figure_to_image(figure, close),
global_step,
walltime,
dataformats="NCHW",
            )
else:
self.add_image(
标签,
figure_to_image(figure, close),
global_step,
walltime,
dataformats="CHW"
            )



[文档]    def add_video(self, tag, vid_tensor, global_step=None, fps=4, walltime=None):
"""添加视频数据到摘要。

注意这需要 ``moviepy`` 包。

参数:
标签（字符串）：数据标识符
vid_tensor (torch.Tensor): 视频数据
全局步数（int）：记录全局步数值
帧率（浮点数或整数）：每秒帧数
walltime (浮点数): 可选覆盖默认 walltime (time.time())
事件自纪元以来的秒数
形状：
vid_tensor: :math:`(N, T, C, H, W)`。对于类型 `uint8`，值应在 [0, 255] 范围内，对于类型 `float`，值应在 [0, 1] 范围内。
"""
torch._C._log_api_usage_once("tensorboard.logging.add_video")
self._get_file_writer().add_summary(
video(tag, vid_tensor, fps), global_step, walltime
        )



[文档]    def 添加音频(
self, 标签, 音频张量, global_step=None, sample_rate=44100, walltime=None
    ):
添加音频数据到摘要。

参数：
标签 (str): 数据标识符
snd_tensor (torch.Tensor): 声音数据
全局步数（整数）：记录的全局步数值
采样率（整数）：以 Hz 为单位的采样率
walltime（浮点数）：可选覆盖默认 walltime（time.time()）
事件自纪元以来的秒数
形状：
snd_tensor: :math:`(1, L)` 的值应在 [-1, 1] 之间。
"""
torch._C._log_api_usage_once("tensorboard.logging.add_audio")
self._get_file_writer().add_summary(
audio(tag, snd_tensor, sample_rate=sample_rate), global_step, walltime
        )



[文档]    def add_text(self, tag, text_string, global_step=None, walltime=None):
添加文本数据到摘要。

Args:
标签 (str): 数据标识符
text_string (str): 要保存的字符串
global_step (int): 全局步数值，用于记录
walltime (float): 可选覆盖默认 walltime (time.time())
seconds after epoch of event
示例::

writer.add_text('lstm', '这是一个 lstm', 0)
writer.add_text('rnn', '这是一个 rnn', 10)
"""
torch._C._log_api_usage_once("tensorboard.logging.add_text")
self._get_file_writer().add_summary(
text(tag, text_string), global_step, walltime
        )


    def add_onnx_graph(自身, prototxt):
        火炬._C._log_api_usage_once(tensorboard.logging.add_onnx_graph)
        自身._get_file_writer().add_onnx_graph(加载 ONNX 图(prototxt))


[文档]    def 添加图(
self, 模型, 输入到模型=None, 详细=False, 使用严格跟踪=True
    ):
添加图形数据到摘要。

参数：
模型 (torch.nn.Module): 绘制模型。
input_to_model (torch.Tensor 或 torch.Tensor 列表): 要输入的变量或变量元组。
需要输入的变量。
verbose (bool): 是否在控制台打印图结构。
use_strict_trace (bool): 是否将关键字参数 `strict` 传递给
`torch.jit.trace`。当您想使跟踪器记录您的可变容器类型（列表、字典）时，请传递 False。
记录您的可变容器类型（列表、字典）。
"""
torch._C._log_api_usage_once("tensorboard.logging.add_graph")
一个有效的 PyTorch 模型应该有一个'forward'方法
self._get_file_writer().add_graph(
graph(model, input_to_model, verbose, use_strict_trace)
        )


    @staticmethod
    def 编码(原始字符串):
        我会使用 urllib，但我不确定 python3 与 python2 等之间的区别
        返回值 = 原始字符串
        返回值 = 返回值.替换(百分号, f百分比{ord(百分号):02x}")
        返回值 = 返回值.替换(根目录, f百分比{ord(根目录):02x}")
        返回值 = 返回值.替换("转义字符", "%%%02x" % (ord("转义字符")))  # noqa: UP031
        返回 返回值


[文档]    def 添加嵌入(
        自身,
        矩阵,
        元数据=无,
        标签图像=无,
        全局步数=无,
        标签=默认,
        元数据标题=无,
    ):
        将嵌入投影仪数据添加到摘要中。

参数：
mat (torch.Tensor 或 numpy.ndarray)：一个矩阵，其中每一行是数据点的特征向量
metadata (列表)：一个标签列表，每个元素将被转换为字符串
label_img (torch.Tensor)：对应每个数据点的图像
全局步数（整数）：记录的全局步数值
标签（字符串）：嵌入名称
元数据标题（列表）：多列元数据的标题列表。如果提供，则每个元数据必须是一个与标题对应的值列表。
一个与标题对应的值列表。
形状：
矩阵：:math:`(N, D)`，其中 N 是数据数量，D 是特征维度

标签图像：:math:`(N, C, H, W)`

示例：

导入关键字
导入 torch
            meta = []
当 len(meta)<100 时：
meta = meta+keyword.kwlist # 获取一些字符串
            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 添加嵌入(torch.randn(100, 5), metadata=meta, label_img=label_img)
writer 添加嵌入(torch.randn(100, 5), 标签_img=label_img)
writer 添加嵌入(torch.randn(100, 5), metadata=meta)

.. 注意::
分类（即非数值）元数据如果用于分类，则不能超过 50 个唯一值。
在嵌入投影仪中着色。

```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
        火炬._C._log_api_usage_once(tensorboard.logging.add_embedding)
        mat = make_np(矩阵)
        如果 global_step 是 无:
            global_step = 0
            清除 pbtxt？

        我们可能应该对标签进行编码，这样斜杠就不会让我们陷入困境？
        我认为这不会给我们带来麻烦，但安全第一。
        subdir = f"{字符串(全局步数).填充(5)}/{自身.编码(标签)}"
        保存路径 = 操作系统.路径.加入(自身._获取文件写入器().获取日志目录(), 子目录)

        文件系统 = tf.输入/输出.文件
        如果 文件系统.存在(保存路径):
            如果 文件系统.isdir(保存路径):
                打印(
                    "警告：嵌入目录存在，您是否为 add_embedding()设置了 global_step?"
                )
            否则:
                提升 目录不存在错误(
                    f路径：`{保存路径}`存在，但是一个文件。无法继续。
                )
        否则:
            文件系统.创建多级目录(保存路径)

        如果 元数据 是 not 无:
            断言 矩阵.shape[0] == 长度(
                元数据
            ), "#标签应与#数据点相等"
            生成 tsv 文件(元数据, 保存路径, 元数据标题=元数据标题)

        如果 标签图片 是 not 无:
            断言 (
                矩阵.shape[0] == 标签图片.shape[0]
            ), "#图像数量应等于#数据点数量"
            创建精灵(标注图片, 保存路径)

        断言 (
            矩阵.维数 == 2
        ), "矩阵应为二维，其中 mat.size(0)是数据点的数量"
        make_mat(矩阵, save_path)

        # 文件系统不一定具有追加语义，因此我们存储一个
        # 内部缓冲区以追加，并在每次之后重写整个文件
        #嵌入已添加
        如果 not 有属性(自身, _投影仪配置):
            自身._投影仪配置 = 投影仪配置()
        嵌入信息 = 获取嵌入信息(
            元数据, 标签图片, 子目录, 全局步数, 标签
        )
        自身.投影仪配置.嵌入.扩展([嵌入信息])

        来自 google.protobuf 导入 文本格式

        config_pbtxt = text_format.MessageToString(自身._projector_config)
        编写 pbtxt(自身.获取文件写入器().获取日志目录(), config_pbtxt)



[文档]    def 添加_pr_曲线(
self,
tag,
labels,
predictions,
global_step=None,
num_thresholds=127,
weights=None,
walltime=None,
    ):
添加精确率召回率曲线。

绘制精确率-召回率曲线可以帮助您了解模型在不同阈值设置下的性能。此功能，
可以让您根据不同的阈值设置来调整模型的表现。
您提供真实标签（T/F）和预测置信度
（通常是模型的输出）针对每个目标。TensorBoard UI
允许您交互式地选择阈值。

参数：
数据标识符
标签（torch.Tensor，numpy.ndarray 或字符串/blobname）
真实数据。每个元素的二进制标签。
预测结果（torch.Tensor，numpy.ndarray 或字符串/blobname）
一个元素被分类为真的概率。
值应在[0, 1]范围内
全局步数（int）：记录全局步数值
num_thresholds (int): 使用来绘制曲线的阈值数量。
walltime (浮点数): 可选覆盖默认 walltime (time.time())
事件自纪元以来的秒数

示例::

从 torch.utils.tensorboard 导入 SummaryWriter
导入 numpy 库
labels = np.random.randint(2, size=100)  # 二进制标签
predictions = np.random.rand(100)
writer = SummaryWriter()
writer.add_pr_curve('pr_curve', labels, predictions, 0)
writer.close()

"""
torch._C._log_api_usage_once("tensorboard.logging.add_pr_curve")
标签，预测 = make_np(标签)，make_np(预测)
self._get_file_writer().add_summary(
pr_curve(tag, labels, predictions, num_thresholds, weights),
global_step,
墙时,
        )


    def 添加原始 PR 曲线(
        自身,
        标签,
        真阳性数量,
        假阳性数量,
        真阴性数量,
        假阴性数量,
        precision,
        召回率,
        全局步数=无,
        数值阈值=127,
        权重=无,
        墙时=无,
    ):
        添加包含原始数据的精确率召回率曲线。

参数：
标签（字符串）：数据标识符
真阳性计数 (torch.Tensor, numpy.ndarray 或字符串/blobname)：真阳性计数
假阳性计数 (torch.Tensor, numpy.ndarray 或字符串/blobname)：假阳性计数
真阴性计数 (torch.Tensor, numpy.ndarray 或字符串/blobname)：真阴性计数
假阴性计数 (torch.Tensor, numpy.ndarray 或字符串/blobname)：假阴性计数
precision (torch.Tensor, numpy.ndarray, 或字符串/blobname): 精度
recall (torch.Tensor, numpy.ndarray, 或字符串/blobname): 召回率
global_step (int): 记录的全局步长值
num_thresholds (int): 绘制曲线所使用的阈值数量
walltime（浮点数）：可选覆盖默认 walltime（time.time()）
事件自纪元以来的秒数
查看：https://github.com/tensorflow/tensorboard/blob/master/tensorboard/plugins/pr_curve/README.md
```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
        火炬._C._log_api_usage_once(tensorboard.logging.add_pr_curve_raw)
        自身.获取文件写入器().添加摘要(
            pr_curve_raw(
                标签,
                真阳性数量,
                假阳性数量,
                真阴性数量,
                假阴性数量,
                precision,
                回忆,
                数阈值,
                权重,
            ),
            全局步数,
            墙时,
        )

    def 添加自定义标量多行图(
        自身, 标签, 分类=默认, 标题="无标题"
    ):
        "创建多行图的快捷方式。类似于 `add_custom_scalars()`，但唯一必要的参数是 *tags*。"

参数：
tags（列表）：在 `add_scalar()` 中使用过的标签列表

示例：

            writer.add_custom_scalars_multilinechart(['twse/0050', 'twse/2330'])
```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
        火炬._C._log_api_usage_once(
            tensorboard.logging.add_custom_scalars_multilinechart
        )
        布局 = {分类: {标题: [多行, 标签]}}
        自身.获取文件写入器().添加摘要(自定义标量(布局))

    def 添加自定义标量至 marginchart(
        自身, 标签, 分类=默认, 标题=未命名
    ):
        创建 marginchart 的缩写。

与`add_custom_scalars()`类似，但唯一必要的参数是*tags*，
应该恰好有 3 个元素。

参数：
标签（列表）：在 ``add_scalar()`` 中使用过的标签列表

示例：

            writer.add_custom_scalars_marginchart(['twse/0050', 'twse/2330', 'twse/2006'])
```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
        火炬._C._log_api_usage_once(
            tensorboard.logging.add_custom_scalars_marginchart
        )
        断言 长度(标签) == 3
        布局 = {分类: {标题: ["边距", 标签]}}
        自身.获取文件写入器().添加摘要(自定义标量(布局))


[文档]    def 添加自定义标量(self, 布局):
通过收集'scalars'中的图表标签来创建特殊的图表。

注意：此函数每个 SummaryWriter()对象只能调用一次。

因为它只提供元数据给 tensorboard，所以可以在训练循环前后调用此函数。

参数：
布局（字典）：{categoryName: *图表*}, 其中 *图表* 也是一个字典
{chartName: *属性列表*}. *属性列表*中的第一个元素是图表的类型
(一个 **多行** 或 **边距**，第二个元素应该是一个包含标签的列表)
您在 add_scalar 函数中使用的，将被收集到新的图表中。

示例::

布局 = {'台湾': {'twse': ['多行', ['twse/0050', 'twse/2330']]},
'美国': {'dow': ['保证金', ['dow/aaa', 'dow/bbb', 'dow/ccc']],
'纳斯达克': ['保证金', ['nasdaq/aaa', 'nasdaq/bbb', 'nasdaq/ccc']]}}

writer.add_custom_scalars(layout)
"""
torch._C._log_api_usage_once("tensorboard.logging.add_custom_scalars")
self._get_file_writer().add_summary(custom_scalars(layout))



[文档]    def 添加网格(
        自身,
        标签,
        顶点,
        颜色=无,
        面部=无,
        配置字典=无,
        全局步数=无,
        墙时=无,
    ):
        添加网格或 3D 点云到 TensorBoard。

可视化基于 Three.js，
因此它允许用户与渲染的对象进行交互。除了基本定义之外
例如顶点、面等，用户还可以进一步提供相机参数、光照条件等。
请查看 https://threejs.org/docs/index.html#manual/en/introduction/Creating-a-scene 以获取
高级用法。

参数：
标签（str）：数据标识符
vertices（torch.Tensor）：顶点的 3D 坐标列表。
colors（torch.Tensor）：每个顶点的颜色
faces（torch.Tensor）：每个三角形内顶点的索引。（可选）
config_dict: 三 JS 类名和配置的字典。
global_step (int): 记录的全局步长值。
walltime (float): 可选的覆盖默认 walltime（time.time()）。
事件自纪元以来的秒数。

形状：
顶点：:math:`(B, N, 3)`。 (批次，顶点数，通道)

颜色：:math:`(B, N, 3)`。对于类型 `uint8`，值应在 [0, 255] 范围内，对于类型 `float`，值应在 [0, 1] 范围内。

面部：:math:`(B, N, 3)`。对于类型 `uint8`，值应在 [0, 顶点数] 范围内。

示例：

从 torch.utils.tensorboard 导入 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]
]
            faces_tensor = torch.as_tensor([
[0, 2, 3]
[0, 3, 1]
[0, 1, 2]
[1, 3, 2]
torch.int).unsqueeze(0)

            writer = SummaryWriter()
            writer.add_mesh('my_mesh', vertices=vertices_tensor, colors=colors_tensor, faces=faces_tensor)

            writer.close()
```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
        火炬._C._log_api_usage_once(tensorboard.logging.add_mesh)
        自身.获取文件写入器().添加摘要(
            网格(标签, 顶点, 颜色, 边界, 配置字典), 全局步数, 墙时
        )



[文档]    def 清空(self):
"""清空事件文件到磁盘。

调用此方法以确保所有挂起的事件都已写入
磁盘。
"""
如果 self.all_writers 为 None：
返回
for writer in self.all_writers.values():
writer.flush()



[文档]    def close(self):
如果 self.all_writers 为 None：
return  # 忽略双重关闭
for writer in self.all_writers.values():
writer.flush()
writer.close()
self.file_writer = self.all_writers = None


    def __进入__(自身):
        返回 self

    def __退出__(自身, 异常类型, 异常值, 异常堆栈):
        自身.关闭()

© 版权所有 PyTorch 贡献者。

使用 Sphinx 构建，并使用 Read the Docs 提供的主题。

文档

查看 PyTorch 的全面开发者文档

查看文档

教程

深入了解初学者和高级开发者的教程

查看教程

资源

查找开发资源，获取您的疑问解答

查看资源

为了分析流量并优化您的体验，我们在本网站上使用 cookies。通过点击或导航，您同意允许我们使用 cookies。作为本网站的当前维护者，适用 Facebook 的 Cookies 政策。了解更多信息，包括关于可用控制的信息：Cookies 政策。