test_Build a Customer Churn Prediction Model

Problem definition

Input data (download): https://raw.githubusercontent.com/IBM/telco-customer-churn-on-icp4d/master/data/Telco-Customer-Churn.csv (Telco customer churn CSV; columns such as tenure, MonthlyCharges, Contract, Churn)
This challenge requires you to build a predictive model for customer churn using the provided dataset. The model should predict whether a customer will churn based on their features.

Every line under Success criteria is in scope for this challenge. Evaluation considers all of those topics, so your code should demonstrate as many skills and topics as possible.

Task brief

Create a predictive model for customer churn using the provided dataset.

Version Control

Mastering Version Control is essential for managing the development of your predictive model for customer churn, ensuring that changes are tracked, collaborated on, and deployed efficiently.

Programming Fundamentals

Master Programming Fundamentals to build a predictive model for customer churn using the provided dataset.

Object-oriented Programming

Implement object-oriented programming principles to structure the predictive model for customer churn.

Data Structures & Algorithms

Implement data structures and algorithms to efficiently analyze the customer churn dataset.

Database Fundamentals

Master Database Fundamentals to effectively manage and query the Telco customer churn dataset for predictive modeling.

API Development Fundamentals

Master API Development Fundamentals to create a robust API for predicting customer churn.

Security Fundamentals

Implement security fundamentals to protect the customer churn prediction model from unauthorized access and data tampering.

Software Design Principles

Apply software design principles to ensure the predictive model for customer churn is maintainable and scalable.

Debugging & Troubleshooting

Debugging & Troubleshooting skill enables you to effectively identify and resolve issues in the predictive model for customer churn.

Ai Assisted Software Development

Leverage AI-assisted tools to streamline the software development process for predicting customer churn.

Containerization (Docker)

Master containerization with Docker to ensure your predictive model for customer churn is consistently deployable across different environments.

Package & Dependency Management

Master Package & Dependency Management to ensure the predictive model for customer churn is built with consistent and secure dependencies.

Language and stack

Choose from Python, JavaScript/TypeScript, Java, C#, or Go. Ensure your README specifies the chosen language and how to run the application.

Scenario

You are a data scientist at a telecommunications company. Your task is to develop a model that predicts customer churn to help the company retain customers.

Deliverables

1. A predictive model that predicts customer churn.
2. A README file with instructions on how to run the application.
3. A Jupyter notebook or script that demonstrates the model's performance.

Success criteria

AI evaluation scores every topic bullet below. Aim to demonstrate as many of these skills and topics as possible in your repository.

Version Control

• Repository Setup (beginner): The learner repo is initialized with a .git directory and a README file.
• Basic Commands (beginner): The learner demonstrates knowledge of git status, git add, and git commit.
• Commits (beginner): The learner makes commits with meaningful messages and timestamps.
• Branching (beginner): The learner creates and switches between branches for different features or fixes.
• Merging (beginner): The learner merges branches back into the main branch without conflicts.
• Conflict Resolution (intermediate): The learner resolves merge conflicts by choosing the correct changes and commits a resolution.
• Pull Requests (intermediate): The learner creates a pull request for a feature branch and includes a description and review request.

Programming Fundamentals

• Variables & Data Types (beginner): The learner demonstrates the ability to declare and initialize variables and use them in the predictive model.
• Operators (beginner): The learner correctly uses operators to manipulate data and features in the predictive model.
• Expressions (beginner): The learner constructs expressions to calculate and transform data for the predictive model.
• Control Flow (beginner): The learner implements control flow structures to manage the flow of the predictive model.
• Functions & Methods (beginner): The learner defines and calls functions or methods to encapsulate functionality in the predictive model.
• Collections (intermediate): The learner utilizes collections to manage and process data sets efficiently in the predictive model.
• Exception Handling (intermediate): The learner implements exception handling to manage errors and exceptions in the predictive model.
• File Handling (beginner): The learner reads and writes files to and from the system for data input and output in the predictive model.

Object-oriented Programming

