Amazon Machine Learning to Recommend Best Workout Time

"""
Darian Johnson
http://darianbjohnson.com
This application uses historical data from your Fitbit to recommend the best time to workout.
1) a User accessed the application and asks what for best time to work out (for either today or tomorrow) 
2) The application pulls the following details from the users fitbit account - Weight, Sleep, Calories Burned the Previous Day
3) This information is passed to an AWS Machine Learning Model to determine at what time of day you are most likely to have the highest number of 'very active minutes'

Notes:
1) I assumed that very active minutes is the best way to determine the effectiveness of a workout.
2) The user must link their fitbit account in order to get a recommendation
3) The application uses a machine learning model - based on the users previous work-out history - to create a recommendation
4) the model is created with two additional lambda functions - one function created the datasource and is kicked off by an SNS call in this function
   The second lamdba function runs every 30 minutes to take follow-up steps to create the model
5) The creation of the model takes between 30-90 mins. The user is informed of progress if s/he attempts to access the application while the model is running
6) The user is also notified if the model fails to be created

You can find out more about this application at http://darianbjohnson.com/workout-recommendation
"""

from __future__ import print_function

import json
import urllib
import base64
import urllib2
import boto3
import time
import datetime

from datetime import date
from datetime import timedelta

#set up variables for AWS services calls
ml = boto3.client('machinelearning')
lamb = boto3.client('lambda')
dynamodb = boto3.client('dynamodb')
sns = boto3.client('sns')

def lambda_handler(event, context):
    """ Route the incoming request based on type (LaunchRequest, IntentRequest,
    etc.) The JSON body of the request is provided in the event parameter.
    """
    print("event.session.application.applicationId=" +
           event['session']['application']['applicationId'])

    """
    Uncomment this if statement and populate with your skill's application ID to
    prevent someone else from configuring a skill that sends requests to this
    function.
    """
    # if (event['session']['application']['applicationId'] !=
    #         "amzn1.echo-sdk-ams.app.49ae8765-f94c-4bca-8dc3-1894a93b4f9c"):
    #     raise ValueError("Invalid Application ID")

    if event['session']['new']:
        on_session_started({'requestId': event['request']['requestId']},
                           event['session'])
    
    #this checks to see if the user has lined their fitbit account   
    if 'accessToken' in event['session']['user']:
        print("exists")
    else:
        print("does not exist")
        return on_NoLink()
    
    #routes based on the request
    if event['request']['type'] == "LaunchRequest":
        return on_launch(event['request'], event['session'])
    elif event['request']['type'] == "IntentRequest":
        return on_intent(event['request'], event['session'])
    elif event['request']['type'] == "SessionEndedRequest":
        return on_session_ended(event['request'], event['session'])
        

def on_session_started(session_started_request, session):
    """ Called when the session starts """
        
    print("on_session_started requestId=" + session_started_request['requestId']
          + ", sessionId=" + session['sessionId'])


def on_launch(launch_request, session):
    """ Called when the user launches the skill without specifying what they
    want
    """

    print("on_launch requestId=" + launch_request['requestId'] +
          ", sessionId=" + session['sessionId'])
    # Dispatch to your skill's launch
    return get_welcome_response()

#routes based on the intent
def on_intent(intent_request, session):
    """ Called when the user specifies an intent for this skill """

    print("on_intent requestId=" + intent_request['requestId'] +
          ", sessionId=" + session['sessionId'])

    intent = intent_request['intent']
    intent_name = intent_request['intent']['name']

    # Dispatch to your skill's intent handlers
    if intent_name == "WhatTimeShouldIWorkOut":
        return getWorkoutTime(intent, session)
    elif intent_name == "WhatTimeShouldIWorkOut_noDay":
        return getWorkoutDay()
    elif intent_name == "AMAZON.HelpIntent":
        return get_welcome_response()
    elif intent_name == "AMAZON.CancelIntent" or intent_name == "AMAZON.StopIntent" or intent_name == "Finished":
        return handle_session_end_request()
    else:
        return misunderstood()

