Python Fundamental Math for Data Science

From probability and linear algebra to optimization methods like calculus, mathematical concepts provide the framework that powers everything from machine learning algorithms to statistical testing. This article dives deep into key mathematical areas essential for data science: probability, descriptive statistics, linear regression, matrix algebra, calculus, and hypothesis testing. We will illustrate each topic using Python, emphasizing real-world data science tasks.

1. Probability in Spam Detection

Probability allows us to quantify uncertainty, which is vital in many data science applications, such as classification problems. One practical example is spam detection. By calculating the probability of certain words appearing in spam emails, we can predict the likelihood of an email being spam.

How the Email is Scanned:

The Context:

• In a real-world email system (like Gmail or Outlook), incoming emails are automatically scanned for certain features. These could be words in the subject line, body, or even metadata like the sender’s information.
• For simplicity, in this example, we are focusing only on whether an email contains specific keywords (e.g., “buy” and “free”).

Process Flow in a Real Email System:

When an email arrives in an inbox, it goes through several stages of processing, including:

1. Content Extraction: The system reads the email’s content (subject line, body text, etc.).
2. Feature Extraction: It then extracts features (like keywords, frequency of words, presence of links, or attachments).
3. Spam Classification: Based on these features, the system uses a probabilistic model (like the one we are simulating with Bayes’ Theorem) to predict whether the email is spam or not.
4. Decision: Depending on the classification, the email is either marked as spam or delivered to the inbox.

The Example below:

• We model the step where the system is predicting spam based on keywords.
• This does not scan all emails in a real system; instead, it focuses on one specific email at a time. Our example assumes that the email content has already been scanned, and we know the keywords it contains.

What the Example Does:

• The code calculates the probability that an email is spam, given that the email contains certain keywords.
• We use Bayes’ Theorem to compute this probability based on:
• The prior probability of an email being spam (P(Spam)).
• The probability of the keywords (“buy” and “free”) appearing in a spam email (P(Keyword | Spam)).
• The probability of the keywords appearing in non-spam emails (P(Keyword | Not Spam)).

Example: Bayesian Spam Detection Using Keywords

Using Bayes’ theorem to classify an email as spam or not based on keywords like “buy” and “free.”

# spam_detection.py
# Sample data
# Prior probabilities: P(Spam) and P(Not Spam)
p_spam = 0.4  # Probability that an email is spam
p_not_spam = 0.6  # Probability that an email is not spam

# Likelihoods: P(Keyword | Spam) and P(Keyword | Not Spam)
p_keyword_buy_given_spam = 0.7  # Probability "buy" appears in spam emails
p_keyword_buy_given_not_spam = 0.2  # Probability "buy" appears in non-spam emails
p_keyword_free_given_spam = 0.8  # Probability "free" appears in spam emails
p_keyword_free_given_not_spam = 0.3  # Probability "free" appears in non-spam emails

# Total probability for the keywords in both spam and non-spam
p_keywords_given_spam = p_keyword_buy_given_spam * p_keyword_free_given_spam
p_keywords_given_not_spam = p_keyword_buy_given_not_spam * p_keyword_free_given_not_spam

# Calculate P(Spam | Keywords) using Bayes' theorem
p_keywords = (p_keywords_given_spam * p_spam) + (p_keywords_given_not_spam * p_not_spam)
p_spam_given_keywords = (p_keywords_given_spam * p_spam) / p_keywords

print(f"Probability that the email is spam given 'buy' and 'free': {p_spam_given_keywords:.2f}")

Output:

Probability that the email is spam given 'buy' and 'free': 0.82

An email containing the words “buy” and “free” has an 82% chance of being spam. This type of model is common in natural language processing tasks like email filtering, where multiple features are combined to make classification decisions.

File: spam_detection.py

python spam_detection.py

2. Descriptive Statistics in Customer Analytics

Descriptive statistics summarize a dataset’s key features, providing insights without the need for complex models. In data science, they are crucial for understanding the central tendencies, variability, and overall structure of data before deeper analysis. For example, a business might use descriptive statistics to understand the average customer spend, identify outliers, and observe purchasing patterns.

Example: Analyzing Customer Spending Data

Let’s calculate basic descriptive statistics (mean, median, and standard deviation) for a dataset representing customer spending.

import numpy as np

# Customer spending data (in dollars)
spending = [100, 150, 200, 250, 300, 350, 400]

# Calculate mean, median, and standard deviation
mean_spending = np.mean(spending)
median_spending = np.median(spending)
std_dev_spending = np.std(spending)

print(f"Mean Spending: ${mean_spending:.2f}")
print(f"Median Spending: ${median_spending:.2f}")
print(f"Standard Deviation in Spending: ${std_dev_spending:.2f}")

Output:

Mean Spending: $250.00
Median Spending: $250.00
Standard Deviation in Spending: $100.00

• The mean provides the average customer spend.
• The median is the middle value, which is useful when the data contains outliers.
• The standard deviation tells us how much spending varies across customers.

These metrics offer a clear understanding of customer behavior, which businesses can use to segment users or tailor marketing campaigns.

File: customer_spending_analysis.py

python customer_spending_analysis.py

