Upload seasons_classifier.py

seasons_classifier.py

@@ -0,0 +1,356 @@
+# -*- coding: utf-8 -*-
+"""Seasons_Classifier
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1XxlbGT6sV_f6wQHDI89ZEBhmLYFYGjxj
+
+###Links for this code###
+
+**REMEMBER**! "Save a copy in Drive" to make it your own notebook!
+
+https://shorturl.at/BxhkJ
+
+https://colab.research.google.com/drive/1Pd8rZMQwvo9miqsDSr18av2V5W9_Do9Z?usp=sharing
+
+###If you want state-of-the-art results (4 parts)###
+
+https://www.kaggle.com/code/jhoward/first-steps-road-to-the-top-part-1/
+
+### Setting up ###
+
+Installing resources... (!) means this piece is not Python.
+
+Installing Gradio is optional (useful if you want to test the app locally for faster iterations).
+
+The special command for fastai installs the latest develpment version, which has some problems fixed, but is always a bit riskier. The commented-out line would install the current stable version.
+"""
+
+!pip install gradio --upgrade
+
+!pip install --upgrade git+https://github.com/fastai/fastai.git  # development version, with some problems fixed, but more risky
+# !pip install fastai --upgrade  # stable version. Some known bugs, but less risky
+
+!pip install fastbook
+!pip install timm
+!pip install huggingface_hub["fastai"]
+
+""""Loading" resources (some we have just installed, others like the pathlib library come by default with Python)"""
+
+from pathlib import Path
+from time import sleep
+from time import time
+
+from fastai.vision.all import *
+from fastai.vision.widgets import *
+from fastbook import *
+from fastcore.parallel import *
+from fastdownload import download_url
+
+from google.colab import drive
+import gradio as gr
+from huggingface_hub import from_pretrained_fastai, notebook_login, push_to_hub_fastai
+import timm
+from torchvision.models import resnet18
+
+"""## Testing automatic dataset tools...
+
+We need to connect to Drive, so that we can access our files:
+"""
+
+drive.mount('/content/drive')
+
+"""We test downloading one image:"""
+
+urls = search_images_ddg('spring scenery', max_images=1)  # URLs returned as a list
+urls[0]  # this will print the first element of the list
+
+dest = '/content/drive/My Drive/Colab Notebooks/tmp/spring_scenery.jpg'  # any Path we like!
+download_url(urls[0], dest, show_progress=False)  # Downloads the img from a URL to a destination path
+
+im = Image.open(dest)  # opens the image as an Image object
+im.thumbnail((256,256))
+im  # remember this is a fast way to print stuff using journals, in normal scripts: print(im)
+
+"""! **Remember** !
+
+It is best to download any images not intended for training to a different folder (tmp for example). Keep your training-data folder clean, or Fastai may confuse the structure of labels.
+
+# Preparing the data
+
+Here we define our categories, and we will search the Internet for examples of each. We also have "extra query texts". We will append each text in this list to the category name to search images.
+
+This specific choices will result later in three categories (spain, france, japan), and the Internet queries will be "spain castle exterior", "spain castle interior", and so on.
+"""
+
+my_categories = 'spring','summer', 'autumn', 'winter'  # here you can insert your own categories
+extra_query_texts = [" scenery"]  # this is part of the Internet query, but not part of the category name (you can also leave it empty: [""])
+main_img_folder = Path('/content/drive/My Drive/Colab Notebooks/scenes')  # this is where you want your training images
+
+"""**Note**: The next part of the code is actually optional, what we need is to have a subfolder with the name of each category within our main folder, with the images of each category inside. But you can create this however you prefer."""
+
+max_images = 50
+for o in my_categories:
+    dest = (main_img_folder / o)
+    dest.mkdir(exist_ok=True, parents=True)
+
+    for suffix in extra_query_texts:
+        download_images(dest, urls=search_images_ddg(f'{o}{suffix}', max_images=max_images))
+        sleep(10)  # Pause between searches to avoid over-loading server
+
+    resize_images(dest, max_size=400, dest=dest)  # CAREFUL, DO YOU WANT TO USE THIS?
+    # resize_images(dest, max_size=800, dest=dest)  # you can comment-out lines that you don't want, like this
+
+"""Here we already have our pictures in their folders. **Stop and go look at them**! Do they look right? Maybe you need to use a different `extra_query_text` for better results? Do you have all the categories that you need? **Feel free to move or delete any images that seem out of place**.
+
+# Cleaning images...
+
+Good! Now we want to quickly check that the methods can load our images with no problems, to avoid errors during training:
+"""
+
+# CLEANING STEP 1-2 (get paths, then try to load images and return paths that failed)
+image_files = get_image_files(main_img_folder)  # looks for the paths of all image files in a folder and subfolders
+failed = verify_images(image_files)  # are these images ok?
+failed  # Do not advance to the next section untill this is empty ([]). Repeat cleaning steps 1 through 3
+
+# CLEANING STEP 3 (remove "unlink" bad images)
+failed.map(Path.unlink)  # deletes any bad image files
+
+"""Here we can see the sizes of our images. If they are too big, training will be slow."""
+
+files = get_image_files(main_img_folder)
+def f(o): return PILImage.create(o).size
+sizes = parallel(f, files, n_workers=8)
+pd.Series(sizes).value_counts()
+
+"""# Resizing images
+
+Sometimes images from the Internet can be big. While this will not particularly result in a better model, it will certainly mean much slower training. This is why we can resize them (agressively while training, more conservatively for the final model; 1080 pixels would be much more than safe).
+"""
+
+original_main_img_folder = main_img_folder
+main_img_folder = Path('/content/drive/My Drive/Colab Notebooks/scenes_small')
+
+resize_images(original_main_img_folder, dest=main_img_folder, max_size=256, recurse=True)
+
+files = get_image_files(main_img_folder)
+def f(o): return PILImage.create(o).size
+sizes = parallel(f, files, n_workers=8)
+pd.Series(sizes).value_counts()
+
+"""# Defining data structures
+
+The `DataBlock` puts together all the algorithm needs to know about our data (what kind of data is it? where do I get it? how do I make splits? where are the labels? what augmentations would you like?)
+"""
+
+data_info = DataBlock(
+    blocks=(ImageBlock, CategoryBlock),  # working with images and classification
+    get_items=get_image_files,  # get images using the method we tried before
+    splitter=RandomSplitter(valid_pct=0.2, seed=42),  # random split for train/validation
+    get_y=parent_label,  # the folder name tells us the image category!
+    item_tfms=Resize(256),
+    batch_tfms=aug_transforms(size=224, min_scale=0.5, flip_vert=False, max_lighting=0.1, max_zoom=1.05, max_warp=0.1))
+
+"""Here you have a lot more info on the available (standard) augmentation methods. https://docs.fast.ai/vision.augment.html
+
+But you even have more weird options! Look for example: https://docs.fast.ai/callback.mixup.html
+
+With the info in our `DataBlock` we can now create our dataloaders, which is what we really need for training and metrics. In our case we have to pass a folder here.
+"""
+
+dls = data_info.dataloaders(main_img_folder)
+
+dls.valid.show_batch(max_n=8, nrows=2)  # always look at your data before training!
+
+"""Images look good, but we want to look at train as well, so we can get an idea of what transformations are doing (**the behaviour of transforms (data augmentation) is different when applied to validation**).
+
+Here you can check if your data augmentation makes sense, and if it is strong enough. If you are unsure, don't be afraid to try different options.
+"""
+
+dls.train.show_batch(max_n=4, nrows=1, unique=True)  # unique means: always use the same example
+
+"""**Remember**: `pretrained` means we are starting with a network already trained in another dataset. We use transfer learning any time we can!
+
+# Training
+
+The "learner" groups useful data for training, including our newly created dataloaders ("dls" in Fastai style), metrics and the type of architecture to use. Fastai has some predefined, like "resnet18". Others come with the Timm library, and we can use them by just typing their name. For example, "mobilenetv2_100".
+"""
+
+learn = cnn_learner(dls, 'mobilenetv2_100', pretrained=True, metrics=error_rate)
+# learn = cnn_learner(dls, resnet18, pretrained=True, metrics=error_rate)  # resnet18 is ideal for fast iterations, but check out other models!
+learn = learn.to_fp16()  # mixed-precision gives faster results with no real downside
+
+"""lr_find, or learning rate finder, implements a method that allows to find a reasonable region for our learning rate. Remember: pick a learning rate where the curve is dropping fast, not where it is at the bottom!"""
+
+learn.lr_find()  # this may take a few minutes...
+
+lr = 0.08  # a bit more agressive than suggested :)
+
+"""The error_rate (% of errors) is useful to understand how good the model is, but judge training by looking at valid_loss instead (error_rate can be "jumpy", as it considers the most probable category, regardless of confidence)."""
+
+learn.fine_tune(epochs=10, base_lr=lr)  # you can specify how many "epochs" and "freeze_epochs" (default=1) you want
+
+"""That's it! Once we have data loaders training a model is really very easy. The difficult part is preparing your data and making sure your data loaders are correctly set up.
+
+# Results
+
+A confusion matrix is much better than a simple number (like "3% error"). This is even more useful if we have many categories.
+"""
+
+interp = ClassificationInterpretation.from_learner(learn)
+interp.plot_confusion_matrix()
+
+"""It is also very useful to examine the images where the model was worst. This can help identify problems. Remember: if results are very good the "top losses" will include images correctly classified (but with lower confidence)."""
+
+interp.plot_top_losses(9, largest=True, nrows=3, figsize=(15, 11))
+
+"""The confusion matrix can sometimes be hard to understand, specially when you deal with many categories. "most_confused" will return your most confused categories, which can be easier to grasp."""
+
+interp.most_confused (min_val=1)
+
+"""# Saving and sharing your work
+
+Do you like your model? Would you like to play with it? Do you want to show off to family and friends? Do you want to make it visible (CV, personal website, etc)? Then you have already done the hardest part! For more on how to use it with new data ("inference") and even how to publish a free online app with your model... check out lessons 1 and 2 from Fastai. If you do create an app please, **please share the link in your project** report and enjoy many bonus points :)
+https://course.fast.ai/
+
+Here we will get individual predictions for some images (this will be a good sanity check for saving and loading models):
+"""
+
+# First we download some example images:
+
+spring_dest = '/content/drive/My Drive/Colab Notebooks/tmp/spring.jpg'
+summer_dest = '/content/drive/My Drive/Colab Notebooks/tmp/summer.jpg'
+autumn_dest = '/content/drive/My Drive/Colab Notebooks/tmp/autumn.jpg'
+winter_dest = '/content/drive/My Drive/Colab Notebooks/tmp/winter.jpg'
+
+urls = search_images_ddg('spring scenery', max_images=1)
+download_url(urls[0], spring_dest, show_progress=False)
+
+urls = search_images_ddg('summer scenery', max_images=1)
+download_url(urls[0], summer_dest, show_progress=False)
+
+urls = search_images_ddg('autumn scenery', max_images=1)
+download_url(urls[0], autumn_dest, show_progress=False)
+
+urls = search_images_ddg('winter scenery', max_images=1)
+download_url(urls[0], winter_dest, show_progress=False)
+
+"""We define the operation so we don't need to rewrite it later."""
+
+def predict_test_images(learner_):
+    learner_.model.eval()
+    start = time.time()
+
+    is_bird,_,probs = learner_.predict(PILImage.create(spring_dest))
+    print(f"Spring image: {is_bird} ({probs})")
+
+    is_bird,_,probs = learner_.predict(PILImage.create(summer_dest))
+    print(f"Summer image: {is_bird} ({probs})")
+
+    is_bird,_,probs = learner_.predict(PILImage.create(autumn_dest))
+    print(f"Autumn image: {is_bird} ({probs})")
+
+    is_bird,_,probs = learner_.predict(PILImage.create(winter_dest))
+    print(f"Winter image: {is_bird} ({probs})")
+
+    end = time.time()
+    elapsed = end - start
+    print(f"Elapsed: {elapsed:.2f} s")
+
+predict_test_images(learn)
+
+"""# Save / load"""
+
+learn.export('model.pkl')
+
+local_learn = load_learner('model.pkl')
+
+"""We expect our predictions to be the same with the loaded model as they were before!"""
+
+predict_test_images(local_learn)
+
+"""# Uploading our model to HuggingFace
+
+Let's save the model properly, as a HuggingFace model that we can share.
+
+Here you will need to create an account and define a Token in settings (Access tokens). I created one with "write" privileges.
+"""
+
+notebook_login()
+
+"""One line to save or load a model from HuggingFace!"""
+
+push_to_hub_fastai(learner=learn, repo_id="Ener3122/Seasons_Classifier")
+
+hf_learn = from_pretrained_fastai("Ener3122/Seasons_Classifier")
+
+"""Again, we check that the predictions are the same (the first time I tried they were not, because informatics are cursed).
+
+(There seems to be some kind of bug with printing at this point, don't worry too much if you get no prints after here).
+"""
+
+predict_test_images(hf_learn)
+
+"""#Gradio
+
+Gradio allows us to create apps very easily!
+
+https://www.gradio.app/guides/quickstart
+
+The main thing we need to do is to get our model and create a main function (in our case to predict images). After that, one line is enough for the main app (locally in this notebook).
+"""
+
+# Here we set our model and get our categories (stored as a "vocab")
+learn = hf_learn
+labels = learn.dls.vocab
+
+# This is the main function, used to predict categories for one image
+def predict(img):
+    img = PILImage.create(img)
+    pred,pred_idx,probs = learn.predict(img)
+    return {labels[i]: float(probs[i]) for i in range(len(labels))}
+
+# We can test the results of prediction are what we expect
+pred_str = predict(spring_dest)
+print(pred_str)
+pred_str = predict(summer_dest)
+print(pred_str)
+pred_str = predict(autumn_dest)
+print(pred_str)
+pred_str = predict(winter_dest)
+print(pred_str)
+
+gr.Interface(fn=predict, inputs=gr.Image(), outputs=gr.Label(num_top_classes=2)).launch(share=True)
+
+"""#Online app
+
+But what good is a local app? We want to be able to share it!
+
+1.   Create HuggingFace account
+2.   Create a new HuggingFace Space
+3.   Go to "files" and click "+ Add File" or eddit files
+
+Using git:
+1.   git clone https:...
+2.   sudo apt-get install git-lfs
+3.   git lfs track "*.pkl"
+4.   git remote set-url origin https://user_name:[email protected]/repo_path
+
+You can copy the structure of this Space: https://huggingface.co/spaces/Pablogps/castles
+
+As you can see, there are three main files:
+
+
+*   requirements.txt, with stuff your Space will need (timm, fastai, toml)
+*   app.py, where you load the model and set the app, just like we did in this notebook
+*   example images for a nicer app
+
+Maybe this will be useful, but note the app.py contents are a bit outdated and will produce errors (use `gr.Image` instead of `gr.inputs.Image`, similarly for the outputs).
+
+https://www.tanishq.ai/blog/posts/2021-11-16-gradio-huggingface.html#footnotes
+
+For more references check the files at my own quick example:
+
+https://huggingface.co/spaces/Pablogps/gradio-test
+"""