Developers, end up saving these information on the server in a config file, which can be compromised if the config file is leaked. If the application is deployed on AWS lambda, it would be risky to save the information in the Environment variables.

If you want to run the same code on multiple environment, you can easily do that by just pointing the lambda to the correct secret in the environment variable.

What is Secret Manager?

Secret Manager is secure storage system sensitive data. Users and applications retrieve secrets with a call to Secrets Manager APIs, eliminating the need to hard-code sensitive information in plain text.

Let’s build an application like i have mentioned above.

Steps:

1. Create a secret in secret manager
2. Create a lambda function and connect it with secret manager
3. Add environment variable in lambda function

1. Create a secret:

Go to Secret Manager, and click on “Store a new secret”.

There are various types of secrets you can store specifically for various AWS services like RDS, Document DB, or your own database on other cloud or on-premise.

In this example we will create a secret of type “Other”, where we can store any information in key-value pairs.

You can then add values in the below text box like this. Below which you can select how you want your secret to be encrypted. You can use a key provided by AWS Secret Manager or create your own key. After selecting the key, click on Next.

On the next page, you can give the name to your secret. There is an option to replicate the secret in many regions. After which, click on Next.

On the next page, you can set to rotate your secrets at a scheduled time. Although it is a optional field, it is best to have automatic rotations turned on. Rotation reduces the risk from leaving credentials unchanged for long periods of time.

On the next page, you can review your secret, and click on “store”.

You have now created your secret. Let’s use this in a python code.

Create a Lambda Function

Create a Lambda function and add the below code

import json
import boto3
import os

def lambda_handler(event, context):
    
    secret = boto3.client("secretsmanager", region_name='us-east-1')
    secret_value = secret.get_secret_value(SecretId=os.environ["client_env"])
    secret_value = json.loads(secret_value["SecretString"])
    print(secret_value)

return {
        'statusCode': 200,
        'body': json.dumps('Hello from Lambda!')
    }

Here we are getting the value of secret from the environment variable. Check the below image to set the environment variable.

The benefit of using the environment variable is, that we can just change the variable and run the same code on completely different environments.

If you liked this post, please 👏👏for it on left, follow me if you want to read more such posts!

Twitter: https://twitter.com/IVaibhavMalpani
LinkedIn: https://www.linkedin.com/in/ivaibhavmalpani/

Keep your secrets to yourself | AWS Secret Manager was originally published in Vaibhav Malpani’s Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introduction to SageMaker Studio:

It helps you Preprocess the data, Train your Machine Learning models using the best possible Algorithm by understanding your data, Deploy the model, Monitor the deployed model, and Debug the model.

SageMaker Autopilot

SageMaker Autopilot automatically inspects raw data, applies feature processors, picks the best set of algorithms, trains and tunes multiple models, tracks their performance, and then ranks the models based on performance, all with just a few clicks.

SageMaker Autopilot can help you build a Classification and Regression Model on a Tabular data with no expertise about Machine Learning. It is quick to build your model and you can build it in a day compared to a Data Scientist who can take about a week or two.

Problem Statement:

We have a dataset of news title and description which are classified into 4 categories consisting of 1-World, 2-Sports, 3-Business, 4-Sci/Tech. This will be a multiclass classification problem and we will try to solve it using SageMaker Autopilot. (I will be using a subset (20% of the complete dataset) to reduces the training time)

Caution ⚠ : Autopilot is not included in free tier, so it will cost you for trying it out.

Steps to build using Autopilot

1. Upload data to an S3 bucket
2. Create an Experiment in SageMaker Studio

• Preprocess Data
• Create a Model
• Deploy Model

3. Test Deployed Model.

Upload data to S3

This is a very simple step. We will create a new bucket in S3 and make 2 folders as ‘input’ and ‘output’. We will then upload the training data in the input folder.

Create an Experiment in SageMaker Studio

If you have not created your SageMaker Studio, you can go here and create it. After the studio is created, click on ‘open studio’.

On the left side, select the SageMaker Experiment list and select the create Experiment.

After that, you will get a window in the middle of your screen. Enter your experiment name and enter the path to your dataset that is stored in S3.

Once you have selected your dataset. Enter the attribute name for which you want to do the predictions. In our case, it is ‘class_index’. We will also need to give a path to store the output data. We will give our output folder as the output data location.

In our case, we know that it is going to be a Multiclass classification, but let’s just select Auto, and let’s see if it is able to understand that our problem type.

After this, just hit ‘Create Experiment’.

We can now see that this pipeline has been created. Wait for it to complete. Once the Analyzing Data step is complete, you will see two new options at the top right corner: ‘Open candidate generation notebook’ and ‘Open data exploration notebook’

Candidate Generation Notebook: This will consist of a notebook that will have generated code for Data Transformation, SageMaker training job pipelines, Auto Hyperparameter tuning, and also the code to deploy the best model. (Do open this file, It’s really interesting)

Data exploration notebook: Once you open this, you can see that it has all the details about our dataset. It has also understood that our dataset was for Multiclass classification and had 4 classes — 1, 2, 3, 4.

Once the pipeline is completed, you will see details about the jobs that have run and it’s accuracy shown as ‘Objective’.

Once you see this screen, select the best-performed job and click on the ‘Deploy model’. Enter an endpoint name and select an appropriate instance type depending on your expected usage. You can select to save the request and response data to the endpoint. After this, hit the “Deploy model’ button.

