We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
Default InputTransform for video classification provide no normalization
## 🐛 Bug

Normalization does not work.

### To Reproduce

```bash
tensor([[[[[157., 157., 158.,  ..., 168., 171., 173.],
           [157., 157., 158.,  ..., 192., 189., 187.],
           [158., 158., 159.,  ..., 201., 214., 217.],
           ...,
           [ 81.,  81.,  82.,  ...,  90.,  91.,  93.],
           [ 81.,  81.,  82.,  ...,  88.,  87.,  87.],
           [ 81.,  81.,  82.,  ...,  87.,  86.,  86.]],

          [[158., 157., 154.,  ..., 177., 177., 177.],
           [159., 158., 156.,  ..., 177., 177., 178.],
           [159., 158., 157.,  ..., 178., 178., 180.],
           ...,
           [ 83.,  83.,  83.,  ..., 114., 112., 107.],
           [ 83.,  83.,  83.,  ..., 113.,  98.,  93.],
           [ 83.,  83.,  83.,  ..., 232., 211., 207.]],

          [[160., 160., 159.,  ..., 112., 102.,  86.],
           [166., 166., 166.,  ..., 116., 103.,  86.],
           [175., 176., 175.,  ..., 114., 105.,  86.],
           ...,
           [ 81.,  81.,  83.,  ...,  93.,  92.,  93.],
           [ 82.,  83.,  83.,  ..., 108., 104., 103.],
           [ 82.,  82.,  82.,  ...,  99.,  97.,  97.]],

          ...,

```


#### Code sample

```python
import os
from argparse import ArgumentParser

from torch.utils.data.sampler import RandomSampler

import flash
from flash.core.finetuning import NoFreeze
from flash.core.data.utils import download_data
from flash.video import VideoClassificationData, VideoClassifier

if __name__ == '__main__':
    parser = ArgumentParser()
    parser.add_argument('--seed', type=int, default=1234)
    parser.add_argument('--backbone', type=str, default="x3d_xs")
    parser.add_argument('--download', type=bool, default=True)
    parser.add_argument('--train_folder', type=str, default=os.path.join(os.getcwd(),
                        "./data/kinetics/train"))
    parser.add_argument('--val_folder', type=str, default=os.path.join(os.getcwd(),
                        "./data/kinetics/val"))
    parser.add_argument('--predict_folder', type=str, default=os.path.join(os.getcwd(),
                        "./data/kinetics/predict"))
    parser.add_argument('--max_epochs', type=int, default=1)
    parser.add_argument('--learning_rate', type=float, default=1e-3)
    parser.add_argument('--gpus', type=int, default=None)
    parser.add_argument('--fast_dev_run', type=int, default=False)
    args = parser.parse_args()


    if args.download:
        # Dataset Credit:Download a video clip dataset.
        # Find more datasets at https://pytorchvideo.readthedocs.io/en/latest/data.html
        download_data("https://pl-flash-data.s3.amazonaws.com/kinetics.zip",
                      os.path.join(os.getcwd(), "data/"))

    datamodule = VideoClassificationData.from_folders(
        train_folder=args.train_folder,
        val_folder=args.val_folder,
        predict_folder=args.predict_folder,
        batch_size=8,
        clip_sampler="uniform",
        clip_duration=2,
        video_sampler=RandomSampler,
        decode_audio=False,
        num_workers=2,
    )

    for batch in datamodule.train_dataloader():
       print(batch['video'])
       break
 
    model = VideoClassifier(backbone=args.backbone, num_classes=datamodule.num_classes, pretrained=False)

    trainer = flash.Trainer(max_epochs=args.max_epochs, gpus=args.gpus, strategy='ddp', fast_dev_run=args.fast_dev_run)
    trainer.finetune(model, datamodule=datamodule, strategy=NoFreeze())
```

### Expected behavior

The input values to the model should be in range [0-1].

### Environment
 
 - OS (e.g., Linux): Linux
 - Python version: 3.8
 - PyTorch/Lightning/Flash Version (e.g., 1.10/1.5/0.7): 
 - GPU models and configuration: 
 - Any other relevant information:

### Additional context

