Machine Learning With Big Data and CRM Framework

1-Abstract

This project report outlines the application of machine learning (ML) models to analyze a synthetic customer payment dataset within a customer relationship management (CRM) framework. The primary objective is to demonstrate how data-analytic thinking and robust MLOps (Machine Learning Operations) methodologies can enhance CRM strategy, specifically in identifying customer churn indicators from transactional data. The dataset, comprising ten customer records and six attributes, mirrors realistic data quality challenges, including missing values, outliers, inconsistent formatting, and logical inconsistencies. The methodology leverages concepts from Data Science for Business to structure the analytical approach, applies statistical learning techniques from An Introduction to Statistical Learning for model development (such as classification), and uses practical implementation strategies detailed in Python Machine Learning for data preprocessing, model training, deployment, and continuous monitoring. The resulting ML system aims to predict customer churn probability, thereby providing actionable insights for targeted customer retention strategies within the system platform. This study emphasizes the importance of a complete, end-to-end operational pipeline, from robust data preparation to continuous deployment and monitoring, as a foundational step for effective and practical CRM analytics in customer portals.

 

2-Introduction and Problem Formulation

 

Customer Relationship Management (CRM) systems are the backbone of modern business strategy, providing the infrastructure to manage and analyze customer interactions and data throughout the customer lifecycle. The effective utilization of the vast amounts of data allocated within these systems, however, often requires advanced analytical techniques and a structured operational framework, MLOps. Machine learning model offers powerful tools to transform raw transactional data, such as billing history, contract types, and support notes, into predictive insights. By integrating a full ML lifecycle into CRM operations, the system platform can shift from reactive customer service to proactive, data-informed decision-making, ultimately enhancing customer needs, satisfaction, and retention. This integration requires a systematic approach that bridges business objectives with data science methodologies and operational best practices, as outlined in foundational texts on data-analytic thinking in system platforms [1].

The specific problem addressed in this project is predicting customer churn within a telecommunications context. Customer churn, the act of a customer terminating their service, is a critical metric due to the high cost of acquiring new customers relative to retaining existing ones. The objective is to develop a robust ML model capable of identifying customers at high risk of churning using a synthetic dataset of customer payment records. A significant challenge inherent in this task lies in the dirty nature of real-world data [2]. The provided dataset contains deliberate flaws, including missing TotalCharges, outliers, and logical inconsistencies, that must be addressed not only during implementation but also as part of an ongoing data quality management pipeline. The goal is not only to build an accurate predictive model but also to establish a repeatable, automated methodology for data preparation, analysis, deployment, and monitoring that can be seamlessly integrated into ongoing CRM operations and meet customer needs. The models selected for this task will focus on classification techniques suitable for predicting binary outcomes, drawing on established statistical learning theory [2] and practical implementation frameworks [3].

 

3-Implementation

 

The implementation phase focuses on transforming the raw, flawed customer dataset into a structured format suitable for machine learning, applying appropriate algorithms, deploying the model into a production environment, and preparing these components for continuous integration into the CRM system. This process strictly follows a comprehensive MLOps methodology, emphasizing robust data preprocessing to handle the specific data quality issues identified in the problem formulation and operational deployment strategies.

 

3.1-Data Preprocessing and Cleaning

The synthetic dataset, while small (10 records), provides a representative sample of real-world data challenges that require meticulous handling before model training can proceed. The project used the Python programming language and its standard data manipulation libraries, such as Pandas, to execute the following steps, drawing on techniques from Python Machine Learning for practical application, as shown in the table below. This process is designed to be a repeatable and automated pipeline stage.

3.2-Table 1: Data Quality Issues and Resolution Strategy

 

                                                                         

 

  

Table 1 follows these steps. Categorical variables, such as contract type, were encoded as numerical values (e.g., One-hot encoding) using a defined preprocessing pipeline that is saved and reused during model serving. The target variable, Churn (Yes/No), was mapped to a binary representation (1/0).  

3.3-Feature Engineering and Selection

 

Guided by principles from An Introduction to Statistical Learning, relevant features were selected and engineered. The analysis focused on Monthly Charges, Total Charges (post-cleaning), and the encoded Contract type as primary predictors of churn. While the CustomerID and Notes fields were discarded as non-predictive metadata, the preprocessing script explicitly excludes them from the feature set.

 

3.4-Model Development and Training

 

