diff --git a/configs/model/fastflow.yaml b/configs/model/fastflow.yaml index cd5abd6b0f..ee0a2d0b20 100644 --- a/configs/model/fastflow.yaml +++ b/configs/model/fastflow.yaml @@ -29,7 +29,7 @@ model: hidden_ratio: 1.0 # options: [1.0, 1.0, 0.16, 0.16] - for each supported backbone optimizer: - class_path: torch.optim.Adam + class_path: torch.optim._multi_tensor.Adam init_args: lr: 0.001 weight_decay: 0.00001 diff --git a/notebooks/200_models/201_fastflow.ipynb b/notebooks/200_models/201_fastflow.ipynb new file mode 100644 index 0000000000..3786ce8b7b --- /dev/null +++ b/notebooks/200_models/201_fastflow.ipynb @@ -0,0 +1,782 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# FastFlow\n", + "\n", + "This notebook demonstrates how to train, test and infer the FastFlow model via Anomalib API. Compared to the CLI entrypoints such as \\`tools/\\.py, the API offers more flexibility such as modifying the existing model or designing custom approaches.\n", + "\n", + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from functools import partial, update_wrapper\n", + "from types import MethodType\n", + "from typing import Any\n", + "\n", + "from matplotlib import pyplot as plt\n", + "from pytorch_lightning import LightningModule, Trainer\n", + "from pytorch_lightning.callbacks import EarlyStopping, ModelCheckpoint\n", + "from torch.optim import Optimizer\n", + "from torch.optim.adam import Adam\n", + "from torch.utils.data import DataLoader\n", + "\n", + "from anomalib.data import InferenceDataset\n", + "from anomalib.data.mvtec import MVTec\n", + "from anomalib.models.fastflow.lightning_model import Fastflow\n", + "from anomalib.post_processing import superimpose_anomaly_map\n", + "from anomalib.pre_processing.transforms import Denormalize\n", + "from anomalib.utils.callbacks import (\n", + " MetricsConfigurationCallback,\n", + " MinMaxNormalizationCallback,\n", + " VisualizerCallback,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Module\n", + "\n", + "To train the model end-to-end, we do need to have a dataset. In our [previous notebooks](https://github.com/openvinotoolkit/anomalib/tree/development/notebooks/100_datamodules), we demonstrate how to initialize benchmark- and custom datasets. In this tutorial, we will use MVTec AD DataModule. We assume that `datasets` directory is created in the `anomalib` root directory and `MVTec` dataset is located in `datasets` directory." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image Shape: torch.Size([32, 3, 256, 256]) Mask Shape: torch.Size([32, 256, 256])\n" + ] + } + ], + "source": [ + "datamodule = MVTec(\n", + " root=\"../../datasets/MVTec/\",\n", + " category=\"bottle\",\n", + " image_size=256,\n", + " train_batch_size=32,\n", + " test_batch_size=32,\n", + " num_workers=8,\n", + " task=\"segmentation\",\n", + ")\n", + "datamodule.setup()\n", + "i, data = next(enumerate(datamodule.test_dataloader()))\n", + "print(f'Image Shape: {data[\"image\"].shape} Mask Shape: {data[\"mask\"].shape}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## FastFlow Model\n", + "\n", + "Now that we have created the MVTec datamodule, we could create the FastFlow model. We could start with printing its docstring." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Fastflow??" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model = Fastflow(input_size=[256, 256], backbone=\"resnet18\", flow_steps=8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Depending on the `training` mode, `model` returns two different outputs. If the model is in `training` mode, it returns the hidden variable and the log of the jacobian, based on the feature maps." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hidden Variable Shape: torch.Size([32, 64, 64, 64])\n" + ] + } + ], + "source": [ + "model.training = True\n", + "train_output = model(data[\"image\"])\n", + "hidden_variables, log_jacobian = train_output\n", + "print(f\"Hidden Variable Shape: {hidden_variables[0].shape}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "During the test/inference mode, the model returns an anomaly heatmap localizing the anomalous regions." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Anomaly Map Shape: torch.Size([32, 1, 256, 256])\n" + ] + } + ], + "source": [ + "model.model.training = False\n", + "anomaly_map = model(data[\"image\"])\n", + "print(f\"Anomaly Map Shape: {anomaly_map.shape}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Optimizer\n", + "\n", + "`LightningModule` has `configure_optimizer` method that returns the optimizer object. This is not implemented in the FastFlow model. Instead, it is left to the user to make it configurable by either CLI or API. Here we will be configuring it via the API. To do so, we first need to create the optimizer object, wrap it around a function and finally inject this function into the model class." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def configure_optimizers(lightning_module: LightningModule, optimizer: Optimizer) -> Any: # pylint: disable=W0613,W0621\n", + " \"\"\"Override to customize the LightningModule.configure_optimizers` method.\"\"\"\n", + " return optimizer\n", + "\n", + "\n", + "optimizer = Adam(params=model.parameters(), lr=0.001, betas=(0.9, 0.999), weight_decay=1e-5)\n", + "fn = partial(configure_optimizers, optimizer=optimizer)\n", + "update_wrapper(fn, configure_optimizers) # necessary for `is_overridden`\n", + "model.configure_optimizers = MethodType(fn, model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Callbacks\n", + "\n", + "To train the model properly, we will to add some other \"non-essential\" logic such as saving the weights, early-stopping, normalizing the anomaly scores and visualizing the input/output images. To achieve these we use `Callbacks`. Anomalib has its own callbacks and also supports PyTorch Lightning's native callbacks. So, let's create the list of callbacks we want to execute during the training." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "callbacks = [\n", + " MetricsConfigurationCallback(\n", + " adaptive_threshold=True,\n", + " image_metric_names=[\"AUROC\"],\n", + " pixel_metric_names=[\"AUROC\"],\n", + " ),\n", + " ModelCheckpoint(\n", + " mode=\"max\",\n", + " monitor=\"pixel_AUROC\",\n", + " ),\n", + " EarlyStopping(\n", + " monitor=\"pixel_AUROC\",\n", + " mode=\"max\",\n", + " patience=3,\n", + " ),\n", + " MinMaxNormalizationCallback(),\n", + " VisualizerCallback(task=\"segmentation\", log_images_to=[\"local\"]),\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training\n", + "\n", + "Now that we set up the datamodule, model, optimizer and the callbacks, we could now train the model.\n", + "\n", + "The final component to train the model is `pytorch_lightning` `Trainer` object, which handles train/test/predict pipeline. Let's create the trainer object to train the model." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n" + ] + } + ], + "source": [ + "trainer = Trainer(\n", + " callbacks=callbacks,\n", + " accelerator=\"auto\", # \\<\"cpu\", \"gpu\", \"tpu\", \"ipu\", \"hpu\", \"auto\">,\n", + " devices=1,\n", + " max_epochs=100,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`Trainer` object has number of options that suit all specific needs. For more details, refer to [Lightning Documentation](https://pytorch-lightning.readthedocs.io/en/stable/common/trainer.html) to see how it could be tweaked to your needs.\n", + "\n", + "Let's train the model now." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/sakcay/miniconda3/envs/anomalib/lib/python3.8/site-packages/torchmetrics/utilities/prints.py:36: UserWarning: Metric `ROC` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n", + " warnings.warn(*args, **kwargs)\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3]\n", + "\n", + " | Name | Type | Params\n", + "-------------------------------------------------------------------\n", + "0 | image_threshold | AdaptiveThreshold | 0 \n", + "1 | pixel_threshold | AdaptiveThreshold | 0 \n", + "2 | training_distribution | AnomalyScoreDistribution | 0 \n", + "3 | min_max | MinMax | 0 \n", + "4 | model | FastflowModel | 7.7 M \n", + "5 | loss | FastflowLoss | 0 \n", + "6 | image_metrics | AnomalibMetricCollection | 0 \n", + "7 | pixel_metrics | AnomalibMetricCollection | 0 \n", + "-------------------------------------------------------------------\n", + "3.5 M Trainable params\n", + "4.2 M Non-trainable params\n", + "7.7 M Total params\n", + "30.678 Total estimated model params size (MB)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/sakcay/miniconda3/envs/anomalib/lib/python3.8/site-packages/torchmetrics/utilities/prints.py:36: UserWarning: Torchmetrics v0.9 introduced a new argument class property called `full_state_update` that has\n", + " not been set for this class (_ResultMetric). The property determines if `update` by\n", + " default needs access to the full metric state. If this is not the case, significant speedups can be\n", + " achieved and we recommend setting this to `False`.\n", + " We provide an checking function\n", + " `from torchmetrics.utilities import check_forward_no_full_state`\n", + " that can be used to check if the `full_state_update=True` (old and potential slower behaviour,\n", + " default for now) or if `full_state_update=False` can be used safely.\n", + " \n", + " warnings.warn(*args, **kwargs)\n", + "/home/sakcay/miniconda3/envs/anomalib/lib/python3.8/site-packages/pytorch_lightning/trainer/trainer.py:1927: PossibleUserWarning: The number of training batches (7) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n", + " rank_zero_warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 11: 100%|██████████| 10/10 [02:14<00:00, 13.47s/it, loss=-4.27e+05, v_num=2, pixel_AUROC=0.974]\n" + ] + } + ], + "source": [ + "trainer.fit(datamodule=datamodule, model=model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The training has finished after 12 epochs. This is because, we set the `EarlyStopping` criteria with a patience of 3, which terminated the training after `pixel_AUROC` stopped improving. If we increased the `patience`, the training would continue further.\n", + "\n", + "## Testing\n", + "\n", + "Now that we trained the model, we could test the model to check the overall performance on the test set. We will also be writing the output of the test images to a file since we set `VisualizerCallback` in `callbacks`." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Testing DataLoader 0: 100%|██████████| 3/3 [00:23<00:00, 7.93s/it]\n" + ] + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+       "┃        Test metric               DataLoader 0        ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+       "│        image_AUROC                    1.0            │\n",
+       "│        pixel_AUROC            0.9744887351989746     │\n",
+       "└───────────────────────────┴───────────────────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m Test metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│\u001b[36m \u001b[0m\u001b[36m image_AUROC \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.0 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m pixel_AUROC \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.9744887351989746 \u001b[0m\u001b[35m \u001b[0m│\n", + "└───────────────────────────┴───────────────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "[{'pixel_AUROC': 0.9744887351989746, 'image_AUROC': 1.0}]" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "trainer.test(datamodule=datamodule, model=model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`trainer.test` returns the `pixel_AUROC` and `image_AUROC` results. We could also find the saved output in `images` directory." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "broken_large broken_small contamination good\n" + ] + } + ], + "source": [ + "! ls images" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Inference\n", + "\n", + "Since we have a trained model, we could infer the model on an individual image or folder of images. Anomalib has an `InferenceDataset` to let you create an inference dataset. So let's try it." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "inference_dataset = InferenceDataset(\n", + " path=\"../../datasets/MVTec/bottle/test/broken_large/000.png\", image_size=(256, 256)\n", + ")\n", + "inference_dataloader = DataLoader(dataset=inference_dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We could utilize `Trainer`'s `predict` method to infer, and get the outputs to visualize" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3]\n", + "/home/sakcay/miniconda3/envs/anomalib/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:240: PossibleUserWarning: The dataloader, predict_dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 96 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " rank_zero_warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicting DataLoader 0: 100%|██████████| 1/1 [00:00<00:00, -48.12it/s]\n" + ] + } + ], + "source": [ + "predictions = trainer.predict(model=model, dataloaders=inference_dataloader)[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`predictions` contain image, anomaly maps, predicted scores, labels and masks. These are all stored in a dictionary. We could check this by printing the `prediction` keys." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['image', 'anomaly_maps', 'pred_scores', 'pred_labels', 'pred_masks'])\n" + ] + } + ], + "source": [ + "print(predictions.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1, 3, 256, 256]) torch.Size([1, 1, 256, 256]) torch.Size([1, 1, 256, 256])\n" + ] + } + ], + "source": [ + "print(\n", + " f'Image Shape: {predictions[\"image\"].shape},\\n'\n", + " 'Anomaly Map Shape: {predictions[\"anomaly_maps\"].shape}, \\n'\n", + " 'Predicted Mask Shape: {predictions[\"pred_masks\"].shape}'\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To properly visualize the predictions, we will need to perform some post-processing operations.\n", + "\n", + "Let's post-process each output one by one. We could start with the image. Each `image` is a tensor and within (0, 1) range. To visualize it, we need to denormalize it to (0, 255) scale. Anomalib already has a class for this. Let's use it." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shape of the Image: (256, 256, 3)\n", + " Min Pixel Value: 29 \n", + " Max Pixel Value: 255\n" + ] + } + ], + "source": [ + "image = predictions[\"image\"][0]\n", + "image = Denormalize()(image)\n", + "print(f\"Image Shape: {image.shape}\\n Min Pixel: {image.min()} \\n Max Pixel: {image.max()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We could now see that `image` is of a numpy array and within the range of \\[0, 255\\]. It's ready to be visualized now." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(image)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The second output of the predictions is the anomaly map. As can be seen above, it's also a torch tensor and of size `torch.Size([1, 1, 256, 256])`. We therefore need to convert it to numpy and squeeze the dimensions to make it `256x256` output to visualize." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "anomaly_map = predictions[\"anomaly_maps\"][0]\n", + "anomaly_map = anomaly_map.cpu().numpy().squeeze()\n", + "plt.imshow(anomaly_map)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We could superimpose (overlay) the anomaly map on top of the original image to get a heat map. Anomalib has a built-in function to achieve this. Let's try it." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "heat_map = superimpose_anomaly_map(anomaly_map=anomaly_map, image=image, normalize=True)\n", + "plt.imshow(heat_map)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`predictions` also contains prediction scores and labels." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(0.7830) tensor(True)\n" + ] + } + ], + "source": [ + "pred_score = predictions[\"pred_scores\"][0]\n", + "pred_labels = predictions[\"pred_labels\"][0]\n", + "print(pred_score, pred_labels)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The last part of the predictions is the mask that is predicted by the model. This is a boolean mask containing True/False for the abnormal/normal pixels, respectively." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pred_masks = predictions[\"pred_masks\"][0].squeeze().cpu().numpy()\n", + "plt.imshow(pred_masks)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That wraps it! In this notebook, we show how we could train, test and finally infer a FastFlow model using Anomalib API." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.12 ('anomalib')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.12" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "f26beec5b578f06009232863ae217b956681fd13da2e828fa5a0ecf8cf2ccd29" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/200_benchmarking/201_benchmarking.ipynb b/notebooks/300_benchmarking/301_benchmarking.ipynb similarity index 100% rename from notebooks/200_benchmarking/201_benchmarking.ipynb rename to notebooks/300_benchmarking/301_benchmarking.ipynb diff --git a/notebooks/README.md b/notebooks/README.md index 914ea67ee2..7163c35f5f 100644 --- a/notebooks/README.md +++ b/notebooks/README.md @@ -14,8 +14,14 @@ | MVTec | [102_mvtec](100_datamodules/102_mvtec.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/development/notebooks/100_datamodules/102_mvtec.ipynb) | | Folder | [103_folder](100_datamodules/103_folder.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/development/notebooks/100_datamodules/103_folder.ipynb) | -## 2. Benchmarking and Hyperparameter Optimization +## 2. Models +| Notebook | GitHub | Colab | +| ------------ | ----------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| Model | [201_fastflow](200_models/201_fastflow.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/development/notebooks/200_models/201_fastflow.ipynb) | + + +## 3. Benchmarking and Hyperparameter Optimization | Notebook | GitHub | Colab | | ------------ | ----------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -| Benchmarking | [201_benchmarking](200_benchmarking/201_benchmarking.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/development/notebooks/200_benchmarking/201_benchmarking.ipynb) | +| Benchmarking | [301_benchmarking](300_benchmarking/301_benchmarking.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/development/notebooks/300_benchmarking/301_benchmarking.ipynb) |