Chapter 3 — Ai Project Cycle

What is the AI Project Cycle? The AI Project Cycle is an iterative sequence of steps used to develop, evaluate, deploy and maintain an AI solution. It ensures that an AI system solves the right problem, uses quality data, is tested correctly, and continues to perform after deployment.

Why follow a cycle? Following a structured cycle helps teams reduce errors, improve model performance, track progress, and address ethical, privacy and reliability concerns.

1. Define the problem: State the goal clearly: what to predict, classify or automate, and what success looks like (e.g., reduce spam by X%). Identify stakeholders and constraints (time, data, privacy).
2. Collect data: Gather relevant data from sensors, logs, surveys or public datasets. Document sources, sampling method and permissions.
3. Prepare & clean data: Handle missing values, remove duplicates, correct errors, and transform data (normalization, encoding categorical values). Good data quality is crucial.
4. Explore & analyze data (EDA): Visualize distributions and relationships, detect outliers and discover important features that influence the outcome.
5. Select model/algorithm: Choose a suitable approach (e.g., decision tree, logistic regression, neural network) based on problem type (classification, regression, clustering), data size and interpretability needs.
6. Train the model: Use training data to learn model parameters. Split data into training and validation (and possibly test) sets to avoid overfitting.
7. Evaluate the model: Measure performance using appropriate metrics (accuracy, precision/recall, MSE) and validate on unseen data. Perform error analysis.
8. Deploy & integrate: Put the model into production (app, API, device) and connect it to data pipelines and user interfaces.
9. Monitor & maintain: Track performance over time, detect data drift, retrain when necessary, and log errors and user feedback.
10. Document & consider ethics: Keep records of data sources, model choices, potential biases, and privacy protections. Consider fairness, accountability and transparency.

Key ideas to remember: The cycle is iterative — you often go back to collect more data, change features, or try different models. Data quality and clear problem definition are as important as the algorithm.

What it is: Problem Definition and Goal Setting is the first and most important step of an AI project. It means clearly stating what problem you want the AI system to solve and what success looks like. A well-defined problem guides data collection, model choice, evaluation, and deployment.

Why it matters: If the problem or goal is vague, the project can waste time building the wrong model, use wrong data, or measure the wrong things. Clear goals keep the team focused and make results measurable.

Key steps:

• Understand the context: Who are the users and stakeholders? What decisions will the AI support?
• State the problem clearly: Write one sentence that describes input, desired output, and the decision the output will support. Example: "Given daily attendance and homework submission history, predict whether a student will submit next week's assignment."
• Decide the type of AI task: Classification, regression, clustering, recommendation, or optimization. This determines suitable models and metrics.
• List constraints and resources: Data availability, privacy rules, computing power, time, and budget.
• Choose success metrics: How will you measure performance? (Examples: accuracy, precision, recall for classification; MAE/RMSE for regression.)
• Set baseline and targets: Record current performance (baseline) and set a realistic target improvement.
• Make goals SMART: Specific, Measurable, Achievable, Relevant, Time-bound.

How to write a good problem statement (quick checklist):

• Specific: What exactly will the system predict or decide?
• Measurable: Which metric(s) will show success?
• Achievable: Is needed data available and legal to use?
• Relevant: Does it help the stakeholders?
• Time-bound: By when should the goal be reached?

Example SMART goal: "Improve automated homework submission detection accuracy from 75% to 88% within 4 months using school LMS data, ensuring false positives remain below 5%."

Choosing metrics by task type:

• Classification: accuracy, precision, recall, F1-score, confusion matrix
• Regression: mean absolute error (MAE), mean squared error (MSE), root mean squared error (RMSE), R-squared
• Clustering: silhouette score, cluster purity

Practical tips: Start small and measurable (a Minimum Viable AI). Always compare models to a simple baseline (e.g., random guess, majority class, or average). Involve users early so the defined goal matches real needs.

Data Collection is the first and one of the most important stages in the AI Project Cycle. It means gathering the raw information (data) needed to build, train and test an AI system. Good data collection ensures the model learns patterns that match the real world and reduces errors caused by bias, missing values or noise.

Goals: obtain enough relevant, representative and high-quality data; decide formats and labels needed; and record metadata (source, time, consent).

