In this project, a dataset containing data on various customers’ annual spending amounts (reported in monetary units) of diverse product categories for the internal structure is analyzed. One goal of this project is to best describe the variation in the different types of customers that a wholesale distributor interacts with. Doing so would equip the distributor with insight into how to best structure their delivery service to meet the needs of each customer.

The dataset for this project can be found on the UCI Machine Learning Repository. For the purposes of this project, the features ‘Channel’ and ‘Region’ will be excluded in the analysis with the focus instead on the six product categories recorded for customers.

Data Exploration

It is important to have a good understanding the data when it comes to clustering it becomes more important that some kind of relation can be seen to identify some patterns inside data.

Let us consider 3 random columns and see what we can make out of it.

When we look at random rows and compare it to how they stand with the overall data we can see that In first row Milk, Frozen, Grocery, Delicatessen detergents_paper are above 50 percentile and Fresh being 25% indicating that they might not be using lots of fresh stuff but it’s a place where everything else is sold. Maybe it’s some kind of fast food chain selling beverages and using frozen foods a lot. Looking at 2nd-row Grocery(3) and Detergents_paper(3) has only 25 percentile in distribution and at the same time Fresh has 75%, and way ahead of mean. Frozen is in the normal mean category. It looks like it’s more of an open place selling fresh stuff more than anything like a Market or something. In the 3rd row Fresh, frozen,detergents_paper is not even in 25 percentile, this would be a differentiating factor for this. Milk and Delicatessen are between 25-50 percentile. With Grocery being above 50 percentile. This might be a cafe with some grocery stuff alongside it.

Let’s work our way through to see if our assumptions are close enough. Let’s try to see the correlation between the features for this we need to plot correlation matrix.

Detergents_paper and grocery seem to be correlated. It can be concluded by looking at the graph, and the correlation matrix is 99% which is very good to relate these two. We can observe that the data are not normally distributed, it looks like only right half of the normal distribution. With all points being skewed to one side. To normalize the data we need to transform the data using the logarithmic scaling function, then the updated data would look like this.

PCA

Now that the data has been scaled to a more normal distribution. We can now apply PCA to the good data to discover which dimensions about the data best maximize the variance of features involved. In addition to finding these dimensions, PCA will also report the explained variance ratio of each dimension — how much variance within the data is explained by that dimension alone. Note that a component (dimension) from PCA can be considered a new “feature” of the space, however, it is a composition of the original features present in the data.

Using pythons inbuilt PCA algorithm when we try to apply PCA

To test any system on how it works we need some metrics to judge for this particular example following metrics are used.

Consider a system where choice is randomly made at each step, i.e. the car goes in random directions at each step without following any rules. The results would be as follows.

A 10-Trial Rolling means experiment has been conducted 10 times to remove any chance that system might give biased results. As expected the system fails miserably both safety and reliability are failed.

States / Features used to make decisions

1. GPS direction (left,right,straight)
2. Signal Light ( Red, Green, None)
3. Oncoming traffic ( left,right, straight,None)
   • The intended direction of travel for a vehicle across the intersection from the Smartcab. Returns None if no vehicle is present.
4. Right sensor
   •  The intended direction of travel for a vehicle to the Smartcab‘s right. Returns None if no vehicle is present.
   • We only need to consider if the vehicle to the right is moving forward, in all other cases the cab will have right of way according to US driving rules.

If we use the above features total combination would be 3 * 2 * 4 * 2 = 48 states so if the system can learn all these state information correctly then it would be able to drive perfectly.

Q Learning

The concept of Q-Learning is fairly straightforward: For every state the agent visits, create an entry in the Q-table for all state-action pairs available. Then, when the agent encounters a state and performs an action, update the Q-value associated with that state-action pair based on the reward received and the iterative update rule implemented. Of course, additional benefits come from Q-Learning, such that we can have the agent choose the best action for each state based on the Q-values of each state-action pair possible.

This is how the Q-table will be formed. Each state will be a key of the self.Q dictionary, and each value will then be another dictionary that holds the action and Q-value. Here is an example:

{ 'state-1': { 
    'action-1' : Qvalue-1,
    'action-2' : Qvalue-2,
     ...
   },
  'state-2': {
    'action-1' : Qvalue-1,
     ...
   },
   ...
}

The agent is expected to learn from its behavior eventually, it is also important that agent acts based on what it has learned so far. This balance can be made using decaying epsilon factor

Following are the results with q learning method rather than random choices.

As we can see the system is more reliable now and how the bad actions have reduced, but the system isn’t ready yet it is able to reach the destination but not without avoiding accidents. This indicates that it needs to learn more in order to achieve that I modified the epsilon such that model learns more slowly.