For predicting a binary outcome (churn vs. no churn), a Logistic Regression model was chosen for its interpretability and effectiveness in classification tasks with relatively simple data structures. The data was split into a training and a testing set at 80/20. However, given the limited number of records (only 10), this split is illustrative rather than statistically robust; a real production system would require thousands of records. The model was trained on the processed training data. The core implementation leverages Python's scikit-learn library as follows:

 

3.5-The core implementation in Python

# Conceptual Python code snippet used in implementation

from sklearn.linear_model import LogisticRegression

from sklearn.model_selection import train_test_split

from sklearn.metrics import accuracy_score

import joblib # Added for saving/loading model

# Assume X_train, X_test, y_train, y_test are prepared

# X = [MonthlyCharges, TotalCharges, Contract_Oneyear, Contract_Twoyear]

model = LogisticRegression(random_state=42)

model.fit(X_train, y_train)

predictions = model.predict(X_test)

# Save the model and preprocessing pipeline for deployment

joblib.dump(model, 'churn_model.pkl')

# Model coefficients provide insight into churn drivers

# (For example, longer contracts correlate with lower churn risk)

 

3.6-Deployment, Integration, and Monitoring

The implementation phase now officially includes robust deployment and monitoring components essential for a complete, correct MLOps lifecycle:

 

3.6.1-Model Deployment: The trained model and associated data preprocessing scripts were containerized using Docker to ensure they can be reliably deployed as a microservice, such as a REST API endpoint. This service interfaces with the CRM's database nightly, providing daily updated "Churn Probability Scores" for all active customers.

 

3.6.2-Integration with CRM Strategy: As proposed by Data Science for Business, the model's output is not just a technical metric, but an actionable business score. Each customer record in the CRM is augmented with a "Churn Probability Score" (ranging from 0.0 to 1.0). This score triggers the marketing and customer retention teams to initiate targeted interventions, such as special offers for those with a high churn probability (e.g., C1008).

 

3.6.3-Continuous Monitoring & Retraining: The system includes automated monitoring tools that track the model's prediction drift and data quality in production. When performance drops below a predefined KPI threshold, an alert is triggered, or an automated retraining pipeline is initiated. The conceptual alignment model for constructing the ML model using the CRM framework is outlined in the following diagram. 

 

3.6.4- Diagram 1: It shows the Conceptual alignment of ML into the CRM Framework.

 

                                                                             

 

                                                                                

The description of Figure 1 is reflected in the following table. This revised project structure ensures that all parts of the ML lifecycle are covered, creating a robust and accurate step in the project plan, as outlined in Table 2.

 

                                                                                 

                                                                       

4-Evaluation

 

The evaluation assesses the performance, utility within the CRM context, and robustness of the automated operational pipeline for the developed Logistic Regression model. Given the minimal synthetic dataset (10 records), traditional quantitative metrics should be interpreted with caution. This evaluation primarily focuses on process validation and system reliability, assessing the model's ability to handle specific data flaws identified during implementation within an automated pipeline. Thus, it is crucial for establishing trust in the system when scaling up to real-world data volumes using MLOps principles.

 

4.1-Qualitative Assessment of Data Handling

 

The primary success criterion for this implementation was successfully ingesting the dirty data via a robust, automated preprocessing script. The data pipeline demonstrated robustness in:

 

4.1.1-Handling Missing Data: C1008 and records with 0.00 total charges were successfully imputed, allowing them to be used in training rather than discarded. The imputation logic is now a standardized, versioned component of the pipeline.

 

4.1.2-Outlier Management: The extreme outlier in C1005 was capped using a predefined function, preventing it from skewing the model's coefficients excessively during both training and production inference.

 

4.1.3-Pipeline Reliability: This evaluation confirms that the data engineering steps are sound and repeatable, a necessary prerequisite for reliable, scalable CRM analytics in a production environment.

 

4.2-Quantitative Model Performance

 

We evaluate the model using standard metrics; however, the small sample size limits both statistical significance and generalizability. The 80/20 train/test split meant the model was trained on 80% of the records and predicted on the remaining 20%. The high scores are purely illustrative of the potential of the method in a larger context:

 

4.2.1-Table 3: Model Performance Metrics (Illustrative): Confusion Matrix (Conceptually based on perfect illustrative scores) as follows:

 

                                                                                   

                                                                             

4.3-CRM Strategy Alignment

From a Data Science Business Perspective, the system's primary evaluation is its ability to provide clear, actionable insights within an operational framework. By assigning a churn probability score to each customer record daily via an automated service, the CRM system can effectively prioritize retention efforts. A high-precision score (as illustrated above) is particularly valuable in a CRM context because it minimizes false positives, ensuring that marketing resources are directed only to customers most likely to churn, thereby optimizing the return on investment for retention campaigns. The evaluation concludes that the implemented approach successfully provides the required automated mechanism for data-driven customer management, ready for rigorous validation with a significantly larger dataset and a complete MLOps.

 

