I’m recognized as an Amazon Alexa Champion and have published more than twenty custom skills on the platform. I continue to look for new ways to stretch this technology, create more robust skills, and share with the community.

Last September, Amazon released a new product for Alexa called Echo Buttons. These hardware devices expand the capabilities for the millions of customers that already have an Alexa. They’re relatively inexpensive, right now going for $20/2 pack.

In April of this year, Amazon opened up the platform for developers like me to begin incorporating them into custom skills. This is my experience so far programming with them.

Echo Button in inactive state.

Getting Started with Echo Buttons

Network connectivity of Echo Buttons

Buttons are paired with Alexa devices through a bluetooth connection, becoming a physical extension of the speaker. All network traffic from the button to use Amazon services goes through the paired device. Don’t buy buttons if you don’t already have an Alexa, as they don’t do anything on their own.

If you have multiple speakers associated with your account, the button will only work with the device it’s currently paired with. The pairing can be undone with just a few steps on your phone. To unpair a device, just use the Alexa companion app and go into the settings section. Select the button that has already been paired, and it will release it. Then go back through the steps to repair to another device.

Screenshot of Alexa App on a Mobile Device

This makes buttons an easy add on for Alexa enthusiasts, and makes them flexible for those with multiple devices.

How Buttons Interact with Custom Skills

Alexa is an event driven architecture. Events are created by the sounds going into the speaker that are translated through Cloud based service. Normally these events are initiated after the array of microphones picks up a command from a user. These commands are then translated by the ASR (Automated Speech Recognition) models depending on which custom skill is being used.

With buttons, a new type of event is created that follows a similar pattern. When the button is pressed, an event is created and sent to the skill that runs in the Cloud. When the button is released, a separate event is created. These events are created independently of anything being picked up by the microphones on the Echo Speaker and flow through a Cloud based service called the Game Engine.

Alexa Event Architecture including Buttons

The Lambda function that contains the logic for the custom skill needs to process these events along with the existing voice triggered ones. Translating request objects is facilitated by the Alexa SDK installed in the Lambda function. Examples of how this works are provided in the Alexa repo.

This opens up new possibilities for gameplay, as a user can leverage both their voice and hands to interact with the skill. Engaging more senses broadens the experience, and enables more complex gaming. For example, in the Seventh Inning Stretch skill, a user can play a baseball game listening on their speaker while pressing the button to swing the bat.

How Skills use the Gadgets API

Using buttons within a custom skill requires the Gadgets API. Documentation is currently on this website, and note that it is still in beta. Buttons are just a type of gadget, and provide a glimpse into what’s possible with enabled hardware.

Connectivity between systems is facilitated by interfaces across the internet. The API that buttons need is invoked by adding directive attributes to a standard Alexa response object. This enables the SDK to handle the explicit details for the HTTPS call (i.e. encoding the header, setting the attributes, error handling, etc.)

Here is an example of adding a directive to set the lights on a button at the same time that the Echo speaker reads back an introduction to the user.