#routes based on the intent
def on_session_ended(session_ended_request, session):
    """ Called when the user ends the session.
    Is not called when the skill returns should_end_session=true
    """
    print("on_session_ended requestId=" + session_ended_request['requestId'] +
          ", sessionId=" + session['sessionId'])
    # add cleanup logic here
    #delete_endpoint(sMLModelId) - we will not need to delete the endpoint, as we have decided to leave the up all the time


# --------------- Functions that control the skill's behavior ------------------

#This is called if the app is started without a secific intent to get the workout recommendation
def get_welcome_response():
    """ If we wanted to initialize the session to have some attributes we could
    add those here
    """
    session_attributes = {}
    card_title = "Welcome"
    speech_output = "Welcome to the Work Out Recommendation App. " \
                    "Please ask me, what is the best time to work out today or what is the best time to work out tomorrow."
    reprompt_text = "Please ask me, what is the best time to work out today or what is the best time to work out tomorrow."
    should_end_session = False
    return build_response(session_attributes, build_speechlet_response(
        card_title, speech_output, reprompt_text, should_end_session))

#This is called if the skill is not linked to a Fitbit account
def on_NoLink():
    """ If we wanted to initialize the session to have some attributes we could
    add those here
    """
    session_attributes = {}
    card_title = "Link Accounts"
    speech_output = "You must have a Fitbit account to use this skill. Please use the Alexa app to link your Amazon account with your Fitbit Account"
    reprompt_text = "Use the Alexa app to link your Amazon account with your Fitbit Account."
    should_end_session = True
    return build_response(session_attributes, build_speechlet_response(
        card_title, speech_output, reprompt_text, should_end_session))
 
#This is called if the Machine Learning Model needs to be created or is in the process of being created
def on_Running_Model(card_title, message):
    """ If we wanted to initialize the session to have some attributes we could
    add those here
    """
    session_attributes = {}
    card_title = card_title
    speech_output = message
    # If the user either does not reply to the welcome message or says something
    # that is not understood, they will be prompted again with this text.
    reprompt_text = message
    should_end_session = True
    return build_response(session_attributes, build_speechlet_response(
        card_title, speech_output, reprompt_text, should_end_session))
        
#This is called if the request is not understood       
def misunderstood():
    """ If we wanted to initialize the session to have some attributes we could
    add those here
    """
    session_attributes = {}
    card_title = "I Do Not Understand" 
    speech_output = "I did not understand your request. " \
                    "Please ask me, what is the best time to work out today or what is the best time to work out tomorrow."
    # If the user either does not reply to the welcome message or says something
    # that is not understood, they will be prompted again with this text.
    reprompt_text = "Please ask me, what is the best time to work out today or what is the best time to work out tomorrow."
    should_end_session = False
    return build_response(session_attributes, build_speechlet_response(
        card_title, speech_output, reprompt_text, should_end_session))

#This is called to end the session 
def handle_session_end_request():
    card_title = "Session Ended"
    speech_output = "Thank you for trying the Work Out Recommendation App. " \
                    "Have a nice day! "
    # Setting this to true ends the session and exits the skill.
    should_end_session = True
    return build_response({}, build_speechlet_response(
        card_title, speech_output, None, should_end_session))


