{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#default_exp data.external"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "from fastai2.torch_basics import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# External data\n",
    "> Helper functions to download the fastai datasets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " A complete list of datasets that are available by default isnide the library are: \n",
    "\n",
    "**Main datasets**:\n",
    "1.    **ADULT_SAMPLE**: A small of the [adults dataset](https://archive.ics.uci.edu/ml/datasets/Adult) to  predict whether income exceeds $50K/yr based on census data. \n",
    "-    **BIWI_SAMPLE**: A [BIWI kinect headpose database](https://www.kaggle.com/kmader/biwi-kinect-head-pose-database). The dataset contains over 15K images of 20 people (6 females and 14 males - 4 people were recorded twice). For each frame, a depth image, the corresponding rgb image (both 640x480 pixels), and the annotation is provided. The head pose range covers about +-75 degrees yaw and +-60 degrees pitch. \n",
    "1.    **CIFAR**: The famous [cifar-10](https://www.cs.toronto.edu/~kriz/cifar.html) dataset which consists of 60000 32x32 colour images in 10 classes, with 6000 images per class.      \n",
    "1.    **COCO_SAMPLE**: A sample of the [coco dataset](http://cocodataset.org/#home) for object detection. \n",
    "1.    **COCO_TINY**: A tiny version of the [coco dataset](http://cocodataset.org/#home) for object detection.\n",
    "-    **HUMAN_NUMBERS**: A synthetic dataset consisting of human number counts in text such as one, two, three, four.. Useful for experimenting with Language Models.\n",
    "-    **IMDB**: The full [IMDB sentiment analysis dataset](https://ai.stanford.edu/~amaas/data/sentiment/).          \n",
    "\n",
    "-    **IMDB_SAMPLE**: A sample of the full [IMDB sentiment analysis dataset](https://ai.stanford.edu/~amaas/data/sentiment/). \n",
    "-    **ML_SAMPLE**: A movielens sample dataset for recommendation engines to recommend movies to users.            \n",
    "-    **ML_100k**: The movielens 100k dataset for recommendation engines to recommend movies to users.             \n",
    "-    **MNIST_SAMPLE**: A sample of the famous [MNIST dataset](http://yann.lecun.com/exdb/mnist/) consisting of handwritten digits.        \n",
    "-    **MNIST_TINY**: A tiny version of the famous [MNIST dataset](http://yann.lecun.com/exdb/mnist/) consisting of handwritten digits.                   \n",
    "-    **MNIST_VAR_SIZE_TINY**:  \n",
    "-    **PLANET_SAMPLE**: A sample of the planets dataset from the Kaggle competition [Planet: Understanding the Amazon from Space](https://www.kaggle.com/c/planet-understanding-the-amazon-from-space).\n",
    "-    **PLANET_TINY**: A tiny version  of the planets dataset from the Kaggle competition [Planet: Understanding the Amazon from Space](https://www.kaggle.com/c/planet-understanding-the-amazon-from-space) for faster experimentation and prototyping.\n",
    "-    **IMAGENETTE**: A smaller version of the [imagenet dataset](http://www.image-net.org/) pronounced just like 'Imagenet', except with a corny inauthentic French accent. \n",
    "-    **IMAGENETTE_160**: The 160px version of the Imagenette dataset.      \n",
    "-    **IMAGENETTE_320**: The 320px version of the Imagenette dataset. \n",
    "-    **IMAGEWOOF**: Imagewoof is a subset of 10 classes from Imagenet that aren't so easy to classify, since they're all dog breeds.\n",
    "-    **IMAGEWOOF_160**: 160px version of the ImageWoof dataset.        \n",
    "-    **IMAGEWOOF_320**: 320px version of the ImageWoof dataset.\n",
    "-    **IMAGEWANG**: Imagewang contains Imagenette and Imagewoof combined, but with some twists that make it into a tricky semi-supervised unbalanced classification problem\n",
    "-    **IMAGEWANG_160**: 160px version of Imagewang.        \n",
    "-    **IMAGEWANG_320**: 320px version of Imagewang. \n",
    "\n",
    "**Kaggle competition datasets**:\n",
    "1. **DOGS**: Image dataset consisting of dogs and cats images from [Dogs vs Cats kaggle competition](https://www.kaggle.com/c/dogs-vs-cats). \n",
    "\n",
    "**Image Classification datasets**:\n",
    "1.    **CALTECH_101**: Pictures of objects belonging to 101 categories. About 40 to 800 images per category. Most categories have about 50 images. Collected in September 2003 by Fei-Fei Li, Marco Andreetto, and Marc 'Aurelio Ranzato.\n",
    "1.    CARS: The [Cars dataset](https://ai.stanford.edu/~jkrause/cars/car_dataset.html) contains 16,185 images of 196 classes of cars.   \n",
    "1.    **CIFAR_100**: The CIFAR-100 dataset consists of 60000 32x32 colour images in 100 classes, with 600 images per class.   \n",
    "1.    **CUB_200_2011**: Caltech-UCSD Birds-200-2011 (CUB-200-2011) is an extended version of the CUB-200 dataset, with roughly double the number of images per class and new part location annotations\n",
    "1.    **FLOWERS**: 17 category [flower dataset](http://www.robots.ox.ac.uk/~vgg/data/flowers/) by gathering images from various websites.\n",
    "1.    **FOOD**:         \n",
    "1.    **MNIST**: [MNIST dataset](http://yann.lecun.com/exdb/mnist/) consisting of handwritten digits.      \n",
    "1.    **PETS**: A 37 category [pet dataset](https://www.robots.ox.ac.uk/~vgg/data/pets/) with roughly 200 images for each class.\n",
    "\n",
    "**NLP datasets**:\n",
    "1.    **AG_NEWS**: The AG News corpus consists of news articles from the AG’s corpus of news articles on the web pertaining to the 4 largest classes. The dataset contains 30,000 training and 1,900 testing examples for each class.\n",
    "1.    **AMAZON_REVIEWS**: This dataset contains product reviews and metadata from Amazon, including 142.8 million reviews spanning May 1996 - July 2014.\n",
    "1.    **AMAZON_REVIEWS_POLARITY**: Amazon reviews dataset for sentiment analysis.\n",
    "1.    **DBPEDIA**: The DBpedia ontology dataset contains 560,000 training samples and 70,000 testing samples for each of 14 nonoverlapping classes from DBpedia. \n",
    "1.    **MT_ENG_FRA**: Machine translation dataset from English to French.\n",
    "1.    **SOGOU_NEWS**: [The Sogou-SRR](http://www.thuir.cn/data-srr/) (Search Result Relevance) dataset was constructed to support researches on search engine relevance estimation and ranking tasks.\n",
    "1.    **WIKITEXT**: The [WikiText language modeling dataset](https://blog.einstein.ai/the-wikitext-long-term-dependency-language-modeling-dataset/) is a collection of over 100 million tokens extracted from the set of verified Good and Featured articles on Wikipedia.  \n",
    "1.    **WIKITEXT_TINY**: A tiny version of the WIKITEXT dataset.\n",
    "1.    **YAHOO_ANSWERS**: YAHOO's question answers dataset.\n",
    "1.    **YELP_REVIEWS**: The [Yelp dataset](https://www.yelp.com/dataset) is a subset of YELP businesses, reviews, and user data for use in personal, educational, and academic purposes\n",
    "1.    **YELP_REVIEWS_POLARITY**: For sentiment classification on YELP reviews.\n",
    "\n",
    "\n",
    "**Image localization datasets**:\n",
    "1.    **BIWI_HEAD_POSE**: A [BIWI kinect headpose database](https://www.kaggle.com/kmader/biwi-kinect-head-pose-database). The dataset contains over 15K images of 20 people (6 females and 14 males - 4 people were recorded twice). For each frame, a depth image, the corresponding rgb image (both 640x480 pixels), and the annotation is provided. The head pose range covers about +-75 degrees yaw and +-60 degrees pitch. \n",
    "1.    **CAMVID**: Consists of driving labelled dataset for segmentation type models.\n",
    "1.    **CAMVID_TINY**: A tiny camvid dataset for segmentation type models.\n",
    "1.    **LSUN_BEDROOMS**: [Large-scale Image Dataset](https://arxiv.org/abs/1506.03365) using Deep Learning with Humans in the Loop\n",
    "1.    **PASCAL_2007**: [Pascal 2007 dataset](http://host.robots.ox.ac.uk/pascal/VOC/voc2007/) to recognize objects from a number of visual object classes in realistic scenes.\n",
    "1.    **PASCAL_2012**: [Pascal 2012 dataset](http://host.robots.ox.ac.uk/pascal/VOC/voc2012/) to recognize objects from a number of visual object classes in realistic scenes.\n",
    "\n",
    "**Audio classification**:\n",
    "1. **MACAQUES**: [7285 macaque coo calls](https://datadryad.org/stash/dataset/doi:10.5061/dryad.7f4p9) across 8 individuals from [Distributed acoustic cues for caller identity in macaque vocalization](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4806230).\n",
    "2. **ZEBRA_FINCH**: [3405 zebra finch calls](https://ndownloader.figshare.com/articles/11905533/versions/1) classified [across 11 call types](https://link.springer.com/article/10.1007/s10071-015-0933-6). Additonal labels include name of individual making the vocalization and its age.\n",
    "\n",
    "**Medical Imaging datasets**:\n",
    "1. **SIIM_SMALL**: A smaller version of the [SIIM dataset](https://www.kaggle.com/c/siim-acr-pneumothorax-segmentation/overview) where the objective is to classify pneumothorax from a set of chest radiographic images.\n",
    "\n",
    "**Pretrained models**:\n",
    "1.    **OPENAI_TRANSFORMER**: The GPT2 Transformer pretrained weights.\n",
    "1.    **WT103_FWD**: The WikiText-103 forward language model weights.\n",
    "1.    **WT103_BWD**: The WikiText-103 backward language model weights."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To download any of the datasets or pretrained weights, simply run `untar_data` by passing any dataset name mentioned above like so: \n",
    "\n",
    "```python \n",
    "path = untar_data(URLs.PETS)\n",
    "path.ls()\n",
    "\n",
    ">> (#7393) [Path('/home/ubuntu/.fastai/data/oxford-iiit-pet/images/keeshond_34.jpg'),Path('/home/ubuntu/.fastai/data/oxford-iiit-pet/images/Siamese_178.jpg'),Path('/home/ubuntu/.fastai/data/oxford-iiit-pet/images/german_shorthaired_94.jpg'),Path('/home/ubuntu/.fastai/data/oxford-iiit-pet/images/Abyssinian_92.jpg'),Path('/home/ubuntu/.fastai/data/oxford-iiit-pet/images/basset_hound_111.jpg'),Path('/home/ubuntu/.fastai/data/oxford-iiit-pet/images/Russian_Blue_194.jpg'),Path('/home/ubuntu/.fastai/data/oxford-iiit-pet/images/staffordshire_bull_terrier_91.jpg'),Path('/home/ubuntu/.fastai/data/oxford-iiit-pet/images/Persian_69.jpg'),Path('/home/ubuntu/.fastai/data/oxford-iiit-pet/images/english_setter_33.jpg'),Path('/home/ubuntu/.fastai/data/oxford-iiit-pet/images/Russian_Blue_155.jpg')...]\n",
    "```\n",
    "\n",
    "To download model pretrained weights: \n",
    "```python \n",
    "path = untar_data(URLs.PETS)\n",
    "path.ls()\n",
    "\n",
    ">> (#2) [Path('/home/ubuntu/.fastai/data/wt103-bwd/itos_wt103.pkl'),Path('/home/ubuntu/.fastai/data/wt103-bwd/lstm_bwd.pth')]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Config -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "class Config:\n",
    "    \"Setup config at `~/.fastai` unless it exists already.\"\n",
    "    config_path = Path(os.getenv('FASTAI_HOME', '~/.fastai')).expanduser()\n",
    "    config_file = config_path/'config.yml'\n",
    "\n",
    "    def __init__(self):\n",
    "        self.config_path.mkdir(parents=True, exist_ok=True)\n",
    "        if not self.config_file.exists(): self.create_config()\n",
    "        self.d = self.load_config()\n",
    "\n",
    "    def __getitem__(self,k):\n",
    "        k = k.lower()\n",
    "        if k not in self.d: k = k+'_path'\n",
    "        return Path(self.d[k])\n",
    "\n",
    "    def __getattr__(self,k):\n",
    "        if k=='d': raise AttributeError\n",
    "        return self[k]\n",
    "\n",
    "    def __setitem__(self,k,v): self.d[k] = str(v)\n",
    "    def __contains__(self,k): return k in self.d\n",
    "\n",
    "    def load_config(self):\n",
    "        \"load and return config if version equals 2 in existing, else create new config.\"\n",
    "        with open(self.config_file, 'r') as f:\n",
    "            config = yaml.safe_load(f)\n",
    "            if 'version' in config and config['version'] == 2: return config\n",
    "            elif 'version' in config: self.create_config(config)\n",
    "            else: self.create_config()\n",
    "        return self.load_config()\n",
    "\n",
    "    def create_config(self, cfg=None):\n",
    "        \"create new config with default paths and set `version` to 2.\"\n",
    "        config = {'data_path':    str(self.config_path/'data'),\n",
    "                  'archive_path': str(self.config_path/'archive'),\n",
    "                  'storage_path': '/tmp',\n",
    "                  'model_path':   str(self.config_path/'models'),\n",
    "                  'version':      2}\n",
    "        if cfg is not None:\n",
    "            cfg['version'] = 2\n",
    "            config = merge(config, cfg)\n",
    "        self.save_file(config)\n",
    "\n",
    "    def save(self): self.save_file(self.d)\n",
    "    def save_file(self, config):\n",
    "        \"save config file at default config location `~/.fastai/config.yml`.\"\n",
    "        with self.config_file.open('w') as f: yaml.dump(config, f, default_flow_style=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If a config file doesn't exist already, it is always created at `~/.fastai/config.yml` location by default whenever an instance of the `Config` class is created. Here is a quick example to explain: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "config_file = Path(\"~/.fastai/config.yml\").expanduser()\n",
    "if config_file.exists(): os.remove(config_file)\n",
    "assert not config_file.exists()\n",
    "\n",
    "config = Config()\n",
    "assert config_file.exists()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The config is now available as `config.d`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'archive_path': '/home/jhoward/.fastai/archive',\n",
       " 'data_path': '/home/jhoward/.fastai/data',\n",
       " 'model_path': '/home/jhoward/.fastai/models',\n",
       " 'storage_path': '/tmp',\n",
       " 'version': 2}"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "config.d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As can be seen, this is a basic config file that consists of `data_path`, `model_path`, `storage_path` and `archive_path`. \n",
    "All future downloads occur at the paths defined in the config file based on the type of download. For example, all future fastai datasets are downloaded to the `data_path` while all pretrained model weights are download to `model_path` unless the default download location is updated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Path('/home/jhoward/.fastai/config.yml'),\n",
       " Path('/home/jhoward/.fastai/config.yml.bak'))"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#hide\n",
    "config = Config()\n",
    "config_path = config.config_path\n",
    "config_file,config_bak = config_path/'config.yml',config_path/'config.yml.bak'\n",
    "config_file,config_bak"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "#This cell is just to make the config file compatible with current fastai\n",
    "# TODO: make this a method that auto-runs as needed\n",
    "if 'data_archive_path' not in config:\n",
    "    config['data_archive_path'] = config.data_path\n",
    "    config.save()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please note that it is possible to update the default path locations in the config file. Let's first create a backup of the config file, then update the config to show the changes and re update the new config with the backup file. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if config_file.exists(): shutil.move(config_file, config_bak)\n",
    "config['archive_path'] = Path(\".\")\n",
    "config.save()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'archive_path': '.',\n",
       " 'data_archive_path': '/home/jhoward/.fastai/data',\n",
       " 'data_path': '/home/jhoward/.fastai/data',\n",
       " 'model_path': '/home/jhoward/.fastai/models',\n",
       " 'storage_path': '/tmp',\n",
       " 'version': 2}"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "config = Config()\n",
    "config.d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `archive_path` has been updated to `\".\"`. Now let's remove any updates we made to Config file that we made for the purpose of this example. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'archive_path': '/home/jhoward/.fastai/archive',\n",
       " 'data_archive_path': '/home/jhoward/.fastai/data',\n",
       " 'data_path': '/home/jhoward/.fastai/data',\n",
       " 'model_path': '/home/jhoward/.fastai/models',\n",
       " 'storage_path': '/tmp',\n",
       " 'version': 2}"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if config_bak.exists(): shutil.move(config_bak, config_file)\n",
    "config = Config()\n",
    "config.d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## URLs -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class URLs():\n",
    "    \"Global constants for dataset and model URLs.\"\n",
    "    LOCAL_PATH = Path.cwd()\n",
    "    URL = 'http://files.fast.ai/data/examples/'\n",
    "    MDL = 'http://files.fast.ai/models/'\n",
    "    S3 = 'https://s3.amazonaws.com/fast-ai-'\n",
    "\n",
    "    S3_IMAGE    = f'{S3}imageclas/'\n",
    "    S3_IMAGELOC = f'{S3}imagelocal/'\n",
    "    S3_AUDI     = f'{S3}audio/'\n",
    "    S3_NLP      = f'{S3}nlp/'\n",
    "    S3_COCO     = f'{S3}coco/'\n",
    "    S3_MODEL    = f'{S3}modelzoo/'\n",
    "\n",
    "    # main datasets\n",
    "    ADULT_SAMPLE        = f'{URL}adult_sample.tgz'\n",
    "    BIWI_SAMPLE         = f'{URL}biwi_sample.tgz'\n",
    "    CIFAR               = f'{URL}cifar10.tgz'\n",
    "    COCO_SAMPLE         = f'{S3_COCO}coco_sample.tgz'\n",
    "    COCO_TINY           = f'{URL}coco_tiny.tgz'\n",
    "    HUMAN_NUMBERS       = f'{URL}human_numbers.tgz'\n",
    "    IMDB                = f'{S3_NLP}imdb.tgz'\n",
    "    IMDB_SAMPLE         = f'{URL}imdb_sample.tgz'\n",
    "    ML_SAMPLE           = f'{URL}movie_lens_sample.tgz'\n",
    "    ML_100k             = 'http://files.grouplens.org/datasets/movielens/ml-100k.zip'\n",
    "    MNIST_SAMPLE        = f'{URL}mnist_sample.tgz'\n",
    "    MNIST_TINY          = f'{URL}mnist_tiny.tgz'\n",
    "    MNIST_VAR_SIZE_TINY = f'{S3_IMAGE}mnist_var_size_tiny.tgz'\n",
    "    PLANET_SAMPLE       = f'{URL}planet_sample.tgz'\n",
    "    PLANET_TINY         = f'{URL}planet_tiny.tgz'\n",
    "    IMAGENETTE          = f'{S3_IMAGE}imagenette2.tgz'\n",
    "    IMAGENETTE_160      = f'{S3_IMAGE}imagenette2-160.tgz'\n",
    "    IMAGENETTE_320      = f'{S3_IMAGE}imagenette2-320.tgz'\n",
    "    IMAGEWOOF           = f'{S3_IMAGE}imagewoof2.tgz'\n",
    "    IMAGEWOOF_160       = f'{S3_IMAGE}imagewoof2-160.tgz'\n",
    "    IMAGEWOOF_320       = f'{S3_IMAGE}imagewoof2-320.tgz'\n",
    "    IMAGEWANG           = f'{S3_IMAGE}imagewang.tgz'\n",
    "    IMAGEWANG_160       = f'{S3_IMAGE}imagewang-160.tgz'\n",
    "    IMAGEWANG_320       = f'{S3_IMAGE}imagewang-320.tgz'\n",
    "\n",
    "    # kaggle competitions download dogs-vs-cats -p {DOGS.absolute()}\n",
    "    DOGS = f'{URL}dogscats.tgz'\n",
    "\n",
    "    # image classification datasets\n",
    "    CALTECH_101  = f'{S3_IMAGE}caltech_101.tgz'\n",
    "    CARS         = f'{S3_IMAGE}stanford-cars.tgz'\n",
    "    CIFAR_100    = f'{S3_IMAGE}cifar100.tgz'\n",
    "    CUB_200_2011 = f'{S3_IMAGE}CUB_200_2011.tgz'\n",
    "    FLOWERS      = f'{S3_IMAGE}oxford-102-flowers.tgz'\n",
    "    FOOD         = f'{S3_IMAGE}food-101.tgz'\n",
    "    MNIST        = f'{S3_IMAGE}mnist_png.tgz'\n",
    "    PETS         = f'{S3_IMAGE}oxford-iiit-pet.tgz'\n",
    "\n",
    "    # NLP datasets\n",
    "    AG_NEWS                 = f'{S3_NLP}ag_news_csv.tgz'\n",
    "    AMAZON_REVIEWS          = f'{S3_NLP}amazon_review_full_csv.tgz'\n",
    "    AMAZON_REVIEWS_POLARITY = f'{S3_NLP}amazon_review_polarity_csv.tgz'\n",
    "    DBPEDIA                 = f'{S3_NLP}dbpedia_csv.tgz'\n",
    "    MT_ENG_FRA              = f'{S3_NLP}giga-fren.tgz'\n",
    "    SOGOU_NEWS              = f'{S3_NLP}sogou_news_csv.tgz'\n",
    "    WIKITEXT                = f'{S3_NLP}wikitext-103.tgz'\n",
    "    WIKITEXT_TINY           = f'{S3_NLP}wikitext-2.tgz'\n",
    "    YAHOO_ANSWERS           = f'{S3_NLP}yahoo_answers_csv.tgz'\n",
    "    YELP_REVIEWS            = f'{S3_NLP}yelp_review_full_csv.tgz'\n",
    "    YELP_REVIEWS_POLARITY   = f'{S3_NLP}yelp_review_polarity_csv.tgz'\n",
    "\n",
    "    # Image localization datasets\n",
    "    BIWI_HEAD_POSE     = f\"{S3_IMAGELOC}biwi_head_pose.tgz\"\n",
    "    CAMVID             = f'{S3_IMAGELOC}camvid.tgz'\n",
    "    CAMVID_TINY        = f'{URL}camvid_tiny.tgz'\n",
    "    LSUN_BEDROOMS      = f'{S3_IMAGE}bedroom.tgz'\n",
    "    PASCAL_2007        = f'{S3_IMAGELOC}pascal_2007.tgz'\n",
    "    PASCAL_2012        = f'{S3_IMAGELOC}pascal_2012.tgz'\n",
    "\n",
    "    # Audio classification datasets\n",
    "    MACAQUES           = 'https://storage.googleapis.com/ml-animal-sounds-datasets/macaques.zip'\n",
    "    ZEBRA_FINCH        = 'https://storage.googleapis.com/ml-animal-sounds-datasets/zebra_finch.zip'\n",
    "\n",
    "    # Medical Imaging datasets\n",
    "    #SKIN_LESION        = f'{S3_IMAGELOC}skin_lesion.tgz'\n",
    "    SIIM_SMALL         = f'{S3_IMAGELOC}siim_small.tgz'\n",
    "\n",
    "    #Pretrained models\n",
    "    OPENAI_TRANSFORMER = f'{S3_MODEL}transformer.tgz'\n",
    "    WT103_FWD          = f'{S3_MODEL}wt103-fwd.tgz'\n",
    "    WT103_BWD          = f'{S3_MODEL}wt103-bwd.tgz'\n",
    "\n",
    "    def path(url='.', c_key='archive'):\n",
    "        \"Return local path where to download based on `c_key`\"\n",
    "        fname = url.split('/')[-1]\n",
    "        local_path = URLs.LOCAL_PATH/('models' if c_key=='models' else 'data')/fname\n",
    "        if local_path.exists(): return local_path\n",
    "        return Config()[c_key]/fname"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The default local path is at `~/.fastai/archive/` but this can be updated by passing a different `c_key`. Note: `c_key` should be one of `'archive_path', 'data_archive_path', 'data_path', 'model_path', 'storage_path'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Path('/home/jhoward/.fastai/archive/oxford-iiit-pet.tgz')"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url = URLs.PETS\n",
    "local_path = URLs.path(url)\n",
    "test_eq(local_path.parent, Config()['archive']); \n",
    "local_path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Path('/home/jhoward/.fastai/models/oxford-iiit-pet.tgz')"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "local_path = URLs.path(url, c_key='model')\n",
    "test_eq(local_path.parent, Config()['model'])\n",
    "local_path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Downloading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "def download_url(url, dest, overwrite=False, pbar=None, show_progress=True, chunk_size=1024*1024,\n",
    "                 timeout=4, retries=5):\n",
    "    \"Download `url` to `dest` unless it exists and not `overwrite`\"\n",
    "    if os.path.exists(dest) and not overwrite: return\n",
    "\n",
    "    s = requests.Session()\n",
    "    s.mount('http://',requests.adapters.HTTPAdapter(max_retries=retries))\n",
    "    # additional line to identify as a firefox browser, see fastai/#2438\n",
    "    s.headers.update({'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:71.0) Gecko/20100101 Firefox/71.0'})\n",
    "    u = s.get(url, stream=True, timeout=timeout)\n",
    "    try: file_size = int(u.headers[\"Content-Length\"])\n",
    "    except: show_progress = False\n",
    "\n",
    "    with open(dest, 'wb') as f:\n",
    "        nbytes = 0\n",
    "        if show_progress: pbar = progress_bar(range(file_size), leave=False, parent=pbar)\n",
    "        try:\n",
    "            if show_progress: pbar.update(0)\n",
    "            for chunk in u.iter_content(chunk_size=chunk_size):\n",
    "                nbytes += len(chunk)\n",
    "                if show_progress: pbar.update(nbytes)\n",
    "                f.write(chunk)\n",
    "        except requests.exceptions.ConnectionError as e:\n",
    "            fname = url.split('/')[-1]\n",
    "            data_dir = dest.parent\n",
    "            print(f'\\n Download of {url} has failed after {retries} retries\\n'\n",
    "                  f' Fix the download manually:\\n'\n",
    "                  f'$ mkdir -p {data_dir}\\n'\n",
    "                  f'$ cd {data_dir}\\n'\n",
    "                  f'$ wget -c {url}\\n'\n",
    "                  f'$ tar xf {fname}\\n'\n",
    "                  f' And re-run your code once the download is successful\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `download_url` is a very handy function inside fastai! This function can be used to download any file from the internet to a location passed by `dest` argument of the function. It should not be confused, that this function can only be used to download fastai-files. That couldn't be further away from the truth. As an example, let's download the pets dataset from the actual source file: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fname = Path(\"./dog.jpg\")\n",
    "if fname.exists(): os.remove(fname)\n",
    "url = \"https://i.insider.com/569fdd9ac08a80bd448b7138?width=1100&format=jpeg&auto=webp\"\n",
    "download_url(url, fname)\n",
    "assert fname.exists()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's confirm that the file was indeed downloaded correctly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from PIL import Image\n",
    "im = Image.open(fname)\n",
    "plt.imshow(im);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As can be seen, the file has been downloaded to the local path provided in `dest` argument. Calling the function again doesn't trigger a download since the file is already there. This can be confirmed by checking that the last modified time of the file that is downloaded doesn't get updated. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if fname.exists(): last_modified_time = os.path.getmtime(fname)\n",
    "download_url(url, fname)\n",
    "test_eq(os.path.getmtime(fname), last_modified_time)\n",
    "if fname.exists(): os.remove(fname)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use the `download_url` function to download the pet's dataset straight from the source by simply passing `https://www.robots.ox.ac.uk/~vgg/data/pets/data/images.tar.gz` in `url`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "def download_data(url, fname=None, c_key='archive', force_download=False):\n",
    "    \"Download `url` to `fname`.\"\n",
    "    fname = Path(fname or URLs.path(url, c_key=c_key))\n",
    "    fname.parent.mkdir(parents=True, exist_ok=True)\n",
    "    if not fname.exists() or force_download: download_url(url, fname, overwrite=force_download)\n",
    "    return fname"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `download_data` is a convenience function and a wrapper outside `download_url` to download fastai files to the appropriate local path based on the `c_key`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If `fname` is None, it will default to the archive folder you have in your config file (or data, model if you specify a different `c_key`) followed by the last part of the url: for instance `URLs.MNIST_SAMPLE` is `http://files.fast.ai/data/examples/mnist_sample.tgz` and the default value for `fname` will be `~/.fastai/archive/mnist_sample.tgz`.\n",
    "\n",
    "If `force_download=True`, the file is alwayd downloaded. Otherwise, it's only when the file doesn't exists that the download is triggered."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#hide\n",
    "try:\n",
    "    test_eq(download_data(URLs.MNIST_SAMPLE), config.archive/'mnist_sample.tgz')\n",
    "    test_eq(download_data(URLs.MNIST_TINY, fname=Path('mnist.tgz')), Path('mnist.tgz'))\n",
    "finally: Path('mnist.tgz').unlink()\n",
    "\n",
    "try:\n",
    "    tst_model = config.model/'mnist_tiny.tgz'\n",
    "    test_eq(download_data(URLs.MNIST_TINY, c_key='model'), tst_model)\n",
    "    os.remove(tst_model)\n",
    "finally:\n",
    "    if tst_model.exists(): tst_model.unlink()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check datasets -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "from nbdev.imports import Config as NbdevConfig\n",
    "__file__ = NbdevConfig().lib_path/'data'/'external.py'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def _get_check(url):\n",
    "    \"internal function to get the hash of the file at `url`.\"\n",
    "    checks = json.load(open(Path(__file__).parent/'checks.txt', 'r'))\n",
    "    return checks.get(url, None)\n",
    "\n",
    "def _check_file(fname):\n",
    "    \"internal function to get the hash of the local file at `fname`.\"\n",
    "    size = os.path.getsize(fname)\n",
    "    with open(fname, \"rb\") as f: hash_nb = hashlib.md5(f.read(2**20)).hexdigest()\n",
    "    return [size,hash_nb]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([3214948, '2dbc7ec6f9259b583af0072c55816a88'],\n",
       " [3214948, '2dbc7ec6f9259b583af0072c55816a88'])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#hide\n",
    "test_eq(_get_check(URLs.MNIST_SAMPLE), _check_file(URLs.path(URLs.MNIST_SAMPLE)))\n",
    "_get_check(URLs.MNIST_SAMPLE), _check_file(URLs.path(URLs.MNIST_SAMPLE))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1637796771, '433b4706eb7c42bd74e7f784e3fdf244'],\n",
       " [2618908000, 'd90e29e54a4c76c0c6fba8355dcbaca5'])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_get_check(URLs.PASCAL_2007),_get_check(URLs.PASCAL_2012)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def _add_check(url, fname):\n",
    "    \"Internal function to update the internal check file with `url` and check on `fname`.\"\n",
    "    checks = json.load(open(Path(__file__).parent/'checks.txt', 'r'))\n",
    "    checks[url] = _check_file(fname)\n",
    "    json.dump(checks, open(Path(__file__).parent/'checks.txt', 'w'), indent=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extract"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def file_extract(fname, dest=None):\n",
    "    \"Extract `fname` to `dest` using `tarfile` or `zipfile`.\"\n",
    "    if dest is None: dest = Path(fname).parent\n",
    "    fname = str(fname)\n",
    "    if   fname.endswith('gz'):  tarfile.open(fname, 'r:gz').extractall(dest)\n",
    "    elif fname.endswith('zip'): zipfile.ZipFile(fname     ).extractall(dest)\n",
    "    else: raise Exception(f'Unrecognized archive: {fname}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`file_extract` is used by default in `untar_data` to decompress the downloaded file. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def _try_from_storage(dest, storage):\n",
    "    \"an internal function to create symbolic links for files from `storage` to `dest` if `storage` exists\"\n",
    "    if not storage.exists(): return\n",
    "    os.makedirs(dest, exist_ok=True)\n",
    "    for f in storage.glob('*'): os.symlink(f, dest/f.name, target_is_directory=f.is_dir())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "with tempfile.TemporaryDirectory() as d:\n",
    "    with tempfile.TemporaryDirectory() as d2:\n",
    "        d,d2 = Path(d),Path(d2)\n",
    "        for k in ['a', 'b', 'c']: os.makedirs(d/k)\n",
    "        for k in ['d', 'e', 'f']: (d/k).touch()\n",
    "        _try_from_storage(d2, d)\n",
    "        for k in ['a', 'b', 'c']: \n",
    "            assert (d2/k).exists()\n",
    "            assert (d2/k).is_dir()\n",
    "        for k in ['d', 'e', 'f']: \n",
    "            assert (d2/k).exists()\n",
    "            assert (d2/k).is_file()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def newest_folder(path):\n",
    "    \"Return newest folder on path\"\n",
    "    list_of_paths = path.glob('*')\n",
    "    return max(list_of_paths, key=lambda p: p.stat().st_ctime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def rename_extracted(dest):\n",
    "    \"Rename file if different from dest\"\n",
    "    extracted = newest_folder(dest.parent)\n",
    "    if not (extracted.name == dest.name): extracted.rename(dest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "let's rename the untar/unzip data if dest name is different from fname"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def untar_data(url, fname=None, dest=None, c_key='data', force_download=False, extract_func=file_extract):\n",
    "    \"Download `url` to `fname` if `dest` doesn't exist, and un-tgz or unzip to folder `dest`.\"\n",
    "    default_dest = URLs.path(url, c_key=c_key).with_suffix('')\n",
    "    dest = default_dest if dest is None else Path(dest)/default_dest.name\n",
    "    fname = Path(fname or URLs.path(url))\n",
    "    if fname.exists() and _get_check(url) and _check_file(fname) != _get_check(url):\n",
    "        print(\"A new version of this dataset is available, downloading...\")\n",
    "        force_download = True\n",
    "    if force_download:\n",
    "        if fname.exists(): os.remove(fname)\n",
    "        if dest.exists(): shutil.rmtree(dest)\n",
    "    if not dest.exists(): _try_from_storage(dest, URLs.path(url, c_key='storage').with_suffix(''))\n",
    "    if not dest.exists():\n",
    "        fname = download_data(url, fname=fname, c_key=c_key)\n",
    "        if _get_check(url) and _check_file(fname) != _get_check(url):\n",
    "            print(f\"File downloaded is broken. Remove {fname} and try again.\")\n",
    "        extract_func(fname, dest.parent)\n",
    "        rename_extracted(dest)\n",
    "    return dest"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`untar_data` is a very powerful convenience function to download files from `url` to `dest`. The `url` can be a default `url` from the `URLs` class or a custom url. If `dest` is not passed, files are downloaded at the `default_dest` which defaults to `~/.fastai/data/`.\n",
    "\n",
    "This convenience function extracts the downloaded files to `dest` by default. In order, to simply download the files without extracting, pass the `noop` function as `extract_func`. \n",
    "\n",
    "Note, it is also possible to pass a custom `extract_func` to `untar_data` if the filetype doesn't end with `.tgz` or `.zip`. The `gzip` and `zip` files are supported by default and there is no need to pass custom `extract_func` for these type of files. \n",
    "\n",
    "Internally, if files are not available at `fname` location already which defaults to `~/.fastai/archive/`, the files get downloaded at `~/.fastai/archive` and are then extracted at `dest` location. If no `dest` is passed the `default_dest` to download the files is `~/.fastai/data`. If files are already available at the `fname` location but not available then a symbolic link is created for each file from `fname` location to `dest`.\n",
    "\n",
    "Also, if `force_download` is set to `True`, files are re downloaded even if they exist. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tempfile import TemporaryDirectory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_eq(untar_data(URLs.MNIST_SAMPLE), config.data/'mnist_sample')\n",
    "\n",
    "with TemporaryDirectory() as d:\n",
    "    d = Path(d)\n",
    "    dest = untar_data(URLs.MNIST_TINY, fname='mnist_tiny.tgz', dest=d, force_download=True)\n",
    "    assert Path('mnist_tiny.tgz').exists()\n",
    "    assert (d/'mnist_tiny').exists()\n",
    "    os.unlink('mnist_tiny.tgz')\n",
    "\n",
    "#Test c_key\n",
    "tst_model = config.model/'mnist_sample'\n",
    "test_eq(untar_data(URLs.MNIST_SAMPLE, c_key='model'), tst_model)\n",
    "assert not tst_model.with_suffix('.tgz').exists() #Archive wasn't downloaded in the models path\n",
    "assert (config.archive/'mnist_sample.tgz').exists() #Archive was downloaded there\n",
    "shutil.rmtree(tst_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes the extracted folder does not have the same name as the downloaded file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#test fname!=dest\n",
    "with TemporaryDirectory() as d:\n",
    "    d = Path(d)\n",
    "    untar_data(URLs.MNIST_TINY, fname='mnist_tiny.tgz', dest=d, force_download=True)\n",
    "    Path('mnist_tiny.tgz').rename('nims_tini.tgz')\n",
    "    p = Path('nims_tini.tgz')\n",
    "    dest = Path('nims_tini')\n",
    "    assert p.exists()\n",
    "    file_extract(p, dest.parent)\n",
    "    rename_extracted(dest)\n",
    "    p.unlink()\n",
    "    shutil.rmtree(dest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "#Check all URLs are in the checks.txt file and match for downloaded archives\n",
    "_whitelist = \"MDL LOCAL_PATH URL WT103_BWD WT103_FWD\".split()\n",
    "checks = json.load(open(Path(__file__).parent/'checks.txt', 'r'))\n",
    "for d in dir(URLs): \n",
    "    if d.upper() == d and not d.startswith(\"S3\") and not d in _whitelist: \n",
    "        url = getattr(URLs, d)\n",
    "        assert url in checks,f\"\"\"{d} is not in the check file for all URLs.\n",
    "To fix this, you need to run the following code in this notebook before making a PR (there is a commented cell for this below):\n",
    "url = URLs.{d}\n",
    "untar_data(url, force_download=True)\n",
    "_add_check(url, URLs.path(url))\n",
    "\"\"\"\n",
    "        f = URLs.path(url)\n",
    "        if f.exists():\n",
    "            assert checks[url] == _check_file(f),f\"\"\"The log we have for {d} in checks does not match the actual archive.\n",
    "To fix this, you need to run the following code in this notebook before making a PR (there is a commented cell for this below):\n",
    "url = URLs.{d}\n",
    "_add_check(url, URLs.path(url))\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Export -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted 00_torch_core.ipynb.\n",
      "Converted 01_layers.ipynb.\n",
      "Converted 02_data.load.ipynb.\n",
      "Converted 03_data.core.ipynb.\n",
      "Converted 04_data.external.ipynb.\n",
      "Converted 05_data.transforms.ipynb.\n",
      "Converted 06_data.block.ipynb.\n",
      "Converted 07_vision.core.ipynb.\n",
      "Converted 08_vision.data.ipynb.\n",
      "Converted 09_vision.augment.ipynb.\n",
      "Converted 09b_vision.utils.ipynb.\n",
      "Converted 09c_vision.widgets.ipynb.\n",
      "Converted 10_tutorial.pets.ipynb.\n",
      "Converted 11_vision.models.xresnet.ipynb.\n",
      "Converted 12_optimizer.ipynb.\n",
      "Converted 13_callback.core.ipynb.\n",
      "Converted 13a_learner.ipynb.\n",
      "Converted 13b_metrics.ipynb.\n",
      "Converted 14_callback.schedule.ipynb.\n",
      "Converted 14a_callback.data.ipynb.\n",
      "Converted 15_callback.hook.ipynb.\n",
      "Converted 15a_vision.models.unet.ipynb.\n",
      "Converted 16_callback.progress.ipynb.\n",
      "Converted 17_callback.tracker.ipynb.\n",
      "Converted 18_callback.fp16.ipynb.\n",
      "Converted 18a_callback.training.ipynb.\n",
      "Converted 19_callback.mixup.ipynb.\n",
      "Converted 20_interpret.ipynb.\n",
      "Converted 20a_distributed.ipynb.\n",
      "Converted 21_vision.learner.ipynb.\n",
      "Converted 22_tutorial.imagenette.ipynb.\n",
      "Converted 23_tutorial.vision.ipynb.\n",
      "Converted 24_tutorial.siamese.ipynb.\n",
      "Converted 24_vision.gan.ipynb.\n",
      "Converted 30_text.core.ipynb.\n",
      "Converted 31_text.data.ipynb.\n",
      "Converted 32_text.models.awdlstm.ipynb.\n",
      "Converted 33_text.models.core.ipynb.\n",
      "Converted 34_callback.rnn.ipynb.\n",
      "Converted 35_tutorial.wikitext.ipynb.\n",
      "Converted 36_text.models.qrnn.ipynb.\n",
      "Converted 37_text.learner.ipynb.\n",
      "Converted 38_tutorial.text.ipynb.\n",
      "Converted 39_tutorial.transformers.ipynb.\n",
      "Converted 40_tabular.core.ipynb.\n",
      "Converted 41_tabular.data.ipynb.\n",
      "Converted 42_tabular.model.ipynb.\n",
      "Converted 43_tabular.learner.ipynb.\n",
      "Converted 44_tutorial.tabular.ipynb.\n",
      "Converted 45_collab.ipynb.\n",
      "Converted 46_tutorial.collab.ipynb.\n",
      "Converted 50_tutorial.datablock.ipynb.\n",
      "Converted 60_medical.imaging.ipynb.\n",
      "Converted 61_tutorial.medical_imaging.ipynb.\n",
      "Converted 65_medical.text.ipynb.\n",
      "Converted 70_callback.wandb.ipynb.\n",
      "Converted 71_callback.tensorboard.ipynb.\n",
      "Converted 72_callback.neptune.ipynb.\n",
      "Converted 73_callback.captum.ipynb.\n",
      "Converted 74_callback.cutmix.ipynb.\n",
      "Converted 97_test_utils.ipynb.\n",
      "Converted 99_pytorch_doc.ipynb.\n",
      "Converted index.ipynb.\n",
      "Converted tutorial.ipynb.\n"
     ]
    }
   ],
   "source": [
    "#hide\n",
    "from nbdev.export import notebook2script\n",
    "notebook2script()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "jupytext": {
   "split_at_heading": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}