"response": {               "shouldEndSession": false,               "outputSpeech": {                     "type": "SSML",                     "ssml": "<speak> Welcome back to Seventh Inning Stretch.<break time=\"1s\"/>We found an prior game in progress. Would you like to resume? </speak>"                 },               "reprompt": {                     "outputSpeech": {                           "type": "SSML",                           "ssml": "<speak> Say yes to resume the in-progress game, or no to delete it.  </speak>"                     }               },               "directives": [    {                           "type": "GadgetController.SetLight",                            "version": 1,                           "targetGadgets": [],                           "parameters": {                      "animations": [               {                         "repeat": 1,                            "targetLights": ["1"],              "sequence": [                          {                    "durationMs": 30000,                                                               "color": "FFFF00",                  "blend": false                                                     }              ]                      }           ],      "triggerEvent": "buttonDown",                                "triggerEventTimeMs": 0    }}

The Game Engine creates events just like the Echo speaker. The same taxonomy is used, and the attributes within the request identifies event details. Below is an example of a request indicating that a button was pressed.

“request”: {   “type”: “GameEngine.InputHandlerEvent”,   “requestId”: “amzn1.echo-api.request.xxx”,   “timestamp”: “2018–07–21T21:33:25Z”,   “locale”: “en-US”,   “originatingRequestId”: “amzn1.echo-api.request.xxx”,   “events”: [     {       “name”: “button_down_event”,       “inputEvents”: [ {         “gadgetId”: “amzn1.ask.gadget.xxxx”,         “timestamp”: “2018–07–21T21:33:25.374Z”,         “color”: “000DD6”,         “feature”: “press”,         “action”: “down”       } ]     }   ] }

Save Battery Life through Roll Call

Echo Buttons are battery powered, making energy management important. When a custom skill requires a button, it must initiate a connection and wake the button. This is done through a process called ‘roll call’ within the custom skill.

To initiate a roll call in a custom skill, add a directive to the response object providing the parameters to perform the task. In parallel, audio instructions need to be included in the response object. These will encourage a user to do something with the buttons. For example, ask the user to press each button to get started.

For specifics on what a directive looks like, here is the roll call directive I use for my Seventh Inning Stretch skill. It’s a series of attributes in a large JSON object. This sets the timeout parameter for when the buttons can go back to sleep if not used (the 300,000 value is in milliseconds — this translates to five minutes), and looks for just the button down event.

"directives": [  {     “type”: “GameEngine.StartInputHandler”,     “timeout”: 300000,     “recognizers”: {       “button_down_recognizer”: {         “type”: “match”,         “fuzzy”: false,         “anchor”: “end”,         “pattern”: [{ “action”: “down” }]       }    },     “events”: {       “button_down_event”: {         “meets”: [“button_down_recognizer”],         “reports”: “matches”,         “shouldEndInputHandler”: false       },       “timeout”: {         “meets”: [“timed out”],         “reports”: “history”,         “shouldEndInputHandler”: true       }     }  }]

The buttons handle the timer for when to turn off. This minimizes the risk of battery drain when a user ends their session. Skills that use buttons should also make a request to the shut off the device if the skill is exited.

Translating Game Engine Events

The Game Engine can create events just like the speaker after it is awake. The request uses the same taxonomy, and the attributes identify details of the event. Here is an example of a request indicating that a button was pressed.

“request”: {   “type”: “GameEngine.InputHandlerEvent”,   “requestId”: “amzn1.echo-api.request.xxx”,   “timestamp”: “2018–07–21T21:33:25Z”,   “locale”: “en-US”,   “originatingRequestId”: “amzn1.echo-api.request.xxx”,   “events”: [     {       “name”: “button_down_event”,       “inputEvents”: [ {         “gadgetId”: “amzn1.ask.gadget.xxxx”,         “timestamp”: “2018–07–21T21:33:25.374Z”,         “color”: “000DD6”,         “feature”: “press”,         “action”: “down”       } ]     }   ] }

The logic within the Lambda function for the skill will need to respond to these events, and process functionality accordingly.

Buttons Can Change Color

Inside the buttons are a series of LED’s that can be turned off and on. They are bright and the color is very rich.

The buttons can also change colors by altering how the different LED’s are illuminated.

Color changing of the buttons is also done within directives in a response object. If you start your skill using the repo for buttons, there are helper functions that make this easy to integrate into your skill.

Closing

If you’re interested in trying out a game that uses them, please test out my baseball simulation game on Alexa. It’s called “Seventh Inning Stretch” and is an attempt to recreate the fun of old handheld games from the 80’s. It’s a good example of what’s possible using these new accessories.

Example of Alexa Skill that uses Buttons

Data can tell lots of stories, and finding the hidden secrets is like finding a needle in a haystack.

After finishing my first data analysis course on Udacity, it was time for a real-world project.

In this project, I’m going to explore baseball data. To be more specific: batting data for every player that played between 1871 and 2016. You can download the entire dataset here.

My process:

1. Have a first look at the data
2. Come up with a question
3. Wrangle the data
4. Explore the data
5. Draw conclusions/predictions
6. Communicate my findings

My goal is to find the secrets of baseball in the data and share it with you, so that you can learn something and improve your game.

antonderegt/data-baseball
data-baseball — A Final project of Udacitygithub.com

First look at the data

The first step is to import a dataset. For the first look, I am going to display the first five entries to get an idea of what I’m dealing with.

import matplotlib.pyplot as pltimport numpy as npimport pandas as pdimport seaborn as sns%matplotlib inline

# Reading the batting datafilename = 'Batting.csv'batting_df = pd.read_csv(filename)

# Printing the first five entriesbatting_df.head()

# Getting some metrics on the home runs, number of games, runs batted in and the number of strikeoutsbatting_df[['HR','G', 'RBI', 'SO']].describe()

Looking at the table above, it seems batters hit an average of 2.8 home runs in a season with an average of 51 games.

batting_df_groupedby_year = batting_df.groupby(['yearID']).sum()homeruns_per_year = batting_df_groupedby_year[['HR']]

# Plotting the heatmap in reverse order to make it easier to see the increasesns.heatmap(homeruns_per_year.iloc[::-1])

Plotting the heatmap

Above you can see the number of home runs increase as the years pass. On the left y-axis you can see the year, and on the right y-axis you can see the number of home runs.

Questions

Before the data will reveal its secrets, I have to ask it a few questions. Here are some examples of questions I can ask the data:

1. Which teams have the most effective batters?
2. Is there a correlation between Strikeouts and Home Runs?
3. Who is the best stealer in history (Caught Stealing vs. Stolen Bases)?
4. Which region produces the best batters (need to merge with another table for that)?
5. What is the relationship between different performance metrics? Do any have a strong negative or positive relationship?
6. What are the characteristics of baseball players with the highest salaries?

The question I am going to focus on is: which metrics correlate and which metrics do not?

Wrangling

# Displaying the batting data for the last ten yearsbatting_last_ten_years = batting_df.groupby(['yearID'], as_index=False).sum().sort_values(by='yearID', ascending=False).head(10)batting_last_ten_years

The dataset I am using is already very clean. I don’t have to do a lot of wrangling to get to the data I need. Above you can see batting data from the last 10 years.

Exploring

In the next code block, I will calculate the correlations between Home runs and all the other metrics. This way we can see which metrics contribute to home runs and which metrics are bad for scoring home runs. For example, I expect batters who play more games to score more home runs. I also expect batters with a high RBI to score the most home runs.

A correlation of 1 between two values is a perfect positive correlation. This means that when one of the two values increases, the other increases as well.

A correlation of -1 is a negative correlation. This means that when one value increases the other decreases.

As the value of a correlation goes to 0, the correlation is very small or non-existent. I will call a positive correlation ++, + or +- depending on the strength of the correlation. No correlation will be 0, and negative correlations will range from -+, — , or — — being a strong negative correlation.

def standardize(data):    return (data - data.mean()) / data.std(ddof=0)

def pearsons_r(x, y):    return (standardize(x) * standardize(y)).mean()

# It doesn't make sense to calculate the correlation between these values and home runsleave_out = ['playerID', 'yearID', 'teamID', 'lgID', 'HR']

# Meaning of the column names in the datadictionary = {'playerID':'Player', 'yearID':'Year', 'teamID':'Team', 'lgID':'League', 'HR':'Home Runs','stint':'Stints', 'G':'Games', 'AB': 'At Bats', 'R': 'Runs', 'H':'Hits', '2B':'Doubles', '3B':'Triples', 'RBI':'Runs Batted In', 'SB':'Stolen Bases', 'CS':'Caught Stealing', 'BB':'Base on Balls', 'SO':'Strikeouts', 'IBB':'Intentional Walks', 'HBP':'Hit by pitch', 'SH':'Sacrifice hits', 'SF':'Sacrifice flies', 'GIDP':'Grounded into double plays'}

strong_positive_correlation = []strong_negative_correlation = []

def correlations_for_hr(df):    columns = list(df)    for x in columns:        if x not in leave_out:            name_of_metric = dictionary[x]            r = pearsons_r(df['HR'], df[x])                        # Calculating the strenth of the correlation            correlation = ''            if r > 0.7:                correlation = '++'                strong_positive_correlation.append(name_of_metric)            elif r > 0.5:                correlation = '+ '            elif r > 0.3:                correlation = '+-'            elif r >= -0.3:                correlation = 'O '            elif r > -0.5:                correlation = '-+'            elif r > -0.7:                correlation = '- '            elif r > -1:                correlation = '--'                strong_negative_correlation.append(name_of_metric)                            print('{} Correlation between Home runs and {}:{}'.format(correlation, name_of_metric, "%.3f"%r))            print('-----------------------------------------')            print('Correlations:')print('-----------------------------------------------------')print(correlations_for_hr(batting_df))print('\n')

print('Positive correlations: {}'.format(strong_positive_correlation))print('\n')

print('Negative correlations: {}'.format(strong_negative_correlation))

Output:

Correlations:--------------------------------------------------------------------O  Correlation between Home runs and Stints: -0.065--------------------------------------------------------------------+  Correlation between Home runs and Games: 0.668--------------------------------------------------------------------+  Correlation between Home runs and At Bats: 0.695--------------------------------------------------------------------++ Correlation between Home runs and Runs: 0.729--------------------------------------------------------------------++ Correlation between Home runs and Hits: 0.703--------------------------------------------------------------------++ Correlation between Home runs and Doubles: 0.725--------------------------------------------------------------------+- Correlation between Home runs and Triples: 0.348--------------------------------------------------------------------++ Correlation between Home runs and Runs Batted In: 0.837--------------------------------------------------------------------O  Correlation between Home runs and Stolen Bases: 0.265--------------------------------------------------------------------+- Correlation between Home runs and Caught Stealing: 0.409--------------------------------------------------------------------++ Correlation between Home runs and Base on Balls: 0.731--------------------------------------------------------------------++ Correlation between Home runs and Strikeouts: 0.822--------------------------------------------------------------------++ Correlation between Home runs and Intentional Walks: 0.753--------------------------------------------------------------------+- Correlation between Home runs and Hit by pitch: 0.497--------------------------------------------------------------------O  Correlation between Home runs and Sacrifice hits: 0.064--------------------------------------------------------------------++ Correlation between Home runs and Sacrifice flies: 0.792--------------------------------------------------------------------++ Correlation between Home runs and Grounded into double plays: 0.767--------------------------------------------------------------------

Positive correlations: ['Runs', 'Hits', 'Doubles', 'Runs Batted In', 'Base on Balls', 'Strikeouts', 'Intentional Walks', 'Sacrifice flies', 'Grounded into double plays']

Negative correlations: []

Reviewing first expectations

Remember my expectations? I expected the number of games and the RBI score to have a positive correlation with home runs. According to my calculations above, the number of games has a positive correlation with a Pearson’s R of .668. So players who played more games in a season have a higher number of home runs. This sounds very logical, since batters who play more games have more chances of scoring a home run.

My other expectation was that a high RBI would mean a high number of home runs. The correlation between home runs and RBI is big with .837! This again is quite logical, because home runs are able to reward the player with the most RBI points.

Another interesting fact is that there are no negative correlations. So, there is no metric that decreases when the number of home runs increases.

# HOME RUNS vs. RUNS BATTED INsns.lmplot(size=10, data=batting_df[['HR', 'RBI']], x='HR', y='RBI', x_estimator=np.mean)

HOME RUNS vs. RUNS BATTED IN

The chart above shows how home runs correlate to RBI. You can see the number of home runs of the x-axis and the number of RBI points on the y-axis.

# HOME RUNS vs. STRIKEOUTSsns.lmplot(size=10, data=batting_df[['HR', 'SO']], x='HR', y='SO', x_estimator=np.mean)

HOME RUNS vs. STRIKEOUTS

The plot above returns an interesting correlation. It’s the correlation between home runs and strikeouts. The Pearson’s R correlation is .822, being almost as high as the correlation between home runs and RBI.

This correlation was more interesting to me because RBI’s are a direct result of home runs. Strikeouts, on the other hand, have a direct correlation to losing your chance at a home run. How on earth would strikeouts result in more home runs?

How are home runs and strikeouts related

To solve this mystery, I started thinking… Maybe the batters who take more risk are more likely to score a home run. Because they swing even on balls that seem hard to hit. So, if taking more risks gives you more home runs, I took a look at risky metrics. Risky metrics are metrics that involve risk-taking, like stealing bases. Let’s have a look at the correlation.

# HOME RUNS vs. CAUGHT STEALINGsns.lmplot(size=10, data=batting_df[['HR', 'CS']], x='HR', y='CS', x_estimator=np.mean)

HOME RUNS vs. CAUGHT STEALING

Above you can see the correlation (.409) between home runs (x-axis) and the number of times a runner gets caught stealing (y-axis). There is a vague correlation, but it’s not enough to make a conclusion. Maybe the risk takers have gotten very good at stealing bases and don’t get caught stealing? Let’s look at stolen bases.

# HOME RUNS vs. STOLEN BASESsns.lmplot(size=10, data=batting_df[['HR', 'SB']], x='HR', y='SB', x_estimator=np.mean)

HOME RUNS vs. STOLEN BASES

Above you can see the correlation of .265 between home runs (x-axis) and stolen bases (y-axis). This correlation is non-existent. So, taking risks has nothing to do with scoring a home run.

The data alone is not going to reveal the secret of scoring a home run. I need to learn more about baseball to solve this mystery. My next plan of attack was watching YouTube videos to see how high scoring batters behave.

As it turns out, scoring a home run has more to do with fine calculations than taking risks. I saw batters waiting for the right pitch. They’d rather get a strike, hoping the next throw will serve them batter, eh better. An added benefit is that the pitcher tires faster as he has to throw more balls.

Conclusions/Predictions

To batters trying to improve their home run stats, I have a few suggestions. Step one in getting more home runs is: play more games, no excuses — play! Step two: get some strikeouts. It sounds counter-intuitive, but it increases your number of home runs. The way this works: it blows out the pitcher and gives the batter more time to wait for the best pitch to hit that GRAND SLAM.

For more about the correlation between home runs and strikeouts, read this article.

Or this one about risks of a tired pitcher

For more check out ditisAnton.com and SIGN UP for my weekly newsletter.