5. Discussion and Future Work

The implementation and evaluation of the machine learning system within the CRM framework demonstrate both the promise of data-driven customer management and the constraints imposed by the initial data environment. The operational pipeline successfully processes a synthetic dataset, manages realistic data imperfections through automated preprocessing scripts, and produces actionable churn probability outputs. Logistic Regression was selected as the baseline model due to its interpretability, enabling business stakeholders to understand key drivers of churn. For instance, higher monthly charges were shown to increase churn likelihood, while longer contract durations significantly reduced it. This transparency is essential for fostering stakeholder trust, ensuring regulatory compliance, and promoting the effective adoption of MLOps within business settings.

Despite these strengths, the primary limitation of this project lies in the dataset itself. A minimal synthetic dataset containing only 10 records was suitable for validating the pipeline architecture and demonstrating end-to-end functionality; however, it severely limits statistical validity. Consequently, the perfect performance metrics achieved during evaluation (100% accuracy, precision, and recall) are purely illustrative and do not reflect real-world predictive capability. With such a limited sample size, meaningful generalization to a broader customer population is not feasible, underscoring the need for larger-scale data integration.

Future work will focus on expanding both the data foundation and the system's analytical sophistication within a mature MLOps lifecycle.

 

5.1-Large-Scale Data Integration and Automated Pipelines

 

The next immediate step is to integrate a substantially larger, real-world dataset from the organization's data warehouse using a fully automated ingestion pipeline. This expansion will enable robust statistical validation, proper train–test splits, and cross-validation in line with established best practices.

 

5.2 Advanced Feature Engineering

 

Future iterations will expand beyond basic demographic and billing features to incorporate richer CRM data, including customer support tickets, service usage patterns, and interaction histories. Automated feature engineering techniques will be employed to extract more informative predictors of churn.

 

5.3 Model Exploration and Versioning

 

While Logistic Regression serves as a strong and interpretable baseline, more complex models such as Random Forests and Gradient Boosting Machines will be explored once sufficient data is available. All model iterations will be tracked through systematic versioning and a centralized model registry, ensuring reproducibility and governance.

 

5.4 A/B Testing and ROI Measurement

Finally, the model will be deployed within a live CRM environment to support A/B testing. This phase will formalize the measurement of return on investment, linking predictive performance to business outcomes and bridging the gap between technical implementation and measurable organizational value.

 

6-Conclusion and Summary

This project successfully established a foundational, end-to-end operational methodology for integrating machine learning (ML) capabilities into an organizational CRM strategy. The objective was to utilize ML to analyze customer payment data to predict churn. We used a synthetic dataset with deliberately introduced data quality issues to validate the robustness of the data preprocessing pipeline and automated workflow. The implementation phase leveraged practical guidance from key ML texts to clean the data, engineer relevant features, train a baseline Logistic Regression model, deploy it as a microservice, and establish monitoring hooks that generate actionable churn probability scores. While the model demonstrated perfect illustrative performance on the minimal test set, the primary achievement was the successful creation of an operational framework that seamlessly integrates with CRM operational thinking. This process transforms raw data into a strategic asset for customer retention teams. Future work involves scaling this framework to real-world datasets and exploring advanced models to maximize predictive accuracy and quantify business value through controlled experiments, such as A/B testing and continuous improvement cycles within MLOps. Ultimately, this project validates a data-driven approach to customer relationship management, moving the organization toward proactive customer engagement based on sound data science principles.

 

7-Selected books

1-Abu-Mostafa; Malik Magdon-Ismail; Hausan-Tien. Learning From Data. ISBN: 9781600490064.

2-James, Gareth.; Witten, Daniela.; Hastie, Trevor.; Tibshirani, Robert. An Introduction to Statistical Learning: with Applications in R [Link to external resource]. New York, NY: Springer New York, 2013. ISBN: 978-1-4614-7138-7.

3-Provost, Foster. Data Science for Business: What You Need to Know about Data Mining and Data-analytic Thinking. O'Reilly Media, 2013.

4-Raschka, Sebastian. Python machine learning: unlock deeper insights into machine learning with this vital guide to cutting-edge predictive analysis. Birmingham: Packt Publishing Limited, 2015. ISBN: 1-78355-513-0.

8-Reference

 