Main steps

• Define what to collect: list features/variables, labels and the target problem (e.g., images + class labels for object recognition).
• Choose sources: primary (surveys, sensors, experiments, images you capture) or secondary (public datasets, APIs, logs, published reports).
• Choose method: random sampling, stratified sampling, convenience sampling, or continuous logging depending on the problem.
• Decide format & storage: structured (tables/CSV), semi-structured (JSON), or unstructured (images, audio, text). Plan folders, filenames and backup/versioning.
• Collect & label: gather data, annotate labels (manual or semi-automated) and keep labeling guidelines for consistency.
• Check quality: check completeness, correctness, consistency, balance and privacy compliance.

Quality checks and common issues

• Missing values — measure fraction missing and decide to impute or remove rows/columns.
• Bias & representativeness — ensure all relevant groups are covered to avoid skewed models.
• Noise & errors — validate and clean outliers, wrong formats or duplicates.
• Label quality — use inter-annotator agreement and clear guidelines.

Tools & techniques: spreadsheets/CSV, Google Forms or survey tools, sensors and data loggers, web scraping, APIs (Twitter, weather), image capture tools, and annotation tools (labelImg, CVAT). Use version control for datasets and keep a README describing the data.

Ethics & privacy: obtain consent for personal data, anonymize identifiers, follow school/home rules and platform terms, and avoid collecting sensitive data unless necessary and secured.

Practical tips: pilot a small collection first to test labels and formats; aim for quality over quantity; plan for balanced classes; keep a clear data dictionary; and think ahead about how you will split the data for training/validation/testing.

What is Data Preparation (Preprocessing)? Data preparation (preprocessing) is the process of cleaning, transforming and organizing raw data so that it can be used effectively by AI models. It is a crucial step in the AI Project Cycle because the quality of input data strongly affects the model's performance.

Why it matters: Real-world data is often messy: it can have missing values, duplicates, inconsistent labels, outliers, or features with very different scales. Preprocessing improves data quality, reduces bias and noise, and helps models learn faster and more accurately.

Common steps in preprocessing

• 1. Data collection and inspection: Gather data and examine types (numerical, categorical, text, images), ranges, missing values and basic statistics (mean, median, counts).
• 2. Cleaning: Remove duplicates, correct typos or inconsistent labels (for example, "yes", "Yes", "Y" → "Yes").
• 3. Handling missing values: Options include removing rows/columns with many missing values, or imputing missing entries using mean, median, mode, forward/backward fill (for time series), or model-based imputation.
• 4. Handling outliers: Detect outliers with boxplots, IQR or z-score and decide to remove, cap, or transform them depending on cause and context.
• 5. Scaling and normalization: Bring features to a similar scale using Min–Max scaling or standardization (z-score) so algorithms that use distances or gradients work well.
• 6. Encoding categorical variables: Convert categories into numbers using label encoding or one-hot encoding. For ordinal categories use integer encoding preserving order.
• 7. Feature selection and extraction: Remove irrelevant or highly correlated features, create new features (e.g., age groups, interaction terms) or use dimensionality reduction if needed.
• 8. Splitting data: Divide data into training, validation and test sets (for example 70% train / 15% validation / 15% test) to evaluate model performance fairly.
• 9. Domain-specific preprocessing: For images: resizing, normalization, augmentation (flip, rotate); for text: tokenization, lowercasing, removing stopwords, stemming/lemmatization.
• 10. Documentation and reproducibility: Save preprocessing steps, random seeds and transformed datasets so results are repeatable.

Practical tips: Always visualize data before and after preprocessing, keep a copy of raw data, and choose methods based on the problem and model (some models need scaling, others do not).

What is EDA? Exploratory Data Analysis (EDA) is the process of examining and summarizing a dataset to understand its main characteristics before building any AI model. EDA helps you find patterns, detect errors, spot outliers, and form hypotheses about the data.

Purpose in the AI Project Cycle (Class 9) EDA is part of Data Preparation and the beginning of Model Building. It ensures the data is clean and that you know which features (columns) are useful for solving the problem.

