Amazon Machine Learning Project: Sales Data in Python

Machine studying initiatives work finest once they join principle to actual enterprise outcomes. In e-commerce, which means higher income, smoother operations, and happier prospects, all pushed by knowledge. By working with practical datasets, practitioners learn the way fashions flip patterns into choices that really matter.

This text walks via a full machine studying workflow utilizing an Amazon gross sales dataset, from downside framing to a submission prepared prediction file. It provides learners a transparent view of how fashions flip insights into enterprise worth, on this article.

Understanding the issue assertion

Earlier than continuing with the coding half, it’s important to look as much as the issue assertion and perceive it. The dataset consists of Amazon e-commerce transactions which present genuine on-line purchasing patterns from precise on-line retail actions. 

The first goal of this mission is to foretell order outcomes and analyze revenue-driving elements utilizing structured transactional knowledge. The event course of requires us to create a supervised machine studying mannequin which learns from previous transaction knowledge to forecast outcomes on new take a look at datasets. 

Key Enterprise Questions Addressed

Which elements affect the ultimate order quantity? 

How do reductions, taxes, and transport prices have an effect on income? 

Can we predict order standing or whole transaction worth precisely? 

What insights can companies extract to enhance gross sales efficiency? 

In regards to the dataset

The dataset consists of 100,000 e-commerce transactions which observe Amazon’s transaction model and embody 20 organized knowledge fields. The artificial knowledge reveals genuine buyer conduct patterns along with precise enterprise operation processes. 

The information set comprises details about worth modifications throughout totally different product sorts and buyer age teams and their cost choices and their order monitoring statuses. The information set comprises properties which make it appropriate for machine studying and analytical work and dashboard improvement. 

Load important Python Libraries

To work on the mannequin improvement course of first it requires important Python library imports to deal with knowledge work. The mix of Pandas and NumPy will allow us to carry out each knowledge dealing with duties and mathematical calculations. Our visualization wants might be fulfilled via using Matplotlib and Seaborn. Scikit-learn supplies capabilities for preprocessing and ML algorithms. Right here is the standard set of imports: 

import pandas as pd 
import numpy as np 
import matplotlib.pyplot as plt 
import seaborn as sns 
from sklearn.model_selection import train_test_split 
from sklearn.preprocessing import LabelEncoder 
from sklearn.ensemble import RandomForestClassifier 
from sklearn.metrics import classification_report, accuracy_score

The libraries allow us to carry out 4 major actions which embody loading CSV knowledge, executing knowledge cleaning and transformation processes, utilizing charts for pattern evaluation, and constructing a classification mannequin. 

Load the datasets

We are going to import knowledge right into a Pandas dataFrame after we full the environment setup. The uncooked CSV file undergoes transformation via this step into an analyzable and programmatically manipulatable format. 

df = pd.read_csv(“Amazon.csv”) 

print(“Form:”, df.form)

Form: (100000, 20) 

We have to verify the info construction after loading as a result of we’d like affirmation that it was imported appropriately. The dataset dimensions are checked whereas we seek for any preliminary issues that have an effect on knowledge high quality. 

print(“nMissing values:n”, df.isna().sum()) 

df.head()

Lacking values: 

OrderID      0 
OrderDate    0 
CustomerID   0 
CustomerName 0 
ProductID    0 
ProductName  0 
Class     0 
Model        0 
Amount     0 
UnitPrice    0 
Low cost     0 
Tax          0 
ShippingCost 0 
TotalAmount  0 
PaymentMethod 0 
OrderStatus  0 
Metropolis         0 
State        0 
Nation      0 
SellerID     0 

dtype: int64

Knowledge Preprocessing

1. Decomposing Date Options 

Fashions can not do math on a string like “2023-01-31”. The 2 components “Month: 1” and “Yr: 2023” create important numerical attributes which might detect seasonal patterns together with vacation gross sales.  

df[“OrderDate”] = pd.to_datetime(df[“OrderDate”], errors=”coerce”) 
df[“OrderYear”] = df[“OrderDate”].dt.12 months
df[“OrderMonth”] = df[“OrderDate”].dt.month 
df[“OrderDay”] = df[“OrderDate”].dt.day

We’ve efficiently extracted three new options: OrderYear, OrderMonth, and OrderDay. The mannequin learns patterns which present “December brings greater gross sales” and “weekend days produce elevated gross sales”.  

2. Dropping Irrelevant Options 

The mannequin requires solely particular columns. The distinctive ID identifiers (OrderID, CustomerID) don’t present predictive info which ends up in mannequin coaching knowledge memorization via overfitting. We additionally dropped OrderDate since we simply extracted its helpful components.  

cols_to_drop = [ 
   “OrderID”, 
   “CustomerID”, 
   “CustomerName”, 
   “ProductID”, 
   “ProductName”, 
   “SellerID”, 
   “OrderDate”,   # already decomposed 
] 

