Backyard Birdbot


This is a silly hobby project to use existing ML models to:

  1. Detect any birds sighted by a webcam
  2. Identify which species they belongs to
  3. Post images and descriptions of the detected birds to twitter (@BackyardBirdbot)

This project is my first Python project, so my main goal was to learn more about Python through experience. The entire program is run through Please excuse my messy code! The current code may differ slightly than the documented version below.


As stated, the aim of the project is to use existing ML models to first detect birds then classify what species it belongs to. We won’t be training any new models here. For object detection, we use the SSD Openimages v4 model published as part of TensorFlow Object Detection API ( For classifying bird species, we fortunately have a lightweight bird species classification model also by TensorFlow/Google ( We use OpenCV to capture our image and feed it to the models. We’ll attempt to describe the code below, please skip this section if you’re not interested.

We first import some libraries and some simple helper functions (the rest can be seen in the actual file:

#  Importing libraries
import numpy as np
import tensorflow as tf
import tensorflow_hub as hub
import cv2 as cv
import matplotlib
import matplotlib.pyplot as plt
import pandas as pd
import tweepy
import config
import os

from PIL import Image
from PIL import ImageColor
from PIL import ImageDraw
from PIL import ImageFont
from PIL import ImageOps

#  Helper functions (Not all are used, this section could be cleaned up)

def im_box_crop(img,box):
    # a function to crop an image using the normalized coordinates indicated by box output from the object detection model.
    im_height, im_width = img.shape[0], img.shape[1]
    ymin  = box[0]
    xmin  = box[1]
    ymax  = box[2]
    xmax  = box[3]
    (left, right, top, bottom) = (xmin * im_width, xmax * im_width, ymin * im_height, ymax * im_height)
    a,b,c,d = int(left) , int(right) , int(top) ,int(bottom)
    img_crop = img[c:d,a:b]
    return img_crop
def an_or_a(string):
    # a function to determine if the bird name should be prefaced with "a" or "an". Inspired by MIT course 6.0001 material (
    if char in an_letters:
    return output

We then need to load the actual models themselves, and initialize the Twitter API through tweepy so that we can post

#  Load models
print('Loading detection/classification models...')
# for the main image detection model
#module_handle = ""
module_handle = ""

detector = hub.load(module_handle).signatures['default']

# for the secondary bird classification model

# we also need to load the labelmap that will correlate the output to the actual
# species name.
print('Models loaded!')

#  setup twitter api

auth = tweepy.OAuthHandler(
api = tweepy.API(auth)

This is where we take our first detour. The bird specie classification model outputs a simple probably vector (965 elements long) corresponding to a background and 964 bird species. the labelmap provided by TF Hub looks like this: image

where the id matches up to the species. However, names like “Haemorhous cassinii” and “Aramus guarauna” are not useful to someone uneducated in ornithology as me. However, looking up 964 species would not be a very fun task! So we use a separate script to scrape wikipedia for the “common” names of these bird species. is shown below:

import wikipedia as wiki
import pandas as pd

# read the labelmap (downloaded from:
df = pd.read_csv('aiy_birds_V1_labelmap.csv')
# background is background[0,'common_name']='background'

# for all the other scientific names in the labelmap,
for index in range(1,len(df)):
    # search for the bird in Wikipedia, the first result is the common name.[index],results=1)
    # amend the dataframe with the common name[index,'common_name']=search_out[0]
    # just a progress update
    if index%10 == 0:
# save the results as a .csv file.

This script simply searches Wikipedia using the scientific name (ex: Haemorhous cassinii) and the first result returns the “common” name (Cassin’s finch). These names are then stored in a pandas dataset and saved as a separate .csv file. The amended .csv file looks like: image

Hence why you can see the loaded label map is the amended file. Back to the main script:

#  Image acquisition
# Wait a millisecond
# Use the front webcam
webcam = cv.VideoCapture(1)
webcam.set(cv.CAP_PROP_FRAME_WIDTH, 1920)
webcam.set(cv.CAP_PROP_FRAME_HEIGHT, 1080)
# minimum score for the model to register it as a bird
while True:

This cell is where everything happens. The content inside the while loop will be explanined further below, but first we initialize our webcam and set the resolution via cv2. cv.VideoCapture() has an index of 1 instead of 0, because the laptop has two cameras and we need the front-facing one.

The first part within that while loop is for acquiring and preparing the image input:

        #Acquire the image from the webcam
        check, frame =
        #get the webcam size
        height, width, channels = frame.shape
        #prepare the crop
        radiusX,radiusY= int(scale*height/100),int(scale*width/100)
        cropped = frame[minY:maxY, minX:maxX]
        frame = cv.cvtColor(cropped, cv.COLOR_BGR2RGB)
        # Convert the frame into a format tensorflow likes
        converted_img  = tf.image.convert_image_dtype(frame, tf.float32)[tf.newaxis, ...]

We first use .read to get an image from the webcam and crop the image (so that only the birdfeeder is in view). For some reason, cv2 uses BGR instead of RGB, so the color channels are reversed as well. It is then converted into an input format that TensorFlow models use.

        # Run the image through the model
        result = detector(converted_img)
        # create empty dict 
        # Loop through the results and see if any are "Birds" 
        # and if there are, store them in to the empty dictionary
        for name, score, box in zip(result['detection_class_entities'], result['detection_scores'], result['detection_boxes']):
            if name=='Bird':
                if score>=minThresh:
        # create empty lists that will contain the name and the score for bird species identification
        # if any birds were found

The converted image is first run through the object detection model. If any of the identified objects are “Bird” and have a score above the set threshold, it gets added into an empty dict object. I’m positive there is a more efficient and cleaner way to do this via filtering the result dict, but this works.

        if num_bird>0:
            # squish the dictionary to a more useful format
            # indices that will be used for image cropping (essentially an array of zeros)    
            # crop the image into the different boxes where birds were detected

If any birds are detected (num_bird>0), we crop the acquired image into boxes where the object detection model thinks “Bird”s are. These cropped images (which need to be 224×224) are then used as inputs to the bird species model.

            # for each cropped box,
            for image_index in range(num_bird):
                # reshape the image into the input format the classification model wants
                # put the image into the classication model
                # which ID # does the model think is most likely?
                # and how confident is the model?
                # if the score is greater than the minimum thershold:
                if out_score>=minIdentThresh*100:
                    # recrop the image here
                    # convert it back to cv2 format (BGR)
                    bird_crop_img = cv.cvtColor(bird_crop_img, cv.COLOR_RGB2BGR)
                    # save the recropped image for posting
                    # get the bird's common name
                    # append the name and score to the empty lists

For each detected “Bird”, the cropped image is put through the species identifier. Then the model’s most likely answer is chosen if its probability exceeds the threshold set earlier. We also crop a new image of the bird (not resized to 224×224) so that we can add it to our post.

            if len(ident_l)>1:     
                # save the captured frame first
                # if a single bird was found
                if num_bird==1:
                    str_1="I have found a bird! I think it's "
                    combined_str="{} {} {} ({})%".format(str_1,str_2,*ident_l,str(*score_l))
                # if multiple birds were found
                    str_1="I have found"
                    str_3="birds! I think they are:"
                    for bird_index in range(num_bird):
                        out_string="{} ({}%)".format(bird_species_str,bird_score_str)
                    separator=", "
                    combined_str="{} {} {} {}".format(str_1,str_2,str_3,separator.join(bird_out_string))
                img_upload_paths.extend(["Cropped_Bird_{}.jpg".format(i) for i in range(num_bird)])
                img_ids=[api.media_upload(i).media_id_string for i in img_upload_paths]
                for i in range(len(img_upload_paths)):
                print("Tweet posted! Waiting for 1 minute")
                print("Bird detected but no species identification.")
        # wait 0.1 seconds and loop again
        print("Turning off camera.")
        print("Camera off.")
        print("Program ended.")

If any species were successfully identified, the text of the tweet is prepared depending on if a single bird or multiple birds were detected. The images (the entire frame captured by the webcam, and individual crops of where birds are) uploaded and sent to Twitter. If a post is made, it waits one minute to look again, otherwise, it waits 0.01 seconds and goes through the while loop looking for birds.


After some tinkering, the code works:



It has a really hard time seeing sparrows (mostly brown) against the backdrop of seeds, which I think is expected. It sometimes has really bad misses for birds during flight, but sometimes it suprises me by presenting results like this:


Good job, bot!

The biggest challenge has been pointing the laptop in the right direction and cropping out everything but the bird feeder. An obvious solution would be to install a separate webcam and it can be secured and set to point at the feeder. Another problem seems to be that it can sometimes identify the same bird as multiple birds, resulting in what you can see in the above image, where a single chickadee was identified as two. I belive non-max supression would be the fix here, but that is yet to be implemented.

The bot is excellent at identifying birds from field guides: image image

So I’m hopeful that the code’s weakness is only with the image acquisition and hardware.