• Steps in EDA: data collection & verification, cleaning (handle missing values, remove duplicates), transformation (convert types, create new features), summarization (statistics), visualization, and interpretation.
• Common issues looked for: missing values, inconsistent formats (e.g., date stored as text), duplicates, outliers, and incorrect data types.
• Outcome: cleaned dataset, summary statistics, visual plots, and notes about which variables matter and why.

How to approach EDA (simple workflow)

1. Understand the problem and what each column means.
2. Preview the data (first few rows, data types, size).
3. Compute summary statistics (mean, median, mode, range, quartiles).
4. Visualize distributions and relationships with plots.
5. Detect and handle missing values and outliers.
6. Document findings and use them to decide features for modelling.

Tools: For Class 9, EDA can be done using spreadsheets (Excel/Google Sheets) or beginner-friendly code (Python with pandas and matplotlib/seaborn).

What is Model Selection and Development?

Model selection and development is the part of the AI project cycle where we choose a suitable kind of model (for example, a classifier or a regressor), build it using data, tune it for better performance, and test it so it can be used in the real world. The goal is to find a model that makes accurate predictions on new data while avoiding mistakes like overfitting or underfitting.

Main steps

1. Understand the problem: Decide whether it is a classification (labels) or regression (numbers) task or another type (clustering, recommendation).
2. Choose candidate models/algorithms: e.g., decision trees, k-nearest neighbours (KNN), logistic regression, linear regression, Naive Bayes, support vector machines (SVM), or simple neural networks.
3. Prepare data and features: Clean data, handle missing values, convert categories to numbers, scale features if needed, and create useful new features.
4. Split the data: Common splits are train/validation/test (e.g., 60/20/20 or 70/15/15). Use cross-validation (k-fold) to get reliable estimates.
5. Train models: Fit each candidate model on training data and evaluate on validation data.
6. Evaluate and compare: Use appropriate metrics (accuracy, precision, recall, F1 for classification; MSE/MAE/RMSE, R^2 for regression).
7. Tune hyperparameters: Adjust settings (like tree depth, number of neighbours, learning rate) using grid search or cross-validation to improve performance.
8. Check for overfitting/underfitting: Use learning curves and validation results. Apply regularization or simpler models if overfitting; increase complexity or get more data if underfitting.
9. Final test and deploy: Evaluate the chosen model on the test set, then deploy the model and monitor its performance in the real world.

Important concepts

• Overfitting: Model is too complex and learns noise; very good on training data but poor on new data.
• Underfitting: Model is too simple and cannot capture patterns; poor on both training and new data.
• Cross-validation: Splits data into k parts and rotates training/validation to get average performance.
• Hyperparameters vs parameters: Parameters are learned from data (e.g., weights in linear regression); hyperparameters are set before training (e.g., tree depth).
• Feature engineering: Creating or transforming inputs can improve model accuracy more than changing algorithms.

Tips for students

• Start with simple models (like linear/logistic regression or small decision trees) before trying complex ones.
• Always keep a separate test set that the model never sees until the final evaluation.
• Use clear evaluation metrics that match the problem (e.g., favour recall for medical diagnosis if missing a disease is dangerous).

Overview: In an AI project, data is usually split into three parts — training, validation and testing — so that a model can learn patterns, be tuned, and be fairly evaluated. This prevents wrong conclusions caused by overfitting (model memorises training data) or underfitting (model is too simple to learn patterns).

Training set: The largest portion of labeled data used to teach the model. The model adjusts its internal parameters (weights) to minimise error on this data. During training the model learns patterns but may begin to overfit if trained too long or with too much complexity.

Validation set: A separate portion used while developing the model to choose settings (hyperparameters) like model size, learning rate or number of training rounds. The validation set helps detect overfitting: if validation error starts increasing while training error keeps decreasing, the model is overfitting. Validation is also used for early stopping and model selection.

Test set: A final portion kept aside and only used once, after the model and its hyperparameters are fixed. It provides an unbiased estimate of how the model will perform on new, unseen data in the real world.

Common data splits: Typical splits are 70% train / 15% validation / 15% test, or 60/20/20. For small datasets, cross-validation (e.g., k-fold) is used to make better use of data.

Key ideas to remember:

• Training = learn parameters. Validation = tune and detect overfitting. Testing = final evaluation.
• Never use test set information to tune the model — that biases the final evaluation.
• Learning curves (training vs validation error over epochs) help decide if the model is overfitting or underfitting.

