transforms模組—PyTorch影象處理與資料增強方法
2023-01-03 21:00:28
計算機視覺任務中，對影象的變換（Image Transform）往往是必不可少的操作，例如在遷移學習中，需要對影象尺寸進行變換以使用預訓練網路的輸入層，又如對資料進行增強以豐富訓練資料。
作為深度學習領域的主流框架，pytorch中提供了豐富的影象變換API。本文將對pytorch中torchvision.transforms提供的豐富多樣的影象變換API進行整理介紹。
為方便下文展示各種影象變換API的效果，我們藉助matplotlib定義一個名為show_image函數來展示圖片，如下所示：
In [1]:
import torch
import numpy as np
from torchvision import transforms
from torchvision.io import read_image
import matplotlib as mpl
import matplotlib.pyplot as plt
mpl.rcParams['font.sans-serif'] = ['SimHei'] # 中文字型支援
In [2]:
def show_image(img_lst, **imshow_kwargs):
"""
img_lst: 儲存影象和標題的list，形如：[(image1, title1),(image2, title2)]。image可以使Pillow.Image物件，也可以是torch.Tensor。
imshow_kwargs: 需要傳遞給plt.imshow的引數
"""
fig, axs =plt.subplots(1,len(img_lst), constrained_layout=True, figsize=(2*len(img_lst),2), squeeze=False)
for i, (img, title) in enumerate(img_lst):
if isinstance(img, torch.Tensor): # 如果是torch.Tensor型別，就必須轉換成Pillow.Image型別，才能進行展示
img = transforms.ToPILImage()(img)
axs[0, i].imshow(np.asarray(img), **imshow_kwargs)
# axs[0, i].set(xticklabels=[], yticklabels=[], xticks=[], yticks=[])
axs[0, i].set_title(title)
plt.show()
1 載入圖片¶
1.1 PIL庫¶
對於儲存在磁碟中的圖片檔案，使用Pillow庫提供的Image類物件進行開啟是一種十分常用的方法，如果你還沒有安裝，你可以通過以下命令方便下文進行：
pip install Pillow
In [3]:
from PIL import Image
我們通過Pillow中提供的方法，開啟一張圖片，並通過show_image()方法進行展示，下文中各種影象變換，我們都將以此圖片為例，進行演示：
In [4]:
raw_img = (Image.open('fruit.jpeg'), '原始圖片')
show_image([raw_img])
1.2 pytorch中提供的影象載入方法¶
pytorch的torchvision.io模組本身也提供有載入影象資料的方法：read_image。該方法直接將圖片載入為Tensor型別資料。
In [5]:
from torchvision.io import read_image
In [6]:
raw_img2 = read_image('fruit.jpeg')
In [7]:
raw_img2.shape
Out[7]:
torch.Size([3, 448, 596])
In [8]:
type(raw_img2)
Out[8]:
torch.Tensor
我們也通過之前定義的show_image()方法進行展示，注意，show_image()方法之所以能展示Tensor型別資料為影象，是因為show_image()方法內將Tensor轉為PIL影象了。
In [9]:
show_image([(raw_img2, 'read_image()')])
3 transforms¶
3.1 Compose¶
在介紹transforms前，有必要先說說Compose。
我們做影象變換時，一般都不會單獨使用一個影象變換API，而是順序使用多個API。對於多個API，transforms模組中提供Compose類，對多個API進行打包。Compose關鍵程式碼如下所示：
In [10]:
class Compose:
def __init__(self, transforms):
self.transforms = transforms
def __call__(self, img):
for t in self.transforms:
img = t(img)
return img
可見，在範例化Compose時，我們需要將用到的的API，按順序存入列表（也可以是其他可迭代物件）中，傳遞給Compose。Compose內部機制，將會首先將影象傳給第一個API，然後將經變換後的影象依次往後需API傳遞。如下所示，我們使用Compose對多個API進行組合：
In [11]:
preprocess = transforms.Compose([
transforms.Resize(350), # 變換尺寸
transforms.CenterCrop(300), # 裁切中心180畫素
transforms.ToTensor(), # 轉為Tensor型別
transforms.Normalize( # 標準化
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]
)
])
In [12]:
raw_img = Image.open('fruit.jpeg')
x = preprocess(raw_img)
x.shape
Out[12]:
torch.Size([3, 300, 300])
我們對邊變換前後的影象：
In [13]:
show_image([(raw_img, '原始影象'),(x, '變換後')])
3.2 自定義影象變換¶
transforms是pytorch中torchvision包提供的影象變換模組，提供了各式各樣的影象變換API，這些API都是通過可呼叫物件，可以是函數、也可以是類，如果是類，就必須實現__call__()方法，至於返回的資料型別，並沒有嚴格限制，只要後續的影象變換API能夠接收就好，但就一般而言，最後一個API的都是Tensor型別資料。所以，如果自定義影象變換API，遵循這些規則去定義可呼叫物件就好。
最簡單的，我們使用lambda定義可呼叫物件：
In [14]:
times_2_plus_1 = transforms.Compose([
lambda x: x * 2,
lambda x: x + 1,
])
In [15]:
times_2_plus_1(2)
Out[15]:
5
當然，這並沒有什麼意義，只是實現將一個數位進行平方再加1的變換，這裡只是演示函數方式實現變換器。接下來，我們試試類方式對影象進行變換，例如影象旋轉：
In [16]:
class RandomRotation:
def __init__(self, angle):
self.angle = angle
def __call__(self, img):
return F.rotate(img, self.angle)
In [44]:
raw_img = Image.open('fruit.jpeg')
In [45]:
tran_img = transforms.RandomRotation(60)(raw_img)
In [46]:
show_image([(raw_img, '原始影象'),(tran_img, '旋轉變換後')])
在transforms模組中，pytorch對於多數變換都同時提供有類方式和函數方式的實現，但相較於函數，我更加推薦使用類的方式去實現變換，因為這種方式能夠在範例化物件時，通過傳遞引數實現更加個性化的客製化，例如進行尺寸變換，可以在構造方法中指定變換尺寸，這是函數方式無法做到的。函數方式更多是用在定義影象變換類使用使用，另外在功能固定、單一，使用函數方式實現也是不錯的選擇。
4 pytorch中開箱即用的影象變換API¶
記憶體中的影象資料一般分為兩種，一種是PIL的Image物件，一種是torch.Tensor(更嚴謹的說，應該是torch.*Tensor，因為也可以是Tensor的子類)，不要槓，我這裡說的是建模過程中的圖片形式，Python當然也可以用其他庫來開啟圖片。相對應的，pytorch中的影象變換API也分為針對PIL.Image物件的API和針對Tensor資料的API以及能同時用於兩種影象形式的API（姑且將這類API稱為通用型影象變換API）。
**注意，即使是通用型API，也可能存在API內某些引數或引數值只適用於Tensor或PIL.Image**
我們先整理通用型的API。
4.1 通用型影象變換API¶
（1）**CenterCrop(size)**¶
CenterCrop的作用是從影象的中心位置裁剪指定大小的影象。例如一些神經網路的輸入影象大小為300$\times$300，而我們上述展示的原始影象的大小為448$\times$596，此時就需要對訓練影象進行裁剪。
CenterCrop只有一個引數：
- size：裁切保留中央多少個畫素
範例程式碼及結果如下：
In [20]:
raw_img2.shape
Out[20]:
torch.Size([3, 448, 596])
In [21]:
raw_img = Image.open('fruit.jpeg')
raw_img2 = read_image('fruit.jpeg')
size = (300, 300)
transform = transforms.CenterCrop(size)
tran_img1 = transform(raw_img)
tran_img2 = transform(raw_img2)
print(f'PIL.Image型別資料裁切後輸出型別為：{type(tran_img1)}')
print(f'torch.Tensor型別資料裁切後輸出型別為：{type(tran_img2)}')
show_image([
(raw_img, '原始影象'),
(tran_img1, 'PIL.Image'), # 對PIL.Image型別圖片進行裁切
(tran_img2, 'torch.Tensor') # 對torch.Tensor型別圖片進行裁切
])
PIL.Image型別資料裁切後輸出型別為：<class 'PIL.Image.Image'> torch.Tensor型別資料裁切後輸出型別為：<class 'torch.Tensor'>
上述範例中，對PIL.Image型別和torch.Tensor型別資料進行了裁切，證明了CenterCrop這類通用型API並不會改變資料型別，輸入什麼型別的影象，輸出還是什麼型別的影象，另外從影象展示結果上看，對兩種型別的影象變換的效果是一樣的。</b>
In [22]:
raw_img = read_image('fruit.jpeg')
size = (300, 300)
transform1 = transforms.Resize(size=300)
transform2 = transforms.Resize(size=(300, 300))
tran_img1 = transform1(raw_img)
tran_img2 = transform2(raw_img)
print(f'size=300，縮放後影象寬高為：{tran_img1.shape}')
print(f'size=(300, 300)，縮放後影象寬高為：{tran_img2.shape}')
show_image([
(raw_img, '原始影象'),
(tran_img1, 'size=300'), # 對PIL.Image型別圖片進行裁切
(tran_img2, 'size=(300, 300)') # 對torch.Tensor型別圖片進行裁切
])
size=300，縮放後影象寬高為：torch.Size([3, 300, 399]) size=(300, 300)，縮放後影象寬高為：torch.Size([3, 300, 300])
（3）**Pad(padding, fill=0, padding_mode='constant')**¶
對影象邊框進行填充，主要引數如下：
- padding：指定填充畫素
- 如果是整型，表示對4個邊框都填充padding個畫素值
- 如果是長度為2的序列，例如，padding=(5, 10)，表示對左右邊框填充5個畫素值，上下邊框填充10個畫素值。
- 如果是長度為4的序列，例如，padding=(5, 10, 15, 20)，表示對左、上、右、下分別填充5、10、15、20個畫素值。
-
fill：填充的內容，預設值為0。**注意，fill的值僅當padding_mode值為'constant'時有效。當輸入影象為Tensor時，fill為int型才有效；當輸入影象為PIL.Image時，fill既可以為int，也可以為序列**。
- 當file是長度為3的序列是，分別用於填充R、G、B通道。
-
padding_mode：填充模式，即以什麼內容填充。預設為值'constant'
- constant：常數填充，填充的內容由fill引數指定。
- edge：用原始影象的最後一個畫素值填充。
- reflect：在邊緣上不重複最後一個值的情況下，使用影象反射進行填充。例如，影象某一行畫素為[1，2，3，4]，左右兩邊充填兩個畫素，因為不重複邊界畫素，左側的畫素值1和右側的畫素值4不進行反射，左側就法則2和3，發射後成了3和2，填充到影象左側，右側反射2和3，反射後成了3和2，填充到影象右側，最終這一行畫素值變成[3，2，1，2，4，3，2]。
- symmetric：就是reflect方式填充，只不過重複邊界畫素值。[1，2，3，4]使用這種方式填充後為[2, 1, 1, 2, 3, 4, 4, 3]。
In [23]:
raw_img = Image.open('fruit.jpeg')
show_image([
(
transforms.Pad(padding=20, fill=0, padding_mode='constant')(raw_img),
"padding=20, \n fill=0, \n padding_mode='constant'"
),
(
transforms.Pad(padding=20, fill=(0, 0, 255), padding_mode='constant')(raw_img),
"padding=20, \n fill=(0, 0, 255), \n padding_mode='constant'"
),
(
transforms.Pad(padding=200, padding_mode='edge')(raw_img),
"padding=200, \n padding_mode='edge'"
),
(
transforms.Pad(padding=200, padding_mode='reflect')(raw_img),
"padding=200, \n padding_mode='reflect'"
),
(
transforms.Pad(padding=200, padding_mode='symmetric')(raw_img),
"padding=200, \n padding_mode='reflect'"
),
])
（4）**ColorJitter(brightness=0, contrast=0, saturation=0, hue=0)**¶
ColorJitter的作用是隨機修改圖片的亮度、對比度、飽和度、色調，常用來進行資料增強，尤其是訓練影象類別不均衡或影象數量較少時。**注意，如果輸入影象為PIL.Image物件，那麼，如果開啟模式為「1」, 「I」, 「F」或者影象透明，將會產生異常。**常用引數如下：
- brightness：亮度變換範圍，預設值為0，即不變換亮度
- 值為float時， 亮度將在[max(0, 1 - brightness), 1 + brightness] 範圍變化。
- 值為(min, max)時，亮度將在[min, max]範圍內變化。不能為負數。
- contrast：對比度，預設值為0，即不變換對比度
- 值為float時， 對比度將在[max(0, 1 - brightness), 1 + brightness] 範圍變化。
- 值為(min, max)時，對比度將在[min, max]範圍內變化。不能為負數。
- saturation：飽和度，預設值為0，即不變換飽和度
- 值為float時， 飽和度將在[max(0, 1 - brightness), 1 + brightness] 範圍變化。
- 值為(min, max)時，飽和度將在[min, max]範圍內變化。不能為負數。
- hue：色調，預設值為0，即不變換色調
- 值為float時， 色調將在[-hue, hue] 範圍變化。
- 值為(min, max)時，色調將在[min, max]範圍內變化。取值建議：0<=hue<=0.5或-0.5<=min<=max<=0.5。
In [24]:
raw_img = Image.open('fruit.jpeg')
show_image([
(
raw_img, '原始影象'
),
(
transforms.ColorJitter(brightness=(1, 10))(raw_img),
"隨機變換亮度\nbrightness=(1, 10)"
),
(
transforms.ColorJitter(contrast=(1, 10))(raw_img),
"隨機變換對比度\ncontrast=(1, 10)"
),
(
transforms.ColorJitter(saturation=(1, 10))(raw_img),
"隨機變換飽和度\nsaturation=(1, 10)"
),
(
transforms.ColorJitter(hue=(0.2, 0.4))(raw_img),
"隨機變換色調\nhue=(0.2, 0.4)"
),
(
transforms.ColorJitter(brightness=(1, 10), contrast=(1, 10), saturation=(1, 10), hue=(0.2, 0.4))(raw_img),
"padding=20, \n fill=0, \n padding_mode='constant'"
)
])
（5）**RandomRotation(degrees[, interpolation, ...])**¶
指定角度範圍隨機旋轉影象。
- degrees：旋轉角度範圍
- 當值為(min, max)時，表示在(min, max)範圍內隨機選取一角度對影象進行旋轉
- 當值為數值時，等同於(-degrees, +degrees)
- interpolation：插值方式
- expand：是否對影象進行擴充套件，以展示整個旋轉後影象。
- center：值為(a, b), 圍繞影象中哪個點進行旋轉, 預設圍繞中心點旋轉
- fill: 填充旋轉後影象外的內容
In [25]:
raw_img = Image.open('fruit.jpeg')
show_image([
(
raw_img, '原始影象'
),
(
transforms.RandomRotation(degrees=(20, 60))(raw_img),
"degrees=(20, 60)"
),
(
transforms.RandomRotation(degrees=60, expand=True)(raw_img),
"degrees=60, \nexpand=True"
),
(
transforms.RandomRotation(degrees=60, center=(0, 0))(raw_img),
"degrees=60, \ncenter=(0, 0)"
),
(
transforms.RandomRotation(degrees=60, fill=(0, 0, 255))(raw_img),
"degrees=60, \nfill=(0, 0, 255)"
)
])
（6）**GaussianBlur(kernel_size[, sigma])**¶
高斯模糊。
In [26]:
raw_img = Image.open('fruit.jpeg')
show_image([
(
raw_img, '原始影象'
),
(
transforms.GaussianBlur(kernel_size =11)(raw_img),
"kernel_size =11"
),
(
transforms.GaussianBlur(kernel_size=(5, 9), sigma=(0.1, 10))(raw_img),
"kernel_size=(5, 9), \nsigma=(0.1, 10)"
),
(
transforms.GaussianBlur(kernel_size =99,sigma=5)(raw_img),
"kernel_size =99,\nsigma=5"
)
])
（7）**FiveCrop(size)**與**TenCrop(size, vertical_flip=False)**¶
分別從影象的四個角以及中心進行五次裁剪，最終將返回一個包含5張裁切後圖片的tuple。
- size：裁切尺寸
- 當值為(h, w)時，在原始影象四個角以及中心各採取一張h $\times$w的影象
- 當值為int時，等同於(size, size)
In [27]:
raw_img = Image.open('fruit.jpeg')
trans = transforms.FiveCrop((200, 200))
trans_imgs = trans(raw_img)
print(f'轉換後輸出變數型別為：{type(trans_imgs)}, 輸出變數長度為：{len(trans_imgs)}')
show_image([
(raw_img, '原始影象'),
(trans_imgs[0], '左上角'),
(trans_imgs[1], '右上角'),
(trans_imgs[2], '左下角'),
(trans_imgs[3], '右下角'),
(trans_imgs[4], '中心'),
])
轉換後輸出變數型別為：<class 'tuple'>, 輸出變數長度為：5
再來說TenCrop(size, vertical_flip=False)。
TenCrop(size, vertical_flip=False)就是在FiveCrop(size)的基礎上，對原始影象進行水平或者垂直翻轉，然後在從翻轉後影象的四個角以及中心進行五次裁剪，所以一共獲取了10張影象返回。引數vertical_flip預設值為False，表示進行水平翻轉，值為True時，表示進行垂直翻轉在裁剪。
（8）**Grayscale(num_output_channels=1)**與**RandomGrayscale(p=0.1)**¶
將影象轉換為灰度影象，預設通道數為1，通道數為3時，RGB三個通道的值相等。
- num_output_channels ：指定最終輸出影象的通道數，值為1時，最終輸出只有一個通道的灰度影象，值為3時，輸出三個通到值相等的灰度影象。預設值為1。
In [28]:
raw_img = read_image('fruit.jpeg')
transform1 = transforms.Grayscale(num_output_channels=1)
transform2 = transforms.Grayscale(num_output_channels=3)
tran_img1 = transform1(raw_img)
tran_img2 = transform2(raw_img)
print(f'num_output_channels=1時，輸出為：{tran_img1.shape}')
print(f'num_output_channels=3時，輸出為：{tran_img2.shape}')
show_image([
(tran_img1, 'num_output_channels=1'),
(tran_img2, 'num_output_channels=3')
], cmap='gray')
num_output_channels=1時，輸出為：torch.Size([1, 448, 596]) num_output_channels=3時，輸出為：torch.Size([3, 448, 596])
RandomGrayscale以一定的概率將影象變為灰度影象。實際上就是以一定的概率執行torchvision.transforms.Grayscale。引數只有一個概率值p，預設值為0.1。這裡不再演示。
In [29]:
raw_img = Image.open('fruit.jpeg')
show_image([
(
raw_img, '原始影象'
),
(
transforms.RandomSolarize(threshold=60, p=1)(raw_img),
"threshold=60, p=1"
),
(
transforms.RandomSolarize(threshold=150, p=1)(raw_img),
"threshold=150, p=1"
),
(
transforms.RandomSolarize(threshold=200, p=1)(raw_img),
"threshold=200, p=1"
)
])
（10）**RandomAffine(degrees, translate=None, scale=None, shear=None, resample=False, fillcolor=0)**¶
RandomAffine的作用是保持影象中心不變的情況下對影象進行隨機的仿射變換。
- degrees：度數範圍。
- 值為（min，max）時，表示在（min，max）之間隨機變換角度
- 值為int時，等同於（-degrees，degrees）
- translate：位移距離。值為tuple型別，例如translate=（a，b），則在範圍[-影象寬度 $\times$ a, 影象寬度 $\times$ a]中隨機取樣水平移位，在範圍[-影象高度 $\times$ b, 影象高度 $\times$ b]中隨機取樣垂直移位。預設值為0，表示不進行位移。
- scale：縮放。值為tuple型別，例如translate=（a，b），表示在[a, b]範圍內隨機取樣進行縮放，預設情況下將保持原始比例。
- shear:可從中選擇的度數範圍。仿射變換的角度。
- interpolation：插值的方法。
- fill:填充畫素的值。預設為0.
In [30]:
raw_img = Image.open('fruit.jpeg')
show_image([
(
raw_img, '原始影象'
),
(
transforms.RandomAffine(degrees=60)(raw_img),
"degrees=60"
),
(
transforms.RandomAffine(degrees=0, translate=(0.2, 0.6))(raw_img),
"translate=(0.2, 0.6)"
),
(
transforms.RandomAffine(degrees=0, scale=(0.4, 0.8))(raw_img),
"scale=(0.4, 0.8)"
),
(
transforms.RandomAffine(degrees=0, shear=60)(raw_img),
"shear=60"
),
(
transforms.RandomAffine(degrees=0, shear=(30, 80))(raw_img),
"shear=(30, 80)"
),
(
transforms.RandomAffine(degrees=80, fill=(0, 255, 255))(raw_img),
"degrees=80,\nfill=(0, 255, 255)"
),
])
（11）**RandomCrop(size, padding=None, pad_if_needed=False, fill=0, padding_mode='constant')**¶
在一個隨機位置上對影象進行裁剪。
- size：裁切保留多少個畫素
- 值為tuple，例如(h, w)，表示裁切尺寸為(h, w)
- 值為int，等同於(size, size)
- padding：填充邊框畫素值
- 如果是整型，表示對4個邊框都填充padding個畫素值
- 如果是長度為2的序列，例如，padding=(5, 10)，表示對左右邊框填充5個畫素值，上下邊框填充10個畫素值。
- 如果是長度為4的序列，例如，padding=(5, 10, 15, 20)，表示對左、上、右、下分別填充5、10、15、20個畫素值。
- pad_if_needed：如果影象小於所需大小，它將先填充影象然後進行裁切以避免引發異常。由於裁剪是在填充之後完成的，所以填充似乎是以隨機偏移量完成的。
- fill：填充的內容，預設值為0
- padding_mode：填充模式，即以什麼內容填充。預設為值'constant'
- constant：常數填充，填充的內容由fill引數指定。
- edge：用原始影象的最後一個畫素值填充。
- reflect：在邊緣上不重複最後一個值的情況下，使用影象反射進行填充。例如，影象某一行畫素為[1，2，3，4]，左右兩邊充填兩個畫素，因為不重複邊界畫素，左側的畫素值1和右側的畫素值4不進行反射，左側就法則2和3，發射後成了3和2，填充到影象左側，右側反射2和3，反射後成了3和2，填充到影象右側，最終這一行畫素值變成[3，2，1，2，4，3，2]。
- symmetric：就是reflect方式填充，只不過重複邊界畫素值。[1，2，3，4]使用這種方式填充後為[2, 1, 1, 2, 3, 4, 4, 3]。
In [31]:
raw_img = Image.open('fruit.jpeg')
show_image([
(
raw_img, '原始影象'
),
(
transforms.RandomCrop(size=200)(raw_img),
"size=200"
),
(
transforms.RandomCrop(size=500,padding=200)(raw_img),
"size=500,padding=200"
)
])
（12）**RandomHorizontalFlip(p=0.5)**與**RandomVerticalFlip(p=0.5)**¶
以一定的概率將影象水平翻轉。引數只有一個概率值p，預設值為0.5。
In [32]:
raw_img = Image.open('fruit.jpeg')
show_image([
(
raw_img, '原始影象'
),
(
transforms.RandomHorizontalFlip(p=1)(raw_img),
"水平翻轉"
)
])
有水平翻轉，就有垂直翻轉，即RandomVerticalFlip(p=0.5)，用法與RandomHorizontalFlip(p=0.5)完全一致，這裡不再介紹。
（13）**RandomPerspective(distortion_scale=0.5, p=0.5, interpolation=3, fill=0)**¶
以一定的概率對影象進行隨機的透視變換。
- distortion_scale：扭曲的角度，取值在[0, 1]之間，預設值為0.5.
- p：執行變換的概率。
- interpolation：插值的方法。
- fill：填充的內容，預設值為0。
In [33]:
raw_img = Image.open('fruit.jpeg')
show_image([
(
raw_img, '原始影象'
),
(
transforms.RandomPerspective(distortion_scale=0.5)(raw_img),
"distortion_scale=0.5"
)
])
In [34]:
raw_img = Image.open('fruit.jpeg')
show_image([
(
raw_img, '原始影象'
),
(
transforms.RandomEqualize(p=1)(raw_img),
"threshold=60, p=1"
)
])
In [35]:
raw_img = Image.open('fruit.jpeg')
trans = transforms.RandomChoice([
transforms.Resize(350),
transforms.RandomEqualize(p=1),
transforms.RandomAffine(degrees=60)
])
show_image([
(
raw_img, '原始影象'
),
(
trans(raw_img), '隨機一次變換'
),
(
trans(raw_img), '隨機一次變換'
)
])
從功能上說，這兩個API都不是專門針對PIL.Image，我不知道官方檔案上為什麼這麼分類。
4.3 專用於torch.*Tensor的影象變換API¶
（1） **LinearTransformation(transformation_matrix, ...)**¶
使用變換矩陣和離線計算的均值向量對影象張量進行變換，可以用在白化變換中，白化變換用來去除輸入資料的冗餘資訊。常用在資料預處理中。
（2）**Normalize(mean, std, inplace=False)**¶
逐channel的對影象進行標準化（均值變為0，標準差變為1），可以加快模型的收斂
（3）**RandomErasing(p=0.5, scale=(0.02, 0.33), ratio=(0.3, 3.3)**¶
隨機選擇影象中的一塊區域，擦除其畫素，主要用來進行資料增強。
- p: 執行擦除的概率。
- scale：擦除區域相對於輸入影象的比例範圍。
- ratio：擦除區域的縱橫比範圍。
- value：擦除區域的填充內容。
- inplace：是否原地修改，預設為False。
In [36]:
raw_img = read_image('fruit.jpeg')
show_image([
(
raw_img, '原始影象'
),
(
transforms.RandomErasing(p=1, scale=(0.2, 0.3),ratio=(0.5, 1.0),value=(0, 0, 255))(raw_img),
"隨機擦除"
)
])
（4）**RandomErasing(p=0.5, scale=(0.02, 0.33), ratio=(0.3, 3.3)**¶
對影象中各畫素資料型別進行轉換。
- dtype : 輸出影象中各個畫素的資料型別
In [37]:
raw_img = read_image('fruit.jpeg')
In [38]:
print(f'轉換前資料型別為：{raw_img.dtype}')
轉換前資料型別為：torch.uint8
In [39]:
img = transforms.ConvertImageDtype(dtype=torch.float32)(raw_img)
In [40]:
print(f'轉換前資料型別後：{img.dtype}')
轉換前資料型別後：torch.float32
In [41]:
raw_img = read_image('fruit.jpeg')
print(f'轉換前影象型別為：{type(raw_img)}')
img = transforms.ToPILImage()(raw_img)
print(f'轉換後影象型別為：{type(img)}')
轉換前影象型別為：<class 'torch.Tensor'> 轉換後影象型別為：<class 'PIL.Image.Image'>
（2）**ToTensor()**¶
將PIL.Image或numpy.ndarray型別影象轉為torch.Tensor型別影象。
In [42]:
raw_img = Image.open('fruit.jpeg')
print(f'轉換前影象型別為：{type(raw_img)}')
img = transforms.ToTensor()(raw_img)
print(f'轉換後影象型別為：{type(img)}')
轉換前影象型別為：<class 'PIL.JpegImagePlugin.JpegImageFile'> 轉換後影象型別為：<class 'torch.Tensor'>
（3）**PILToTensor()**¶
將PIL.Image(shape為：(H x W x C))型別影象轉為torch.Tensor(shape為： (C x H x W))。
In [43]:
raw_img = Image.open('fruit.jpeg')
print(f'轉換前影象型別為：{type(raw_img)}，')
img = transforms.ToTensor()(raw_img)
print(f'轉換後影象型別為：{type(img)}')
轉換前影象型別為：<class 'PIL.JpegImagePlugin.JpegImageFile'>， 轉換後影象型別為：<class 'torch.Tensor'>
作者：奧辰
微訊號：chb1137796095
Github：https://github.com/ChenHuabin321
歡迎加V交流，共同學習，共同進步！
本文版權歸作者和部落格園共有，歡迎轉載，但未經作者同意必須保留此段宣告，且在文章頁面明顯位置給出原文連結，否則保留追究法律責任的權利。