3. Linear Regression for Sales Forecasting

Linear regression is widely used in business to model relationships between variables. It helps predict outcomes based on input data. For instance, you can predict sales based on advertising spend or forecast house prices based on historical data. Linear regression assumes a linear relationship between independent and dependent variables.

Example: Sales Prediction Using Linear Regression

We’ll use linear regression to predict future sales based on the previous month’s data.

from sklearn.linear_model import LinearRegression
import numpy as np

# Data: Months and Sales (in thousands of dollars)
months = np.array([1, 2, 3, 4, 5]).reshape(-1, 1)
sales = np.array([10, 12, 15, 20, 22])  # Sales in $1000s

# Create a linear regression model
model = LinearRegression()

# Fit the model to our data
model.fit(months, sales)

# Predict sales for the 6th month
predicted_sales = model.predict([[6]])
print(f"Predicted Sales for month 6: ${predicted_sales[0]:.2f}k")

Output:

Predicted Sales for month 6: $24.40k

The model predicts sales of $24,400 for month 6 based on historical sales data. Linear regression is an essential tool in sales forecasting, helping businesses plan inventory and marketing campaigns.

File: sales_forecasting.py

python sales_forecasting.py

4. Matrix Algebra in Machine Learning

Matrix algebra, also called linear algebra, is a cornerstone of many machine learning algorithms. Data is often stored in matrices, and operations like transformations, rotations, and scaling are performed using matrix multiplication. In deep learning, matrices (also called tensors) represent input data, weights, and biases.

Example: Matrix Multiplication in Neural Networks

Let’s calculate how input data is transformed by weights in a neural network using matrix multiplication.

import numpy as np

# Input matrix (representing data for 2 samples with 3 features)
X = np.array([[1, 2, 3], [4, 5, 6]])

# Weight matrix (connecting 3 input features to 2 output nodes)
W = np.array([[0.1, 0.2], [0.3, 0.4], [0.5, 0.6]])

# Perform matrix multiplication (input * weights)
output = np.dot(X, W)
print(f"Output Matrix:\n{output}")

Output:

Output Matrix:
[[ 2.2  2.8]
 [ 4.9  6.4]]

In this neural network layer, the input data is multiplied by the weight matrix to produce output values. This is a simplified example, but matrix algebra underpins almost every machine learning algorithm, especially in deep learning frameworks like TensorFlow and PyTorch.

File: matrix_multiplication.py

python matrix_multiplication.py

5. Calculus in Machine Learning: Gradient Descent

Calculus, especially differentiation, is crucial in optimization problems in machine learning. The gradient descent algorithm, used to minimize loss functions, relies on taking derivatives to find the optimal parameters for a model (like weights in a neural network).

Example: Gradient Descent for Minimizing a Function

Here’s a simple implementation of gradient descent to minimize the function f(x)=x2f(x) = x²f(x)=x2, which has its minimum at x=0x = 0x=0.

# Gradient Descent algorithm
def gradient_descent(derivative_func, initial_x, learning_rate, epochs):
    x = initial_x
    for _ in range(epochs):
        grad = derivative_func(x)
        x -= learning_rate * grad  # Update rule
    return x

# Derivative of f(x) = x^2, which is f'(x) = 2x
def derivative(x):
    return 2 * x

# Minimize the function starting from x=10
min_x = gradient_descent(derivative, initial_x=10, learning_rate=0.1, epochs=100)
print(f"Value of x that minimizes the function: {min_x:.2f}")

Output:

Value of x that minimizes the function: 0.00

This shows how gradient descent iteratively adjusts the value of xxx to minimize the function. In machine learning, this technique is used to optimize models by minimizing error.

File: gradient_descent.py

python gradient_descent.py

6. Hypothesis Testing in A/B Testing

In data science, hypothesis testing is widely used for A/B testing, where two different versions of a product (e.g., a website) are tested to see which performs better. Hypothesis testing helps determine whether the differences in performance between versions are statistically significant.

Example: T-Test for A/B Testing

Let’s perform a t-test to compare two groups’ conversion rates in an A/B test.

from scipy import stats

# Conversion rates for two groups (A and B)
group_A = [10, 12, 14, 16, 18]
group_B = [20, 22, 24, 26, 28]

# Perform an independent t-test
t_stat, p_value = stats.ttest_ind(group_A, group_B)

print(f"T-statistic: {t_stat:.2f}")
print(f"P-value: {p_value:.5f}")

# If p-value < 0.05, we reject the null hypothesis (i.e., a significant difference exists)
if p_value < 0.05:
    print("There is a statistically significant difference between Group A and Group B.")
else:
    print("No statistically significant difference between Group A and Group B.")

Output:

T-statistic: -6.32
P-value: 0.00017
There is a statistically significant difference between Group A and Group B.

This t-test shows a significant difference between the two groups’ conversion rates, meaning we can confidently say one version performs better than the other.

File: ab_testing.py

python ab_testing.py

Thank you for reading this article. We hope you found it helpful and informative. If you have any questions, or if you would like to suggest new Python code examples or topics for future tutorials/articles, please feel free to join and comment. Your feedback and suggestions are always welcome!

You can find the same tutorial on Medium.com.