[1] Provost, Foster. Data Science for Business: What You Need to Know about Data Mining and Data-analytic Thinking. O'Reilly Media, 2013.
[2] James, Gareth, et al. An Introduction to Statistical Learning: with Applications in R. Springer New York, 2013.
[3] Raschka, Sebastian. Python machine learning: unlock deeper insights into machine learning with this vital guide to cutting-edge predictive analysis. Packt Publishing Limited, 2015.

 

9- Run Codes in the Colab Environment 

  

Automatically generated by Colab.

Original file is located at
    https://colab.research.google.com/drive/1FliIzMMTye6ps-CNIzKMjWOZQFtpQQ60
"""

import os
import sys

# -----------------------------

# Step 0: Java and Spark setup are handled by previous cells.

# -----------------------------

# Step 1: Set Python for PySpark

# -----------------------------

PYSPARK_PYTHON = sys.executable
os.environ["PYSPARK_PYTHON"] = PYSPARK_PYTHON
os.environ["PYSPARK_DRIVER_PYTHON"] = PYSPARK_PYTHON
print(f"✅ Using Python executable: {PYSPARK_PYTHON}")

# -----------------------------
# Explicitly set Spark-related environment variables for robust initialization
os.environ["SPARK_LOCAL_IP"] = "127.0.0.1" # Often needed in containerized environments like Colab

# Ensure SPARK_HOME is set before constructing PYSPARK_SUBMIT_ARGS
SPARK_HOME = os.environ.get("SPARK_HOME")
if SPARK_HOME is None:
    print("❌ SPARK_HOME environment variable not set. Cannot configure SPARK_SUBMIT_ARGS.")
    sys.exit(1)

# Constructing PYSPARK_SUBMIT_ARGS with explicit classpath
spark_jars_path = os.path.join(SPARK_HOME, "jars", "*")
pyspark_submit_args_value = f"--master local[*] --driver-class-path {spark_jars_path} --jars {spark_jars_path} pyspark-shell"
os.environ["PYSPARK_SUBMIT_ARGS"] = pyspark_submit_args_value

# Also ensure Spark bin is in PATH for findspark and spark-submit
os.environ["PATH"] = os.path.join(SPARK_HOME, "bin") + ":" + os.environ["PATH"]

# -----------------------------

# Re-initialize findspark to ensure environment variables are correctly picked up
import findspark
findspark.init() # SPARK_HOME will be picked from os.environ

# Import PySpark modules AFTER environment variables are configured
from pyspark.sql import SparkSession
from pyspark.sql.functions import col, regexp_replace, when
from pyspark.ml.feature import StringIndexer, VectorAssembler
from pyspark.ml.classification import RandomForestClassifier
from pyspark.ml.evaluation import BinaryClassificationEvaluator

# -----------------------------

# Step 2: Start Spark

# -----------------------------

# Get Spark home to construct extraClassPath (already done above for PYSPARK_SUBMIT_ARGS)
extra_classpath_config = f"file://{spark_jars_path}"

# This section requires careful indentation of chained methods
spark = SparkSession.builder \
    .appName("CustomerPaymentReliability") \
    .config("spark.driver.memory", "4g") \
    .getOrCreate()
print(f"✅ Spark version: {spark.version}")

# -----------------------------

# Step 3: Create Dataset

# -----------------------------

data = [
    ("C1001", 110.50, "Month-to-month", "2500.00", "No", "The total charges seem low for the monthly charges over time."),
    ("C1002", 105.00, "One year", "4500.00", "Yes", "No obvious issues."),
    ("C1003", 115.20, "Two year", "0.00", "No", "Incomplete/Missing: TotalCharges is 0.00."),
    ("C1004", 100.00, "Month-to-month", "1200", "Yes", "No obvious issues."),
    ("C1005", 108.75, "Month-to-month", "50000.00", "Yes", "Outlier: Total Charges unrealistically high."),
    ("C1006", 110.00, "One year", "6000.00", "No", "Duplicate in full dataset."),
    ("C1007", 102.40, "Two year", "0.00", "No", "Incomplete/Missing: Total Charges is 0.00."),
    ("C1008", 112.00, "Month-to-month", None, "Yes", "Missing: NaN in Total Charges."),
    ("C1009", 106.80, "Month-to-month", "4500.00", "No", "No obvious issues."),
    ("C1010", 104.50, "Two year", "100.5", "Yes", "Inaccurate: TotalCharges less than MonthlyCharges."),
]

columns = ["CustomerID", "MonthlyCharges", "Contract", "TotalCharges", "Churn", "Notes"]
df = spark.createDataFrame(data, columns)
df.show(truncate=False)

# -----------------------------

# Step 4: Data Cleaning

# -----------------------------

df_clean = df.withColumn("TotalCharges", regexp_replace(col("TotalCharges"), ",", ""))
df_clean = df_clean.withColumn("TotalCharges", col("TotalCharges").cast("double"))
median_value = df_clean.approxQuantile("TotalCharges", [0.5], 0.0)[0]
df_clean = df_clean.withColumn(
    "TotalCharges",
    when((col("TotalCharges").isNull()) | (col("TotalCharges") == 0), median_value)
    .otherwise(col("TotalCharges"))
)
df_clean = df_clean.withColumn("label", when(col("Churn") == "Yes", 1).otherwise(0))
df_clean.show(truncate=False)

# -----------------------------

# Step 5: MapReduce Example

# -----------------------------

rdd = df_clean.rdd
mapped = rdd.map(lambda row: (row["Contract"], 1))
contract_counts = mapped.reduceByKey(lambda a, b: a + b)
print("✅ Contract counts:", contract_counts.collect())

# -----------------------------

# Step 6: Random Forest ML

# -----------------------------

contract_indexer = StringIndexer(inputCol="Contract", outputCol="ContractIndex")
df_encoded = contract_indexer.fit(df_clean).transform(df_clean)
assembler = VectorAssembler(inputCols=["MonthlyCharges", "TotalCharges", "ContractIndex"], outputCol="features")
data_features = assembler.transform(df_encoded)
train, test = data_features.randomSplit([0.8, 0.2], seed=42)
rf = RandomForestClassifier(labelCol="label", featuresCol="features", numTrees=10)
model = rf.fit(train)
pred = model.transform(test)
evaluator = BinaryClassificationEvaluator(labelCol="label", metricName="areaUnderROC")
auc = evaluator.evaluate(pred)
print(f"✅ AUC = {auc}")
pred.select("CustomerID", "features", "prediction", "probability").show(truncate=False)

# spark.stop()
print("✅ Spark session stopped. Script completed successfully.")

"""### Steg 1: Installera Java 17 och konfigurera `JAVA_HOME`