epsilon = 1/(t*t) , t-number of trails

After modifying the epsilon values the new results are more reliable as shown below.

To ensure the robustness number of trials also have been increased to 300 instead of 200 and you can observe how exploration factor decreases after some time and system tends to act based on state information it has learned from previous experiments.

Full details of the code along with python simulator code is present on my github page.

This  simple python code would do the Normalization for us

def normalize(x):
    return (255.-x)/255.
# To increase speed vectorize the method
normalize = np.vectorize(normalize)

Constructing Tensors with input data

In order to user TensorFlow, we need to first convert data from arrays/series to Tensor Flow objects, I’ll be using the following function to convert the input.

import tensorflow as tf

def neural_net_image_input(image_shape):
    """
    Return a Tensor for a batch of image input
    : image_shape: Shape of the images
    : return: Tensor for image input.
    """
    a = list(image_shape)
    a = [None] + a
    return tf.placeholder(tf.float32,shape = a, name='x')

placeholder is a variable which can be used to store different kinds of data, similarly, we should also create.

Why Convolution?

Convolution has a lot of success with images rather than direct Neural Networks.

In a conventional Neural Network the whole image would be treated as a feature, but in the convolution, neural network Images of different sizes are considered at each step this way objects located anywhere inside the image can be trained. Consider classifying if an image has a cat or not if we use conventional Neural Network a cat in the top right corner would be different from a cat in the bottom left, this would mean we need a lot of variations of training data in order for our system to work properly.

Whereas when we consider smaller blocks we make sure that properties from all blocks are considered when we consider the above image which has different stages and at each stage, we further reduce the size of sliding window and each stage gives different properties of the image, like one level considered the texture other edges and other objects as a whole.

def conv_net(x, keep_prob):
    """
    Create a convolutional neural network model
    : x: Placeholder tensor that holds image data.
    : keep_prob: Placeholder tensor that hold dropout keep probability.
    : return: Tensor that represents logits
    """
   
    #    Play around with different number of outputs, kernel size and stride
    # Function Definition from Above:
    #    conv2d_maxpool(x_tensor, conv_num_outputs, conv_ksize, conv_strides, pool_ksize, pool_strides)

    cv1 = conv2d_maxpool(x, 64, [3,3],[1,1],[2,2],[2,2] )
    cv1 = conv2d_maxpool(cv1, 128, [3,3],[1,1],[2,2],[2,2] )
    cv1 = conv2d_maxpool(cv1, 256, [3,3],[1,1],[2,2],[2,2] )
    
    # Apply a Flatten Layer
    # Function Definition from Above:
    #   flatten(x_tensor)
    cv1 = flatten(cv1)

    # Apply 1, 2, or 3 Fully Connected Layers
    #    Play around with different number of outputs
    # Function Definition from Above:
    #   fully_conn(x_tensor, num_outputs)
    num_outputs = 512
    
    cv1 = fully_conn(cv1,num_outputs)
    cv1 = tf.nn.dropout(cv1,keep_prob)
    cv1 = fully_conn(cv1,256)
    cv1 = fully_conn(cv1,128)
    
    # Apply an Output Layer
    #    Set this to the number of classes
    # Function Definition from Above:
    #   output(x_tensor, num_outputs)
    cv1 = output(cv1, 10)
    
    
    return cv1

Understanding Accelerometer :-

The accelerometer has 3 axes and is contained inside the watch, it is oriented as shown below, to further understand how accelerometer works following working of Gyroscope from this post of my blog, working of accelerometer would be similar to this.

The current method for ensuring above gestures are performed needs a Smart Watch (Either Android or IOS, Consisting of Accelerometer and Gyroscope), and an android phone which has Bluetooth and WIFI.

The existing model is tested on LG watch Urbane (An Android smartwatch) which can be connected to any android phone, the data is uploaded to a database named Fire Base: Google’s online database. All the required computations required to predict the gesture are done inside the watch.

Using Android Studio environment to implement, a Decision Tree approach which has co-variance, standard deviation and root mean square of accelerometer and gyroscope values as qualifiers is used.

Algorithm

when we are performing different hand gestures, the values of accelerometer changes according to the movement of the watch. During one of the gestures, which involves rotating around the thumb ( Number 6 in Fig 1), when the dominant hand has the watch Z axis is oriented perpendicular to the wrist, the y-axis is oriented along the arm, and X-axis is perpendicular to y. X axis is where the majority of the movement happens.

So the majority of the change should be in along this axis when we consider a sample data from training and plot the graph comparing X-axis acceleration with all other gestures it is as indicated below.