On the left side, click on the SageMaker endpoint list as shown in the image below. First, you will see the status as ‘creating’. Wait for it to turn into ‘InService’. When it InService that means your model has been deployed and ready to be tested. You can deploy multiple models on multiple endpoints as shown below.

Test Deployed Model:

You can test your code on local using the below code.

import boto3,sys

endpoint_name = ""

SageMaker_client = boto3.Session().client('runtime.sagemaker')

response = SageMaker_client.invoke_endpoint(EndpointName=endpoint_name, ContentType='text/csv', Body="Flintoff, Collingwood lead England to win, Andrew Flintoff hit a typically brutal 99 and took the final wicket Friday as England cruised to a comfortable series-clinching victory over India in the second one-day cricket international at the Oval.")
print(response['Body'])

And you should get the output as 2 for the above call as the news is related to Sports.

What did we learn?

• Building Machine Learning model on tabular data with no prior knowledge using SageMaker Autopilot.
• Deploying models in a highly scalable environment.

If you liked this post, please 👏👏for it on left, follow me if you want to read more such posts!

Twitter: https://twitter.com/IVaibhavMalpani
LinkedIn: https://www.linkedin.com/in/ivaibhavmalpani/

Twitter: https://twitter.com/IVaibhavMalpani
LinkedIn: https://www.linkedin.com/in/ivaibhavmalpani/

AutoML using Amazon SageMaker Autopilot | Multiclass Classification was originally published in Vaibhav Malpani’s Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

Objective:

To deploy your Machine Learning/Deep Learning model which has the following capabilities:

• Automatic scaling up and down
• Highly reliable and redundant
• out-of-the-box stable HTTPS endpoint
• Pay per use
• Custom domain

Pre-requisites:

• Basic understanding of Docker
• Google Cloud Platform account.
• A Machine Learning model already built and saved in a file.

Before we begin,

Make sure you have a Machine Learning model that is saved in a file.

Also, you should have the code ready that takes the input parameter required by the model, read the model file in your code, give the input parameter to the model and the model returns back the output.

As there are 100’s of ways to read a model, give input to the model, and get a response from a model, I will show below a template of what your code should look like:

def run_model(input):
    model = read_model('./model_file')
    result = model.get_result(input)
    return result

For this blog,

I have decided to show a demo by using Python Flask Web Framework as python is mostly used for machine learning, it will be useful for a greater audience. But you can use any language that you want to write the above code.

Once you have written the above code, keep it in folder which contains the above code, your model, and requirements.txt

Now make a new file and name it Dockerfile. Below is the example that you can use if you are using python. (Make sure the name of the file that you have written above is app.py to use the exact code. else you need to make changes in the last line of the code.)

FROM python:3.7

# Copy local code to the container image.
ENV APP_HOME /app
WORKDIR $APP_HOME
COPY . .

# Install production dependencies.
RUN pip install gunicorn
RUN pip install -r requirements.txt

# Run the web service on container startup. Here we use the gunicorn
# webserver, with one worker process and 8 threads.
# For environments with multiple CPU cores, increase the number of workers
# to be equal to the cores available.
CMD exec gunicorn — bind :$PORT — workers 1 — threads 8 app:app

That’s it. That’s all the code we needed to write.

After this, set up a GCP project and download, install, and setup gcloud on your local machine. here

After that, just use the below-given commands.

1. Gcloud builds: This build an image of the code and model.

gcloud builds submit --tag gcr.io/PROJECT-ID/helloworld

2. Gcloud run deploy: This pushes the locally built image to google cloud container registry. It also deploys this image on cloud run that runs in a serverless manner.

gcloud run deploy --image gcr.io/PROJECT-ID/helloworld --platform managed

After this go to https://console.cloud.google.com/run

You can see, your image is deployed. Click on it to get more details. There on the top middle, you can see the URL at which your model is deployed. Try sending a request to this URL and see if you get the expected output. If not, try checking the logs that you can see just below the URL.

Well, that’s it. Your model is now running self-managed, highly scalable servers.

If you liked this post, please clap for it; follow me if you want to read more such posts!

Twitter: https://twitter.com/IVaibhavMalpani
LinkedIn: https://www.linkedin.com/in/ivaibhavmalpani/

Deploy highly scalable Machine Learning model | Cloud Run was originally published in Vaibhav Malpani’s Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

Scientists all around the world have been working on face recognition using machine learning for more than a decade now. As a human, it’s easy for us to remember the face and the name of the person. But, it’s tough for a machine to remember this. With the growth of Neural Networks (NN) and many libraries making it easy to build a NN, this problem has become a bit easier. This blog will teach you everything that you need to know about building your own Face recognition ML model using the Pytorch library.

Applications of Face Recognition:

• Attendance system in schools, colleges.
• Tracking in-time and out-time of office employees.
• Security Video monitoring to detect an unidentified person in your premise

Objective:

To build our own Face recognition model using CNN. We will use the Pytorch library to help us build CNNs. To train the model we would be using Amazon Sagemaker and save the trained model on S3.

Pre-requisites:

• Basic python programming knowledge
• Understanding of how CNNs work (Read here)
• An AWS account

Getting Data:

To start off we will need a face dataset to train our model for face recognition. I have shared the dataset below to use for this tutorial. You can add your own images to the dataset. Train and Test them out on how the model works.

I have uploaded images for a few celebrities to train our model. I have very few images and still, it managed to get me over 90% accuracy. To get the best results out of a CNN model, just give it more data. :)

The GitHub link also contains the jupyter notebook for running the complete code. The notebook assumes that you have already done all the installing for torch and torchvision. For more details on how to install it locally on your machine → click here

GitHub for Dataset and Jupyter Notebook

Please feel free to comment down below if you get stuck somewhere in the code. I will be more than happy to help you

Setting up SageMaker Instance:

Training CNNs requires a lot of computing power. It’s best advised to use a machine with GPU to get results comparatively quickly. For this blog, we are going to use an Amazon SageMaker Notebook instance. We are going to use the “ml.p2.xlarge” instance which has an NVIDIA Tesla K80 GPU. To use this you will need to increase your quota limit for your GPU. Read more about it here to know how to do it.

I would recommend to use a instance with GPU, to get the results quickly

Once the status of your SageMaker instance shows “inService”, Click on “Open Jupyter” to get started with your Jupyter notebook instance.

Click on the top right corner and upload your data set and the Jupyter notebook that I have shared at the end of this blog. (You will have to upload the dataset in zip format, as we cannot upload a folder to jupyter notebook. But don’t worry we have taken care of unzipping the data for you in the notebook code)

Building Models:

I will explain a few snippets from the jupyter notebook provided earlier. You can go through the notebook to understand the rest of it which is quite straightforward.

from torchvision import models
model = models.alexnet(pretrained=True)

You can see that we are using a pre-trained Model (alexnet). torchvision provides a lot of pre-trained models that have been trained on millions of images. By using this, we just edit the top layer of the model architecture by editing the out_features of the existing model.