• Classes & Objects (beginner): The learner demonstrates the use of classes to encapsulate customer data and model logic.
• Constructors (beginner): The learner includes constructors in classes to initialize customer objects with relevant data.
• Encapsulation (beginner): The learner ensures that customer data is encapsulated within classes, preventing direct access from outside the class.
• Inheritance (intermediate): The learner uses inheritance to create specialized customer classes that inherit from a general customer class.
• Polymorphism (intermediate): The learner demonstrates polymorphism by defining methods that behave differently based on the type of customer object.
• Abstraction (intermediate): The learner abstracts complex customer churn prediction logic into methods that can be reused and modified independently.
• Interfaces (intermediate): The learner defines interfaces that customer classes implement, ensuring a consistent API for customer-related operations.
• Composition (intermediate): The learner uses composition to build complex customer objects from simpler ones, enhancing code reusability and maintainability.

Data Structures & Algorithms

• Arrays (beginner): Correctly initialize and manipulate arrays to store customer data.
• Lists (beginner): Use lists to maintain a collection of customer records.
• Stacks (beginner): Implement a stack to manage customer service requests.
• Queues (beginner): Use a queue to process customer churn predictions in order.
• Hash Tables (intermediate): Efficiently store and retrieve customer data using hash tables.
• Sorting (intermediate): Implement a sorting algorithm to order customer data by tenure or charges.
• Searching (intermediate): Use a searching algorithm to find specific customer records.
• Time Complexity (intermediate): Analyze and optimize the time complexity of implemented algorithms.

Database Fundamentals

• Relational Databases (beginner): The learner demonstrates the ability to connect to and interact with a relational database.
• SQL Basics (beginner): The learner writes basic SQL queries to select, filter, and sort data.
• CRUD Operations (beginner): The learner performs Create, Read, Update, and Delete operations on the database.
• Joins (intermediate): The learner writes SQL queries that join multiple tables to retrieve comprehensive data.
• Indexes (intermediate): The learner creates and uses indexes to improve query performance.
• Transactions (intermediate): The learner writes SQL queries that ensure data integrity through transactions.

API Development Fundamentals

• HTTP Basics (beginner): The API correctly handles HTTP requests and responses.
• REST Principles (beginner): The API adheres to RESTful principles, using standard HTTP methods (GET, POST, PUT, DELETE) for appropriate operations.
• CRUD APIs (beginner): The API provides endpoints to create, read, update, and delete customer data.
• Request & Response (beginner): The API correctly formats requests and responses in JSON.
• Status Codes (beginner): The API uses appropriate HTTP status codes to indicate success or failure.
• JSON (beginner): The API correctly parses and generates JSON data.
• API Validation (intermediate): The API includes validation for input data to ensure it meets expected formats and constraints.

Security Fundamentals

• Authentication (beginner): Ensure that only authenticated users can access the customer churn prediction model.
• Authorization (beginner): Verify that users can only access resources they are authorized to.
• Input Validation (beginner): Confirm that the model properly validates input data to prevent injection attacks.
• Password Security (beginner): Ensure that user passwords are stored securely and not in plain text.

Software Design Principles

• Separation of Concerns (beginner): The codebase is organized into distinct modules, each handling a specific part of the application such as data processing, model training, and prediction.
• DRY (beginner): Avoid code duplication by reusing common functions and classes across different parts of the application.
• KISS (beginner): Keep the implementation simple and straightforward, avoiding unnecessary complexity in the model and its interactions.
• SOLID Principles (intermediate): Implement classes and functions that adhere to the SOLID principles, ensuring the code is easy to understand, extend, and maintain.
• Dependency Injection (intermediate): Use dependency injection to manage dependencies between components, making the system more modular and testable.

Debugging & Troubleshooting

• Breakpoints (beginner): The learner sets breakpoints in the code to pause execution at specific points.
• Debugging Techniques (beginner): The learner uses debugging tools to step through the code and inspect variables.
• Logging (beginner): The learner adds logging statements to track the flow of execution and capture variable values.
• Stack Traces (intermediate): The learner interprets stack traces to identify the source of errors.
• Root Cause Analysis (intermediate): The learner determines the underlying cause of a problem and proposes a solution.

