Example: Neural Network on Customer Purchase Protection

Real-Life Example: Customer Purchase Prediction

1. Define the Problem:
   • We want to predict whether a customer will make a purchase (0 for no, 1 for yes) based on three features:
     1. Browsing Time: Time spent on the website.
     2. Number of Pages Viewed: Pages viewed during the visit.
     3. Previous Purchase History: Whether the customer has made a previous purchase (0 for no, 1 for yes).
2. Collect and Prepare Data:
   • Let’s create a simple dataset for illustration.

Dataset

• Inputs (X):
  • Each row represents a customer.
  • Each column represents a feature.

import numpy as np

# Input features: [Browsing Time, Number of Pages Viewed, Previous Purchase History]
X = np.array([[5, 15, 0],
              [20, 25, 1],
              [10, 20, 0],
              [25, 30, 1]])

Outputs (y):

• Each row represents the target output (purchase or not).

# Output labels: [Purchase (1) or Not (0)]
y = np.array([[0],
              [1],
              [0],
              [1]])

Step-by-Step Implementation

Step 1: Define the Neural Network Structure

input_size = X.shape[1]  # Number of input features (3)
hidden_size = 4  # Number of neurons in the hidden layer
output_size = y.shape[1]  # Number of output neurons (1)

Step 2: Initialize Weights and Biases

def initialize_parameters(input_size, hidden_size, output_size):
    np.random.seed(1)  # Seed for reproducibility
    W1 = np.random.randn(input_size, hidden_size) * 0.01
    b1 = np.zeros((1, hidden_size))
    W2 = np.random.randn(hidden_size, output_size) * 0.01
    b2 = np.zeros((1, output_size))
    return W1, b1, W2, b2

Step 3: Define the Activation Function and Its Derivative

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    return x * (1 - x)

Step 4: Forward Propagation

def forward_propagation(X, W1, b1, W2, b2):
    Z1 = np.dot(X, W1) + b1
    A1 = sigmoid(Z1)
    Z2 = np.dot(A1, W2) + b2
    A2 = sigmoid(Z2)
    return Z1, A1, Z2, A2

Step 5: Backpropagation

def backpropagation(X, y, Z1, A1, Z2, A2, W1, b1, W2, b2, learning_rate):
    m = X.shape[0]
    dZ2 = A2 - y
    dW2 = np.dot(A1.T, dZ2) / m
    db2 = np.sum(dZ2, axis=0, keepdims=True) / m
    dA1 = np.dot(dZ2, W2.T)
    dZ1 = dA1 * sigmoid_derivative(A1)
    dW1 = np.dot(X.T, dZ1) / m
    db1 = np.sum(dZ1, axis=0, keepdims=True) / m

    # Update parameters
    W1 -= learning_rate * dW1
    b1 -= learning_rate * db1
    W2 -= learning_rate * dW2
    b2 -= learning_rate * db2

    return W1, b1, W2, b2

Step 6: Training the Network

def train(X, y, input_size, hidden_size, output_size, epochs, learning_rate):
    W1, b1, W2, b2 = initialize_parameters(input_size, hidden_size, output_size)

    for epoch in range(epochs):
        # Forward propagation
        Z1, A1, Z2, A2 = forward_propagation(X, W1, b1, W2, b2)
        
        # Backpropagation
        W1, b1, W2, b2 = backpropagation(X, y, Z1, A1, Z2, A2, W1, b1, W2, b2, learning_rate)
        
        # Optionally print the loss every 100 epochs
        if epoch % 100 == 0:
            loss = np.mean(np.square(y - A2))
            print(f'Epoch {epoch}, Loss: {loss}')
    
    return W1, b1, W2, b2

Step 7: Making Predictions

def predict(X, W1, b1, W2, b2):
    _, _, _, A2 = forward_propagation(X, W1, b1, W2, b2)
    return A2

# Example usage
if __name__ == "__main__":
    # Define the neural network structure
    input_size = X.shape[1]
    hidden_size = 4  # Number of neurons in the hidden layer
    output_size = y.shape[1]
    epochs = 10000
    learning_rate = 0.1

    # Train the neural network
    W1, b1, W2, b2 = train(X, y, input_size, hidden_size, output_size, epochs, learning_rate)

    # Make predictions
    predictions = predict(X, W1, b1, W2, b2)
    print("Final output after training:")
    print(predictions)

Step-by-Step Explanation

Define the Problem:

• We have 4 examples of customer behavior with 3 features each.We want to predict whether they will make a purchase based on their browsing time, number of pages viewed, and previous purchase history.

Prepare the Data:

• X represents the input features.y represents the target output (purchase or not).

Initialize Weights and Biases:

• Initialize small random values for weights (W1, W2).Initialize zeros for biases (b1, b2).

Define Activation Functions:

• Use sigmoid function for activation.Use its derivative for backpropagation.

Forward Propagation:

• Compute intermediate values (Z1, A1, Z2, A2) using current weights and biases.

Backpropagation:

• Calculate gradients of loss with respect to weights and biases.Update weights and biases using these gradients.

Training:

• Train the network for a specified number of epochs.Adjust weights and biases iteratively to minimize the loss.

Making Predictions:

• Use the trained network to make predictions on new data.

Conclusion

By following these steps, we can implement a neural network to predict customer purchases based on their behavior. The key steps include data preparation, network initialization, forward propagation, backpropagation, training, and making predictions.