df = df.drop(columns=cols_to_drop)

The dataframe now comprises solely important components which create predictive worth. The mannequin now detects frequent patterns via product class and tax charges whereas we take away particular buyer ID info which might create “leakage” and noise. 

3. Dealing with Lacking Values 

The preliminary verify confirmed no lacking values however we’d like our methods to deal with real-world circumstances. The mannequin will crash if upcoming knowledge comprises lacking info. We implement a security web by filling gaps with the median (for numbers) or “Unknown” (for textual content). 

print(“nMissing values after transformations:n”, df.isna().sum())

# If any lacking values in numeric columns, fill with median
numeric_cols = df.select_dtypes(embody=[“int64”, “float64”]).columns.tolist()

for col in numeric_cols:
if df[col].isna().sum() > 0:
df[col] = df[col].fillna(df[col].median())

Class 0
Model 0
Amount 0
UnitPrice 0
Low cost 0
Tax 0
ShippingCost 0
TotalAmount 0
PaymentMethod 0
OrderStatus 0
Metropolis 0
State 0
Nation 0
OrderYear 0
OrderMonth 0
OrderDay 0
dtype: int64

# For categorical columns, fill with “Unknown”
categorical_cols = df.select_dtypes(embody=[“object”]).columns.tolist()

for col in categorical_cols:
df[col] = df[col].fillna(“Unknown”)

print(“nFinal dtypes after cleansing:n”)

Class object
Model object
Amount int64
UnitPrice float64
Low cost float64
Tax float64
ShippingCost float64
TotalAmount float64
PaymentMethod object
OrderStatus object
Metropolis object
State object
Nation object
OrderYear int32
OrderMonth int32
OrderDay int32
dtype: object

The pipeline is now bulletproof. The ultimate dtypes verify confirms that our knowledge is absolutely prepped: all categorical variables are objects (prepared for encoding) and all numerical variables are int32 or float64 (prepared for scaling). 

Exploratory knowledge evaluation (EDA)

The Knowledge Evaluation course of begins with our preliminary examination of information which we deal with as an interview course of to be taught concerning the knowledge’s traits. Our investigation contains three major components which we use to establish patterns and outliers and study distributional traits. 

Statistical Abstract: We have to perceive the mathematical properties of our numerical columns. Are the costs affordable? Are there any unfavourable values that exist in prohibited areas? 

# 2. Fundamental Knowledge Understanding / EDA (light-weight) 
print(“nDescriptive stats (numeric):n”) 

df.describe()

The descriptive statistics desk supplies essential context: 

Amount: The measurement goes from 1 to five with three as its common worth. Shoppers who store at retail shops have a tendency to indicate this conduct which companies use for his or her B2B purchases. 

UnitPrice: The worth ranges between 5.00 and 599.99 which reveals that there exists a number of product tiers. 

The goal variable TotalAmount reveals extensive variance as a result of its commonplace deviation approaches 724 which suggests our mannequin should keep its capability to course of transactions starting from small purchases to most purchases of 3534.98. 

Categorical Evaluation 

We have to know the cardinality (variety of distinctive values) of our categorical options. The mannequin experiences bloat and overfitting points as a result of excessive cardinality happens when there are millions of distinctive cities within the dataset. 

print(“nUnique values in some categorical columns:”)

for col in [“Category”, “Brand”, “PaymentMethod”, “OrderStatus”, “Country”]:
print(f”{col}: {df[col].nunique()} distinctive”)

Distinctive values in some categorical columns: 

Class: 6 distinctive 
Model: 10 distinctive 
PaymentMethod: 6 distinctive 
OrderStatus: 5 distinctive 
Nation: 5 distinctive

Visualizing the Goal Distribution 

The histogram reveals the frequency of various transaction quantities. A easy curve (KDE) permits us to see the density. With the curve being barely proper skewed subsequently tree-based fashions like Random Forest deal with very nicely. 

sns.histplot(df[“TotalAmount”], kde=True)
plt.title(“TotalAmount distribution”)
plt.present()

The TotalAmount visualization permits us to find out whether or not the info reveals any skewed distribution. The information requires a Log Transformation when it reveals excessive skewness with only some high-priced merchandise and quite a few low-cost gadgets. 

Function Engineering

Function engineering develops new variables via the method of reworking current variables to spice up mannequin efficiency. In Supervised Studying, we should explicitly inform the mannequin what to foretell (y) and what knowledge to make use of to make that prediction (X). 

target_column = “TotalAmount”

X = df.drop(columns=[target_column])
y = df[target_column]

numeric_features = X.select_dtypes(embody=[“int64”, “float64”]).columns.tolist()
categorical_features = X.select_dtypes(embody=[“object”]).columns.tolist()

print(“nNumeric options:”, numeric_features)
print(“Categorical options:”, categorical_features)

