What’s Destroying My Yard? Pest Detection With Raspberry Pi

└── images
    ├── 1.jpg
    ├── 2.jpg
    ├── 3.jpg
    └── etc...

def take_picture():
  image_name = get_image_name()
  camera = picamera.PiCamera()
  camera.resolution = (400, 400)
  camera.rotation = 180
  camera.start_preview()
  time.sleep(2)
  camera.capture(image_name)
  camera.stop_preview()
  camera.close()
  return image_name

def main():
  while True:
    sensor_state = GPIO.input(pir_sensor_pin)
    if sensor_state == GPIO.HIGH:
      image_name = take_picture()
      // determine if the photo contains an animal

Image classification is a widely used application of machine learning, focusing on the task of analyzing an image and determining its contents or identifying the objects present within it.

The image classification process relies on the utilization of a model, which is a file that has been trained to recognize specific patterns. Creating such a file can be done through platforms like Edge Impulse, or you can find pre-trained models on platforms like TensorFlow.

In the context of this project, the ideal model would be capable of identifying common yard animals such as squirrels, chipmunks, raccoons, skunks, and others. However, I was unable to locate a pre-existing model for this purpose (if you know of one, please let me know in the comments). While building my own model was an option, it required a substantial collection of rodent images, which I didn't have readily available. Gathering a sufficient number of images from the internet proved to be a challenging task.

Ultimately, I opted to utilize a project called CameraTraps developed by Microsoft. Within CameraTraps, there is a model called the MegaDetector, which not only boasts an impressive name but also possesses the capability to detect animals and humans in still images.

CameraTraps, while highly effective, poses a significant challenge for Raspberry Pi devices due to its extensive capability of detecting various animal species. Running the detector on a Raspberry Pi is possible, and I will demonstrate how shortly. However, it's important to note that processing individual photos using the MegaDetector can take around 1 to 2 minutes, which may not be suitable for real-time applications. If you intend to utilize the MegaDetector, it might be advisable to capture images on the Pi and perform the actual processing on a more powerful system. In my case, I opted to keep everything running on the Pi for simplicity.

To set up the MegaDetector on your own, begin by following the setup instructions provided by MegaDetector. This process involves downloading the latest model file (.pb) and installing the necessary dependencies using pip.

Next, you can use the following code to execute the detector itself. Feel free to experiment with the confidence_threshold, but I have set it relatively low (60%) to capture any animal-like detections, especially during initial testing.

from pathlib import Path
from run_tf_detector_batch import load_and_run_detector_batch

# This just gets a reference to the MegaDetector’s model (.pb) file
model = ‘./md_v4.1.0'
model = ”.join([str(f) for f in Path(‘.').rglob(‘*.pb')])

def process_image(file_name):
# This runs the detector itself and tosses the output in an
# output.json file.
return load_and_run_detector_batch(
model_file=model,
image_file_names=[file_name],
checkpoint_path='./output.json'
confidence_threshold=0.6,
)

The load_and_run_detector_batch function provides an array of images, allowing for the processing of multiple images simultaneously. Each image in the array contains an array itself, consisting of the objects detected by the MegaDetector.

{
 "images": [
  {
   "file": "images/1.jpg",
   "max_detection_conf": 0.971,
   "detections": [
    {
     "category": "1",
     "conf": 0.971,
     "bbox": [
      0.3231,
      0.004868,
      0.6683,
      0.3121
     ]
    }
   ]
  }
 ]

Therefore, we require a code snippet to parse the JSON data and determine whether the MegaDetector has identified an animal. Here is an example of such code:

def is_animal_image(ml_result):
  for detection in ml_result['detections']:
    # A detection of '1' is an animal ('2' is a human)
    if detection['category'] == '1':
      return True
  return False

To consolidate all the components, when we zoom out to our main function, the updated code would appear as follows:

def main():
  while True:
    sensor_state = GPIO.input(pir_sensor_pin)
    if sensor_state == GPIO.HIGH:
      image_name = take_picture()

      # This is the new stuff that processes the image from
      # the camera. If the image does not contain an animal,
      # delete the image.
      ml_result = process_image(image_name)[0]
      if is_animal_image(ml_result):
        print('Animal detected!')
      else:
        print('No animal detected')
        os.remove(image_name)

    time.sleep(5)

main()

And now, we have an algorithm that can detect motion, capture pictures, and analyze them to identify animals. It's quite impressive!

However, there's one last coding aspect I'd like to address, which is notifications. I wanted to be notified whenever the camera detected an animal so that I could rush out and try to see it myself. Let's explore how to implement this functionality.

First, you'll need to set up a notification system of your choice. This could be an email notification, a message to a mobile device, or any other method that suits your preferences. Once you have your notification system in place, you can integrate it into the code.