#This is the main function that retrieves values from the users Fitbit account and interacts with the machine learning model to recommend the best workout time 
def getWorkoutTime(intent, session):
    card_title = "Workout Recommendation"
    speech_output = "Based on your schedule, the best time to work out is " 
    reprompt_text = "no Value"
    current_date = time.strftime("%Y-%m-%d")

    session_attributes = {}
    should_end_session = False
    
    Fitbit_Access_Token= session['user']['accessToken']
    
    #This either sets or retrieves session variables
    if session.get('attributes', {}) and "fitbit_user_id" in session.get('attributes', {}):
        weight = session['attributes']['weight']
        fitbit_user_id = session['attributes']['fitbit_user_id']
        sMLModelId = session['attributes']['Model_Id']
        sMLModelType = session['attributes']['Model_Type']
        
        endpoint = create_endpoint(sMLModelId)
        
    else:
        #calls the Fitbit function to retrieve user id and current weight
        profile = get_profile(Fitbit_Access_Token)
        parsed_profile = json.loads(profile)
        weight = parsed_profile['weight']
        fitbit_user_id = parsed_profile['fitbit_user_id']
        
        #this block routes the user to either proceed or exit, based on the readiness of the machine learning model
        if check_if_model_exists(fitbit_user_id) == "Pending":
            return on_Running_Model("Running Model", "Your Fitbit historical data is being analyzed to provide the best workout recommendations. Please check back in an hour.")
        elif check_if_model_exists(fitbit_user_id) == "Failed":
            return on_Running_Model("Running Model", "For some reason, the system was not able to complete the analysis. Our engineers are looking into a solution.")
        elif check_if_model_exists(fitbit_user_id) == "Small":
            return on_Running_Model("Running Model", "You do not have enough Fitbt workout history to perform custom analysis. Please try again after you have used your Fitbit to log approximately 30 workouts.")
        elif check_if_model_exists(fitbit_user_id) == "Run Model":
            #if the model has not been created, then a message is sent via SNS to a second lambda function that creates the required machine learning model
            sns_message = json.dumps({'Fitbit_User_Id':fitbit_user_id,'Fitbit_Access_Token':Fitbit_Access_Token,'weight':weight })
            response = sns.publish(
                TopicArn='arn:aws:sns:us-east-1:039057814095:Start_ML_Model',
                Message=sns_message)
            return on_Running_Model("Running Model", "Your Fitbit historical data needs to be analyzed to provide the best workout recommendations. This process will take about an hour.") 
        
        model_attr = get_ml_model(fitbit_user_id)
        parsed_model_attr = json.loads(model_attr)
        sMLModelId = parsed_model_attr['Model_Id']
        sMLModelType = parsed_model_attr['Model_Type']
        
        session_attributes = {'weight':weight, 'fitbit_user_id': fitbit_user_id, 'Model_Id':sMLModelId, 'Model_Type':sMLModelType}

        endpoint = create_endpoint(sMLModelId)
    
    #this looks at the slot to determine if the request is for today or tomorrow 
    if 'Day' in intent['slots']:
        daytoschedule = intent['slots']['Day']['value']
        if daytoschedule == "today":
            today = date.today()
            DayofWeek = today.strftime("%A")
            Spoken_value = ['this morning', 'mid-day today', 'this afternoon', 'this evening']
        elif daytoschedule == "tomorrow":
            tomorrow = date.today() + timedelta(days=1)
            DayofWeek = tomorrow.strftime("%A")
            Spoken_value = ['tomorrow morning', 'mid-day tomorrow', 'tomorrow afternoon', 'tomorrow evening']
        
        #this block retrieves sleep and calories from the Fitbit. These values are passed to the machine learning model to retrieve a recommendation
        #I have left placeholders for calendar details. Right now, it is not integrated as the skill can only link to one 3rd party account
        #I will build a seperate authetication on my website to support adding calendar functionality
        Sleep_Mins = get_sleep(Fitbit_Access_Token, daytoschedule)
        Previous_Day_Active_Calorie_Output = get_calories(Fitbit_Access_Token, daytoschedule) 
        Meeting_Tentative_Mins = 0
        Meeting_Organizer_Mins = 0
        Meetng_Attendee_Mins = 0
        OutOfOffice_Mins = 0
        
        #this recommendation will look at 4 times of day to determine the most optimal time to workout
        timeofday = ['Morning', 'Mid-Day', 'Afternoon', 'Evening']

        #this block loops through the timeofday dictionary and saves the value with the highest prediction 
        OldPredictValue = -1000
        Best_Time_Of_Day = "any time of day"
        i=0
        for times in timeofday:
            print(DayofWeek + ":" + times + ":" + str(get_projectedvalue(sMLModelId, endpoint, DayofWeek, times, str(Sleep_Mins), str(Meeting_Tentative_Mins),\
            str(Meeting_Organizer_Mins), str(Meetng_Attendee_Mins), str(OutOfOffice_Mins), str(weight), str(Previous_Day_Active_Calorie_Output))))
            PredictValue = get_projectedvalue(sMLModelId, endpoint, DayofWeek, times, str(Sleep_Mins), str(Meeting_Tentative_Mins),\
            str(Meeting_Organizer_Mins), str(Meetng_Attendee_Mins), str(OutOfOffice_Mins), str(weight), str(Previous_Day_Active_Calorie_Output))
            if PredictValue > OldPredictValue:
                Best_Time_Of_Day = Spoken_value[i]
                OldPredictValue = PredictValue
                
            i = i+1
            
            
        speech_output = "Based on your previous activity, the best time for you to work out is " + Best_Time_Of_Day + "."
        reprompt_text = speech_output
        
        print("The best time of day to work out is " + Best_Time_Of_Day)
   
        
    else:
        speech_output = "I did not understand your request. " \
                    "Please ask me, what is the best time to work out today or what is the best time to work out tomorrow."
        reprompt_text = "Please ask me, what is the best time to work out today or what is the best time to work out tomorrow."
    return build_response(session_attributes, build_speechlet_response(
        card_title, speech_output, reprompt_text, should_end_session))