What are Evaluation Metrics?

Evaluation metrics are numbers we use to measure how well an AI model (or project) is performing. They tell us whether the model's predictions are correct, and help us compare different models and improve them during the AI Project Cycle.

Why they matter:

• Show strength and weaknesses of a model.
• Help choose the right model for the problem.
• Guide improvements (for example, reducing wrong predictions that matter most).

Core idea — Confusion Matrix (for two-class problems)

A confusion matrix summarizes predictions vs actual results. For a binary problem (Yes/No or Positive/Negative) it looks like:

Definitions:

• TP: model correctly predicted positive.
• TN: model correctly predicted negative.
• FP: model predicted positive but it was negative (false alarm).
• FN: model predicted negative but it was positive (miss).

Common evaluation metrics (intuition)

• Accuracy — How many predictions are correct overall. Good when classes are balanced.
• Precision — Of all predicted positives, how many are actually positive? (Measures exactness; low precision = many false alarms.)
• Recall (Sensitivity) — Of all actual positives, how many did the model find? (Measures completeness; low recall = many misses.)
• F1-score — Harmonic mean of precision and recall; useful when you need a balance between precision and recall.
• Specificity — Of all actual negatives, how many were correctly identified (TN / (TN + FP)).

Which metric to choose?

• If missing a positive is dangerous (e.g., disease detection), prioritize recall (catch more cases), even if precision falls.
• If false alarms are costly (e.g., sending costly coupons), prioritize precision.
• For balanced, simple tasks (balanced classes), accuracy can be enough.
• For imbalanced data (rare events), use precision, recall, F1 rather than accuracy.

Other practical points

• Metrics can change with the decision threshold of the model — raising the threshold may increase precision but lower recall.
• Use cross-validation or a separate test set to get reliable metric estimates.

Deployment and Integration is the stage in an AI project where a trained and tested model is put into real use and connected with the systems that users or other programs interact with. Deployment means making the AI model available to perform tasks (for example, classifying images or answering questions). Integration means connecting the deployed model into applications, websites, databases, or devices so it fits into the existing workflow.

Key steps in this stage:

• Prepare the model for deployment (optimize size and speed, package dependencies).
• Choose a deployment method: cloud service, on-premises server, or edge/device deployment.
• Expose the model through an API or embed it into an application or device.
• Integrate with data sources and user interfaces so inputs reach the model and outputs are used correctly.
• Test in the production-like environment (can include A/B testing) and plan methods for rollback if problems appear.
• Monitor performance and maintain the model: track accuracy, latency, errors, data drift and update the model when needed.

Important non-technical concerns include privacy and security of data, user consent, and maintaining reliability (uptime). Deployment is not the end of the project: it requires continuous monitoring, logging, and periodic re-training when new data changes model behaviour.

Definition & importance: Monitoring, maintenance and iteration are the ongoing activities after an AI model is deployed. Monitoring checks the model’s performance and health in production. Maintenance fixes issues, updates software and data pipelines, and ensures reliability. Iteration uses feedback and monitored data to improve the model (retrain, tune, redesign) so the system continues to meet goals and adapt to change.

Key components:

• Monitoring: Track metrics (accuracy, latency, resource use), data quality (missing values, outliers), and business KPIs (click-through rate, conversion). Set alerts for threshold breaches.
• Maintenance: Bug fixes, pipeline checks, dependency updates, model rollbacks, data labeling and cleaning, and hardware maintenance.
• Iteration: Analyze monitored data, identify root causes for failures or drift, collect/label new data, retrain or change architecture, validate, and redeploy. This creates a continuous feedback loop.

Typical workflow:

1. Instrument the system: add logs, metrics, tracing and monitoring dashboards.
2. Define alerting rules and acceptance thresholds for performance and reliability.
3. Detect anomalies (sudden drop in accuracy, increase in latency, data drift).
4. Investigate and perform maintenance (fix code, clean data, adjust thresholds).
5. Iterate: gather new labeled examples, retrain or fine-tune model, validate on test set and A/B test in production.
6. Deploy updated model and continue monitoring.

Common problems and responses:

• Model drift (input distribution changes): detect using distribution comparison (e.g., PSI or KL divergence), then collect representative new data and retrain.
• Performance regressions: run backtests and A/B tests; rollback if needed; tune hyperparameters or change model features.
• Data quality issues: add validation checks and automated cleaning pipelines.
• Resource or latency issues: optimize model (quantization, pruning) or scale infrastructure.

Best practices:

• Automate monitoring and alerts; keep human-in-the-loop for critical decisions.
• Version models and datasets (so you can reproduce and rollback).
• Use small, frequent iterations rather than rare large overhauls.
• Define clear success metrics tied to business goals.

Ethics, Privacy and Responsible AI

Artificial Intelligence (AI) should be designed and used in ways that are safe, fair and respect people's rights. In the AI Project Cycle (planning, data collection, data preparation, model building, evaluation, deployment and monitoring), ethics and privacy must be considered at every step so that the system does not harm users or society.

Key ethical principles

• Fairness: AI must avoid unfair treatment or discrimination against people because of characteristics such as gender, caste, religion or disability.
• Privacy: Personal information must be kept confidential and used only with consent and for the stated purpose.
• Transparency and explainability: People affected by AI decisions should be able to understand why a decision was made.
• Accountability: Developers and organisations should take responsibility for harms caused by AI and be able to explain and fix problems.
• Safety and robustness: AI systems should work reliably and handle unexpected situations without causing harm.

Practical steps in the AI Project Cycle

• Plan: Identify social risks, who will be affected, what data is needed and whether consent is required. Perform an impact assessment if the system could affect people’s rights.
• Data collection: Collect only the data you need (data minimisation). Ask for informed consent, anonymise personal identifiers where possible, and check data sources for bias.
• Data preparation: Clean data carefully but avoid removing or altering minority-group examples in ways that hide real differences. Document choices (data sheets) so others can review them.
• Model building: Choose models that balance accuracy and fairness. Use techniques for privacy (e.g., anonymisation, differential privacy) and fairness-aware training if needed.
• Evaluation: Test model performance across different groups (gender, region, age) and measure fairness, privacy risk and robustness to errors. Use human review for important decisions.
• Deployment: Provide clear explanations for users, allow appeals or human override, and limit access to sensitive outputs. Ensure secure data storage and transmission.
• Monitoring and maintenance: Continuously monitor for harmful behaviour, performance drift and new privacy risks; update the model and documentation as needed.

Common challenges and solutions

• Bias in data: If training data reflects past discrimination, the model can learn it. Solution: audit data, balance samples, use fairness metrics and adjust training.
• Privacy leaks: Models may reveal sensitive information. Solution: anonymise data, use techniques like differential privacy, and restrict outputs.
• Lack of explainability: Complex models (like deep learning) are hard to explain. Solution: use simpler models where possible or add explainability tools (feature importance, local explanations).
• Unclear responsibility: When decisions are automated, users may not know who is accountable. Solution: assign clear human oversight, maintain logs and documentation.

Teaching students in Class 9 should focus on the idea that ethical AI is not just technical — it is about values, rights and careful design choices. Simple practices such as asking for consent, anonymising names, checking for unfair outcomes and documenting decisions are powerful steps toward responsible AI.

Overview: Documentation, reporting and presentation are the final and essential phases of the AI Project Cycle. They ensure your work is reproducible, understandable to stakeholders, and usable for decision-making. Good documentation preserves project knowledge; clear reporting communicates results and implications; effective presentation persuades and informs different audiences.

Documentation (What to record)

• Title & Abstract: Short summary of objectives, methods, key results and conclusions.
• Problem Statement & Objectives: Why the project exists and the specific questions/hypotheses.
• Data: Source, collection method, size, schema, class distribution, any preprocessing (cleaning, missing values, normalization), sample records and privacy considerations.
• Methodology: Algorithms/models used, features, hyperparameters, training/validation/test split, cross-validation strategy.
• Experiments & Results: Experimental setup, evaluation metrics, tables/plots of results, comparisons, statistical significance if applicable.
• Environment & Reproducibility: Software/libraries + versions, random seeds, hardware, directory structure, code repository links, instructions to reproduce results.
• Ethics & Limitations: Bias analysis, privacy risks, limitations of the model, and mitigation steps.
• Conclusions & Future Work: Main findings, recommended actions, and possible next steps.
• References & Appendices: Datasets, papers, annotated code snippets, raw logs.

