[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

flash_tutorials/image_classification/image_classification.py

@@ -1,39 +1,37 @@
 #!/usr/bin/env python
-# coding: utf-8
 
 # %% [markdown]
 # In this tutorial, we'll go over the basics of lightning Flash by finetuning/predictin with an ImageClassifier on [Hymenoptera Dataset](https://www.kaggle.com/ajayrana/hymenoptera-data) containing ants and bees images.
-# 
+#
 # # Finetuning
-# 
+#
 # Finetuning consists of four steps:
-#  
+#
 #  - 1. Train a source neural network model on a source dataset. For computer vision, it is traditionally  the [ImageNet dataset](http://www.image-net.org/search?q=cat). As training is costly, library such as [Torchvion](https://pytorch.org/docs/stable/torchvision/index.html) library supports popular pre-trainer model architectures . In this notebook, we will be using their [resnet-18](https://pytorch.org/hub/pytorch_vision_resnet/).
-#  
+#
 #  - 2. Create a new neural network  called the target model. Its architecture replicates the source model and parameters, expect the latest layer which is removed. This model without its latest layer is traditionally called a backbone
-#  
+#
 #  - 3. Add new layers after the backbone where the latest output size is the number of target dataset categories. Those new layers, traditionally called head will be randomly initialized while backbone will conserve its pre-trained weights from ImageNet.
-#  
+#
 #  - 4. Train the target model on a target dataset, such as Hymenoptera Dataset with ants and bees. However, freezing some layers at training start such as the backbone tends to be more stable. In Flash, it can easily be done with `trainer.finetune(..., strategy="freeze")`. It is also common to `freeze/unfreeze` the backbone. In `Flash`, it can be done with `trainer.finetune(..., strategy="freeze_unfreeze")`. If one wants more control on the unfreeze flow, Flash supports `trainer.finetune(..., strategy=MyFinetuningStrategy())` where `MyFinetuningStrategy` is subclassing `pytorch_lightning.callbacks.BaseFinetuning`.
 
 import flash
 from flash.core.data.utils import download_data
 from flash.image import ImageClassificationData, ImageClassifier
 
-
 # %% [markdown]
 # ## 1. Download data
 # The data are downloaded from a URL, and save in a 'data' directory.
 # %%
-download_data("https://pl-flash-data.s3.amazonaws.com/hymenoptera_data.zip", 'data/')
+download_data("https://pl-flash-data.s3.amazonaws.com/hymenoptera_data.zip", "data/")
 
 
 # %% [markdown]
 # ## 2. Load the data
-# 
+#
 # Flash Tasks have built-in DataModules that you can use to organize your data. Pass in a train, validation and test folders and Flash will take care of the rest.
 # Creates a ImageClassificationData object from folders of images arranged in this way:</h4>
-# 
+#
 #    train/dog/xxx.png
 #    train/dog/xxy.png
 #    train/dog/xxz.png
@@ -60,7 +58,7 @@
 
 # %% [markdown]
 # ## 4. Create the trainer. Run once on data
-# The trainer object can be used for training or fine-tuning tasks on new sets of data. 
+# The trainer object can be used for training or fine-tuning tasks on new sets of data.
 # You can pass in parameters to control the training routine- limit the number of epochs, run on GPUs or TPUs, etc.
 # For more details, read the  [Trainer Documentation](https://pytorch-lightning.readthedocs.io/en/latest/trainer.html).
 # In this demo, we will limit the fine-tuning to run just one epoch using max_epochs=2.
@@ -89,7 +87,9 @@
 # ## 8. Predicting
 # ### 1. Load the model from a checkpoint
 # %%
-model = ImageClassifier.load_from_checkpoint("https://flash-weights.s3.amazonaws.com/0.7.0/image_classification_model.pt")
+model = ImageClassifier.load_from_checkpoint(
+    "https://flash-weights.s3.amazonaws.com/0.7.0/image_classification_model.pt"
+)
 
 # %% [markdown]
 # ### 2. Predict what's on a few images! ants or bees?

flash_tutorials/tabular_classification/tabular_classification.py

@@ -1,31 +1,28 @@
 #!/usr/bin/env python
-# coding: utf-8
 
 # %% [markdown]
 # In this notebook, we'll go over the basics of lightning Flash by training a TabularClassifier on [Titanic Dataset](https://www.kaggle.com/c/titanic).
 
 # # Training
 # %%
 
-from torchmetrics.classification import Accuracy, Precision, Recall
-
 import flash
 from flash.core.data.utils import download_data
-from flash.tabular import TabularClassifier, TabularClassificationData
-
+from flash.tabular import TabularClassificationData, TabularClassifier
+from torchmetrics.classification import Accuracy, Precision, Recall
 
 # %% [markdown]
 # ###  1. Download the data
 # The data are downloaded from a URL, and save in a 'data' directory.
 # %%
-download_data("https://pl-flash-data.s3.amazonaws.com/titanic.zip", 'data/')
+download_data("https://pl-flash-data.s3.amazonaws.com/titanic.zip", "data/")
 
 
 # %% [markdown]
 # ###  2. Load the data
 # Flash Tasks have built-in DataModules that you can use to organize your data. Pass in a train, validation and test folders and Flash will take care of the rest.
-# 
-# Creates a TabularData relies on [Pandas DataFrame](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html). 
+#
+# Creates a TabularData relies on [Pandas DataFrame](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html).
 # %%
 datamodule = TabularClassificationData.from_csv(
     ["Sex", "Age", "SibSp", "Parch", "Ticket", "Cabin", "Embarked"],
@@ -40,8 +37,8 @@
 
 # %% [markdown]
 # ###  3. Build the model
-# 
-# Note: Categorical columns will be mapped to the embedding space. Embedding space is set of tensors to be trained associated to each categorical column. 
+#
+# Note: Categorical columns will be mapped to the embedding space. Embedding space is set of tensors to be trained associated to each categorical column.
 # %%
 model = TabularClassifier.from_data(datamodule)
 
@@ -73,16 +70,17 @@
 
 # %% [markdown]
 # ###  8. Load the model from a checkpoint
-# 
-# `TabularClassifier.load_from_checkpoint` supports both url or local_path to a checkpoint. If provided with an url, the checkpoint will first be downloaded and laoded to re-create the model. 
+#
+# `TabularClassifier.load_from_checkpoint` supports both url or local_path to a checkpoint. If provided with an url, the checkpoint will first be downloaded and laoded to re-create the model.
 # %%
 model = TabularClassifier.load_from_checkpoint(
-    "https://flash-weights.s3.amazonaws.com/0.7.0/tabular_classification_model.pt")
+    "https://flash-weights.s3.amazonaws.com/0.7.0/tabular_classification_model.pt"
+)
 
 
 # %% [markdown]
 # ###  9. Generate predictions from a sheet file! Who would survive?
-# 
+#
 # `TabularClassifier.predict` support both DataFrame and path to `.csv` file.
 # %%
 datamodule = TabularClassificationData.from_csv(

flash_tutorials/text_classification/text_classification.py

@@ -1,41 +1,39 @@
 #!/usr/bin/env python
-# coding: utf-8
 
 # %% [markdown]
 # In this notebook, we'll go over the basics of lightning Flash by finetunig a TextClassifier on [IMDB Dataset](https://www.imdb.com/interfaces/).
-# 
+#
 # # Finetuning
-# 
+#
 # Finetuning consists of four steps:
-#  
+#
 #  - 1. Train a source neural network model on a source dataset. For text classication, it is traditionally  a transformer model such as BERT [Bidirectional Encoder Representations from Transformers](https://arxiv.org/abs/1810.04805) trained on wikipedia.
 # As those model are costly to train, [Transformers](https://github.com/huggingface/transformers) or [FairSeq](https://github.com/pytorch/fairseq) libraries provides popular pre-trained model architectures for NLP. In this notebook, we will be using [tiny-bert](https://huggingface.co/prajjwal1/bert-tiny).
-# 
-#  
+#
+#
 #  - 2. Create a new neural network the target model. Its architecture replicates all model designs and their parameters on the source model, expect the latest layer which is removed. This model without its latest layers is traditionally called a backbone
-#  
-# 
+#
+#
 # - 3. Add new layers after the backbone where the latest output size is the number of target dataset categories. Those new layers, traditionally called head, will be randomly initialized while backbone will conserve its pre-trained weights from ImageNet.
-#  
-# 
+#
+#
 # - 4. Train the target model on a target dataset, such as Hymenoptera Dataset with ants and bees. However, freezing some layers at training start such as the backbone tends to be more stable. In Flash, it can easily be done with `trainer.finetune(..., strategy="freeze")`. It is also common to `freeze/unfreeze` the backbone. In `Flash`, it can be done with `trainer.finetune(..., strategy="freeze_unfreeze")`. If a one wants more control on the unfreeze flow, Flash supports `trainer.finetune(..., strategy=MyFinetuningStrategy())` where `MyFinetuningStrategy` is subclassing `pytorch_lightning.callbacks.BaseFinetuning`.
 # %%
 
 import flash
 from flash.core.data.utils import download_data
 from flash.text import TextClassificationData, TextClassifier
 
-
 # %% [markdown]
 # ###  1. Download the data
 # The data are downloaded from a URL, and save in a 'data' directory.
 # %%
-download_data("https://pl-flash-data.s3.amazonaws.com/imdb.zip", 'data/')
+download_data("https://pl-flash-data.s3.amazonaws.com/imdb.zip", "data/")
 
 
 # %% [markdown]
 # ## 2. Load the data</h2>
-# 
+#
 # Flash Tasks have built-in DataModules that you can use to organize your data. Pass in a train, validation and test folders and Flash will take care of the rest.
 # Creates a TextClassificationData object from csv file.
 # %%
@@ -51,9 +49,9 @@
 
 # %% [markdown]
 # ##  3. Build the model
-# 
+#
 # Create the TextClassifier task. By default, the TextClassifier task uses a [tiny-bert](https://huggingface.co/prajjwal1/bert-tiny) backbone to train or finetune your model demo. You could use any models from [transformers - Text Classification](https://huggingface.co/models?filter=text-classification,pytorch)
-# 
+#
 # Backbone can easily be changed with such as `TextClassifier(backbone='bert-tiny-mnli')`
 # %%
 model = TextClassifier(num_classes=datamodule.num_classes, backbone="prajjwal1/bert-tiny")
@@ -67,8 +65,8 @@
 
 # %% [markdown]
 # ##  5. Fine-tune the model
-# 
-# The backbone won't be freezed and the entire model will be finetuned on the imdb dataset 
+#
+# The backbone won't be freezed and the entire model will be finetuned on the imdb dataset
 # %%
 trainer.finetune(model, datamodule=datamodule, strategy="freeze")