Predict Email Engagement Likelihood .ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96ccfdd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Example notebook to predict next EmailEngagement for a user. This examples assumes you have setup the Salesforce CDP and connected with Salesforce Marketing Cloud \n",
    "# Prerequsit 1 : AWS SageMaker Jupyter notebook with conda_mxnet_p38 Kernel\n",
    "# Prerequsit 2 : Create the connected App in Salesforce by following this article https://developer.salesforce.com/docs/atlas.en-us.c360a_api.meta/c360a_api/c360a_api_python_connector.htm\n",
    "# Prerequsit 3 : Below example assumes your Salesforce CDP is connected to Marketing Cloud and you have access to EmailEngagement object\n",
    "# Prerequsit 4 : Upload inference.py to your notebook folder from https://github.com/salesforce-marketingcloud/cdp-calculated-insights/blob/main/inference.py\n",
    "# Prerequsit 5 : In Salesfroce Genie, you have created folloiwng Calculated Insights with name \"email_engagement_insight__cio\"  \n",
    "\n",
    "#SELECT COUNT(ssot__EmailEngagement__dlm.ssot__Id__c) AS engagement_count__c,\n",
    "#ssot__EmailEngagement__dlm.ssot__IndividualId__c AS customer_id__c, \n",
    "#ssot__EmailEngagement__dlm.ssot__EngagementChannelActionId__c AS \n",
    "#engagement_type__c \n",
    "#FROM ssot__EmailEngagement__dlm \n",
    "#GROUP BY customer_id__c, engagement_type__c\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7f37117-d693-4ee8-99de-595a124e4fa3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "!pip install salesforce-cdp-connector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8eca7198-55d5-432a-bff5-4790d7b9ca79",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Get sklearn version and make sure that image version supports it\n",
    "import sklearn\n",
    "print(sklearn.__version__)\n",
    "!pip install sagemaker --upgrade\n",
    "# https://docs.aws.amazon.com/sagemaker/latest/dg/sklearn.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df2fc7d2-ed69-4605-9cd1-6578d702bdc3",
   "metadata": {},
   "outputs": [],
   "source": [
    "from salesforcecdpconnector.connection import SalesforceCDPConnection\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "import sagemaker\n",
    "import joblib\n",
    "import boto3\n",
    "from botocore.exceptions import ClientError\n",
    "import json\n",
    "import os\n",
    "#import pickle\n",
    "#import tarfile\n",
    "#from sagemaker.estimator import Estimator\n",
    "import time\n",
    "from time import gmtime, strftime\n",
    "import subprocess\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52fd45d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "#please update the IAM role with your own\n",
    "role = \"arn:aws:iam::240852588578:role/service-role/AmazonSageMaker-ExecutionRole-20221014T121197\"\n",
    "sagemaker_session = sagemaker.Session()\n",
    "#Bucket for model artifacts \n",
    "bucket = sagemaker_session.default_bucket()\n",
    "print(bucket)\n",
    "\n",
    "project_name = \"genie_email_rf_demo\"\n",
    "end_point_prefix = \"genie-email-rf-demo\"\n",
    "\n",
    "secret_name = \"genie/jdbc\"\n",
    "region_name = \"us-east-1\"\n",
    "\n",
    "# Create a Secrets Manager client\n",
    "session = boto3.session.Session()\n",
    "region_name = session.region_name\n",
    "\n",
    "s3 = session.resource('s3')\n",
    "\n",
    "sagemaker_client = session.client(\n",
    "    service_name='sagemaker',\n",
    "    region_name=region_name\n",
    ")\n",
    "\n",
    "runtime_client = session.client(\n",
    "    service_name ='sagemaker-runtime',\n",
    "    region_name=region_name\n",
    ")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f6aed4c",
   "metadata": {},
   "source": [
    "#Optional - Incase you want to store the secretes in AWS Secret Manager \n",
    "secretsmanager_client = session.client(\n",
    "    service_name='secretsmanager',\n",
    "    region_name=region_name\n",
    ")\n",
    "\n",
    "try:\n",
    "    get_secret_value_response = secretsmanager_client.get_secret_value(\n",
    "        SecretId=secret_name\n",
    "    )\n",
    "except ClientError as e:\n",
    "    # For a list of exceptions thrown, see\n",
    "    # https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html\n",
    "    raise e\n",
    "\n",
    "# Decrypts secret using the associated KMS key.\n",
    "cred = json.loads(get_secret_value_response['SecretString'])\n",
    "\n",
    "\n",
    "conn = SalesforceCDPConnection(\n",
    "        cred['AppUrl'], \n",
    "        cred['user'], \n",
    "        cred['password'], \n",
    "        cred['clientId'], \n",
    "        cred['clientSecret']\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c696bf95",
   "metadata": {},
   "outputs": [],
   "source": [
    "conn = SalesforceCDPConnection(\n",
    "       'https://login.salesforce.com/', \n",
    "        'pleasechangethis@salesforce.com', \n",
    "        'yourpassword',  \n",
    "        'clientIdhp7If35rb6Q77EoLPos_ESHlSLZebs834IWvvvxS54f7JxFgucuydEA.oK4oSYl4ZvmS',\n",
    "        'clientSecretEDAC047CFFF82B1C8B0A4D07C15256E12BFB66FF062A98BAAC0E')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91c138b2-1b0f-452c-991d-88fa18125f5c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "curs = conn.cursor()\n",
    "query = \"SELECT engagement_type__c, engagement_count__c FROM email_engagement_insight__cio limit 900000\"\n",
    "curs.execute(query)\n",
    "df = pd.DataFrame(curs.fetchall());\n",
    "df.columns = ['engagement_type__c','engagement_count__c']\n",
    "df.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f05eb718-24ec-48ff-a6ef-5f793ef8ee32",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = df.drop([\"engagement_type__c\"], axis=1)\n",
    "y = df[\"engagement_type__c\"]\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "559956ce-6a72-4862-85ce-7322e73f38c0",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "model = RandomForestClassifier()\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "y_pred = model.predict(X_test)\n",
    "\n",
    "\n",
    "\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(accuracy)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa9fd3cc-4ecb-4913-ab15-5807edea6ed9",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Save model artifacts to S3\n",
    "\n",
    "with open('model.joblib', 'wb') as f:\n",
    "    joblib.dump(model,f)\n",
    "\n",
    "#Build tar file with model data + inference code \n",
    "bashCommand = \"tar -cvpzf model.tar.gz model.joblib inference.py\"\n",
    "process = subprocess.Popen(bashCommand.split(), stdout=subprocess.PIPE)\n",
    "output, error = process.communicate()\n",
    "\n",
    "#Upload tar.gz to bucket\n",
    "model_artifacts = f\"s3://{bucket}/{project_name}/model.tar.gz\"\n",
    "response = s3.meta.client.upload_file('model.tar.gz', bucket, project_name+'/model.tar.gz')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97255b3d-697a-4a24-9e29-b7afeebbcebb",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# retrieve sklearn image \n",
    "image_uri = sagemaker.image_uris.retrieve(\n",
    "    framework=\"sklearn\",\n",
    "    region=region_name,\n",
    "    version=\"1.0-1\",\n",
    "    py_version=\"py3\",\n",
    "    instance_type=\"ml.m5.xlarge\",\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf7ec083-88c8-4d17-981c-9f8bfc680761",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#Step 1: Model Creation \n",
    "model_name = end_point_prefix + strftime(\"%Y-%m-%d-%H-%M-%S\", gmtime())\n",
    "print(\"Model name: \" + model_name)\n",
    "create_model_response = sagemaker_client.create_model(\n",
    "    ModelName=model_name,\n",
    "    Containers=[\n",
    "        {\n",
    "            \"Image\": image_uri,\n",
    "            \"Mode\": \"SingleModel\",\n",
    "            \"ModelDataUrl\": model_artifacts,\n",
    "            \"Environment\": {'SAGEMAKER_SUBMIT_DIRECTORY': model_artifacts,\n",
    "                           'SAGEMAKER_PROGRAM': 'inference.py'} \n",
    "        }\n",
    "    ],\n",
    "    ExecutionRoleArn=role,\n",
    ")\n",
    "print(\"Model Arn: \" + create_model_response[\"ModelArn\"])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3bce73d5-c6fa-4914-ad09-a683c194e4d6",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#Step 2: EPC Creation \n",
    "sklearn_epc_name = end_point_prefix + strftime(\"%Y-%m-%d-%H-%M-%S\", gmtime())\n",
    "endpoint_config_response = sagemaker_client.create_endpoint_config(\n",
    "    EndpointConfigName=sklearn_epc_name,\n",
    "    ProductionVariants=[\n",
    "        {\n",
    "            \"VariantName\": \"sklearnvariant\",\n",
    "            \"ModelName\": model_name,\n",
    "            \"InstanceType\": \"ml.c5.large\",\n",
    "            \"InitialInstanceCount\": 1\n",
    "        },\n",
    "    ],\n",
    ")\n",
    "print(\"Endpoint Configuration Arn: \" + endpoint_config_response[\"EndpointConfigArn\"])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f0537c7-4772-46bb-a947-f6fa70c9949e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#Step 3: SageMaker Inference EndPoint Creation \n",
    "endpoint_name = end_point_prefix + strftime(\"%Y-%m-%d-%H-%M-%S\", gmtime())\n",
    "create_endpoint_response = sagemaker_client.create_endpoint(\n",
    "    EndpointName=endpoint_name,\n",
    "    EndpointConfigName=sklearn_epc_name,\n",
    ")\n",
    "print(\"Endpoint Arn: \" + create_endpoint_response[\"EndpointArn\"])\n",
    "\n",
    "\n",
    "#Monitor creation\n",
    "describe_endpoint_response = sagemaker_client.describe_endpoint(EndpointName=endpoint_name)\n",
    "while describe_endpoint_response[\"EndpointStatus\"] == \"Creating\":\n",
    "    describe_endpoint_response = sagemaker_client.describe_endpoint(EndpointName=endpoint_name)\n",
    "    print(describe_endpoint_response[\"EndpointStatus\"])\n",
    "    time.sleep(15)\n",
    "print(describe_endpoint_response)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8809ce94-d874-44a9-ab17-5588432a495d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#Test SageMaker Inference EndPoint  \n",
    "#runtime_client = boto3.client('sagemaker-runtime')\n",
    "content_type = \"application/json\"\n",
    "request_body = {\"Input\": [['2.000000000000000000']]}\n",
    "data = json.loads(json.dumps(request_body))\n",
    "payload = json.dumps(data)\n",
    "endpoint_name = describe_endpoint_response['EndpointName']\n",
    "\n",
    "\n",
    "response = runtime_client.invoke_endpoint(\n",
    "    EndpointName=endpoint_name,\n",
    "    ContentType=content_type,\n",
    "    Body=payload)\n",
    "result = json.loads(response['Body'].read().decode())['Output']\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0991aeef-f717-4262-81ce-e8ca504da956",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create API Gateway \n",
    "#Create API gateway to expose SageMaker inference endpoint using a lambda function. Lambda function can also perform any required preprocessing.\n",
    "#https://www.youtube.com/watch?v=-iU36P8hizs. To use pandas a lambda layer is needed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfbee35b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Next We will use Salesforce CDP to consume inference enpoints"
   ]
  }
 ],
 "metadata": {
  "instance_type": "ml.m5.large",
  "kernelspec": {
   "display_name": "conda_mxnet_p38",
   "language": "python",
   "name": "conda_mxnet_p38"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}