Reporting (How to communicate results in writing)

• Audience-aware summaries: Executive summary for non-technical stakeholders, technical section for peers.
• Key metrics up front: Present primary evaluation numbers (accuracy, precision/recall, F1, confusion matrix) prominently.
• Visuals and tables: Use clear charts and tables; captions must explain what the reader should notice.
• Interpretation not just numbers: Explain why a model performs a certain way, practical implications, and recommended next steps.
• Actionable recommendations: e.g., deploy model X for triage, collect more data on class Y, or adjust threshold for recall/precision trade-off.

Presentation (Delivering to an audience)

• Structure: 1) Title & goal, 2) Data & approach (brief), 3) Key results, 4) Business/real-world implications, 5) Demo (if possible), 6) Limitations & next steps, 7) Q&A.
• Design tips: 6–8 slides for a short presentation, one main idea per slide, large readable fonts, consistent colors, and minimal text—use visuals.
• Storytelling: Lead with the problem and why it matters, show how your solution addresses it, and end with concrete recommendations.
• Live demo & backup: If demoing a model, have a video or screenshots ready if the live demo fails. Time the demo and rehearse transitions.
• Handling technical questions: Prepare appendix slides with extra technical details, hyperparameters, ablation studies and code links for interested audiences.
• Accessibility & Ethics: Avoid jargon for general audiences, call out privacy/ethical considerations and informed consent where relevant.

Practical tips & standards

• Use version control (Git) and label releases (v1, v1.1). Keep a CHANGELOG.
• Name files and folders clearly: data/, notebooks/, src/, reports/, results/.
• Include a README with one-line purpose, setup steps, how to run experiments and how to reproduce figures/tables.
• Keep a short checklist before submission/presentation: reproducibility, backup, data privacy check, citation list, and slide rehearsal.

What it means: "Tools, Platforms and Resources" are the software, hardware, services and learning materials you use at each step of an AI project. Choosing the right ones helps you collect and prepare data, build and evaluate models, and deploy solutions safely and efficiently.

Categories & role in the AI project cycle:

• Data collection tools: sensors, cameras, web-scrapers, forms, APIs and public datasets — used to gather raw data.
• Annotation & cleaning tools: LabelImg, CVAT, VoTT, spreadsheets — for labeling and fixing data quality.
• Exploration & preprocessing: Excel/Google Sheets, Python (pandas, NumPy), visualization libraries — to explore and prepare data.
• Modeling frameworks & libraries: scikit-learn (classical ML), TensorFlow/Keras, PyTorch (deep learning) — to build and train models.
• Notebooks & development platforms: Jupyter, Google Colab, VS Code — interactive coding and experiments.
• Cloud & AutoML platforms: Google Cloud AutoML, Azure ML, IBM Watson, Teachable Machine — for training or automating parts of the pipeline without heavy coding.
• Deployment & serving: Flask/Streamlit (web apps), TensorFlow Lite/ONNX (mobile/edge), Docker, Firebase — to make models available to users.
• Compute & storage: local CPU/GPU, Colab/Tensor Processing Units (TPUs), cloud VMs and storage — to run experiments and store data/models.
• Collaboration & versioning: Git/GitHub, Google Drive — for code and dataset management.
• Resources & learning: tutorials, documentation, datasets (Kaggle, UCI), ethics guidelines — to learn and ensure responsible design.

How to choose: match the tool to the project stage, team skills and constraints (time, budget, compute). For example, use Teachable Machine or Colab for quick classroom prototypes; choose TensorFlow/PyTorch when you need full control and performance; choose TensorFlow Lite for mobile deployment.

Practical tips:

• Start small: prototype in Colab or a notebook before moving to heavy compute.
• Use open datasets for practice (MNIST, CIFAR, Kaggle) and document dataset licenses.
• Keep track of versions for code and data (Git, dataset snapshots).
• Measure model performance using standard formulas (accuracy, precision, recall, MSE) and choose metrics that match your problem.
• Consider ethics and privacy: anonymize data, check bias in datasets, follow CBSE/ICAI guidelines when relevant.

