Images get rotated randomly

Hi everyone,

I was experimenting with the notebook of lesson 2 and applied it on my own dataset which was a set of building images. When I assign the data to the parameter via the ImageDataBunch function and then make it show the data, some of the images appear to be rotated 90 degrees. I tried adding max_rotate = 0. to the transformation but that did not help. Does anyone have any idea on what to do?



This is because of the flip_vert Transform. You can see all the options for the get_transforms function here:

Hi Brad, thanks for the reply. By flipping, the picture should not be rotated 90 degrees in clockwise or counterclockwise direction, but it should be mirrored upside down. Besides, the default value for flip_vert is set to be False. So, I don’t believe this has to do with the flipping.

I also tried setting do_flip to False but that helped neither. Here is a screenshot of what the data looks like (pay attention to the top-right corner):

flip_vert also does 90 degree rotations:

  • flip_vert : limit the flips to horizontal flips (when False) or to horizontal and vertical flips as well as 90-degrees rotations (when True)

It will be hard to help further without seeing any code.

Have you checked to make sure these source images are in the proper orientation on disk?

Thanks for the docs and help.
Looks like in some way that I don’t know some random images where rotated on disk. I will check out to see if rotating them will solve the problem.

I also had this problem (images being rotated by 90 degrees) when running the notebook of lesson 2: .

I tried get_transforms(max_rotate=None, do_flip=False) but I still have this issue.

I have verified that the images in disk are not rotated.

Anyone know the reason?

How have you verified that the images on the disk are not rotated?
There is an “Exif” tag called “orientation” which informs most modern programs as to which rotation to use for a photo. This is a property that is written upon the file and is sometimes very hard to find.

I suggest using a Python package, e.g. exif to review this tag for your photos. I wrote a code based on this StackOverflow answer for detecting all images in a directory which contain this tag and rotating them to the correct orientation without using this tag:

from exif import Image as ExifImage
from PIL import Image
from glob import glob
import os.path

transformation_funcs = {
    6: lambda img: img.rotate(-90, resample=Image.BICUBIC, expand=True),
    8: lambda img: img.rotate(90, resample=Image.BICUBIC, expand=True),
    3: lambda img: img.rotate(180, resample=Image.BICUBIC, expand=True),
    2: lambda img: img.transpose(Image.FLIP_LEFT_RIGHT),
    5: lambda img: img.rotate(-90, resample=Image.BICUBIC, expand=True).transpose(Image.FLIP_LEFT_RIGHT),
    7: lambda img: img.rotate(90, resample=Image.BICUBIC, expand=True).transpose(Image.FLIP_LEFT_RIGHT),
    4: lambda img: img.rotate(180, resample=Image.BICUBIC, expand=True).transpose(Image.FLIP_LEFT_RIGHT),

dir_path = [path to directory containing you images]

for img_path in glob(os.path.join(dir_path, '*.jpg')):
    with open(img_path, 'rb') as image_file:
        my_image = ExifImage(image_file)
        orientation = my_image.orientation.value
        print('  N/A skipping')
    if orientation == 1:
        print('  1 skipping')
        print(' ', orientation, 'transforming')
    my_image.orientation = 1
    with open(img_path, 'wb') as image_file:
    img =
    img = transformation_funcs[orientation](img)

You need to have the exif and PIL libraries installed.
Sorry for the mess, by the way, I wrote this quick and dirty.

1 Like

I ran into the same problem with exif orientation attributes. @shoval thanks for the neat code snippet.

Instead of manipulating files on disk, I decided to write a simple ExifImageBlock, which can be passed instead of an ImageBlock. It will simply apply the exif transformation to the pixel tensor, making sure the images have correct orientation in memory. In case anybody else is stumbling upon this issue, fee free to use the following code cell snippet.

from exif import Image as ExifImage

def exif_type_tfms(fn, cls, **kwargs):     
  def get_orientation(fn: (Path, str)):
    with open(fn, 'rb') as image_file:
      exif_img = ExifImage(image_file)
        return exif_img.orientation.value
      except AttributeError:
        # ignore orientation unset
        return 1
  def f(img, rotate=0, transpose=False):
    img = img.rotate(rotate, expand=True)
    if transpose:
      img = img.transpose(Image.FLIP_LEFT_RIGHT)
    return img

  # Image.rotate will do shorcuts on these magic angles, so no need for any 
  # specific resampling strategy
  trafo_fns = {
    1: partial(f, rotate=0),
    6: partial(f, rotate=270),
    8: partial(f, rotate=90),
    3: partial(f, rotate=180),
    2: partial(f, rotate=0, transpose=True),
    5: partial(f, rotate=270, transpose=True),
    7: partial(f, rotate=90, transpose=True),
    4: partial(f, rotate=180, transpose=True),
  img = cls.create(fn, **kwargs)
  orientation = get_orientation(fn)
  img = trafo_fns[orientation](img)
  return cls(img)

def ExifImageBlock(cls=PILImage):
  if images are rotated with the EXIF orentation flag
  it must be respected when loading the images

  ExifImageBlock can be pickled (which is important to dump learners)
  >>> pickle.dumps(ExifImageBlock())
  return TransformBlock(type_tfms=partial(exif_type_tfms, cls=cls), batch_tfms=IntToFloatTensor)

import doctest
doctest.run_docstring_examples(ExifImageBlock, globals(), optionflags=doctest.ELLIPSIS)

Indeed discussion and docs are useful and can be helpful for many people. :slightly_smiling_face: Thanks!