def invoke_prediction(mail_body): mail_body = mail_body.replace('\r\n', ' ').replace('\r', ' ').replace('\n', ' ') mail_body = [mail_body] # print(mail_body) runtime = boto3.client('runtime.sagemaker') one_hot_test_messages = one_hot_encode(mail_body, vocabulary_length) encoded_test_messages = vectorize_sequences(one_hot_test_messages, vocabulary_length) msg = json.dumps(encoded_test_messages.tolist()) response = runtime.invoke_endpoint(EndpointName=sagemaker_endpoint, ContentType='application/json', Body=msg) # print(response) result = response['Body'] res = json.loads(result.read().decode("utf-8")) # print(res) predicted_score = int(res['predicted_label'][0][0]) predicted_probability = float(res['predicted_probability'][0][0]) predicted_label = 'Spam' if predicted_score == 1 else 'Ham' predicted_probability = predicted_probability if predicted_score == 1 else ( 1 - predicted_probability) print("Predicted Label = %s ; Prediction Confidence = %.2f" % (predicted_label, predicted_probability)) return predicted_label, predicted_probability
def handler(event, context): sms = event['body'] if 'httpMethod' in event: if event['httpMethod'] == 'OPTIONS': return response(200, '') elif event['httpMethod'] == 'POST': test_messages = [sms.encode('ascii','ignore')] one_hot_test_messages = one_hot_encode(test_messages, vocabulary_lenght) encoded_test_messages = vectorize_sequences(one_hot_test_messages, vocabulary_lenght) encoded_test_messages = mx.nd.array(encoded_test_messages) output = net(encoded_test_messages) sigmoid_output = output.sigmoid() prediction = mx.nd.abs(mx.nd.ceil(sigmoid_output - 0.5)) output_obj = {} output_obj['predicted_label'] = np.array2string(prediction.asnumpy()[0][0]) output_obj['predicted_probability'] = np.array2string(sigmoid_output.asnumpy()[0][0]) return response(200, output_obj) else: return response(405, 'null')
def predictspam(body): vocabulary_length = 9013 #test_messages = ["FreeMsg: Txt: CALL to No: 86888 & claim your reward of 3 hours talk time to use from your phone now! ubscribe6GBP/ mnth inc 3hrs 16 stop?txtStop"] one_hot_test_messages = one_hot_encode(body, vocabulary_length) encoded_test_messages = vectorize_sequences(one_hot_test_messages, vocabulary_length) data = json.dumps(encoded_test_messages.tolist()) response = runtime.invoke_endpoint(EndpointName=ENDPOINT_NAME, ContentType="application/json", Body=data) # print("Response: ", response) # result = response["Body"].read() # print("Result: ", result) # pred = int(result["predictions"][0]["score"]) # print("Prediction: ", pred) # return pred res = json.loads(response["Body"].read()) print("Prediction: ", res['predicted_label']) if res['predicted_label'][0][0] == 0: label = 'Ham' else: label = 'Spam' score = round(res['predicted_probability'][0][0], 4) return label, score * 100
def checkForSpam(body): one_hot_test_messages = one_hot_encode([body], vocabulary_length) encoded_test_messages = vectorize_sequences(one_hot_test_messages, vocabulary_length) response = runtime.invoke_endpoint(EndpointName=ENDPOINT_NAME, ContentType='application/json', Body=json.dumps( encoded_test_messages.tolist())) return json.loads(response["Body"].read().decode())
def hit_sagemaker(text): """ Hit sagemaker endpoint with text and get response. Return the confidence and other information. """ ENDPOINT_NAME = "sms-spam-classifier-mxnet-2020-05-12-05-34-38-136" runtime= boto3.client('runtime.sagemaker') vocabulary_length = 9013 test_messages = [text] one_hot_test_messages = one_hot_encode(test_messages, vocabulary_length) encoded_test_messages = vectorize_sequences(one_hot_test_messages, vocabulary_length) response = runtime.invoke_endpoint(EndpointName=ENDPOINT_NAME, ContentType='application/json', Body=json.dumps(encoded_test_messages.tolist())) return response['Body'].read().decode('UTF-8') pass
def lambda_handler(event, context): # TODO implement print(event) test_messages = read_from_s3() #test_messages = ["FreeMsg: Txt: CALL to No: 86888 & claim your reward of 3 hours talk time to use from your phone now! ubscribe6GBP/ mnth inc 3hrs 16 stop?txtStop"] one_hot_test_messages = one_hot_encode(test_messages, 9013) encoded_test_messages = vectorize_sequences(one_hot_test_messages, 9013) print(encoded_test_messages) payload = json.dumps(encoded_test_messages.tolist()) lo = payload.strip('[') lo = lo.strip(']') endpoint_name = 'sms-spam-classifier-ll-2020-05-07-07-24-58-952' runtime = boto3.Session().client(service_name='sagemaker-runtime', region_name='us-east-1') response = runtime.invoke_endpoint(EndpointName=endpoint_name, ContentType='text/csv', Body=lo) result = json.loads(response['Body'].read().decode()) res = result['predictions'] print(res) return {'statusCode': 200, 'body': json.dumps('Hello from Lambda!')}
import pandas as pd import numpy as np import pickle from sms_spam_classifier_utilities import one_hot_encode from sms_spam_classifier_utilities import vectorize_sequences df = pd.read_csv('dataset/SMSSpamCollection', sep='\t', header=None) df[df.columns[0]] = df[df.columns[0]].map({'ham': 0, 'spam': 1}) targets = df[df.columns[0]].values messages = df[df.columns[1]].values # one hot encoding for each SMS message one_hot_data = one_hot_encode(messages, vocabulary_length) encoded_messages = vectorize_sequences(one_hot_data, vocabulary_length) df2 = pd.DataFrame(encoded_messages) df2.insert(0, 'spam', targets) # Split into training and validation sets (80%/20% split) split_index = int(np.ceil(df.shape[0] * 0.8)) train_set = df2[:split_index] val_set = df2[split_index:] train_set.to_csv('dataset/sms_train_set.csv', header=False, index=False) val_set.to_csv('dataset/sms_val_set.csv', header=False, index=False) # We have to upload the two files back to Amazon S3 in order to be accessed by the Amazon SageMaker training cluster.
def lambda_handler(event, context): s3 = boto3.client("s3") vocabulary_length = 9013 ENDPOINT_NAME = os.environ['ENDPOINT_NAME'] runtime = boto3.client('runtime.sagemaker') ses = boto3.client('ses') test_messages = [] if event: print("My Event is : ", event) file_obj = event["Records"][0] filename = str(file_obj["s3"]['object']['key']) print("filename: ", filename) fileObj = s3.get_object(Bucket="filtered-mail-box", Key=filename) print("file has been gotten!") msg = email.message_from_bytes(fileObj['Body'].read()) subject = msg["Subject"] return_path = msg["Return-Path"] date = msg["Date"] if msg.is_multipart(): for part in msg.walk(): content_type = part.get_content_type() if "plain" in content_type: payload = part.get_payload().rstrip("\n") #print(payload) newpayload = "" for line in payload: newpayload = newpayload + line.rstrip('\n') print(newpayload) test_messages.append(newpayload) one_hot_test_messages = one_hot_encode(test_messages, vocabulary_length) encoded_test_messages = vectorize_sequences(one_hot_test_messages, vocabulary_length) data = np.array(encoded_test_messages) #print(data) data = encoded_test_messages payload_to_endpoint = json.dumps(data.tolist()) response = runtime.invoke_endpoint(EndpointName=ENDPOINT_NAME, ContentType='application/json', Body=payload_to_endpoint) result = json.loads(response['Body'].read().decode()) print(result) predicted_probability = result['predicted_probability'][0][0] predicted_label = result['predicted_label'][0][0] classification_confidence_score = predicted_probability * 100 #print(predicted_label) if predicted_label == 1.0: classification = 'SPAM' else: classification = 'HAM' print("The email was categorized as {} with a {}% confidence.".format( classification, classification_confidence_score)) print(subject, return_path, date) SENDER = "Karan Mankar <*****@*****.**>" RECIPIENT = return_path BODY_TEXT = ( "We received your email sent at {} with the subject {}.\n\n" "Here is a 240 character sample of the email body:{} \n\n" "The email was categorized as {} with a {}% confidence.".format( date, subject, payload, classification, classification_confidence_score)) CHARSET = "UTF-8" response = ses.send_email( Destination={ 'ToAddresses': [ RECIPIENT, ], }, Message={ 'Body': { 'Text': { 'Charset': CHARSET, 'Data': BODY_TEXT }, }, 'Subject': { 'Charset': CHARSET, 'Data': "Spam Classification", }, }, Source=SENDER, ) print(response) return {'statusCode': 200, 'body': json.dumps('Hello from Lambda!')}
def lambda_handler(event, context): sender=os.environ["sender"] endpoint=os.environ["endpoint"] print(endpoint) BUCKET_NAME,KEY_NAME=event["Records"][0]["s3"]["bucket"]["name"],event["Records"][0]["s3"]["object"]["key"] s3=boto3.client("s3") response=s3.get_object(Bucket=BUCKET_NAME, Key=KEY_NAME) emailcontent = response['Body'].read().decode('utf-8') text=email.message_from_string(emailcontent) content=str(text.get_payload()[0]).split("\n") print(content) content=[" ".join(content[2:-1])] if len(content)>=2 else content print(content) subject,received_date,email_address=text.get("subject"),text.get("Date"),text.get("From") print(subject,received_date,email_address) # exit() # email=re.search("Return-Path: <.*>", emailcontent).group(0)[14:-1] # received_date=re.findall("Date: .*\r\n",emailcontent)[-1][6:].replace("\r\n","") # subject=re.findall("Subject: .*\r\n",emailcontent)[-1][9:].replace("\r\n","") # print(received_date,subject) # emailcontent=emailcontent.split("\r\n") # print(json.dumps(emailcontent,indent=2)) # pos1=emailcontent.index("Content-Type: text/plain; charset=\"UTF-8\"") # # print(pos1) # uni=emailcontent[pos1-1] # # print(uni) # start,end=None,None # for i,v in enumerate(emailcontent): # if uni==v: # if start is None: # start=i # elif end is None: # end=i # else: # break # # print(start,end) # content=[" ".join([v for v in emailcontent[start+3:end-1] if v!="\n"])] # print(content) #test_messages = ["FreeMsg: Txt: CALL to No: 86888 & claim your reward of 3 hours talk time to use from your phone now! ubscribe6GBP/ mnth inc 3hrs 16 stop?txtStop"] vocabulary_length = 9013 one_hot_test_messages = one_hot_encode(content, vocabulary_length) encoded_test_messages = vectorize_sequences(one_hot_test_messages, vocabulary_length) #endpoint="sms-spam-classifier-mxnet-2020-05-09-11-08-10-423" contentType = "application/json" runtime=boto3.client('sagemaker-runtime') response = runtime.invoke_endpoint(EndpointName=endpoint, ContentType=contentType, Body=json.dumps(encoded_test_messages.tolist())) res=json.loads(response["Body"].read().decode()) label="spam" if res["predicted_label"][0][0]>0.5 else "normal" probability=res["predicted_probability"][0][0]*100 m1="We received your email sent at {} with the subject {}.".format(received_date,subject) m2="Here is a 240 character sample of the email body:" m3=content[0][:240] m4="The email was categorized as {} with a {}% confidence.".format(label,probability) msg="\n".join([m1,m2,m3,m4]) print(msg) send_msg_to_visitor(sender,email_address,msg) return { 'statusCode': 200, 'body': json.dumps('Hello from Lambda!') }
def lambda_handler(event, context): print("DEBUG event:", event) s3_info = event['Records'][0]['s3'] bucket_name = s3_info['bucket']['name'] key_name = s3_info['object']['key'] # get the email in S3 s3_response = s3_client.get_object( Bucket=bucket_name, Key=key_name, ) print('DEBUG s3_response:', s3_response) email_string = s3_response['Body'].read().decode('utf-8') email_arr = email_string.splitlines() email_subject = "" received_from = "" from_idx = 0 for i, line in enumerate(email_arr): if line.startswith('Subject:'): email_subject = line[9:] elif line.startswith('From:'): received_from = line[6:] elif line.startswith('X-SES-Outgoing'): from_idx = i + 1 if email_subject and received_from and from_idx: break body_arr = email_arr[from_idx:] print("DEBUG body_arr:", body_arr) body_string_to_check = ' '.join(body_arr) print("DEBUG body_string_to_check:", body_string_to_check) body_string_to_send = '\n'.join(body_arr) body_string_to_send = body_string_to_send[:240] # vectorizing message test_messages = [body_string_to_check] one_hot_test_messages = one_hot_encode(test_messages, vocabulary_length) encoded_test_messages = vectorize_sequences(one_hot_test_messages, vocabulary_length) json_message = json.dumps(encoded_test_messages.tolist()) # send vectorized message to sage maker sagemaker_response = runtime.invoke_endpoint(EndpointName = ENDPOINT_NAME, ContentType = "application/json", Body = json_message) decoded_sagemaker_response = json.loads(sagemaker_response['Body'].read().decode()) print("DEBUG decoded_sagemaker_response:", decoded_sagemaker_response) classification_number = decoded_sagemaker_response['predicted_label'][0][0] if classification_number == 0.0: classification = 'HAM' elif classification_number == 1.0: classification = 'SPAM' classification_confidence_score = decoded_sagemaker_response['predicted_probability'][0][0] * 100 print("DEBUG classification:", classification) print("DEBUG classification_confidence_score:", classification_confidence_score) # write reponse email email_time = s3_response['LastModified'] # create both timezone objects curr_tz = pytz.timezone("US/Eastern") curr_tz_time = email_time.astimezone(curr_tz) subject = f'Spam Indentification of email "{email_subject}"' body = f''' We received your email sent at {curr_tz_time.ctime()} with the subject "{email_subject}". Here is a 240 character sample of the email body: {body_string_to_send} The email was categorized as {classification} with a {classification_confidence_score}% confidence. ''' # send response email try: response = ses_client.send_email( Destination={ 'ToAddresses': [ '*****@*****.**', ], }, Message={ 'Body': { 'Text': { 'Charset': 'UTF-8', 'Data': body, }, }, 'Subject': { 'Charset': 'UTF-8', 'Data': subject, }, }, Source='*****@*****.**', ) except ClientError as e: print("DEBUG error:", e.response['Error']) else: print("Email sent! Message ID:"), print(response['MessageId'])
def lambda_handler(event, context): print("DEBUG event:", event) s3_info = event['Records'][0]['s3'] bucket_name = s3_info['bucket']['name'] key_name = s3_info['object']['key'] # get the email in S3 s3_response = s3_client.get_object( Bucket=bucket_name, Key=key_name, ) print('DEBUG s3_response:', s3_response) email_string = s3_response['Body'].read().decode('utf-8') msg = email.message_from_string(email_string) received_from = msg["from"] email_subject = msg["subject"] #reading the body part of msg if msg.is_multipart(): for part in msg.walk(): ctype = part.get_content_type() cdispo = str(part.get("Content-Disposition")) # skip any text/plain (txt) attachments if ctype == "text/plain" and "attachment" not in cdispo: email_payload = part.get_payload(decode=True) # decode break else: email_payload = msg.get_payload(decode=True) email_body_string = email_payload.decode("utf-8") body_arr = email_body_string.splitlines() print("DEBUG body_arr:", body_arr) print("DEBUG received_from:", received_from) print("DEBUG email_subject:", email_subject) body_string_to_check = ' '.join(body_arr) print("DEBUG body_string_to_check:", body_string_to_check) body_string_to_send = '\n'.join(body_arr) body_string_to_send = body_string_to_send[:240] # vectorizing message test_messages = [body_string_to_check] one_hot_test_messages = one_hot_encode(test_messages, vocabulary_length) encoded_test_messages = vectorize_sequences(one_hot_test_messages, vocabulary_length) json_message = json.dumps(encoded_test_messages.tolist()) # send vectorized message to sage maker sagemaker_response = runtime.invoke_endpoint( EndpointName=ENDPOINT_NAME, ContentType="application/json", Body=json_message) decoded_sagemaker_response = json.loads( sagemaker_response['Body'].read().decode()) print("DEBUG decoded_sagemaker_response:", decoded_sagemaker_response) classification_number = decoded_sagemaker_response['predicted_label'][0][0] if classification_number == 0.0: classification = 'HAM' elif classification_number == 1.0: classification = 'SPAM' classification_confidence_score = decoded_sagemaker_response[ 'predicted_probability'][0][0] * 100 print("DEBUG classification:", classification) print("DEBUG classification_confidence_score:", classification_confidence_score) # write reponse email email_time = s3_response['LastModified'] # create both timezone objects curr_tz = pytz.timezone("US/Eastern") curr_tz_time = email_time.astimezone(curr_tz) subject = f'Spam Indentification of email "{email_subject}"' body = f''' We received your email sent at {curr_tz_time.ctime()} with the subject "{email_subject}". Here is a 240 character sample of the email body: {body_string_to_send} The email was categorized as {classification} with a {classification_confidence_score}% confidence. ''' # send response email try: response = ses_client.send_email( Destination={ 'ToAddresses': [ received_from, ], }, Message={ 'Body': { 'Text': { 'Charset': 'UTF-8', 'Data': body, }, }, 'Subject': { 'Charset': 'UTF-8', 'Data': subject, }, }, Source='*****@*****.**', ) except ClientError as e: print("DEBUG error:", e.response['Error']) else: print("Email sent! Message ID:"), print(response['MessageId'])
def lambda_handler(event, context): # Update EndpointName = os.environ['myEnvParameterEndpointName'] objectKey = event["Records"][0]["s3"]["object"]["key"] bucket = 'hw3-spam-detection-email-s1-cf' s3 = boto3.resource('s3') obj = s3.Object(bucket, objectKey) msg = obj.get()['Body'].read().decode('utf-8') msg = email.message_from_string(msg) pay_load_text = '' if msg.is_multipart(): for part in msg.get_payload(): if part.get_content_type() == 'text/plain': pay_load_text = part.get_payload() else: pay_load_text = msg.get_payload() EMAIL_BODY = pay_load_text messages = re.sub('[ \n\r\t\f]+', ' ', pay_load_text).replace('*', '').strip() print(messages) EMAIL_RECEIVE_DATE = msg['Date'] EMAIL_SUBJECT = msg['Subject'] EMAIL_FROM = msg['from'] # EMAIL_BODY = "FreeMsg: Txt: CALL to No: 86888 & claim your reward of 3 hours talk time to use from your phone now! ubscribe6GBP/ mnth inc 3hrs 16 stop?txtStop" # EMAIL_BODY = re.sub('[ \t\n]+', ' ', EMAIL_BODY).replace('*', '').strip() # print(EMAIL_BODY) # # EMAIL_BODY = "I am Jim." # EMAIL_RECEIVE_DATE = 'Fri, 26 Mar 2021 05:58:41 +0000' # EMAIL_SUBJECT = 'Dummy email subject' # EMAIL_FROM = 'iPhone5 A1429 <*****@*****.**>' # Encode to narray vocabulary_length = 9013 messages = [messages] one_hot_messages = one_hot_encode(messages, vocabulary_length) encoded_messages = vectorize_sequences(one_hot_messages, vocabulary_length) payload = json.dumps(encoded_messages.tolist()) # Predict by SageMaker client = boto3.client('sagemaker-runtime') response = client.invoke_endpoint(EndpointName=EndpointName, Body=payload, ContentType='application/json') result = json.loads(response['Body'].read().decode()) CLASSIFICATION_CONFIDENCE_SCORE = result['predicted_probability'][0][0] predicted_label = result['predicted_label'][0][0] CLASSIFICATION = 'ham' if predicted_label == 0: CLASSIFICATION = 'ham' CLASSIFICATION_CONFIDENCE_SCORE = 1 - CLASSIFICATION_CONFIDENCE_SCORE else: CLASSIFICATION = 'spam' # Reply to the sender of the email # Amazon SES SENDER = "iPhone5 A1429 <*****@*****.**>" RECIPIENT = EMAIL_FROM AWS_REGION = "us-east-1" SUBJECT = 'Spam detection of ' + EMAIL_SUBJECT # The email body for recipients with non-HTML email clients. BODY_TEXT = ("We received your email sent at " + EMAIL_RECEIVE_DATE + " with the subject " + EMAIL_SUBJECT + ".\n\n" + "Here is the email body:\n" + EMAIL_BODY + "\n\n" + "The email was categorized as " + CLASSIFICATION + " with a " + str(float(CLASSIFICATION_CONFIDENCE_SCORE) * 100) + "% confidence.") # The character encoding for the email. CHARSET = "UTF-8" client = boto3.client('ses', region_name=AWS_REGION, aws_access_key_id='aws_access_key_id', aws_secret_access_key='aws_secret_access_key') # Try to send the email. try: #Provide the contents of the email. response = client.send_email( Destination={ 'ToAddresses': [ RECIPIENT, ], }, Message={ 'Body': { 'Text': { 'Charset': CHARSET, 'Data': BODY_TEXT, }, }, 'Subject': { 'Charset': CHARSET, 'Data': SUBJECT, }, }, Source=SENDER, # If you are not using a configuration set, comment or delete the # following line # ConfigurationSetName=CONFIGURATION_SET, ) # Display an error if something goes wrong. except ClientError as e: print(e.response['Error']['Message']) else: print("Email sent! Message ID:") print(response['MessageId']) # TODO implement return {'statusCode': 200, 'body': json.dumps('Hello from Lambda!')}
def lambda_handler(event, context): print("Received event: " + json.dumps(event)) for each_email in event['Records']: bucket = each_email['s3']['bucket']['name'] key = each_email['s3']['object']['key'] # retrieve information part email_obj = s3_client.Object(bucket, key) email_file_body = str(email_obj.get()['Body'].read()) Info_start = email_file_body.rfind("From:") email_file_body = email_file_body[Info_start:] # get email body CLASSIFICATION = '' CLASSIFICATION_CONFIDENCE_SCORE = 0.00 email_body = email_file_body.replace("\\r", "").replace("\\n", "") left_charset = email_body.find("charset=") right_charset = email_body.rfind("charset=") email_body = email_body[left_charset:right_charset] right = email_body.rfind("--0000") email_body = email_body[15:right] if len(email_body) > 240: email_body = email_body[:240] # get the classification result of email_body mxnet_pred = MXNetPredictor('spam') vocabulary_length = 9013 test_messages = [email_body] one_hot_test_messages = one_hot_encode(test_messages, vocabulary_length) encoded_test_messages = vectorize_sequences(one_hot_test_messages, vocabulary_length) result = mxnet_pred.predict(encoded_test_messages) CLASSIFICATION_CONFIDENCE_SCORE = round(float(result["predicted_probability"][0][0]) * 100, 2) if result["predicted_label"][0][0] == 1.0: CLASSIFICATION = "Spam Message" elif result["predicted_label"][0][0] == 0.0: CLASSIFICATION = "Ham Message" # get other email information email_info = email_file_body.split("\\r\\n") email_address = '' email_date = '' email_subject = '' for each_info in email_info: if each_info.startswith('From: '): starting_pos = each_info.find('<') + 1 email_address = each_info[starting_pos:-1] elif each_info.startswith('Date: '): starting_pos = each_info.find(':') + 2 temp = each_info[starting_pos:] temp_end = temp.find(':') - 2 email_date = temp[:temp_end].strip() elif each_info.startswith('Subject: '): starting_pos = each_info.find(':') + 2 email_subject = each_info[starting_pos:] reply1 = 'We received your email sent at ' + email_date + ' with the subject ' + email_subject + '.\n' reply2 = 'Here is a 240 character sample of the email body: \n' reply3 = email_body + '\n' reply4 = 'The email was categorized as ' + CLASSIFICATION + ' with a ' + str(CLASSIFICATION_CONFIDENCE_SCORE) + '% confidence.' response = ses_client.send_email( Source = '*****@*****.**', Destination = { 'ToAddresses': [ email_address, ] }, Message = { 'Subject': { 'Data': email_subject }, 'Body': { 'Text': { 'Data': reply1 + reply2 + reply3 + reply4 }, 'Html': { 'Data': '<p>' + reply1 + '</p>' + '<p>' + reply2 + '</p>' + '<p>' + reply3 + '</p>' + '<p>' + reply4 + '</p>' } } }, ReplyToAddresses = [ email_address, ] ) return { 'statusCode': 200, 'body': json.dumps('Hello from Lambda!') }
def lambda_handler(event, context): s3 = boto3.client('s3', region_name='us-east-1') info = event['Records'][0]['s3'] bucket = info['bucket']['name'] name = info['object']['key'] # Get the email file = s3.get_object(Bucket=bucket, Key=name)['Body'].read() message = email.message_from_string(file.decode("utf-8")) #print(message) ret_body = '' if message.is_multipart(): for pl in message.get_payload(): ret_body += pl.get_payload() else: ret_body += message.get_payload() print(ret_body) ret_body = ret_body.replace("=E2=80=93=20\r\n", "\r\n") ret_body = ret_body.replace("=\r\n", "\r\n").replace("\r\n=20", "\r\n") print(ret_body) body = ret_body.replace("\n", "").replace("\r", "") print(body) # Sagemaker part runtime = boto3.client('runtime.sagemaker') # Prepare the message to test vocabulary_length = 9013 test_msg = [body] one_hot_test_messages = one_hot_encode(test_msg, vocabulary_length) encoded_test_messages = vectorize_sequences(one_hot_test_messages, vocabulary_length) encoded_json_msg = json.dumps(encoded_test_messages.tolist()) runtime = boto3.client('runtime.sagemaker', region_name='us-east-1') response = runtime.invoke_endpoint(EndpointName=ENDPOINT_NAME, ContentType='text/csv', Body=encoded_json_msg) response = json.loads(response['Body'].read().decode()) print("Response: ", response) score = int(response["predicted_label"][0][0]) Classification = 'HAM' if score == 0 else "SPAM" Probability = response["predicted_probability"][0][0] # Prepare the return email aws_region = "us-east-1" sender = message['To'] recipient = message['From'] subject = "Analysis for your email" body_text = "We received your email sent at {} with the subject {}.\r\n".format( message['Date'], message['SUBJECT']) body_text += "\r\nHere is a 240 character sample of the email body:\r\n" body_text += "\r\n" + ret_body[:240] + "\r\n" body_text += "\r\nThe email was categorized as {} ".format(Classification) body_text += "with a {:.5%} confidence.".format(Probability) send_email(sender, recipient, aws_region, subject, body_text) return { 'statusCode': 200, 'body': json.dumps('We have already know if your email is spam or not') }