{"id":1377,"date":"2021-12-15T21:00:55","date_gmt":"2021-12-15T21:00:55","guid":{"rendered":"https:\/\/salarydistribution.com\/machine-learning\/2021\/12\/15\/build-a-computer-vision-model-using-amazon-rekognition-custom-labels-and-compare-the-results-with-a-custom-trained-tensorflow-model\/"},"modified":"2021-12-15T21:00:55","modified_gmt":"2021-12-15T21:00:55","slug":"build-a-computer-vision-model-using-amazon-rekognition-custom-labels-and-compare-the-results-with-a-custom-trained-tensorflow-model","status":"publish","type":"post","link":"https:\/\/salarydistribution.com\/machine-learning\/2021\/12\/15\/build-a-computer-vision-model-using-amazon-rekognition-custom-labels-and-compare-the-results-with-a-custom-trained-tensorflow-model\/","title":{"rendered":"Build a computer vision model using Amazon Rekognition Custom Labels and compare the results with a custom trained TensorFlow model"},"content":{"rendered":"
\n

Building accurate computer vision models to detect objects in images requires deep knowledge of each step in the process\u2014from labeling, processing, and preparing the training and validation data, to making the right model choice and tuning the model\u2019s hyperparameters adequately to achieve the maximum accuracy. Fortunately, these complex steps are simplified by Amazon Rekognition Custom Labels<\/a>, a service of Amazon Rekognition<\/a> that enables you to build your own custom computer vision models for image classification and object detection tasks without requiring any prior computer vision expertise or advanced programming skills.<\/p>\n

In this post, we showcase how we can train a model to detect bees in images using Amazon Rekognition Custom Labels. We also compare these results against a custom-trained TensorFlow model (DIY model). We use Amazon SageMaker<\/a> as the platform to develop and train our model. Finally, we demonstrate how to build a serverless architecture to process new images using Amazon Rekognition APIs.<\/p>\n

When and where to use each model<\/h2>\n

Before diving deeper, it is important to understand the use cases that drive the decision of which model to use, whether it\u2019s an Amazon Rekognition Custom Labels model or a DIY model.<\/p>\n

Amazon Rekognition Custom Labels models are a great choice when our desired goal is to achieve maximum quality results in our task quickly. These models are heavily optimized and fine-tuned to perform at a high accuracy and recall. This is a cloud service, so when the model is trained, images must be uploaded to the cloud to be analyzed. A great advantage of this service is that the user doesn\u2019t need to have expertise to run this training pipeline. You can do it on the AWS Management Console<\/a> with just a few clicks, and it takes care of the heavy lifting of training and fine-tuning the model for you. Then, a simple set of API calls is offered, tailored to this specific model, for you to apply when needed.<\/p>\n

DIY models are the choice for advanced users with expertise in machine learning (ML). They allow you to control every aspect of the model, and tune the training data and the necessary parameters as needed. This requires advanced coding skills. These models trade off accuracy for latency: you can run them faster at the expense of lower qualitative performance. This lower latency fits really well in low bandwidth scenarios where the model needs to be deployed on the edge. For instance, IoT devices that support these models can host and run them and only upload the inference results to the cloud, which reduces the amount of data sent upstream.<\/p>\n

Overview of solution<\/h2>\n

To build our DIY model, we follow the solution from the GitHub repo TensorFlow 2 Object Detection API SageMaker<\/a>, which consists of these steps:<\/p>\n

    \n
  1. Download and prepare our bee dataset.<\/li>\n
  2. Train the model using a SageMaker custom container instance.<\/li>\n
  3. Test the model using a SageMaker model endpoint.<\/li>\n<\/ol>\n

    After we have our DIY model, we can proceed with the steps to build our bee detection model using Amazon Rekognition Custom Labels:<\/p>\n

      \n
    1. Deploy a serverless architecture using AWS CloudFormation<\/a>.<\/li>\n
    2. Download and prepare our bee dataset.<\/li>\n
    3. Create a project in Amazon Rekognition Custom Labels and import the dataset.<\/li>\n
    4. Train the Amazon Rekognition Custom Labels model.<\/li>\n
    5. Test the Amazon Rekognition Custom Labels model using the automatically generated API endpoint using Amazon Simple Storage Service<\/a> (Amazon S3) events.<\/li>\n<\/ol>\n

      Amazon Rekognition Custom Labels lets you manage the ML model training process on the Amazon Rekognition console<\/a>, which simplifies the end-to-end process. After we train both models, we can compare them.<\/p>\n

      Set up the environment<\/h2>\n

      We prepare our serverless environment using the CloudFormation template on GitHub<\/a>. On the AWS CloudFormation console, we create a new stack and use the template.yaml<\/code> file present in the root folder of our code repository. We provide a unique Amazon Simple Storage Service<\/a> (Amazon S3) bucket name when prompted, where our images are downloaded for further processing. We also provide a name for the inference processing Amazon Simple Queue Service<\/a> (Amazon SQS) queue, as well as an AWS Key Management Service<\/a> (AWS KMS) alias to securely encrypt the inference pipeline.<\/p>\n

      The architecture diagram is as follows, and it is used for detecting objects in new images as they are uploaded to our bucket.<\/p>\n

      \"\"<\/a><\/p>\n

      Following the first notebook (1_prepare_data<\/code>), we download and store our images in a bucket in Amazon S3. The dataset is already curated and annotated, and the images used have been licensed under CC0<\/a>. For convenience, the dataset is stored in a single .zip archive: dataset.zip<\/a>.<\/p>\n

      Inside the dataset folder, the manifest file output.manifest<\/code> contains the bounding box annotations of the dataset. The Amazon S3 references of these images belong to a different S3 bucket where the images were annotated originally. To import this manifest in Amazon Rekognition Custom Labels, the notebook rewrites the manifest file according to the bucket name we chose.<\/p>\n

      Train your DIY model<\/h2>\n

      To establish a comparison between a DIY and Amazon Rekognition Custom Labels model, we follow the steps in the following public repository<\/a> that demonstrates how to train a TensorFlow2 model using the same dataset.<\/p>\n

      We follow the steps described in this repository to train an EfficientNet object detector using our bee dataset. We modify the training notebook so that it runs for 10,000 steps. The model trains for about 2 hours, achieving an average precision of 83% and a recall of 56%.<\/p>\n

      Create your Amazon Rekognition Custom Labels project<\/h2>\n

      To create your bee detection project, complete the following steps:<\/p>\n

        \n
      1. On the Amazon Rekognition console, choose Amazon Rekognition Custom Labels<\/strong>.<\/li>\n
      2. Choose Get Started<\/strong>.<\/li>\n
      3. For Project name, enter bee-detection<\/code>.<\/li>\n
      4. Choose Create project<\/strong>.
        \"\"<\/a><\/li>\n<\/ol>\n

        Import your dataset<\/h2>\n

        We created a manifest using the first notebook (1_prepare_data<\/code>) that contains the Amazon S3 URIs of our image annotations. We follow these steps to import our manifest into Amazon Rekognition Custom Labels:<\/p>\n

          \n
        1. On the Amazon Rekognition Custom Labels console, choose Create dataset<\/strong>.<\/li>\n
        2. Select Import images labeled by Amazon SageMaker Ground Truth<\/strong>.<\/li>\n
        3. Name your dataset (for example, bee_dataset<\/code>).<\/li>\n
        4. Enter the Amazon S3 URI<\/strong> of the manifest file that we created.<\/li>\n
        5. Copy the bucket policy that appears on the console.<\/li>\n
        6. Open the Amazon S3 console in a new tab and access the bucket where the images are stored.<\/li>\n
        7. On the Permissions <\/strong>tab, enter the bucket policy to allow access of the dataset by Amazon Rekognition Custom Labels.<\/li>\n
        8. Go back to the dataset creation console and choose Submit<\/strong>.
          \"\"<\/a><\/li>\n<\/ol>\n

          Train your model<\/h2>\n

          After the dataset is imported into Amazon Rekognition Custom Labels, we can train a model immediately.<\/p>\n

            \n
          1. Choose Train Model<\/strong> from the dataset page.<\/li>\n
          2. For Choose project<\/strong>, choose your bee-detection<\/code> project.<\/li>\n
          3. For Choose training dataset<\/strong>, choose your bee_dataset<\/code> dataset.<\/li>\n<\/ol>\n

            As part of model training, Amazon Rekognition Custom Labels requires a labeled test dataset to validate the model training. Amazon Rekognition Custom Labels uses the test dataset to verify how well your trained model predicts the correct labels and to generate evaluation metrics. Images in the test dataset are not used to train your model and should represent the same types of images you use your model to analyze.<\/p>\n

              \n
            1. For Create test set<\/strong>, select how you want to provide your test dataset.<\/li>\n<\/ol>\n

              Amazon Rekognition Custom Labels provides three options:<\/p>\n