torchvision.io¶

该软件包提供用于执行 IO 的函数操作。它们目前特定于读取和写入视频和图像。torchvision.io

视频¶

torchvision.io.read_video(文件名： str， start_pts： int = 0， end_pts：可选[float] = 无， pts_unit： str = 'pts'） → Tuple[torch.Tensor、torch 的 Tensor 和 Torch 的 T张量， Dict[str， Any]][来源]¶

从文件中读取视频，同时返回视频帧和音频帧

参数

filename （str） – 视频文件的路径
start_pts （int if pts_unit = 'pts'， float / Fraction if pts_unit = 'sec'，可选） – 视频的开始演示时间
end_pts （int if pts_unit = 'pts'， float / Fraction if pts_unit = 'sec'，可选） – 结束演示时间
pts_unit （str， optional） – 解释 start_pts 和 end_pts 值的单位， “pts”或“sec”。默认为 'pts'。

返回

T 视频帧 aframes （Tensor[K， L]）：音频帧，其中 K 是声道数，L 是点数 info （Dict）：视频和音频的元数据。可以包含字段 video_fps （float）和 audio_fps （int）

返回类型

vframes （张量 [T， H， W， C]）

torchvision.io.read_video_timestamps(文件名： str， pts_unit： str = 'pts'） → Tuple[List[int]， optional[float]][源]¶

列出视频帧时间戳。

请注意，该函数会逐帧解码整个视频。

参数

filename （str） – 视频文件的路径
pts_unit （str， optional） – 将返回时间戳值的单位 “pts”或“sec”。默认为 'pts'。

返回

视频中每个帧的演示时间戳。 video_fps （float， optional）：视频的帧速率

返回类型

pts （如果 pts_unit = 'pts'，则为 List[int]，如果 pts_unit = 'sec'，则为 List[Fraction]）

torchvision.io.write_video(文件名：str，video_array：torch。张量，fps：浮点数，video_codec：str = 'libx264'，选项：可选[Dict[str，任意]] = 无，audio_array：可选[torch.张量] = 无，audio_fps：可选[浮点数] = 无，audio_codec：可选[str] = 无，audio_options：可选[dict[str， any]] = 无） → 无[来源]¶

在视频文件中写入 [T， H， W， C] 格式的 4d 张量

参数

filename （str） – 保存视频的路径
video_array （Tensor[T， H， W， C]） – 包含各个帧的张量，作为 [T， H， W， C] 格式的 uint8 张量
fps （Number） – 每秒视频帧数
video_codec （str） – 视频编解码器的名称，即“libx264”、“h264”等。
options （Dict） – 包含要传递到 PyAV 视频流中的选项的字典
audio_array （Tensor[C， N]） – 包含音频的张量，其中 C 是通道数 N 是样本数
audio_fps （Number） – 音频采样率，通常为 44100 或 48000
audio_codec （str） – 音频编解码器的名称，即 “mp3”、“aac” 等。
audio_options （Dict） – 包含要传递到 PyAV 音频流中的选项的字典

细粒度视频 API¶

除了功能之外，我们还提供高性能与函数相比，用于更精细的控制。它在完全支持 torchscript 的同时完成所有这些工作。read_videoread_video

class （path， stream='video'）[来源]torchvision.io.VideoReader¶

细粒度视频阅读 API。支持从单个视频中逐帧读取各种流容器。

例

以下示例创建一个对象，查找到 2 秒 point 并返回单个帧：VideoReader

import torchvision
video_path = "path_to_a_test_video"
reader = torchvision.io.VideoReader(video_path, "video")
reader.seek(2.0)
frame = next(reader)

VideoReader实现可迭代 API，使其适合将其与结合使用以进行更高级的阅读。因此，我们可以在 for 循环中使用实例：VideoReader

reader.seek(2)
for frame in reader:
    frames.append(frame['data'])
# additionally, `seek` implements a fluent API, so we can do
for frame in reader.seek(2):
    frames.append(frame['data'])

使用，我们可以读取 2 到 5 秒之间的所有帧，其中以下代码：

for frame in itertools.takewhile(lambda x: x['pts'] <= 5, reader.seek(2)):
    frames.append(frame['data'])

同样，可以实现在 2 秒时间戳后读取 10 帧如下：

for frame in itertools.islice(reader.seek(2), 10):
    frames.append(frame['data'])

注意

每个流描述符由两部分组成：流类型（例如 'video'）和唯一的 Stream ID（由视频编码决定）。这样，如果视频容器包含多个相同类型的流，用户可以访问他们想要的流。如果仅传递流类型，则解码器会自动检测该类型的第一个流。

参数

path （string） – 支持格式的视频文件的路径
stream （string， optional） – 所需流的描述符，后跟流 ID，格式为 .默认为。当前可用的选项包括{stream_type}:{stream_id}"video:0"['video', 'audio']

__next__()[来源]¶

解码并返回当前流的下一帧。帧被编码为具有 mandatory 的 dict data 和 pts 字段，其中 data 是一个张量，pts 是一个帧的演示时间戳（以秒为单位）作为 float 进行。

返回: 一个字典，包含解码帧（）和相应的时间戳（），以秒为单位datapts
返回类型: (dict （字典）)

get_metadata()[来源]¶

返回视频元数据

返回: 包含每个流的持续时间和帧速率的字典
返回类型: (dict （字典）)

seek(time_s：float）[来源]¶

在当前流中查找。

参数: time_s （float） – 寻道时间（以秒为单位）

注意

当前的实现是所谓的 precise seek。这表示跟随 seek，调用 to 将返回 frame 替换为确切的时间戳（如果存在）或时间戳大于 .next()time_s

set_current_stream(stream： str）[来源]¶

设置当前流。显式定义我们正在操作的流。

参数: stream （string） – 所需流的描述符。默认为 Currently available stream types include . 每个描述符由两部分组成：流类型（例如 'video'）和唯一的 Stream ID（由视频编码决定）。这样，如果视频容器包含多个相同类型的流，用户可以访问他们想要的流。如果仅传递流类型，则解码器会自动检测第一个流并返回它。"video:0"['video', 'audio']
返回: 成功时为 True，否则为 False
返回类型: (布尔)

检查视频的示例：

import torchvision
video_path = "path to a test video"
# Constructor allocates memory and a threaded decoder
# instance per video. At the moment it takes two arguments:
# path to the video file, and a wanted stream.
reader = torchvision.io.VideoReader(video_path, "video")

# The information about the video can be retrieved using the
# `get_metadata()` method. It returns a dictionary for every stream, with
# duration and other relevant metadata (often frame rate)
reader_md = reader.get_metadata()

# metadata is structured as a dict of dicts with following structure
# {"stream_type": {"attribute": [attribute per stream]}}
#
# following would print out the list of frame rates for every present video stream
print(reader_md["video"]["fps"])

# we explicitly select the stream we would like to operate on. In
# the constructor we select a default video stream, but
# in practice, we can set whichever stream we would like
video.set_current_stream("video:0")

图像¶

类 [来源]torchvision.io.ImageReadMode¶

读取图像时支持各种模式。

用于按原样加载图像、转换为灰度、具有透明度的灰度、RGB 和具有透明度的 RGB。ImageReadMode.UNCHANGEDImageReadMode.GRAYImageReadMode.GRAY_ALPHAImageReadMode.RGBImageReadMode.RGB_ALPHA

torchvision.io.read_image(路径：str，模式：torchvision.io.image.ImageReadMode = <ImageReadMode.UNCHANGED： 0>） → torch。张量[来源]¶

将 JPEG 或 PNG 图像读取为 3 维 RGB 张量。（可选）将图像转换为所需的格式。输出张量的值为 uint8，介于 0 和 255 之间。

参数

path （str） – JPEG 或 PNG 图像的路径。
mode （ImageReadMode） – 用于选择性转换图像的读取模式。违约：。有关各种可用模式。ImageReadMode.UNCHANGEDImageReadMode

返回

输出（Tensor[image_channels， image_height， image_width]）

使用的示例：read_image

torchvision.io.decode_image(输入：Torch。张量，模式： torchvision.io.image.ImageReadMode = <ImageReadMode.UNCHANGED： 0>） → torch。张量[来源]¶

检测图像是 JPEG 还是 PNG，并执行适当的操作将图像解码为 3 维 RGB Tensor。

（可选）将图像转换为所需的格式。输出张量的值为 uint8，介于 0 和 255 之间。

参数

input （Tensor） – 一个一维 uint8 张量，包含 PNG 或 JPEG 图像。
mode （ImageReadMode） – 用于选择性转换图像的读取模式。违约：。有关各种可用模式。ImageReadMode.UNCHANGEDImageReadMode

返回

输出（Tensor[image_channels， image_height， image_width]）

torchvision.io.encode_jpeg(输入：Torch。Tensor，质量：int = 75）→ torch。张量[来源]¶

采用 CHW 布局中的输入张量，并返回包含内容的缓冲区的相应 JPEG 文件。

参数

input （Tensor[channels， image_height， image_width]）） - 通道的 int8 图像张量，其中必须为 1 或 3。cc
quality （int） – 生成的 JPEG 文件的质量，它必须是介于 1 和 100。默认值：75

返回

一个一维 int8 张量，其中包含: JPEG 文件。

返回类型

输出（Tensor[1]）

torchvision.io.decode_jpeg(输入：Torch。张量，模式： torchvision.io.image.ImageReadMode = <ImageReadMode.UNCHANGED： 0>， device： str = 'cpu'） → torch。张量[来源]¶

将 JPEG 图像解码为 3 维 RGB 张量。（可选）将图像转换为所需的格式。输出张量的值为 uint8，介于 0 和 255 之间。

参数

input （Tensor[1]） – 一个一维 uint8 张量，包含 JPEG 图像的原始字节。此张量必须在 CPU 上，无论参数如何。device
mode （ImageReadMode） – 用于（可选）的读取模式转换图像。违约：。有关各种可用模式。ImageReadMode.UNCHANGEDImageReadMode
device （str 或 torch.device） – 解码图像将在其上的设备被存储。如果指定了 cuda 设备，则图像将被解码使用 NVJPEG。这只是支持 CUDA 版本 >= 10.1

返回

输出（Tensor[image_channels， image_height， image_width]）

torchvision.io.write_jpeg(输入：Torch。张量，文件名：str，质量：int = 75）[来源]¶

获取 CHW 布局中的输入张量并将其保存在 JPEG 文件中。

参数

input （Tensor[channels， image_height， image_width]） - 通道的 int8 图像张量，其中必须为 1 或 3。cc
filename （str） – 保存图像的路径。
quality （int） - 生成的 JPEG 文件的质量，它必须是一个数字介于 1 和 100 之间。默认值：75

torchvision.io.encode_png(输入：Torch。Tensor，compression_level：int = 6） → torch。张量[来源]¶

采用 CHW 布局中的输入张量，并返回包含内容的缓冲区。

参数

input （Tensor[channels， image_height， image_width]） - 通道的 int8 图像张量，其中必须为 3 或 1。cc
compression_level （int） – 结果文件的压缩系数，它必须是一个数字介于 0 和 9 之间。默认值：6

返回

一个一维 int8 张量，其中包含: PNG 文件。

返回类型

张量[1]

torchvision.io.decode_png(输入：Torch。张量，模式： torchvision.io.image.ImageReadMode = <ImageReadMode.UNCHANGED： 0>） → torch。张量[来源]¶

将 PNG 图像解码为 3 维 RGB 张量。（可选）将图像转换为所需的格式。输出张量的值为 uint8，介于 0 和 255 之间。

参数

input （Tensor[1]） – 一个一维 uint8 张量，包含 PNG 图像的原始字节。
mode （ImageReadMode） – 用于（可选）的读取模式转换图像。违约：。有关各种可用模式。ImageReadMode.UNCHANGED

返回

输出（Tensor[image_channels， image_height， image_width]）

torchvision.io.write_png(输入：Torch。张量，文件名：str，compression_level：int = 6）[来源]¶

采用 CHW 布局的输入张量（如果是灰度图像，则为 HW）并将其保存在 PNG 文件中。

参数

input （Tensor[channels， image_height， image_width]） - 通道的 int8 图像张量，其中必须为 1 或 3。cc
filename （str） – 保存图像的路径。
compression_level （int） – 结果文件的压缩系数，它必须是一个数字介于 0 和 9 之间。默认值：6

torchvision.io.read_file(path： str） → torch 的 Torch 进行。张量[来源]¶

读取文件的字节内容并将其作为 uint8 Tensor 输出替换为 1 个维度。

参数: path （str） – 要读取的文件的路径
返回: data （张量）

torchvision.io.write_file(文件名：str，数据：torch。张量）→ None[来源]¶

将具有一维的 uint8 张量的内容写入文件。

参数

filename （str） – 要写入的文件的路径
data （Tensor） – 要写入输出文件的内容

torchvision.io¶

视频¶

细粒度视频 API¶

图像¶

文档

教程

资源