Gain insights into predicting retail sales with TensorFlow. Delve into data analysis, training models, and extracting insights using industry techniques. Explore efficient model evaluation with experts from top tech companies.

APLCS.tar.gz

case-study

In this course, you'll work on an industry-level machine learning project based on predicting weekly retail sales given different factors. You will learn the most efficient techniques used to train and evaluate scalable machine learning models. After completing this course, you will be able to take on industry-level machine learning projects, from data analysis to creating efficient models and providing results and insights.

The code for this course is built around the TensorFlow framework, which is one of the premier frameworks for industry machine learning, and the Python pandas library for data analysis. Basic knowledge of Python and TensorFlow are prerequisites. To get some experience with TensorFlow, try our course: Machine Learning for Software Engineers.

This course was created by AdaptiLab, a company specializing in evaluating, sourcing, and upskilling enterprise machine learning talent. It is built in collaboration with industry machine learning experts from Google, Microsoft, Amazon, and Apple.

Applied Machine Learning: Industry Case Study with TensorFlow

# Chapter Goals:
- Process the embedding feature columns used for the machine learning model's input layer

# A. Feature embeddings

The other feature column for categorical features is embedding feature columns. For our dataset, the embedding features are `'Store'` and `'Dept'`. Both these features have many more categories than the indicator features, so using a one-hot vector representation wouldn't necessarily be the most efficient or useful.

Furthermore, there are connections between categories for both the `'Store'` and `'Dept'` features. For example, we may see similar sales trends between stores in the same region or between departments that sell complementary items (e.g. milk and cereal).

These are trends that can be encapsulated by an embedding feature column, which maps each category to a real-number vector of a specified dimension. We can set the vector dimension to anything, but a good rule of thumb is to set it equal to the $4^{th}$ root of the number of categories.

import tensorflow as tf

stores = list(range(1, 46))
stores_col = tf.feature_column.categorical_column_with_vocabulary_list(
    'StoreID', stores, dtype=tf.int64)
embedding_dim = int(45**0.25)  # 4th root
feature_col = tf.feature_column.embedding_column(
    stores_col, embedding_dim)