Ai Assisted Software Development

• Working with AI Assistants (beginner): Utilize AI tools to assist in understanding the dataset and model requirements.
• Prompt Writing Fundamentals (beginner): Write clear and concise prompts to guide AI in generating code and documentation.
• Code Generation (beginner): Generate initial code snippets using AI assistance to set up the project environment.
• AI-assisted Debugging (beginner): Use AI to identify and fix bugs in the code.
• AI-assisted Refactoring (intermediate): Refactor code with AI suggestions to improve readability and efficiency.
• AI-assisted Unit Testing (intermediate): Create unit tests with AI assistance to ensure code functionality.
• AI-assisted Documentation (beginner): Generate documentation using AI to explain the code and model.
• AI Output Validation (intermediate): Validate AI-generated code and documentation for accuracy and relevance.
• AI Limitations & Hallucinations (beginner): Acknowledge and mitigate potential AI limitations and hallucinations in the development process.
• Responsible AI Usage (beginner): Ensure ethical and responsible use of AI tools throughout the project.

Containerization (Docker)

• What is Containerization (beginner): Demonstrate understanding of containerization by explaining its benefits in a README.
• Docker Architecture (beginner): Include a diagram or description of Docker's architecture in the README.
• Docker Images (beginner): Show a minimal Dockerfile that defines a Docker image for the application.
• Docker Containers (beginner): Demonstrate running a container from the built image.
• Dockerfile Basics (beginner): Include a Dockerfile in the repository with basic instructions.
• Building Images (beginner): Provide a command or script to build the Docker image from the Dockerfile.
• Running Containers (beginner): Show how to run the container with the built image.
• Environment Variables (beginner): Demonstrate setting environment variables in the Dockerfile or when running the container.
• Docker Volumes (beginner): Include a Docker volume in the setup to persist data.
• Docker Networks (beginner): Configure a Docker network for the containers to communicate.
• Docker Compose (intermediate): Use Docker Compose to define and run multi-container Docker applications.
• Container Debugging (intermediate): Provide steps for debugging issues within a running container.

Package & Dependency Management

• Package Managers Overview (beginner): The learner demonstrates understanding of package managers by including a README with instructions on how to install dependencies.
• Semantic Versioning (beginner): The learner correctly uses semantic versioning in the package.json or equivalent file.
• Version Constraints (intermediate): The learner specifies version constraints in the package.json or equivalent file to ensure compatibility.
• Installing Dependencies (beginner): The learner successfully installs all required dependencies for the project.
• Dependency Lock Files (intermediate): The learner includes a lock file (e.g., package-lock.json, yarn.lock) that reflects the installed dependencies.
• Updating Dependencies (intermediate): The learner demonstrates updating dependencies to the latest compatible versions.
• Transitive Dependencies (intermediate): The learner manages transitive dependencies to avoid version conflicts.
• Private Package Repositories (beginner): The learner configures access to private package repositories if necessary.
• Publishing Packages (beginner): The learner demonstrates publishing a package to a public or private repository.
• Dependency Security & Vulnerability Scanning (intermediate): The learner runs a security scan on dependencies and addresses any vulnerabilities.
• License Management (beginner): The learner includes appropriate licenses for third-party dependencies.
• Dependency Best Practices (intermediate): The learner follows best practices for dependency management, such as avoiding unnecessary dependencies and keeping them up to date.

How to submit

1. Register and connect your GitHub account.
2. When the challenge starts, SahkaarX will create a private repository and notify you.
3. Clone the repository, implement your solution, and push your changes.
4. Submit your solution in the application.

What happens after you submit

After you submit, an AI will review your repository. When the challenge window closes, a human judge will review your submission and the conversation transcript before finalizing results.

Intellectual property

Participants own the intellectual property in their submission. SahkaarX may host, evaluate, display on leaderboards, and otherwise operate the challenge. The GitHub repository is a private repo under the participant or team leader account.