AlexNet(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))
    (1): ReLU(inplace=True)
    (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (3): Conv2d(64, 192, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (4): ReLU(inplace=True)
    (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (6): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (7): ReLU(inplace=True)
    (8): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (9): ReLU(inplace=True)
    (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(6, 6))
  (classifier): Sequential(
    (0): Dropout(p=0.5, inplace=False)
    (1): Linear(in_features=9216, out_features=4096, bias=True)
    (2): ReLU(inplace=True)
    (3): Dropout(p=0.5, inplace=False)
    (4): Linear(in_features=4096, out_features=4096, bias=True)
    (5): ReLU(inplace=True)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
)

As you can see in the above example the “out_feautres” is 1000, but in our dataset, we want to classify into 6 classes (ben_afflek, brad_pitt, elton_john, jerry_seinfeld, madonna, mindy_kaling)

So to edit the final layer, we have used the below code.

class_names = train_data.classes
model.classifier[6] = nn.Linear(num_ftrs, len(class_names))

So after this, our model architecture looks like this:

AlexNet(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))
    (1): ReLU(inplace=True)
    (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (3): Conv2d(64, 192, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (4): ReLU(inplace=True)
    (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (6): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (7): ReLU(inplace=True)
    (8): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (9): ReLU(inplace=True)
    (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(6, 6))
  (classifier): Sequential(
    (0): Dropout(p=0.5, inplace=False)
    (1): Linear(in_features=9216, out_features=4096, bias=True)
    (2): ReLU(inplace=True)
    (3): Dropout(p=0.5, inplace=False)
    (4): Linear(in_features=4096, out_features=4096, bias=True)
    (5): ReLU(inplace=True)
    (6): Linear(in_features=4096, out_features=6, bias=True)
  )
)

After the model architecture is designed as we needed to, we need to decide on our loss function and optimizer. In my experience, the below-given loss function and optimizer work well for face recognition.

criterion   = nn.CrossEntropyLoss()
optimizer   = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

Now that we have our model, loss function, and optimizer, we can pass this to our “train_model” function. It also takes num_epochs as one of the parameters. To get the best output, keep it 500.

train_model function prints the accuracy of the model in the training and testing phase. At the end of the training, returns the model with the best accuracy during the testing phase.

Once you get the best model after training, you can use the below-given code to test your model. This snippet takes a folder with just images in it as input and outputs the name of the person in the images. Of course, it only understands the faces on which we had trained earlier.

import glob
from PIL import Image
from torch.autograd import Variable
from os import listdir
with torch.no_grad():

base_path = "./face_test/"
correct = 0
total = 0
array = ['ben_afflek', 'brad_pitt' ,'elton_john', 'jerry_seinfeld', 'madonna', 'mindy_kaling']
test_transform = transforms.Compose([transforms.Resize(256),transforms.CenterCrop(224),transforms.ToTensor(),transforms.Normalize(mean=mean,std=std)])
onlyfiles = [f for f in listdir(base_path)]
print(onlyfiles)
for files in onlyfiles:
images=glob.glob(base_path + files)
for image in images:
img = Image.open(image)
trans = transforms.ToPILImage()
trans1 = transforms.ToTensor()
transformed_image = test_transform(img).float()
transformed_image = Variable(transformed_image, requires_grad=True)
transformed_image = transformed_image.unsqueeze(0)
transformed_image = transformed_image.to(device)
outputs = model(transformed_image)
_, predicted = torch.max(outputs.data, 1)
predicted_index_value = predicted.cpu().numpy()[0]+array[predicted_index_value])
imshow(trans1(img),array[predicted_index_value])

You can keep iterating with training and testing, till you get a model that you feel comfortable with.

Since you have trained this on a Sagemaker notebook instance, you need to save it S3, so that you can reuse this model again.

Below given code saves the model on the Sagemaker instance and uploads it to S3.

torch.save(model, './model_final')

import boto3
file_name = './model_final'
s3 = boto3.resource('s3')
bucket='my_bucket_name' # Replace with your s3 bucket name
s3.meta.client.upload_file(file_name, bucket, 'final_pytorch_model')

To load back the saved model you can just run all the necessary imports for the torch library and use the below code to load the model. (complete code included in the Jupyter notebook)

model = torch.load('./saved_model')
model.eval()

What did we learn?

• how to build a CNN model using Pytorch Library
• How to spin up a SageMaker Notebook Instance to build the CNN model quickly without the need to buy expensive GPUs.
• Saving the trained model onto S3

In the next blog, we will learn how to deploy any Machine Learning model on AWS to get the best scalability and reliability.

If you liked this post, please clap for it; follow me if you want to read more such posts!

Twitter: https://twitter.com/IVaibhavMalpani
LinkedIn: https://www.linkedin.com/in/ivaibhavmalpani/

Face Recognition using Pytorch on Amazon Sagemaker was originally published in Vaibhav Malpani’s Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

Since the last time, I wrote a blog on how to win at Deepracer? a LOT has changed on the Deepracer Console. You could read that to know the very basics of Deepracer and Reinforcement Learning. This blog will guide you to build your model on the new Deepracer Console. This can help you get ready for the Deepracer leagues at your nearest summits (for more details) and also for Virtual circuits that take place throughout the year.

This blog is divided into 3 parts:

1. Steps on how to build the model for Deepracer
2. Pricing for Deepracer
3. Key Takeaways

Steps to build your Deepracer Model:

1. Setup account resources
2. Build your vehicle in Garage
3. Create a Model
4. Evaluate your Model

1. Setup account resources:

• Navigate here to get started
• Look of Step 0: Create account resources
• Just click on Create Resource there.

2. Build your vehicle in Garage:

Before you hop on to start building your model, it’s good to configure your vehicle in your garage.

• Navigate to garage here
• Click Build New Vehicle at the top right corner
• The first thing you see here is to set up an extra camera or sensor if you have one, else stick to the just front camera. This also gives you option to add the LIDAR sensor for object detection and avoid it.

• Next, you could see Neural Network Topologies, which now lets you select the CNN layer depending upon the task you want to do out of your Deepracer.
• 3 Layer CNN: A shallower network of fewer layers trains much faster than a deeper network of more layers. It is ideal for training models that are built with less complex tasks to master.
• 5 Layer CNN: A deeper neural network, with more layers, will take longer to train but will be able to handle more complex tasks.

• Next is setting up Action Space,

• Maximum steering angle: This is the maximum angle you want the Deepracer to turn.
• Steering angle granularity: This is how fine you want to divide the steering angle. In the above case, the Steering angle is divided as (-30, -15, 0, 15, 30)
• Maximum Speed: This is the maximum speed you want your Deepracer to go at any given angle.
• Speed Granularity: This is how fine you want to divide your Max speed.
• On the basis of all the above-mentioned values, the below-shown table is formed. Which gives your Deepracer, choices to choose from while performing an action.

• Another new addition in Deepracer 2020, was giving developers to change the Visual appearance of your Deepracer.

• Just click Done at the end and you have built your Customized Deepracer Car, Parked in your Garage :)

3. Create a Model:

• To start with creating model, Navigate here
• Enter a model name
• Select a track on which you wish to train your Deepracer
• Select Next
• Choose the race type here and the car to be used from your Garage

• Next, You have to give a reward function. Refer THIS to get started with writing your Reward Function.

What is a reward function? — It is you giving points for good action taken by the Deepracer and reducing points for taking an incorrect action.

• Give your hyperparameters. (If this is your first model, don’t worry about this, just let this be set to defaults). Click here for more details on Hyperparameters.
• Select your stop condition, meaning asking the Deepracer console to train the Deepracer for a given amount of time. Train for at least 250 minutes to get a decent running model.

4. Evaluate the Model:

• Navigate here to look at a list of all models.
• Click on your model name
• There you could see your Training Progress.

• Below this, you could see Start new evaluation.
• On clicking this, Select the track on which you want to test your model. (Yes, you can evaluate on a different track than the one you have trained it on)
• Choose the number of trials to evaluate your model. It’s good to choose 5 trails. ;)
• Choose the Race Type that you want to evaluate.
• Click on Start evaluation.

Pricing:

• AWS DeepRacer provides a Free Tier, that covers the first 7 hours of training.
• After this, it cost around 4 to 5 dollars an hour to train and evaluate your model. checkout here for more information about the pricing.

Key Takeaways:

1. You should be careful while choosing the training time of your model. If you train it too much it will overfit the track and won’t be able to perform with slight changes in the environment, whereas on the other hand if your train it less, the model won’t be strong enough to make correct decisions.
2. Your primary focus while building and training the model on the virtual environment should be on the accuracy and reliability of your model and not the speed or lap time of your DeepRacer. As in the Physical racing league, you will be able to accelerate your DeepRacer using their app on the phone.

Best of luck for 2020. I hope you win and get a chance to participate in the Grand Deepracer League at re:Invent 2020.

If you liked this post, please clap for it; follow me if you want more such posts!

Getting Started with Deepracer (2020 edition) was originally published in Vaibhav Malpani’s Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

AWS Launched the Deepracer at re:Invent 2018. Since then buzz around the autonomous car is been growing rapidly.

In 2019…

AWS hosted the “Deepracer League” in 22 cities all around the globe. Participants could also race in the virtual league that was held every month (for more details). Winners at each summit and at each virtual circuit got an expense paid trip to Las Vegas and participate in AWS Deepracer League at re:Invent 2019.

In 2020…

AWS plans to host the official “Deepracer League” in 30 cities this time. Even if there is no “Official Deepracer League”[1] in your city, most likely you would be having a Deepracer league at your nearest summit (for more details). You can attend these summits and race. If you looking for a way to attend re:Invent 2020, you can participate and win in the 24 ‘virtual circuits’ races that you can join from anywhere in the world.

What has changed since Inception?

Deepracer started with the basic idea of developers learning about Reinforcement Learning (RL) with the fun of racing against someone. This idea has helped a lot of developers around the world with no Machine Learning (ML) background to get started with RL.

The Idea of just racing against time on a plane race track was good, but now it’s growing in 2020. With the introduction of AWS Deepracer Evo AWS will add Light Detection and Ranging (LIDAR) sensor which can help detect and avoid any obstacle. This year AWS also plans to introduce head-to-head racing, which means racing against another Deepracer that is on the same track.

So what can you do??

• Learn how to build your model on AWS. (you can refer to “Getting Started with Deepracer (2020 edition)” for a step-by-step tutorial.
• Participate in AWS Deepracer League at your nearest summit
• Participate in Virtual Circuits from anywhere in the world

How will it help you?

• It can get you on-boarded onto AWS if you’re not familiar with it.
• Get an expense paid trip to Las Vegas and participate in Deepracer League at re:Invent 2020 (If you win at any official summit).
• It will get you started with Machine Learning.
• You get to meet amazing community members with the same passion for ML and racing.

Get more help form Deepracer Global Community — here

Watch Video’s from Deepracer Experts Bootcamp — here.

[1] Official Deepracer Leagues are the ones that AWS announces of their website and considers these race winners for the re:Invent.

If you liked this post, please clap for it; follow me if you want more such posts!

AWS Deepracer Roadmap for 2020 was originally published in Vaibhav Malpani’s Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

In an enterprise, you would have a lot of files that have a lot of information in various formats like ‘PPT’, ‘PDF’, ‘TXT’ etc. but it’s just very hard to find it quickly when it’s most needed. Let’s say even if find the file, you will need to browse through a lot of pages to exactly find what you were looking for. Also looking for files in folders and browsing through it is not as natural as talking, right? (This will make sense as we move along)

Today we will learn how to extract information by naturally talking to a chunk of files

To get started:

1. A lot of files (If you are an enterprise, you already have it :D )
2. AWS account for using Amazon Kendra

For this demo, I did not have enough files so I created them. I took a lot of random words and extracted the data related to it from Wikipedia and saved them in separate text files using the below-shown code (will only work on python 3)

Problem statement

We will consider the above-extracted files as our chunk of files and try to make a search engine over these files using Amazon Kendra. It’s a highly accurate and easy to use enterprise search service that’s powered by machine learning.

Steps:

1. Create Index
2. Add Data Sources
3. Test and Deploy

1. Create Index:

• Give any index name that would help you recognize what data is present in that index.
• In IAM Role, you can select an existing role or choose ‘create a new role’
• Encryption of data can vary for everyone, in this case, I am not selecting the encryption option.
• click on create after you are done with the above steps. It can take up to 30 minutes to create the index.

2. Add Data Sources:

Data could be imported from the S3 bucket, SharePoint and Amazon RDS. For our demo, I have uploaded the wiki files on a S3 bucket.

• Click on ‘Add connector’ below the S3 bucket
• Give a name to your data source
• On the next screen ‘browse S3’ bucket and select the bucket which has your data files.
• We will select ‘sync run schedule’ frequency as ‘on-demand’ for our demo. You could choose appropriately depending upon your use-case.
• And at the end select ‘create’
• After that, the below window will show up. Click on ‘Sync now’ to start the data syncing from S3 to Amazon Kendra.

3. Test and Deploy:

Click on ‘Search Console’ on the below-shown dashboard.

We can start with simple searches like this:

As you can see it can easily find files that have apple word in it.

Let’s see how the search reacts when we give it complex queries.

As you can see from the above result, Amazon Kendra understands natural language questions and gives the answer which is easy-to-understand.

Pricing:

Free tier:

The service provides free usage of up to 30 days of the Developer Edition (coming soon) from the time you create your first index.

Pricing table:

Customer story:

When Material scientists at 3M lead new research, they need access to information from prior relevant research information that’s buried in the many patents they hold in their huge knowledge base. Finding the right information is often exhausting (but not exhaustive) and time-consuming. To deal with this issue, they decided to use Amazon Kendra.

If you liked this post, please clap for it; follow me if you want more such posts!

Build your custom Search Engine using Machine Learning | AWS Kendra was originally published in Vaibhav Malpani’s Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

Want to predict your upcoming sales revenue??

Want to know appropriate inventory levels of a particular item to stock??

Want to predict the right level of available resources, such as staffing levels, raw material etc. to maximize revenue and control costs??

To run a successful business, you should be ready for the future. No matter the scale of the business, you should be ready for any circumstance. Almost all companies have been facing the problem of predicting its sales revenue, inventory management, workforce and resource management, financial planning, supply chain, healthcare, etc.

Before machine learning, people could only predict based on their experiences. But obviously, that cannot be precise. Since all the companies have been storing all these transactions (sales figures, inventory data) for a long time, this can be used to forecast the future using machine learning.

A good forecaster is not smarter than everyone else. He merely has his ignorance better organized.

Amazon Forecast:

Amazon Forecast is a fully managed service that uses machine learning to deliver highly accurate forecasts. It can achieve forecasting accuracy levels that used to take months of engineering in as little as a few hours with no machine learning experience to get started.

Amazon Forecast has helped succeed customers like CasaOne, CJ Logistics, OMOTOR, etc. https://aws.amazon.com/forecast/customers/

Steps:

1. Create Dataset and Import data
2. Train a Predictor
3. Generate Forecasts

Problem Statement (Download Dataset):

Predicting the sales of an item for the next 10 days based on past sales records for 30 months.

Create Dataset and Import data:

To Start Forecasting your data, Upload it to an S3 Bucket.

Open Amazon Forecast console and select “Create Dataset Group”.

To create a dataset group, there are 3 more steps:

1. Create Dataset Group
2. Create Target Time Series Dataset
3. Import Target Time Series Data

Create Dataset Group:

You can give any Dataset Group Name and since our dataset is of forecasting retail we have selected Domain as “Retail”.

Amazon Forecast supports the following dataset domains:

• RETAIL Domain — For retail demand forecasting
• INVENTORY_PLANNING Domain — For supply chain and inventory planning
• EC2 CAPACITY Domain — For forecasting Amazon Elastic Compute Cloud (Amazon EC2) capacity
• WORK_FORCE Domain — For workforce planning
• WEB_TRAFFIC Domain — For estimating future web traffic
• METRICS Domain — For forecasting metrics, such as revenue and cash flow
• CUSTOM Domain — For all other types of time-series forecasting

Create Target Time Series Dataset:

In this step, you have to describe the Data scheme and the Frequency of your data needs to be given to Amazon Forecast.

Import Target Time Series Data:

In this step, Give the timestamp format of your dataset. It has to be a form of “yyyy-MM-dd” or “yyyy-MM-dd HH:mm:ss”.

You can create a new IAM role or select an existing role.

In the Data Location field, enter the path of your dataset present in S3.

To complete your first step, click on “Start Import” and wait for the import to complete.

Train a Predictor:

After the import is done, you would see a screen as shown below. Click on the “Start” button beside “Predictor Training”.

In this step, we will forecast for the next 10 days. So we’ve set the Forecast horizon as 10. For the “Algorithm Selection” you can select a manual algorithm or select “AutoML”. The rest of the things can be kept as default and click “Train Predictor”.

Amazon Forecast will now start to train the forecasting model by understanding the data and forming an algorithm that fits best for the provided dataset. It might take around 10–20 minutes depending on the size of your dataset.

Generate Forecasts:

After training your dataset, It’s finally time to generate the forecast and have a look into the future!!

After the training, you would see the above screen. Click on the “Start” button right next to “Forecast Generation”.

Here you can enter any name for your forecast and select the Training model that we have just trained.

Once that is done. It’s time to now forecast sales.

Click on “Lookup Forecast” as seen below.

Here you would be asked for the select your forecaster. Select a start date and end date. Remember, That the difference between the start and end date should not be greater than the “Forecast Horizon” that you had mentioned while training your model.

Since in our data we had only one item. We had to put the item_id as 1. Now hit “Get Forecast” and scroll down to see the results.

You would see something the result as mentioned below. The results have Time on the X-axis and the expected sales on the Y-axis.

The result does look confusing as to what is P10, P50 and P90 forecasts. These are the Prediction quantiles. By calculating prediction quantiles, the model shows how much uncertainty is associated with each forecast.

For the P10 prediction, the true value is expected to be lower than the predicted value, 10% of the time. For the P50 prediction, the true value is expected to be lower than the predicted value, 50% of the time. For the P90 prediction, the true value is expected to be lower than the predicted value, 90% of the time.

If you think you might face a problem of storage space or cost of investment if you overstock the item, you might wanna choose the P10 forecast. as you will be overstock for only 10% of the time else you would be sold out every day.

But on the other hand, the cost of not selling the item is extremely high or the cost of invested capital is low or it would result in huge amounts of lost revenue you might wanna choose the P90 forecast.

Summary:

We have imported the data to an S3 bucket and uploaded them to the Forecast dataset. Trained the model using the AutoML predictor and used that to generate a forecast. You have successfully built your first “Time Series Forecasting” model, using Amazon Forecast.

If you face any problem, please feel free to comment below. Amazon Forecast also has great documentation: https://docs.aws.amazon.com/forecast/latest/dg/how-it-works.html

If you liked this post, please clap for it; follow me if you want more such posts!

Grow your business by forecasting its future using AWS Forecast was originally published in Vaibhav Malpani’s Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

Amazon Web Services had organized its 1st Developer Summit in Seattle. Approximately 65 Developers spread over various tracks ( Containers, Serverless, Databases, AI/ML, and Dev Tools) were invited from all over the globe in which I was the only one from India. The event was for 3 days in which the 1st Day was common for all the tracks and Day 2 and Day 3 focused on respectively specific tracks (in my case “AI/ML track”).

Day 1:

Amazon Web Services experts developed and tracks on the vision and strategic investments for categories like serverless, databases, and machine learning (ML)… I’m excited to start using them.

Participants got to interact with Amazon Employees and could share their current problems and feedback with any services that they use while solving real-life problems.

After the sessions, we were invited to the “Amazon Spheres” for drinks and dinner. The place was just majestic.

Day 2:

The next day started with everyone’s face lit up and recovered from Jet Lag. We all were very excited to get started with the AI/ML tracks. Excitement skyrocketed when we got an “ AWS DeepLens” from Amazon.

1. AWS Deepracer workshop: AWS Deepracer is an amazon service and is the easiest way to get started with Reinforcement Learning. I was a 90 minutes session by Scott Pletcher which explained a lot about how to get started using AWS Deepracer. We also had a virtual competition of completing 100% track in the most possible time. It was tougher to make the deepracer car run slowly. Among all, I got the slowest lap time.

2. AWS Deepracer Community: Lyndon Leggate explained how to he started the AWS Deepracer Community. He was at the London AWS Summit competing in the AWS Deepracer League. There he started talking with few of the folks who were also there for the League and after the event, all of them wanted to continue the talk. So he ended up creating a slack channel for it. Since then in the last 4 months, the community has grown to more than 10,000 Deepracing Enthusiasts. He also shared the vision for this community. To join the community visit www.deepracing.io

3. Recommendation using Amazon SageMaker: Pavlos Mitsoulis, A Data Scientist at Expedia Group explained how he had built a “Hotel Recommendation System” using Amazon SageMaker. He explained how he had built the algorithm and how easy it was to train and deploy a model using Amazon SageMaker.

4. AWS DeepLens: Alex Schultz explained how he found a solution to read storybooks to his kids using AWS DeepLens. He built a solution that was trained on a lot of kid storybooks called “ReadToMe”. Using ReadToMe if a storybook is held in front of the AWS Deeplens it would read the story like a normal human being.

After this, we had a few lighting talks each for 15 minutes.

1. The first one was by Or Hiltch which explained the importance of having a structured way of writing a technical blog. A blog can be structured as:

What — Explain the reader about the problem that you are going to solve.

Why — Why the reader should read the blog and what will he learn.

How — Explain how are you solving the problem

Summary — It’s very important to summarize your blog, as it makes the reader recall whatever he has read without scrolling up the blog.

2. Agustinus Nalwan explained how to keep your talk interesting to have the maximum impact of your talk. He also talked about how can we keep the audience engaged coming from different backgrounds. Be it someone who is just graduated to someone who knows everything about the topic of your talk.

3. Kesha Williams told us that she gets asked that she is always at a conference. Continuing further she explained how we can create a great social presence and to reach a point where if we enter a room, we need not have to introduce ourselves.

Kesha also shared a few tips with us:

1. Don’t be afraid to tell your story.

2. Technical expertise can’t stand on its own.

3. You don’t have to be an expert.

4. Be ready for criticism.

After all the sessions, We were taken to the Living Computer Museum. It provides a one-of-a-kind, hands-on experience with computer technology from the 1960s to the present. It honors the history of computing with the world’s largest collection of fully restored and usable supercomputers, mainframes, minicomputers, and microcomputers.

Day 3

It was the last day of our session and the morning started with everyone building up their social network with each other.

1. The Technological Founder Evolution Path: The Co-founder and CTO at Skyline AI Or Hiltch explained his transformation through different phases of building up his own company. A company that started with 3 and grew to 35 demanded all kinds of different roles from him.

2. Amazon Lex: The talk on Lex by Gillian Armstrong focused not on building the bot using Lex, but on things that get neglected while building a successful Chatbot. She explained how building a chatbot from POC to Production is not a linear line but it’s an exponential curve.

3. Amazon SageMaker Ground Truth: We had a workshop by Mahendra Bairagi on Ground Truth. Amazon SageMaker Ground Truth helps you build highly accurate training datasets for machine learning. It offers easy access to public and private human labelers and provides them with built-in workflows and interfaces for common labeling tasks.

4. Amazon Personalize: The Second workshop was by Chris King and yifei ma was on Amazon Personalize. It is a machine learning service that makes it easy for developers to create individualized recommendations for customers using their applications.

The Day and the Event concluded with Good-byes to everyone and connecting on social media for future collaborations.

Kudos to the Team (Cameron Peron, Ian Massingham, Ross Barich, and others) for organizing an impeccable event. It was a great mixture of learning, networking, and fun. Finally, Thanks to AWS for Sponsoring the complete event.

My overall experience was very good. I was very happy with how the events were scheduled and the workshops were very helpful to get us started with using the technology.

It was nice to meet amazon employees who work on the technology that we use since it helped us convey our suggestions to the respective Project Managers about the product and also give feedback on their work.

If you liked this post, clap for it; follow me if you want more such posts!

My Experience at AWS Developer Summit, 2019 was originally published in Vaibhav Malpani’s Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

In my previous blog, I spoke about the importance of having a VR Chatbot over a Traditional Chatbot. Here I’ll explain how exactly would you start building a VR Chatbot.

Steps:

1. AWS Configuration
2. Start a Scene
3. Import a host
4. Speech Component
5. State Machine
6. Dialogue Component

1. AWS Configuration:

AWS Sumerian requires a lot of rules and IAM configuration and it’s quite tough to do it all correctly and quickly (I wasted 2 days on it). So just to make things easier, You can use this link ,which will do all the configuration required for AWS Sumerian.

From the above image, click on “Launch Stack” besides “Using Host, Speech and Dialogue Components”.

After the configuration is complete, go to “output” tab, there you will get “Congnito Identity Pool ID”. Copy it somewhere, you would be need it in the coming steps.

2. Start a Scene

Go to AWS console, seach for “Amazon Sumerian” service and open it.

Click on “Create new scene”, give a name for your scene, click create and wait for it to load.

On loading you will see below screen

On the Top Right hand side you would see “AWS Configuration”. Click on it to toggle and enter the “Congnito Identity Pool ID” in the provided text box.

That’s it! All the configuration for our Chatbot are done now. Let’s get to the Exciting part.

3. Import a host

To create a VR chatbot, Let’s start with Getting a Host for your Chatbot. Host is essentially a face for you Chatbot.

Click on “Import Assets” at the top.

You can scroll down to see lot of “Host Assets”. Select any hosts from various options offered and click on add.

You would see it in the left lower corner

Now to get the host in your scene, toggle the imported “host asset” (in this case ‘Wes TShirt’) and select and drag the host entity(the one in red in the image) to the middle of your scene.

Sometimes the host is too small to even get noticed. Try zooming in to the scene by scrolling up with your mouse.

Your scene is now ready with your host in the middle.

4. Speech Component

Let’s now give a voice to the host.

Click on the host and in the right side corner you will see all the configurations that you can add to the host.

Click on add component and select “Speech” if it’s not present. You can now select a wide range of Voices depending on the gender of your host and also the locale in which you plan to use the Chatbot.

Click on the “+” sign to add a speech. A new window would popup. Here you can add any speech that you want and save it. The newly created speech would be shown in the bottom left corner. Select it and drag it to the speech setting. You can click play besides the speech object to hear the voice select and try changing it till you find a perfect match.

Just below that you would find a “Gesture Map”. Click on it to toggle and then click “+”. It will add a new “DefaultGestureMap”. You can open if from the bottom left corner and change it if you want to. For most of the cases it works quite fine. Select

Now to add Gesture to our Speech, Select the button highlighted in the image.

After that click on edit speech, to see the speech file. Now you might notice that few different lines are added to your speech file.

5. State Machine:

This essentially is a way of guiding the Sumerian entities about how to perform one action after other. Here we have states and actions are added to each step. Using the state machine graph, we can create a path for our entity.

To start making the State Machine for the host, click on host and on the right hand side select “Add Component” and then select “State Machine”. Click on “+” to start building your behaviour.

You would now see a “State Machine Graph”. You can rename the “state 1” to whatever name you want. On the right side of the graph, click on “Add action”. A new window pops up. In the search bar type “AWS SDK Ready” and select it. This action basically checks if all the AWS Configurations are ready to use. On the top on State Machine Graph, Select “Add State”. Click on the state and select “add action” and search for “Start Speech” and select add. After adding the action you will need to select which speech to run on the right side. After this you now need to connect these states. You can do that by selecting “On AWS SDK Ready” and dragging the arrow to the “start speech” state. At the end of all this, your State Machine graph Should look like below.

Now we are done with “speech setting” for the Host. You can now try clicking on “Play the Scene” in the middle at the bottom and Voila!! The host has started speaking. Notice that it is also giving gestures based on the words in your speech.

6. Dialogue Component

To start off you will have to build a Amazon Lex bot. This bot should include the conversation that you want in your VR Chatbot. After you have built and tested the functionality of you Lex bot, copy and save the name of your Lex bot.

Click on the host and on the right hand side select “Add Component” and then select “Dialogue”. Paste the name of your bot in Bot Name and below that put “$LATEST” for Bot Alias to always get the latest version of your Lex bot.

Now the behavior for conversational chatting would be different from a normal speech. So to start conversing with your host we will have to build a new State Machine Graph.

Action used in each state of State Machine graph

1. AWS SDK Ready
2. Intro speech — speech that would introduce the bot (optional)
3. Key down — select a key on right hand side
4. Start Microphone Recording, Key up — select the same key that you selected in previous step
5. Stop Microphone Recording.
6. Send Audio Input to Dialogue Bot
7. Start Speech — check “Use Lex Response” on right hand side

Join these states as mentioned below:

That’s it!! Now playing the scene to see your Virtual Chatbot in action!

Applications:

1. Booking Appointment for Restaurant, Doctor’s office, Hotel and Flight Booking etc.
2. FAQ about your organization or any specific products.

If you liked this post, 👏 for it; follow me if you want more such posts!

How to Build a Virtual Reality Chatbot using AWS Sumerian | AWS was originally published in Vaibhav Malpani’s Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.