wip app.py

app.py

@@ -1,7 +1,56 @@
+from tkinter.tix import COLUMN
 import streamlit as st
 import numpy as np
 import pandas as pd
 import PIL
+import torch
+import pickle
+import boto3
+
+# import time
+import torchvision.transforms as transforms
+
+class SaveFeatures():
+    features=None
+    def __init__(self, m): 
+        self.hook = m.register_forward_hook(self.hook_fn)
+        self.features = None
+    def hook_fn(self, module, input, output): 
+        out = output.detach().cpu().numpy()
+        if isinstance(self.features, type(None)):
+            self.features = out
+        else:
+            self.features = np.row_stack((self.features, out))
+    def remove(self): 
+        self.hook.remove()
+
+
+def read_image_from_s3(bucket, key, region_name='us-west-2'):
+    """Load image file from s3.
+
+    Parameters
+    ----------
+    bucket: string
+        Bucket name
+    key : string
+        Path in s3
+
+    Returns
+    -------
+    np array
+        Image array
+    """
+    s3 = boto3.resource('s3', region_name=region_name)
+    bucket = s3.Bucket(bucket)
+    object = bucket.Object(key)
+    response = object.get()
+    file_stream = response['Body']
+    im = Image.open(file_stream).convert('RGB')
+    return im
+
+
+def make_predictions():
+    print("hi")
 
 # ---- Title Screen -----------
 st.title('Image Optimization: Email Industry')
@@ -13,8 +62,138 @@ st.image(img)
 
 st.markdown('Adding an image to an email campaign that will provide optimal engagement metrics can be challenging. How do you know which image to upload to your HTML, that will make an impact or significantly move the needle? And why would this image garner the best engagement? This model seeks to help campaign engineers understand which images affect their user engagement rate the most. The specific model is implemented using ResNet 18 and ResNet 34 for image embeddings extraction, and then we used these image embeddings as further inputs into a Gradient Boosted Tree model to generate probabilities on a user-specified target variable. The base model was adapted to car images and accurately predicted the user engagement rates with 91% accuracy. This model is adaptable for any large-scale marketing campaign using images. This model will identify the best images for optimal engagement for an email marketing campaign and serve engagement metrics prior to campaign launch. The model serves up several different images in milliseconds, so the campaign engineer understands which image to select in the campaign for optimized engagement.')
 