For more on word embedding, check out our course [Image Recognition](https://www.educative.io/collection/6083138522447872/5093907643760640) on educative.

# Time to Code!
In this chapter you'll be creating the embedding feature columns for the dataset by completing the `add_embedding_columns` function. We've already filled the function with skeleton code that iterates through the embedding features in the dataset.

Each embedding feature column is built from a vocabulary list. The vocabulary list comes from the unique values of the feature in the `final_dataset` DataFrame.

**Set `vocab_list` equal to the unique values in `final_dataset[feature_name]`, cast as a list.**

Using the vocabulary list, we'll create the categorical column for the feature. Each of our dataset's embedding features has datatype `tf.int64`.

**Set `vocab_col` equal to `tf.feature_column.categorical_column_with_vocabulary_list` with `feature_name` and `vocab_list` as the required arguments, as well as `tf.int64` for the `dtype` keyword argument.**

Following the general rule of thumb, we set the embedding dimension as the $4^{th}$ root of the size of the vocabulary list.

**Set `embedding_dim` equal to the length of `vocab_list` raised to the power of `0.25` and cast as an integer.**

import tensorflow as tf

# Add the embedding feature columns to the list of feature columns
def add_embedding_columns(final_dataset, feature_columns):
    embedding_features = ['Store', 'Dept']
    for feature_name in embedding_features:
        # CODE HERE
        

import numpy as np
import pandas as pd
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'

import tensorflow as tf

train_df = pd.read_csv('weekly_sales.csv')
features_df = pd.read_csv('features.csv')
stores_df = pd.read_csv('stores.csv')
merged_features = features_df.merge(stores_df, on='Store')
na_values = pd.isna(merged_features)
na_features = na_values.any()
markdowns = [
    'MarkDown1',
    'MarkDown2',
    'MarkDown3',
    'MarkDown4',
    'MarkDown5'
]
merged_features = merged_features.drop(columns=markdowns)
na_cpi_int = na_values['CPI'].astype(int)
na_indexes_cpi = na_cpi_int.to_numpy().nonzero()[0]
na_une_int = na_values['Unemployment'].astype(int)
na_indexes_une = na_une_int.to_numpy().nonzero()[0]
na_indexes = na_indexes_cpi
na_rows = merged_features.iloc[na_indexes]
for i in na_indexes_cpi:
    merged_features.at[i, 'CPI'] = merged_features.at[i - 1, 'CPI']
for i in na_indexes_une:
    merged_features.at[i, 'Unemployment'] = merged_features.at[i - 1, 'Unemployment']
features = ['Store', 'Date', 'IsHoliday']
final_dataset = train_df.merge(merged_features, on=features)
final_dataset['IsHoliday'] = final_dataset['IsHoliday'].astype(int)

def add_int_features(dataset_row, feature_dict):
    int_vals = ['Store', 'Dept', 'IsHoliday', 'Size']
    for feature_name in int_vals:
        list_val = tf.train.Int64List(value=[dataset_row[feature_name]])
        feature_dict[feature_name] = tf.train.Feature(int64_list=list_val)

def add_float_features(dataset_row, feature_dict, has_labels):
    float_vals = ['Temperature', 'Fuel_Price', 'CPI', 'Unemployment']
    if has_labels:
        float_vals.append('Weekly_Sales')
    for feature_name in float_vals:
        list_val = tf.train.FloatList(value=[dataset_row[feature_name]])
        feature_dict[feature_name] = tf.train.Feature(float_list=list_val)

def create_example(dataset_row, has_labels):
    feature_dict = {}
    add_int_features(dataset_row, feature_dict)
    add_float_features(dataset_row, feature_dict, has_labels)
    byte_type = dataset_row['Type'].encode()
    list_val = tf.train.BytesList(value=[byte_type])
    feature_dict['Type'] = tf.train.Feature(bytes_list=list_val)
    features_obj = tf.train.Features(feature=feature_dict)
    return tf.train.Example(features=features_obj)

def create_example_spec(has_labels):
    example_spec = {}
    int_vals = ['Store', 'Dept', 'IsHoliday', 'Size']
    float_vals = ['Temperature', 'Fuel_Price', 'CPI', 'Unemployment']
    if has_labels:
        float_vals.append('Weekly_Sales')
    for feature_name in int_vals:
        example_spec[feature_name] = tf.FixedLenFeature((), tf.int64)
    for feature_name in float_vals:
        example_spec[feature_name] = tf.FixedLenFeature((), tf.float32)
    example_spec['Type'] = tf.FixedLenFeature((), tf.string)
    return example_spec

def parse_features(ser_ex, example_spec, has_labels):
    parsed_features = tf.parse_single_example(ser_ex, example_spec)
    features = {k: parsed_features[k] for k in parsed_features if k != 'Weekly_Sales'}
    if not has_labels:
        return features
    label = parsed_features['Weekly_Sales']
    return features, label

def ref_add_embedding_columns(final_dataset, feature_columns):
    embedding_features = ['Store', 'Dept']
    for feature_name in embedding_features:
        vocab_list = list(final_dataset[feature_name].unique())
        vocab_feature_col = tf.feature_column.categorical_column_with_vocabulary_list(
                feature_name, vocab_list, dtype=tf.int64)
        embedding_dim = int(len(vocab_list)**0.25)
        feature_col = tf.feature_column.embedding_column(vocab_feature_col, embedding_dim)
        feature_columns.append(feature_col)

def test_feature_columns(user_output, ref_output, num_features):
    for i in range(num_features):
        if hasattr(user_output[i], 'combiner'):
            assert user_output[i].categorical_column.key == ref_output[i].categorical_column.key
        else:
            assert user_output[i] == ref_output[i]

def add_embedding_columns(final_dataset, feature_columns):
    embedding_features = ['Store', 'Dept']
    for feature_name in embedding_features:
        vocab_list = list(final_dataset[feature_name].unique())
        vocab_feature_col = tf.feature_column.categorical_column_with_vocabulary_list(
                feature_name, vocab_list, dtype=tf.int64)
        embedding_dim = int(len(vocab_list)**0.25)
        feature_col = tf.feature_column.embedding_column(vocab_feature_col, embedding_dim)
        feature_columns.append(feature_col)


Learn about the embedding feature columns for the ML model's input layer.

What you'll learn from this course

Preliminary Data Analysis

Data Processing

Model Predictions

Embedding Columns

Chapter Goals:

A. Feature embeddings

Time to Code!