(pytorch) Я хочу нормализовать [0 255] целочисленный тензор в [0 1] плавающий тензор - PullRequest
Новая
       37

(pytorch) Я хочу нормализовать [0 255] целочисленный тензор в [0 1] плавающий тензор

2 голосов
/ 17 февраля 2020

Я хочу нормализовать [0 255] целочисленный тензор в [0 1] плавающий тензор.

Я использовал набор данных cifar10 и хотел иметь дело с целочисленным тензором изображения.
поэтому я сделал их целочисленным тензорным при загрузке набора данных, я использовал «transforms.ToTensor ()», чтобы значения были установлены на [0 1] float 

tensor([[[0.4588, 0.4588, 0.4588,  ..., 0.4980, 0.4980, 0.5020],
         [0.4706, 0.4706, 0.4706,  ..., 0.5098, 0.5098, 0.5137],
         [0.4824, 0.4824, 0.4824,  ..., 0.5216, 0.5216, 0.5294],
         ...,
         [0.3098, 0.3020, 0.2863,  ..., 0.4549, 0.3608, 0.3137],
         [0.2902, 0.2902, 0.2902,  ..., 0.4431, 0.3333, 0.3020],
         [0.2706, 0.2941, 0.2941,  ..., 0.4157, 0.3529, 0.3059]],

        [[0.7725, 0.7725, 0.7725,  ..., 0.7569, 0.7569, 0.7608],
         [0.7765, 0.7765, 0.7765,  ..., 0.7608, 0.7608, 0.7686],
         [0.7765, 0.7765, 0.7765,  ..., 0.7608, 0.7608, 0.7725],
         ...,
         [0.6510, 0.6314, 0.6078,  ..., 0.6941, 0.6510, 0.6392],
         [0.6314, 0.6235, 0.6118,  ..., 0.6784, 0.6196, 0.6275],
         [0.6157, 0.6235, 0.6157,  ..., 0.6549, 0.6431, 0.6314]],

Чтобы сделать их [0 255] целочисленный тензор. 

temp = np.floor(temp_images*256)
temp_int = torch.tensor(temp, dtype=torch.int32)
temp_images = torch.clamp(temp, 0, 255)

и результат был 

torch.IntTensor
tensor([[[[ 94., 100., 100.,  ...,  98., 100., 102.],
          [ 86., 100., 101.,  ...,  83.,  91., 103.],
          [ 90., 100.,  99.,  ...,  80.,  66.,  86.],
          ...,
          [ 92.,  92.,  90.,  ...,  77., 107., 119.],
          [ 76.,  91., 100.,  ...,  95., 158., 170.],
          [ 86.,  83.,  87.,  ...,  97., 176., 205.]],

         [[105., 111., 111.,  ..., 109., 112., 113.],
          [ 97., 111., 112.,  ...,  94., 102., 114.],
          [101., 111., 110.,  ...,  90.,  77.,  97.],
          ...,
          [111., 110., 108.,  ...,  88., 120., 131.],
          [ 95., 108., 114.,  ..., 105., 165., 172.],
          [106., 100., 101.,  ..., 108., 183., 206.]],

         [[ 62.,  68.,  68.,  ...,  66.,  68.,  70.],
          [ 55.,  69.,  70.,  ...,  51.,  59.,  71.],
          [ 59.,  69.,  68.,  ...,  48.,  34.,  54.],
          ...,
          [ 59.,  59.,  56.,  ...,  54.,  95., 107.],
          [ 49.,  61.,  66.,  ...,  76., 152., 166.],
          [ 61.,  55.,  54.,  ...,  73., 170., 206.]]],

, прежде чем пересылать их в сеть, я хочу, чтобы они [0 1] снова попали в тензор.

Поэтому я попытался 

transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))

Но результат не нормализуется до [0 1], а скорее становится больше ...! 

tensor([[[117., 117., 117.,  ..., 127., 127., 128.],
         [120., 120., 120.,  ..., 130., 130., 131.],
         [123., 123., 123.,  ..., 133., 133., 135.],
         ...,
         [ 79.,  77.,  73.,  ..., 116.,  92.,  80.],
         [ 74.,  74.,  74.,  ..., 113.,  85.,  77.],
         [ 69.,  75.,  75.,  ..., 106.,  90.,  78.]],

        [[197., 197., 197.,  ..., 193., 193., 194.],
         [198., 198., 198.,  ..., 194., 194., 196.],
         [198., 198., 198.,  ..., 194., 194., 197.],

до 

tensor([[[233., 233., 233.,  ..., 253., 253., 255.],
         [239., 239., 239.,  ..., 259., 259., 261.],
         [245., 245., 245.,  ..., 265., 265., 269.],
         ...,
         [157., 153., 145.,  ..., 231., 183., 159.],
         [147., 147., 147.,  ..., 225., 169., 153.],
         [137., 149., 149.,  ..., 211., 179., 155.]],

        [[393., 393., 393.,  ..., 385., 385., 387.],
         [395., 395., 395.,  ..., 387., 387., 391.],
         [395., 395., 395.,  ..., 387., 387., 393.],
         ...,
         [331., 321., 309.,  ..., 353., 331., 325.],
         [321., 317., 311.,  ..., 345., 315., 319.],
         [313., 317., 313.,  ..., 333., 327., 321.]],

Как я могу нормализовать [0 255] целочисленный тензор в [0 1] плавающий тензор?

1 Ответ

0 голосов
/ 17 февраля 2020

Проблема в том, что вы, похоже, неправильно понимаете, что делает transforms.Normalize. Цитировать из документации PyTorch :

Нормализовать тензорное изображение со средним и стандартным отклонением. Учитывая среднее значение: (M1,...,Mn) и стандартное значение: (S1,..,Sn) для n каналов, это преобразование нормализует каждый канал входа torch.*Tensor, т. Е. input[channel] = (input[channel] - mean[channel]) / std[channel]

Расчет для значения, произнесите 100, и тогда предоставленное вами стандартное значение будет означать: 100 - 0.5 / 0.5 = 199. Конечно, вы можете увеличить стандартное значение и среднее значение, но это не гарантирует вам точный результат, который вы можете ожидать. Как указано в комментариях, лучшим способом будет, вероятно, инвертировать выполненные вами операции, чтобы сначала получить тензор до [0 255].

Редактировать: Как выясняется, согласно этому сообщению на форуме , кажется, что преобразования из PIL-изображений в тензоры автоматически превращают ваш диапазон значений в [0 1] (и в [0 255], если вы преобразуете в изображение PIL соответственно), как написано мелким шрифтом transforms.ToTensor. Для обратного преобразования это не указано явно , но может быть применено через mode.

...