+uploaded_file = st.file_uploader("Upload an image", type=["png", "jpg", "jpeg"])
+
+if uploaded_file is not None:
+    upload_img = PIL.Image.open(uploaded_file)
+    st.image(upload_img, caption='Uploaded Image', width=300)
+else:
+    upload_img = None
+    # st.write("")
+    # st.write("Classifying...")
+    # label = predict_label(image)
+    # st.write('%s (%.2f%%)' % (label[0], label[1]*100))
+
+
+# Drop down menu
+
+target_variables = ['Open Rate',
+                    'Click Through Open Rate',
+                    'Revenue Generated per Email',
+                    'Conversion Rate']
+campaign_types = ['Abandoned Cart',
+                  'Newsletter',
+                  'Promotional',
+                  'Survey',
+                  'Transactional',
+                  'Webinar',
+                  'Engagement', 
+                  'Review_Request', 
+                  'Product_Announcement']
+
+industry_types =['Energy',
+                 'Entertainment',
+                 'Finance and Banking',
+                 'Healthcare',
+                 'Hospitality',
+                 'Real Estate', 'Retail', 'Software and Technology']
+
+
+target = st.selectbox('Target Variables',target_variables, index=0)
+campaign = st.selectbox('Campaign Types',campaign_types, index=0)
+industry = st.selectbox('Industry Types',industry_types, index=0)
+
+
+if st.button('Generate Predictions'):
+    if upload_img is None:
+        st.error('Please upload an image')
+    else:
+        placeholder = st.empty()
+        placeholder.write("Loading Data...")
+
+        # Starting Predictions
+
+        data = pd.read_csv('data/wrangled_data_v2.csv', index_col=0)
+        data_mod = data.copy()
+        data_mod = data[(data.campain_type == campaign) & (data.industry == industry)]
+
+        embeddings_df = pd.read_csv('data/embeddings_df.csv',index_col=0)
+        embeddings_df = embeddings_df.iloc[data.index]
+
+
+        # Transform to tensor 
+        # transforming user input PIL Image to tensor
+
+        # single_img_path = list(uploaded_image.value.keys())[0]
+        single_image = upload_img.convert('RGB') # converting grayscale images to RGB
+        # st.image(single_image, caption='Uploaded Image', width=300)
+
+        my_transforms = transforms.Compose([
+        transforms.Resize((224,224)),
+        transforms.ToTensor()
+        ])
+
+        image_tensor = my_transforms(single_image).unsqueeze(0) # transforming into tensor, unsqueeze to match input batch size dimensions
+
+
+    
+        placeholder.write('Loading Model...')
+
+        model_path = 'model/my_checkpoint1.pth'
+        model = torch.load(model_path,map_location=torch.device('cpu'))
+        model.eval()
+        image_imbeddings = SaveFeatures(list(model._modules.items())[-1][1])
+
+        with torch.no_grad():
+            outputs = model(image_tensor)  # switched for cpu: image_tensor.cuda() (no cuda)
+        img_embeddings = image_imbeddings.features[0]
+
+
+        xgb_model = pickle.load(open("model/xgb_grid_model.pkl", "rb"))
+        col_names = ['Abarth', 'Cab', 'Convertible', 'Coupe', 'GS', 'Hatchback', 'IPL', 'Minivan', 'R', 'SRT-8', 'SRT8', 'SS', 'SUV', 'Sedan', 'SuperCab', 'Superleggera', 'Type-S', 'Van', 'Wagon', 'XKR', 'Z06', 'ZR1']
+        img_df = pd.DataFrame([img_embeddings], columns=col_names)
+
+        #####
+        # Getting Probabilities for Subsetted Dataframe
+        full_df_probs = xgb_model.predict_proba(embeddings_df)
+        full_df_probs = [i[1] for i in full_df_probs]
+        prob_series = pd.Series(full_df_probs, index= embeddings_df.index)
+
+        # 2 from each 
+        top_10 = prob_series.sort_values(ascending=False)[:20]
+        random_4_from_top_10 = top_10.sample(replace=False,n=2)
+        
+        # 2 from top 10 to 100
+        top_10_100 = prob_series.sort_values(ascending=False)[20:100]
+        random_4_from_top_10_100 = top_10_100.sample(replace=False,n=2)
+
+        alternate_probs = pd.concat([random_4_from_top_10, random_4_from_top_10_100], axis=0)
+
+        ######
+        # Making predictions on user input and displaying results:
+        img_pred = xgb_model.predict(img_df)[0]
+        img_proba = xgb_model.predict_proba(img_df)[0][1]
+
+        ######
+        # making dictionary for max probability for recommendation
+        max_prob_dict = {}
+        max_prob_dict['current_image'] = img_proba
+        for i in range(len(alternate_probs)):
+            max_prob_dict['Alternate Image '+ str(i+1)] = alternate_probs.values[i]
 
+        st.write('Below are the probabilities if alternate recommended images were used')
 
+        img_index = alternate_probs.index[0]
+        img_path = data.iloc[img_index][0]
+        bucket = 'sagemaker-us-west-2-647020561811'
+        key = 'sagemaker/Marlov-Image/'
 
+        s3 = boto3.resource('s3')
+        bucket = s3.Bucket(bucket)
+        # for obj in bucket.objects.filter(Prefix=key):
+        for obj in bucket.objects.all():
+            key = obj.key
+            body = obj.get()['Body'].read()
+        # alt_img = read_image_from_s3(bucket,key,img_path)
 
-#
+        placeholder.empty()