Splitting the practice and take a look at knowledge 

The mannequin analysis course of requires separate knowledge as a result of coaching knowledge can’t be used for evaluation, which parallels the observe of offering college students with examination solutions earlier than the take a look at. The information distribution consists of two components: Coaching Set which serves instructional functions and Check Set which verifies outcomes. 

X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)

print(“nTrain form:”, X_train.form, “Check form:”, X_test.form)

Right here now we have used the 80-20 % rule, which suggests randomly out of all the info now we have 80% might be used because the practice knowledge and the remainder 20% might be used to check it because the take a look at knowledge set. 

Construct Machine Studying Mannequin

Creating the ML pipeline would concerned the next processes:

1. Creating Preprocessing Pipelines 

The uncooked numbers of every measurement scale in another way as a result of they embody measurements that vary from 1 to five for Amount and from 5 to 500 for Value. The fashions obtain quicker convergence when researchers implement knowledge scaling methods. One-Scorching Encoding supplies the mandatory methodology to remodel categorical textual content into numerical format. The ColumnTransformer system permits us to use totally different transformation strategies for each column kind in our dataset. 

numeric_transformer = Pipeline(
steps=[
(“scaler”, StandardScaler())
]
)

categorical_transformer = Pipeline(
steps=[
(“onehot”, OneHotEncoder(handle_unknown=”ignore”))
]
)

preprocessor = ColumnTransformer(
transformers=[
(“num”, numeric_transformer, numeric_features),
(“cat”, categorical_transformer, categorical_features),
]
)

2. Defining the Random Forest Mannequin 

We’ve chosen the Random Forest Regressor for this mission. The ensemble methodology constructs a number of resolution bushes which it makes use of to compute forecast outcomes via prediction averaging. The system demonstrates robust robustness towards overfitting issues whereas it excels at managing non-linear connections between variables. 

mannequin = RandomForestRegressor(
n_estimators=200,
max_depth=None,
random_state=42,
n_jobs=-1
)

# Full pipeline
regressor = Pipeline(
steps=[
(“preprocessor”, preprocessor),
(“model”, model),
]
)

We created the mannequin with n_estimators=200 to construct 200 resolution bushes and n_jobs=-1 to allow all CPU cores for speedier mannequin improvement. The most effective observe for this implementation requires customers to create a single Pipeline object which mixes the preprocessor and mannequin to deal with their whole operational course of as one unit. 

3. Coaching the Mannequin 

This stage represents the first studying course of. The pipeline processes coaching knowledge via transformation steps earlier than it makes use of the Random Forest mannequin on the transformed knowledge. 

regressor.match(X_train, y_train) 

print(“nModel coaching full.”)

The mannequin now understands how totally different enter variables (Class Value Tax and many others.) relate to the output variable (Complete Quantity). 

Make predictions on the take a look at dataset

Now we take a look at the mannequin on the take a look at knowledge (i.e, 20,000 “unseen” data). The mannequin efficiency evaluation makes use of statistical metrics to match its predicted outcomes (y_pred) with the precise outcomes (y_test). 

y_pred = regressor.predict(X_test)

mae = mean_absolute_error(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred)

print(“nTest metrics:”)
print(“MAE :”, mae)
print(“MSE :”, mse)
print(“RMSE:”, rmse)
print(“R2 :”, r2)

Check metrics: 

MAE : 3.886121525000014 
MSE : 41.06268576375389 
RMSE: 6.408017303640331 
R2  : 0.99992116450905

This signifies: 

The Imply Absolute Error (MAE) worth stands at roughly 3.88. Our prediction reveals a median error of $3.88. 

The R2 Rating worth stands at roughly 0.9999. That is close to good. The impartial variables (Value, Tax, Delivery) nearly completely account for the Complete Quantity in line with this outcome. The Complete components in artificial monetary knowledge follows the equation Complete = Value * Qty + Tax + Delivery – Low cost. 

Put together submission file

The system requires contributors to current their predictions in line with predetermined output specs which should not be altered.  

submission = pd.DataFrame({ 
   “OrderID”: df.loc[X_test.index, “OrderID”], 
   “PredictedTotalAmount”: y_pred 
}) 

submission.to_csv(“submission.csv”, index=False)

The analysis system accepts this file for direct submission whereas stakeholders also can obtain it. 

Conclusion

This machine studying mission demonstrates its full course of via demonstration of uncooked e-commerce transaction knowledge transformation into helpful predictive outcomes. The structured workflow methodology lets you handle precise datasets with full assurance and understanding of the method. The success of the mission relies on the 5 steps which embody preprocessing and EDA and have engineering and modeling. 

The mission helps in growing your machine studying capabilities whereas coaching you to deal with actual work conditions. The pipeline wants further optimization work earlier than it will probably operate as a suggestion system with superior fashions or deep studying methods. 

Steadily Requested Questions