#this is called if the slot - today or tommorrow - is not included in the request.
#as an enhancement, I could ask if the user assumes today, and if yes, then run the mdoel for today
def getWorkoutDay():
    """ If we wanted to initialize the session to have some attributes we could
    add those here
    """
    session_attributes = {}
    card_title = "What Day should I check?" 
    speech_output = "You did not tell me what day to check. " \
                    "Please ask me, what is the best time to work out today or what is the best time to work out tomorrow"
    reprompt_text = "Please ask me, what is the best time to work out today or what is the best time to work out tomorrow."
    should_end_session = False
    return build_response(session_attributes, build_speechlet_response(
        card_title, speech_output, reprompt_text, should_end_session))


# --------------- Helpers that build all of the responses ----------------------


def build_speechlet_response(title, output, reprompt_text, should_end_session):
    return {
        'outputSpeech': {
            'type': 'PlainText',
            'text': output
        },
        'card': {
            'type': 'Simple',
            #'title': 'SessionSpeechlet - ' + title,
            #'content': 'SessionSpeechlet - ' + output
            'title': title,
            'content': output
        },
        'reprompt': {
            'outputSpeech': {
                'type': 'PlainText',
                'text': reprompt_text
            }
        },
        'shouldEndSession': should_end_session
    }


def build_response(session_attributes, speechlet_response):
    return {
        'version': '1.0',
        'sessionAttributes': session_attributes,
        'response': speechlet_response
    }


# --------------- Functions to access the users Fitbit account ----------------------    

#this returns the user id and the current weight
#user id is needed to determine the correct machine learning model
#weight is used as part of the prediction input
def get_profile(Fitbit_Access_Token):
    URL = 'https://api.fitbit.com/1/user/-/profile.json'
    req = urllib2.Request(URL)
    
    #Add the headers, first we base64 encode the client id and client secret with a : inbetween and create the authorisation header
    req.add_header('Authorization', 'Bearer ' + Fitbit_Access_Token)
    req.add_header('Content-Type', 'application/x-www-form-urlencoded')
    
    #Fire off the request
    
    try:
        response = urllib2.urlopen(req)
        FullResponse = response.read()
        #print ("Output >>> " + FullResponse)
        parsed_response = json.loads(FullResponse)
        weight = round((parsed_response['user']['weight'])*2.20462,1)
        user_id = parsed_response['user']['encodedId']
        return json.dumps({'weight':weight, 'fitbit_user_id':user_id})
    except urllib2.URLError as e:
        print (e.code)
        print (e.read())   
        
#this returns the number of minutes asleep
#if sleep is 0 or the request is for tomorrow, then we assume the user got 6 hours of sleep
def get_sleep(Fitbit_Access_Token, day):
    today = date.today()
    URL =  'https://api.fitbit.com/1/user/-/sleep/date/' + today.strftime("%Y-%m-%d") + '.json'
    req = urllib2.Request(URL)
    
    #Add the headers, first we base64 encode the client id and client secret with a : inbetween and create the authorisation header
    req.add_header('Authorization', 'Bearer ' + Fitbit_Access_Token)
    req.add_header('Content-Type', 'application/x-www-form-urlencoded')
    
    if day == "today":
        try:
            response = urllib2.urlopen(req)
            FullResponse = response.read()
            #print ("Output >>> " + FullResponse)
            parsed_response = json.loads(FullResponse)
            sleep = parsed_response['summary']['totalMinutesAsleep']
            if str(sleep) == str(0):
                sleep = 360 
            return sleep
        except urllib2.URLError as e:
            print (e.code)
            print (e.read()) 
            return 360

    elif day == "tomorrow":
            return 360