When we look at corresponding values when comparing gesture 6 in Figure 1 to remaining gestures, the difference is significant.

The root mean square of X-axis acceleration thus can be used as a feature to determine one of the gestures. Similarly when we consider remaining axis in accelerometer, and gyroscope, and upon collection many data sets and using decision tree technique, the algorithm is able to differentiate different gestures.

In this project, I analyzed which factors affect customers orders, and predict what orders would be reordered next.

The dataset can be downloaded here.

Understanding the size of each department.

As we can see produce is most consumed in terms of orders placed followed by dairy and beverages. Let us see which department products are reordered more, which would be ideal for us to predict users next orders.

Although produce had a major share of orders, dairy was most reordered and personal care was least reordered. When we see a number of options the user has in each department i.e. the size of each department, and interesting relation could be made.

We can see “personal care” which has a lot of options to choose from so user tends to try new things every time, a similar pattern with snacks and pantry. It also would depend on kind of department we are dealing with. But the ideal size of the department should be less than beverages in order to make sure we can predict re-order rate happily.

The dataset for this project originates from the UCI Machine Learning Repository. The Boston housing data was collected in 1978 and each of the 506 entries represent aggregated data about 14 features for homes from various suburbs in Boston, Massachusetts.

I’m using three features from the Boston housing dataset: ‘RM’,’LSTAT’, and ‘PTRATIO’. For each data point (neighborhood):

• ‘RM’ is the average number of rooms among homes in the neighborhood.
• ‘LSTAT’ is the percentage of homeowners in the neighborhood considered “lower class” (working poor).
• ‘PTRATIO’ is the ratio of students to teachers in primary and secondary schools in the neighborhood.

Preprocessing:- The following preprocessing steps have been made to the dataset:

• 16 data points have a ‘MEDV’ value of 50.0. These data points likely contain missing or censored values and have been removed.
• 1 data point has an ‘RM’ value of 8.78. This data point can be considered an outlier and has been removed.
• The features ‘RM’,’LSTAT’,’PTRATIO’, and ‘MEDV’ are essential. The remaining non-relevant features have been excluded.
• The feature ‘MEDV’ has been multiplicatively scaled to account for 35 years of market inflation.

The Statistics for Boston housing dataset:

Minimum price: $105,000.00
Maximum price: $1,024,800.00
Mean price: $454,342.94
Median price $438,900.00
Standard deviation of prices: $165,171.13

Implementation: Define a Performance Metric

It is difficult to measure the quality of a given model without quantifying its performance over training and testing. This is typically done using some type of performance metric, whether it is through calculating some type of error, the goodness of fit, or some other useful measurement. For this project, I calculated the coefficient of determination, R², to quantify your model’s performance. The coefficient of determination for a model is a useful statistic in regression analysis, as it often describes how “good” that model is at making predictions.

The values for R² range from 0 to 1, which captures the percentage of squared correlation between the predicted and actual values of the target variable. A model with an R² of 0 is no better than a model that always predicts the mean of the target variable, whereas a model with an R² of 1 perfectly predicts the target variable. Any value between 0 and 1 indicates what percentage of the target variable, using this model, can be explained by the features. A model can be given a negative R² as well, which indicates that the model is arbitrarily worse than one that always predicts the mean of the target variable.

After implementing a decision tree and varying depth the results are as follows.

Let’s analyze max_depth= 10, The training data has a good accuracy, but the testing data is failing very badly. The variance is very high in this case.

What happens to the score of the training curve and testing curve as more training points are added?

Since variance is high here it means that the model is overfitting, so if we add more data to it would certainly help in preventing overfitting and might decrease variance ( we could also decrease features, but in this, case we already have very few features so that doesn’t seem ideaThe testing curve would be depended on how training curve is trained, so if we increase the number of points in training data and model doesn’t overfit then testing curve would improve its performance.

We can conclude this based on the learning curves

depth = 1: High Bias, since we can see that training score is pretty bad, that means it’s underfitting the curve. depth = 10: High variance, the graph shows that the training score is pretty good, but the testing score is very poor indicating the model has overfitted and is failing to predict properly. Looking at the Complexity curves we can see that when max_depth = 4 the training and validation scores are pretty good, as it increases the accuracy drops down for validation although it fits training perfectly it’s an over fit.

Best model

Best model can be obtained by tuning parameters which can be done using Hyper Parameter tuning, which is obtained by shuffling all the parameters, this can be done using GridsearchCv in python. An R^2 score of 0.9 has been achieved and which could be used to safely predict the housing prices.