By default [VideoClassInputTransform](https://github.com/PyTorchLightning/lightning-flash/blob/master/flash/video/classification/input_transform.py#L35) performs necessary preprocessing step. One step that is missing is dividing by 255. i.e. adding `Lambda(lambda x: x/255.)` function.

I can create a PR with a quick fix.


--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `flash/video/classification/input_transform.py`
Content:
```
1 # Copyright The PyTorch Lightning team.
2 #
3 # Licensed under the Apache License, Version 2.0 (the "License");
4 # you may not use this file except in compliance with the License.
5 # You may obtain a copy of the License at
6 #
7 #     http://www.apache.org/licenses/LICENSE-2.0
8 #
9 # Unless required by applicable law or agreed to in writing, software
10 # distributed under the License is distributed on an "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 # See the License for the specific language governing permissions and
13 # limitations under the License.
14 from dataclasses import dataclass
15 from typing import Callable
16 
17 import torch
18 
19 from flash.core.data.io.input_transform import InputTransform
20 from flash.core.data.transforms import ApplyToKeys
21 from flash.core.utilities.imports import _KORNIA_AVAILABLE, _PYTORCHVIDEO_AVAILABLE, requires
22 
23 if _KORNIA_AVAILABLE:
24     import kornia.augmentation as K
25 
26 if _PYTORCHVIDEO_AVAILABLE:
27     from pytorchvideo.transforms import UniformTemporalSubsample
28     from torchvision.transforms import CenterCrop, Compose, RandomCrop
29 else:
30     ClipSampler, LabeledVideoDataset, EncodedVideo, ApplyTransformToKey = None, None, None, None
31 
32 
33 @requires("video")
34 @dataclass
35 class VideoClassificationInputTransform(InputTransform):
36 
37     image_size: int = 244
38     temporal_sub_sample: int = 8
39     mean: torch.Tensor = torch.tensor([0.45, 0.45, 0.45])
40     std: torch.Tensor = torch.tensor([0.225, 0.225, 0.225])
41     data_format: str = "BCTHW"
42     same_on_frame: bool = False
43 
44     def per_sample_transform(self) -> Callable:
45         if self.training:
46             per_sample_transform = [RandomCrop(self.image_size, pad_if_needed=True)]
47         else:
48             per_sample_transform = [CenterCrop(self.image_size)]
49 
50         return ApplyToKeys(
51             "video", Compose([UniformTemporalSubsample(self.temporal_sub_sample)] + per_sample_transform)
52         )
53 
54     def per_batch_transform_on_device(self) -> Callable:
55         return ApplyToKeys(
56             "video",
57             K.VideoSequential(
58                 K.Normalize(self.mean, self.std),
59                 data_format=self.data_format,
60                 same_on_frame=self.same_on_frame,
61             ),
62         )
63
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/flash/video/classification/input_transform.py b/flash/video/classification/input_transform.py
--- a/flash/video/classification/input_transform.py
+++ b/flash/video/classification/input_transform.py
@@ -30,6 +30,10 @@
     ClipSampler, LabeledVideoDataset, EncodedVideo, ApplyTransformToKey = None, None, None, None
 
 
+def normalize(x: torch.Tensor) -> torch.Tensor:
+    return x / 255.0
+
+
 @requires("video")
 @dataclass
 class VideoClassificationInputTransform(InputTransform):
@@ -48,7 +52,8 @@
             per_sample_transform = [CenterCrop(self.image_size)]
 
         return ApplyToKeys(
-            "video", Compose([UniformTemporalSubsample(self.temporal_sub_sample)] + per_sample_transform)
+            "video",
+            Compose([UniformTemporalSubsample(self.temporal_sub_sample), normalize] + per_sample_transform),
         )
 
     def per_batch_transform_on_device(self) -> Callable:

{"golden_diff": "diff --git a/flash/video/classification/input_transform.py b/flash/video/classification/input_transform.py\n--- a/flash/video/classification/input_transform.py\n+++ b/flash/video/classification/input_transform.py\n@@ -30,6 +30,10 @@\n     ClipSampler, LabeledVideoDataset, EncodedVideo, ApplyTransformToKey = None, None, None, None\n \n \n+def normalize(x: torch.Tensor) -> torch.Tensor:\n+    return x / 255.0\n+\n+\n @requires(\"video\")\n @dataclass\n class VideoClassificationInputTransform(InputTransform):\n@@ -48,7 +52,8 @@\n             per_sample_transform = [CenterCrop(self.image_size)]\n \n         return ApplyToKeys(\n-            \"video\", Compose([UniformTemporalSubsample(self.temporal_sub_sample)] + per_sample_transform)\n+            \"video\",\n+            Compose([UniformTemporalSubsample(self.temporal_sub_sample), normalize] + per_sample_transform),\n         )\n \n     def per_batch_transform_on_device(self) -> Callable:\n", "issue": "Default InputTransform for video classification provide no normalization\n## \ud83d\udc1b Bug\r\n\r\nNormalization does not work.\r\n\r\n### To Reproduce\r\n\r\n```bash\r\ntensor([[[[[157., 157., 158.,  ..., 168., 171., 173.],\r\n           [157., 157., 158.,  ..., 192., 189., 187.],\r\n           [158., 158., 159.,  ..., 201., 214., 217.],\r\n           ...,\r\n           [ 81.,  81.,  82.,  ...,  90.,  91.,  93.],\r\n           [ 81.,  81.,  82.,  ...,  88.,  87.,  87.],\r\n           [ 81.,  81.,  82.,  ...,  87.,  86.,  86.]],\r\n\r\n          [[158., 157., 154.,  ..., 177., 177., 177.],\r\n           [159., 158., 156.,  ..., 177., 177., 178.],\r\n           [159., 158., 157.,  ..., 178., 178., 180.],\r\n           ...,\r\n           [ 83.,  83.,  83.,  ..., 114., 112., 107.],\r\n           [ 83.,  83.,  83.,  ..., 113.,  98.,  93.],\r\n           [ 83.,  83.,  83.,  ..., 232., 211., 207.]],\r\n\r\n          [[160., 160., 159.,  ..., 112., 102.,  86.],\r\n           [166., 166., 166.,  ..., 116., 103.,  86.],\r\n           [175., 176., 175.,  ..., 114., 105.,  86.],\r\n           ...,\r\n           [ 81.,  81.,  83.,  ...,  93.,  92.,  93.],\r\n           [ 82.,  83.,  83.,  ..., 108., 104., 103.],\r\n           [ 82.,  82.,  82.,  ...,  99.,  97.,  97.]],\r\n\r\n          ...,\r\n\r\n```\r\n\r\n\r\n#### Code sample\r\n\r\n```python\r\nimport os\r\nfrom argparse import ArgumentParser\r\n\r\nfrom torch.utils.data.sampler import RandomSampler\r\n\r\nimport flash\r\nfrom flash.core.finetuning import NoFreeze\r\nfrom flash.core.data.utils import download_data\r\nfrom flash.video import VideoClassificationData, VideoClassifier\r\n\r\nif __name__ == '__main__':\r\n    parser = ArgumentParser()\r\n    parser.add_argument('--seed', type=int, default=1234)\r\n    parser.add_argument('--backbone', type=str, default=\"x3d_xs\")\r\n    parser.add_argument('--download', type=bool, default=True)\r\n    parser.add_argument('--train_folder', type=str, default=os.path.join(os.getcwd(),\r\n                        \"./data/kinetics/train\"))\r\n    parser.add_argument('--val_folder', type=str, default=os.path.join(os.getcwd(),\r\n                        \"./data/kinetics/val\"))\r\n    parser.add_argument('--predict_folder', type=str, default=os.path.join(os.getcwd(),\r\n                        \"./data/kinetics/predict\"))\r\n    parser.add_argument('--max_epochs', type=int, default=1)\r\n    parser.add_argument('--learning_rate', type=float, default=1e-3)\r\n    parser.add_argument('--gpus', type=int, default=None)\r\n    parser.add_argument('--fast_dev_run', type=int, default=False)\r\n    args = parser.parse_args()\r\n\r\n\r\n    if args.download:\r\n        # Dataset Credit:Download a video clip dataset.\r\n        # Find more datasets at https://pytorchvideo.readthedocs.io/en/latest/data.html\r\n        download_data(\"https://pl-flash-data.s3.amazonaws.com/kinetics.zip\",\r\n                      os.path.join(os.getcwd(), \"data/\"))\r\n\r\n    datamodule = VideoClassificationData.from_folders(\r\n        train_folder=args.train_folder,\r\n        val_folder=args.val_folder,\r\n        predict_folder=args.predict_folder,\r\n        batch_size=8,\r\n        clip_sampler=\"uniform\",\r\n        clip_duration=2,\r\n        video_sampler=RandomSampler,\r\n        decode_audio=False,\r\n        num_workers=2,\r\n    )\r\n\r\n    for batch in datamodule.train_dataloader():\r\n       print(batch['video'])\r\n       break\r\n \r\n    model = VideoClassifier(backbone=args.backbone, num_classes=datamodule.num_classes, pretrained=False)\r\n\r\n    trainer = flash.Trainer(max_epochs=args.max_epochs, gpus=args.gpus, strategy='ddp', fast_dev_run=args.fast_dev_run)\r\n    trainer.finetune(model, datamodule=datamodule, strategy=NoFreeze())\r\n```\r\n\r\n### Expected behavior\r\n\r\nThe input values to the model should be in range [0-1].\r\n\r\n### Environment\r\n \r\n - OS (e.g., Linux): Linux\r\n - Python version: 3.8\r\n - PyTorch/Lightning/Flash Version (e.g., 1.10/1.5/0.7): \r\n - GPU models and configuration: \r\n - Any other relevant information:\r\n\r\n### Additional context\r\n\r\nBy default [VideoClassInputTransform](https://github.com/PyTorchLightning/lightning-flash/blob/master/flash/video/classification/input_transform.py#L35) performs necessary preprocessing step. One step that is missing is dividing by 255. i.e. adding `Lambda(lambda x: x/255.)` function.\r\n\r\nI can create a PR with a quick fix.\r\n\n", "before_files": [{"content": "# Copyright The PyTorch Lightning team.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#     http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\nfrom dataclasses import dataclass\nfrom typing import Callable\n\nimport torch\n\nfrom flash.core.data.io.input_transform import InputTransform\nfrom flash.core.data.transforms import ApplyToKeys\nfrom flash.core.utilities.imports import _KORNIA_AVAILABLE, _PYTORCHVIDEO_AVAILABLE, requires\n\nif _KORNIA_AVAILABLE:\n    import kornia.augmentation as K\n\nif _PYTORCHVIDEO_AVAILABLE:\n    from pytorchvideo.transforms import UniformTemporalSubsample\n    from torchvision.transforms import CenterCrop, Compose, RandomCrop\nelse:\n    ClipSampler, LabeledVideoDataset, EncodedVideo, ApplyTransformToKey = None, None, None, None\n\n\n@requires(\"video\")\n@dataclass\nclass VideoClassificationInputTransform(InputTransform):\n\n    image_size: int = 244\n    temporal_sub_sample: int = 8\n    mean: torch.Tensor = torch.tensor([0.45, 0.45, 0.45])\n    std: torch.Tensor = torch.tensor([0.225, 0.225, 0.225])\n    data_format: str = \"BCTHW\"\n    same_on_frame: bool = False\n\n    def per_sample_transform(self) -> Callable:\n        if self.training:\n            per_sample_transform = [RandomCrop(self.image_size, pad_if_needed=True)]\n        else:\n            per_sample_transform = [CenterCrop(self.image_size)]\n\n        return ApplyToKeys(\n            \"video\", Compose([UniformTemporalSubsample(self.temporal_sub_sample)] + per_sample_transform)\n        )\n\n    def per_batch_transform_on_device(self) -> Callable:\n        return ApplyToKeys(\n            \"video\",\n            K.VideoSequential(\n                K.Normalize(self.mean, self.std),\n                data_format=self.data_format,\n                same_on_frame=self.same_on_frame,\n            ),\n        )\n", "path": "flash/video/classification/input_transform.py"}], "after_files": [{"content": "# Copyright The PyTorch Lightning team.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#     http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\nfrom dataclasses import dataclass\nfrom typing import Callable\n\nimport torch\n\nfrom flash.core.data.io.input_transform import InputTransform\nfrom flash.core.data.transforms import ApplyToKeys\nfrom flash.core.utilities.imports import _KORNIA_AVAILABLE, _PYTORCHVIDEO_AVAILABLE, requires\n\nif _KORNIA_AVAILABLE:\n    import kornia.augmentation as K\n\nif _PYTORCHVIDEO_AVAILABLE:\n    from pytorchvideo.transforms import UniformTemporalSubsample\n    from torchvision.transforms import CenterCrop, Compose, RandomCrop\nelse:\n    ClipSampler, LabeledVideoDataset, EncodedVideo, ApplyTransformToKey = None, None, None, None\n\n\ndef normalize(x: torch.Tensor) -> torch.Tensor:\n    return x / 255.0\n\n\n@requires(\"video\")\n@dataclass\nclass VideoClassificationInputTransform(InputTransform):\n\n    image_size: int = 244\n    temporal_sub_sample: int = 8\n    mean: torch.Tensor = torch.tensor([0.45, 0.45, 0.45])\n    std: torch.Tensor = torch.tensor([0.225, 0.225, 0.225])\n    data_format: str = \"BCTHW\"\n    same_on_frame: bool = False\n\n    def per_sample_transform(self) -> Callable:\n        if self.training:\n            per_sample_transform = [RandomCrop(self.image_size, pad_if_needed=True)]\n        else:\n            per_sample_transform = [CenterCrop(self.image_size)]\n\n        return ApplyToKeys(\n            \"video\",\n            Compose([UniformTemporalSubsample(self.temporal_sub_sample), normalize] + per_sample_transform),\n        )\n\n    def per_batch_transform_on_device(self) -> Callable:\n        return ApplyToKeys(\n            \"video\",\n            K.VideoSequential(\n                K.Normalize(self.mean, self.std),\n                data_format=self.data_format,\n                same_on_frame=self.same_on_frame,\n            ),\n        )\n", "path": "flash/video/classification/input_transform.py"}]}