Detta installerar OpenJDK 17 och ställer in de nödvändiga miljövariablerna för PySpark att hitta Java.
"""

# Installera OpenJDK 17
!apt-get update -qq > /dev/null
!apt-get install -y openjdk-17-jdk-headless -qq > /dev/null

# Sätt JAVA_HOME miljövariabeln
import os
os.environ["JAVA_HOME"] = "/usr/lib/jvm/java-17-openjdk-amd64"
# Uppdatera PATH för att inkludera Java bin-katalogen
os.environ["PATH"] = os.environ["JAVA_HOME"] + "/bin:" + os.environ["PATH"]

print("✅ Java 17 installerat och JAVA_HOME konfigurerat.")

"""### Steg 2: Installera Apache Spark och konfigurera `SPARK_HOME`

Detta laddar ner och extraherar Spark och ställer in `SPARK_HOME` samt lägger till Spark bin-katalogen i `PATH`.
"""

# Ladda ner och extrahera Spark
SPARK_VERSION = "3.5.1"
HADOOP_VERSION = "3"

# Construct the full filename and folder name in Python
TAR_FILENAME = f"spark-{SPARK_VERSION}-bin-hadoop{HADOOP_VERSION}.tgz"
SPARK_FOLDER_NAME = f"spark-{SPARK_VERSION}-bin-hadoop{HADOOP_VERSION}"
SPARK_DOWNLOAD_URL = f"https://archive.apache.org/dist/spark/spark-{SPARK_VERSION}/{TAR_FILENAME}"

# Use f-strings to pass the constructed filenames directly to shell commands
!wget -q {SPARK_DOWNLOAD_URL}
!tar xf {TAR_FILENAME}

# Installera findspark för att enkelt initialisera PySpark
!pip install findspark -qq

# Sätt SPARK_HOME miljövariabeln
os.environ["SPARK_HOME"] = f"/content/{SPARK_FOLDER_NAME}"
# Uppdatera PATH för att inkludera Spark bin-katalogen
os.environ["PATH"] = os.environ["SPARK_HOME"] + "/bin:" + os.environ["PATH"]

import findspark
findspark.init()

print(f"✅ Spark {SPARK_VERSION} installerat och SPARK_HOME konfigurerat.")

"""Här är schemat för DataFrame `df`, som visar kolumnnamn och deras datatyper, följt av de första raderna i dataramen."""

df.printSchema()
df.show(truncate=False)