What is project management? Project management is the process of planning, organizing, executing, monitoring and closing work to achieve specific goals within constraints such as time, scope and resources. In the AI project cycle (Class 9), project management ensures the AI project (data collection, model building, evaluation, deployment and documentation) finishes on time and meets objectives.

Core phases (simplified):

• Initiation: Define problem, goals, success criteria and stakeholders.
• Planning: Break project into tasks, estimate time/resources, set milestones and assign roles.
• Execution: Team members perform tasks (data gathering, coding, testing, documentation).
• Monitoring & Control: Track progress, manage risks, adjust plan when needed.
• Closure: Final evaluation, presentation, lessons learned and handover.

Key constraints (the triple constraint): Scope (what will be delivered), Time (schedule), Cost/Resources (people, tools). Changing one affects the others.

Team roles (school-friendly):

• Project Manager / Coordinator: Plans schedule, assigns tasks, communicates with teacher/stakeholders, monitors progress.
• Researcher / Domain Expert: Gathers background info, defines data needs and success criteria.
• Data Collector / Data Engineer: Collects and cleans data, prepares datasets for training/testing.
• Developer / Model Builder: Implements algorithms, trains and tunes models.
• Tester / Evaluator: Creates test cases, evaluates model performance and fairness, reports issues.
• UI/Presenter / Designer: Builds simple user interface or presentation materials and visualizations.
• Documenter / Reporter: Writes report, documents steps, produces final presentation.
• Stakeholders (teacher, users): Provide requirements, review progress and accept final deliverable.

Best practices for student AI projects:

• Define a clear, measurable objective (e.g., 85% accuracy on test set or demonstrate 3 failure cases).
• Break work into small tasks with deadlines (use a simple Gantt or Kanban board).
• Assign clear ownership for each task and a backup person.
• Hold short, regular check-ins (15 minutes) to remove blockers.
• Track risks (data shortage, tool issues) and plan mitigations early.
• Validate model with a test set and a user demo; document limitations and ethics.

Communication & roles matrix: Use a simple RACI idea — Responsible, Accountable, Consulted, Informed — so everyone knows responsibilities and who decides.

What this topic covers
Case studies and mini projects show how the AI Project Cycle is applied to real problems. They guide students through identifying a problem, collecting and preparing data, building or choosing a simple model, evaluating results, and presenting findings. Mini projects are short, hands‑on exercises that let learners practise each step of the cycle.

AI Project Cycle steps (applied to case studies / mini projects)

• 1. Problem definition: State the objective clearly (what to predict or classify, constraints, success criteria).
• 2. Data collection: Gather examples (images, text, sensor readings, etc.) from trustworthy sources; note size and labels.
• 3. Data preparation: Clean, label, and split the data (train / test or train / validation / test); perform simple preprocessing like resizing images, removing duplicates, or normalizing numbers.
• 4. Model selection / design: Choose a simple approach (rule‑based, k‑NN, decision tree, basic neural network, or even spreadsheet logic) appropriate to the data and class level.
• 5. Training / Implementation: Teach the model using training examples or implement rules; for non‑coding projects this may be designing flowcharts or spreadsheet formulas.
• 6. Evaluation: Test on unseen data; use basic metrics (accuracy, error rate) and inspect mistakes to improve the solution.
• 7. Deployment & Presentation: Demonstrate the working prototype, create a report with results, limitations, and ethical considerations (bias, privacy).

Why case studies and mini projects are important

• They show real benefits and limitations of AI on small scales.
• They build practical skills: data handling, simple modelling, teamwork, and communication.
• They encourage design thinking: understanding user needs, constraints, and evaluation.

Tips for successful mini projects

• Start with a narrow, well‑defined problem (e.g., classify two categories, not ten).
• Use small, labelled datasets (50–500 examples) suitable for classroom work.
• Keep evaluation simple and visual: confusion matrix, sample correct/incorrect predictions.
• Document assumptions, data sources, and ethical considerations (consent for images, fairness).
• Iterate: collect more data or improve preprocessing if results are poor.

Assessment and reporting
A good project report includes: problem statement, data description, method, evaluation (metrics + sample outputs), conclusion, limitations and future improvements, and ethical notes.