#this returns the number of active calories burned the previous day
def get_calories(Fitbit_Access_Token, day):
    today = date.today()
    yesterday = today - timedelta(days=1)

    if day == "today":
        URL =  'https://api.fitbit.com/1/user/-/activities/date/' + yesterday.strftime("%Y-%m-%d") + '.json'
    elif day == "tomorrow":
        URL =  'https://api.fitbit.com/1/user/-/activities/date/' + today.strftime("%Y-%m-%d") + '.json'
    
    req = urllib2.Request(URL)
    #Add the headers, first we base64 encode the client id and client secret with a : inbetween and create the authorisation header
    req.add_header('Authorization', 'Bearer ' + Fitbit_Access_Token)
    req.add_header('Content-Type', 'application/x-www-form-urlencoded')
    
    try:
        response = urllib2.urlopen(req)
        FullResponse = response.read()
        #print ("Output >>> " + FullResponse)
        parsed_response = json.loads(FullResponse)
        activities = parsed_response['summary']['activityCalories']
        return activities
    except urllib2.URLError as e:
        print (e.code)
        print (e.read()) 
        return 0

# --------------- Functions to access the machine learning model ---------------------- 

#creates the endpoint to access the machine model via API
def create_endpoint(sMLModelId):
    oCreateEndpoint = ml.create_realtime_endpoint(
        MLModelId=sMLModelId)
    return oCreateEndpoint['RealtimeEndpointInfo']['EndpointUrl']

#deletes the endpoint
def delete_endpoint(sMLModelId):
    oCreateEndpoint = ml.delete_realtime_endpoint(
        MLModelId=sMLModelId
        )

#passes in the values from the fitbit account and returns the predicted number of active minutes
#I have left in placeholder for calendar details, to integrate at a later point in time
def get_projectedvalue(sMLModelId, EndpointUrl, DayofWeek, TimeOfDay, Sleep_Mins, Meeting_Tentative_Mins, Meeting_Organizer_Mins, Meetng_Attendee_Mins, OutOfOffice_Mins, Weight, Previous_Day_Active_Calorie_Output):
    prediction = ml.predict(
        MLModelId=sMLModelId,
        Record={
            'DayofWeek': DayofWeek,
            'TimeofDay': TimeOfDay,
            'SleepMins': Sleep_Mins,
            'Weight': Weight,
            'PreviousDayCalories': Previous_Day_Active_Calorie_Output
        },
        PredictEndpoint=EndpointUrl)
    return prediction['Prediction']['predictedValue']
 
#queries a dynamodb table to determine the appropriate model for the active user  
def get_ml_model(fitbit_user_id):
    table = 'Workout_Recommendations'
    response = dynamodb.get_item(TableName = table,
        Key={
             'Fitbit_User_Id' : {
              "S" : fitbit_user_id
                }
            }
    )
    return json.dumps({'Model_Id':response['Item']['ML_Model_Id']['S'],'Model_Type': response['Item']['Model_Type']['S']})

#determines if the model exists and is ready for use    
def check_if_model_exists(fitbit_user_id):
    table = 'Workout_Recommendations'
    response = dynamodb.get_item(TableName = table,
        Key={
             'Fitbit_User_Id' : {
              "S" : fitbit_user_id
                }
            }
    )

    if 'Item' in response:
        if response['Item']['Model_Type']['S'] == 'PENDING':
            return "Pending"
        elif response['Item']['Model_Type']['S'] == 'FAILED':
            return "Failed"
        elif response['Item']['Model_Type']['S'] == 'SMALL':
            return "Small"
        else:
            return "Continue"
    else:
        return "Run Model"