CropCare AI — Crop Disease Detection and Classification Using Deep Learning — is a BTech Computer Science Deep Learning project delivered as a complete, modern, professional, and interactive website. Its purpose is to detect and classify crop diseases from leaf images, helping in early disease identification and reducing crop losses. The site is built for a university project demonstration and faculty evaluation, and it must be presentable with confidence during an individual Deep Learning project evaluation and viva.
The product is a genuine Python Flask application: a real TensorFlow/Keras model performs inference on uploaded leaf images, real training logs and saved model files back the experiment and comparison views, and real dataset information backs the dataset explorer. Where a real value does not exist, the interface says so — "Not evaluated yet" — rather than inventing one. The audience is the Student Researcher who builds, runs, and explains the project, and the Faculty Evaluator who inspects the pipeline, metrics, and documentation during evaluation.
CropCare AI is a single Python Flask web application with eight pages. The Flask backend serves the HTML5/CSS3/JavaScript/Bootstrap 5 frontend, exposes a prediction endpoint that runs actual TensorFlow/Keras inference, and reads real dataset metadata, training logs, saved model files, and evaluation results from the project's organized directory structure (app.py, routes/, model/, training/, dataset/, templates/, static/css/, static/js/, tests/, docs/, requirements.txt, README.md). Chart.js renders all charts. Pytest covers the backend and pipeline.
The active human actors are the Student Researcher and the Faculty Evaluator. Both browse the site anonymously; no account, login, or role-based permission is part of the accepted scope. The Student Researcher uploads leaf images and reads real predictions, studies the Deep Learning Lab, and reviews training and documentation content. The Faculty Evaluator inspects real training logs, model comparison metrics, error analysis, and the demonstration checklist.
The application is primarily Python-based, with HTML, CSS, and JavaScript for the frontend. Java, Spring Boot, React, and Node.js are excluded. The provisioned infrastructure inventory lists a shared backend process, a MariaDB database, a React frontend, and a LiteLLM gateway backed by PostgreSQL; these are infrastructure facts only. The accepted product is a Flask application with a server-rendered Bootstrap frontend, and no accepted workflow requires a React UI, a LiteLLM model-provider call, or application-owned persistent data. The Flask backend is the shared backend process for all feature routes; the provisioned database and gateway do not create domain entities, authentication, or model-provider behavior.
Removed from scope
CropCare AI is delivered as a locally runnable Python Flask website. All eight pages are first-party, publicly reachable surfaces with no access requirement: a visitor opens the site and can immediately browse the dashboard, upload a leaf, explore the dataset, read the Deep Learning Lab, inspect training experiments, compare models, review error analysis, and read the project documentation. There is no sign-in, no user account, and no differentiated permission; the site presents the same genuine project state to every visitor.
The delivery boundary is defined by truthfulness. The Disease Detection page runs real inference only when the trained model and weights are configured; otherwise it shows a clear message explaining how to configure them and never produces a prediction. The Dataset Explorer shows real dataset information only when the dataset is available. Model Training and Experiments, Model Comparison, and Error Analysis show real logs, saved model files, and evaluation results, and display "Not evaluated yet" for anything not yet measured. Training is never reported as complete unless it actually completed.
The current scope covers the eight accepted pages and the Flask backend that supports them. Future improvements are described only in the Project Documentation page as narrative content and are not current features.
The reference directive for "existing project files and model implementation" is declared as content_source and feature_reference with the instruction to inspect first, reuse where appropriate, and not overwrite or delete existing files without checking them first. No verified factual entities, collection items, field values, dates, contacts, links, or media references were supplied in the authoritative thread beyond the project structure and technology list already captured above; the inventory therefore records only the required project structure and the reuse obligation.
app.py, routes/, model/, training/, dataset/, templates/, static/css/, static/js/, tests/, docs/, requirements.txt, README.md.FR-01 — Project website. As a Student Researcher, I should have a complete, modern, professional, and interactive website for CropCare AI — Crop Disease Detection and Classification Using Deep Learning, so that the project can be demonstrated and evaluated. (explicit) Acceptance: all eight pages are reachable and functional.
FR-02 — Disease detection purpose. As a Student Researcher, I should detect and classify crop diseases from leaf images, so that early disease identification is supported and crop losses can be reduced. (explicit) Acceptance: a real leaf image produces a real classification result.
FR-03 — Flask backend. As a Student Researcher, I should have a genuine Python 3.11 Flask backend, so that the site runs locally on Python. (explicit) Acceptance: the application starts and serves all pages locally.
FR-04 — TensorFlow/Keras inference. As a Student Researcher, I should have actual TensorFlow/Keras model inference, so that predictions come from the trained model. (explicit) Acceptance: the prediction endpoint returns outputs produced by the loaded Keras model.
FR-05 — Image processing. As a Student Researcher, I should have OpenCV and Pillow used for image processing, so that uploaded images are handled and prepared correctly. (explicit)
FR-06 — Data analysis. As a Student Researcher, I should have NumPy, Pandas, and Scikit-learn used for data analysis, so that dataset statistics and evaluation metrics are computed genuinely. (explicit)
FR-07 — Frontend stack. As a Student Researcher, I should have an HTML5, CSS3, JavaScript, and Bootstrap 5 frontend, so that the interface is built on the specified web technologies. (explicit)
FR-08 — Charts. As a Student Researcher, I should have Chart.js render the charts, so that dataset, training, and comparison charts are interactive. (explicit)
FR-09 — Testing. As a Student Researcher, I should have Pytest tests, so that the backend and pipeline can be verified. (explicit)
FR-10 — Palette. As a Faculty Evaluator, I should see a forest-green, emerald-green, white, and warm-cream color palette, so that the site reads as a premium agricultural AI dashboard. (explicit)
FR-11 — Motion and layout. As a Faculty Evaluator, I should see a clean, modern layout with subtle animations and smooth transitions, so that the interface feels polished without distraction. (explicit)
FR-12 — Typography and surfaces. As a Faculty Evaluator, I should see professional typography, rounded cards, soft shadows, and elegant icons, so that the interface looks professionally crafted. (explicit)
FR-13 — Imagery. As a Faculty Evaluator, I should see high-quality agricultural imagery, crop leaves, and plant disease illustrations, so that the agricultural context is visually clear. (explicit)
FR-14 — Responsive design. As a Faculty Evaluator, I should see a responsive design for desktop, tablets, and mobile devices, so that the site is usable on any screen. (explicit)
FR-15 — SaaS-style interface. As a Faculty Evaluator, I should see a modern SaaS-style interface suitable for a university project demonstration and faculty evaluation, so that the project presents well. (explicit)
FR-16 — Not a basic template. As a Faculty Evaluator, I should not see a basic template or a plain white website, so that the interface is visually impressive yet easy to understand and navigate. (explicit)
FR-17 — Home identity. As a Faculty Evaluator, I should see the CropCare AI logo and project name on the Home / Dashboard, so that the project is immediately identified. (explicit)
FR-18 — Hero heading. As a Faculty Evaluator, I should see the hero heading "Detect Crop Diseases. Protect Every Harvest." on the Home / Dashboard. (explicit)
FR-19 — Hero subtitle. As a Faculty Evaluator, I should see a subtitle explaining how deep learning identifies crop diseases from leaf images. (explicit)
FR-20 — Detect Disease button. As a Student Researcher, I should see a prominent "Detect Disease" button on the Home / Dashboard that leads to Disease Detection, so that I can start an analysis quickly. (explicit)
FR-21 — Overview cards. As a Faculty Evaluator, I should see overview cards for total images evaluated, supported disease classes, available models, and model accuracy, so that the project's real state is summarized. (explicit) Acceptance: each card shows a real value or "Not evaluated yet".
FR-22 — Workflow section. As a Faculty Evaluator, I should see a workflow section reading Upload Image → AI Analysis → Disease Prediction → Recommended Next Steps. (explicit)
FR-23 — Objectives and benefits. As a Faculty Evaluator, I should see a section explaining the project's objectives and benefits. (explicit)
FR-24 — No fabricated statistics. As a Faculty Evaluator, I should never see fabricated model accuracy or fake statistics; actual values appear when available and otherwise "Not evaluated yet". (explicit)
FR-25 — Image upload formats. As a Student Researcher, I should upload JPG, JPEG, or PNG leaf images on Disease Detection. (explicit) Acceptance: supported formats are accepted; other formats produce a useful validation message.
FR-26 — Drag and drop. As a Student Researcher, I should drag and drop images into the upload area. (explicit)
FR-27 — Preview. As a Student Researcher, I should preview the selected image before analysis. (explicit)
FR-28 — Analyze Leaf. As a Student Researcher, I should click "Analyze Leaf" to run actual model inference through the Python Flask backend. (explicit) Acceptance: the request reaches the backend prediction endpoint and returns real model output.
FR-29 — Result details. As a Student Researcher, I should view the predicted disease class, confidence score, inference time, and class-wise probabilities. (explicit)
FR-30 — Result panel. As a Student Researcher, I should see a clear result panel with the uploaded leaf image and prediction. (explicit)
FR-31 — Educational information. As a Student Researcher, I should receive general educational information about the predicted disease and suggested next steps. (explicit)
FR-32 — Model unavailable message. As a Student Researcher, I should see a clear message explaining how to configure the trained model and weights when they are unavailable, and never a random or hardcoded prediction. (explicit)
FR-33 — Dataset summary. As a Faculty Evaluator, I should see dataset summary and image counts on Dataset Explorer. (explicit)
FR-34 — Classes and samples. As a Faculty Evaluator, I should see disease classes and sample leaf images. (explicit)
FR-35 — Split distribution. As a Faculty Evaluator, I should see training, validation, and testing split distribution. (explicit)
FR-36 — Class distribution charts. As a Faculty Evaluator, I should see class distribution charts. (explicit)
FR-37 — Image preview and information. As a Faculty Evaluator, I should see image preview and basic image information. (explicit)
FR-38 — Source and license. As a Faculty Evaluator, I should see dataset source and license information. (explicit)
FR-39 — Real dataset only. As a Faculty Evaluator, I should see only real dataset information when the dataset is available. (explicit) Acceptance: when the dataset is unavailable, a clear message appears and no invented data is shown.
FR-40 — Neurons and perceptrons. As a Student Researcher, I should study artificial neurons and perceptrons in the Deep Learning Lab. (explicit)
FR-41 — MLPs. As a Student Researcher, I should study Multilayer Perceptrons (MLPs). (explicit)
FR-42 — CNNs. As a Student Researcher, I should study Convolutional Neural Networks (CNNs). (explicit)
FR-43 — Forward and backpropagation. As a Student Researcher, I should study forward propagation and backpropagation. (explicit)
FR-44 — Activation functions. As a Student Researcher, I should study activation functions such as ReLU, sigmoid, and softmax. (explicit)
FR-45 — Loss and gradient descent. As a Student Researcher, I should study loss functions and gradient descent. (explicit)
FR-46 — SGD, momentum, Nesterov. As a Student Researcher, I should study Stochastic Gradient Descent, momentum, and Nesterov acceleration. (explicit)
FR-47 — Tensor operations. As a Student Researcher, I should study tensor operations, matrix multiplication, broadcasting, reshaping, and inner products. (explicit)
FR-48 — Initialization, normalization, regularization, augmentation. As a Student Researcher, I should study weight initialization, normalization, regularization, and data augmentation. (explicit)
FR-49 — SVD and gradient checking. As a Student Researcher, I should study Singular Value Decomposition (SVD) and gradient checking. (explicit)
FR-50 — Lab presentation. As a Student Researcher, I should see clear diagrams, formulas, simple explanations, and small interactive demonstrations suitable for a Deep Learning viva. (explicit)
FR-51 — Architecture and configuration. As a Faculty Evaluator, I should see model architecture and configuration on Model Training and Experiments. (explicit)
FR-52 — Loss curves. As a Faculty Evaluator, I should see training and validation loss curves. (explicit)
FR-53 — Accuracy curves. As a Faculty Evaluator, I should see training and validation accuracy curves. (explicit)
FR-54 — Hyperparameters. As a Faculty Evaluator, I should see epochs, batch size, learning rate, and optimizer. (explicit)
FR-55 — Split details. As a Faculty Evaluator, I should see dataset split details. (explicit)
FR-56 — Status and history. As a Faculty Evaluator, I should see training status and experiment history. (explicit)
FR-57 — MLP baseline and CNN. As a Student Researcher, I should have a simple MLP baseline and a CNN model supported. (explicit)
FR-58 — Pretrained model condition. As a Student Researcher, I should include a pretrained model such as ResNet only if it can be implemented and tested properly. (explicit) Acceptance: it is shown only when genuinely implemented and tested.
FR-59 — No false completion. As a Faculty Evaluator, I should never see a claim that training completed unless it actually has; real training logs and saved model files are used. (explicit)
FR-60 — Model comparison metrics. As a Faculty Evaluator, I should compare available models on accuracy, precision, recall, F1-score, inference time, and confusion matrix. (explicit)
FR-61 — Tables and charts. As a Faculty Evaluator, I should see clear tables and interactive charts on Model Comparison. (explicit)
FR-62 — Not evaluated yet. As a Faculty Evaluator, I should see "Not evaluated yet" for missing results on Model Comparison. (explicit)
FR-63 — Confusion matrix visualization. As a Faculty Evaluator, I should see a confusion matrix visualization on Error Analysis. (explicit)
FR-64 — Per-class metrics. As a Faculty Evaluator, I should see per-class precision, recall, and F1-score. (explicit)
FR-65 — Correct and misclassified examples. As a Faculty Evaluator, I should see correctly classified and misclassified examples. (explicit)
FR-66 — False positives and negatives. As a Faculty Evaluator, I should see false positives and false negatives. (explicit)
FR-67 — Overfitting and underfitting. As a Faculty Evaluator, I should see overfitting and underfitting analysis. (explicit)
FR-68 — Limitations and causes. As a Faculty Evaluator, I should see limitations and possible causes of incorrect predictions. (explicit)
FR-69 — Problem statement. As a Faculty Evaluator, I should read the problem statement in Project Documentation. (explicit)
FR-70 — Objectives and motivation. As a Faculty Evaluator, I should read objectives and motivation. (explicit)
FR-71 — Architecture diagram. As a Faculty Evaluator, I should see a system architecture diagram. (explicit)
FR-72 — Dataset description and licensing. As a Faculty Evaluator, I should read dataset description and licensing. (explicit)
FR-73 — Preprocessing methodology. As a Faculty Evaluator, I should read data preprocessing methodology. (explicit)
FR-74 — Model architecture documentation. As a Faculty Evaluator, I should read the model architecture. (explicit)
FR-75 — Training methodology. As a Faculty Evaluator, I should read training methodology. (explicit)
FR-76 — Evaluation metrics and actual results. As a Faculty Evaluator, I should read evaluation metrics and actual results. (explicit)
FR-77 — Limitations and future improvements. As a Faculty Evaluator, I should read limitations and future improvements. (explicit)
FR-78 — References and contribution. As a Faculty Evaluator, I should read references and individual contribution. (explicit)
FR-79 — Demonstration checklist. As a Faculty Evaluator, I should use a project checklist for the final demonstration and viva. (explicit)
FR-80 — Upload and validation. As a Student Researcher, I should have image upload and validation in the Flask backend. (explicit)
FR-81 — Prediction endpoint. As a Student Researcher, I should have a prediction endpoint. (explicit)
FR-82 — Efficient model loading. As a Student Researcher, I should have efficient model loading. (explicit)
FR-83 — Consistent preprocessing. As a Student Researcher, I should have preprocessing consistent with the model's training pipeline. (explicit)
FR-84 — Input validation and errors. As a Student Researcher, I should receive input validation and useful error messages. (explicit)
FR-85 — Safe file handling. As a Student Researcher, I should have safe handling of uploaded files. (explicit)
FR-86 — Code separation. As a Student Researcher, I should have clear separation between frontend, backend, model, and training code. (explicit)
FR-87 — Project structure. As a Student Researcher, I should have an organized project structure containing app.py, routes/, model/, training/, dataset/, templates/, static/css/, static/js/, tests/, docs/, requirements.txt, and README.md. (explicit)
FR-88 — Working controls. As a Faculty Evaluator, I should find every navigation link, button, form, upload area, and chart working as intended. (explicit)
FR-89 — Genuine outputs. As a Faculty Evaluator, I should see genuine model outputs wherever available. (explicit)
FR-90 — Graceful missing data. As a Faculty Evaluator, I should see missing datasets and model weights handled gracefully. (explicit)
FR-91 — Setup and testing instructions. As a Student Researcher, I should have clear setup instructions and testing instructions. (explicit)
FR-92 — Local run. As a Student Researcher, I should run the website easily locally using Python. (explicit)
FR-93 — Modular and readable. As a Faculty Evaluator, I should find the implementation modular, readable, and suitable for academic evaluation. (explicit)
FR-94 — Complete deliverable. As a Student Researcher, I should have the complete CropCare AI website with a polished frontend, a Python Flask backend, working image-upload functionality, and integration with the actual deep learning model. (explicit)
FR-95 — Inspect and reuse. As a Student Researcher, I should have available project files and any existing model implementation inspected first and reused where appropriate, without overwriting or deleting existing files without checking them first. (explicit)
FR-96 — Evaluation priority. As a Faculty Evaluator, I should see a working disease-detection pipeline, a professional interface, genuine evaluation metrics, and clear explanations that support the individual Deep Learning project evaluation and viva. (explicit)
FR-97 — Local Flask runtime. As a Student Researcher, I should run the Flask backend locally with Python 3.11, so that the accepted journeys are executable. (required_inference)
FR-98 — Configured model and weights. As a Student Researcher, I should configure the trained TensorFlow/Keras model and weights for real inference, so that Disease Detection can return genuine predictions. (required_inference)
FR-99 — Available dataset. As a Student Researcher, I should make the dataset available, so that Dataset Explorer can show real information. (required_inference)
FR-100 — Real logs and saved models. As a Student Researcher, I should have real training logs and saved model files, so that Model Training and Experiments, Model Comparison, and Error Analysis can show genuine results. (required_inference)
The Student Researcher is the BTech Computer Science student who built CropCare AI and must present it during an individual Deep Learning project evaluation and viva. Her product context is the whole site: she runs the Flask application locally, uploads leaf images to demonstrate the working detection pipeline, and walks the evaluator through the dataset, the training experiments, the model comparison, and the error analysis.
Her primary goal is to demonstrate a genuine, working deep learning pipeline with real predictions and real metrics, and to explain the underlying concepts clearly. Her distinct accepted responsibilities are uploading and analyzing leaf images on Disease Detection and reading the predicted class, confidence, inference time, and class-wise probabilities; studying the Deep Learning Lab concepts — neurons and perceptrons, MLPs, CNNs, forward and backpropagation, ReLU/sigmoid/softmax, loss functions and gradient descent, SGD with momentum and Nesterov acceleration, tensor operations, initialization/normalization/regularization/augmentation, and SVD and gradient checking — with diagrams, formulas, and interactive demonstrations; and reviewing the training experiments and documentation. Her inputs are leaf images in JPG, JPEG, or PNG and her decisions are which image to analyze and which experiment or concept to present. She interacts with the Faculty Evaluator by walking through the pages and explaining results. Her observable success is a real prediction displayed with its confidence and probabilities, and a coherent viva narrative backed by real logs and metrics.
The Faculty Evaluator is the faculty member assessing the project during demonstration and viva. Their product context is verification: they check whether the pipeline is genuine, whether the reported metrics come from real training and evaluation, and whether the student can explain the deep learning concepts.
Their primary goal is to confirm that the project is real, complete, and academically sound. Their distinct accepted responsibilities are inspecting the real training logs, saved model files, and experiment history on Model Training and Experiments; comparing models on accuracy, precision, recall, F1-score, inference time, and confusion matrix on Model Comparison; reviewing the confusion matrix, per-class metrics, correct and misclassified examples, false positives and negatives, overfitting and underfitting analysis, and limitations on Error Analysis; and using the project checklist for the final demonstration and viva in Project Documentation. Their inputs are the displayed real values and the student's explanations; their decisions are whether the evidence is genuine and complete. They interact with the Student Researcher by questioning results and requesting demonstrations. Their observable success is finding real values or an honest "Not evaluated yet" everywhere, with no fabricated statistics and no non-working controls.
The creative direction is authoritative: warm editorial clarity after Frank Chimero — calm, academic, and trustworthy rather than a startup pitch. The user's explicit palette requirement (forest green, emerald green, white, warm cream) is satisfied by these tokens.
Mode: light.
Color tokens by role
#F4EEE2 (warm cream ground)#FFFDF7 (paper-white cards)#1E2B22 (ink)#14532D (forest green — headings, rules, primary button block)#1F7A4D (emerald — actions and data)#6B7A6C (secondary text, labels)Typography
Shape and spacing
Imagery
Motion
Readability rule
clamp(...); imagery and decoration may crop or bleed but never cover readable text or controls.The public entry is a cream editorial page. The headline "Detect Crop Diseases. Protect Every Harvest." is set left in Fraunces at 64px desktop and 34px mobile, spanning nine columns with a thin forest-green rule beneath it. Under the subline "Deep learning reads a leaf image and classifies its disease. You see the model result and the next steps." sits the "Detect Disease" call to action as a solid forest-green block. A large flat leaf illustration occupies the right column. Below, the four overview cards present total images evaluated, supported disease classes, available models, and model accuracy — each value or the words "Not evaluated yet" in the same type size. The workflow appears as a ruled horizontal sequence — Upload Image → AI Analysis → Disease Prediction → Recommended Next Steps — with small flat leaf icons, followed by the objectives and benefits section. Every page opens with a warm illustrated band and a numbered section label, carrying the same editorial rhythm.
Interaction Model: Animated Motion Tempo: restrained Hero Dimensionality: flat
Landing Hero Motion Brief
app.py, routes/, model/, training/, dataset/, templates/, static/css/, static/js/, tests/, docs/, requirements.txt, README.md.requirements.txt. (required_inference)
01Deep learning project · leaf diagnosis
Deep learning reads a leaf image and classifies its disease. You see the model result and the next steps.
Not evaluated yet
Not evaluated yet
Not evaluated yet
Not evaluated yet
02How it works
No. 03 — Objectives & Benefits
Crop diseases take hold quietly. A lesion that is obvious on a photograph can be easy to miss in a field, and late detection usually means lost yield that cannot be recovered. CropCare AI is a Deep Learning study of how far an image classifier can be pushed in reading a leaf and naming what it shows.
The first objective is technical: build and train convolutional models that take a single leaf image and classify its disease, using a consistent preprocessing pipeline between training and inference. The second is developmental: establish a clean workflow across dataset preparation, training experiments, evaluation and error review, so that the resulting model is measured honestly rather than assumed to work.
Alongside the model sits an examinable record — training curves, per-class precision, recall and F1-scores, and a confusion matrix that shows exactly where the classifier is confident and where it is not. Every value on this site is read from stored experiment output; anything not yet measured is shown as Not evaluated yet.
For a student and their evaluator, the benefit is a working, traceable pipeline: from image upload through analysis to a predicted class and recommended next steps, with the model's reasoning exposed as class-wise probabilities. For the wider goal of early disease identification, a model that flags a likely problem early can support a more timely response — providing its limits are understood as clearly as its strengths.

01Deep learning project · leaf diagnosis
Deep learning reads a leaf image and classifies its disease. You see the model result and the next steps.
Not evaluated yet
Not evaluated yet
Not evaluated yet
Not evaluated yet
02How it works
No. 03 — Objectives & Benefits
Crop diseases take hold quietly. A lesion that is obvious on a photograph can be easy to miss in a field, and late detection usually means lost yield that cannot be recovered. CropCare AI is a Deep Learning study of how far an image classifier can be pushed in reading a leaf and naming what it shows.
The first objective is technical: build and train convolutional models that take a single leaf image and classify its disease, using a consistent preprocessing pipeline between training and inference. The second is developmental: establish a clean workflow across dataset preparation, training experiments, evaluation and error review, so that the resulting model is measured honestly rather than assumed to work.
Alongside the model sits an examinable record — training curves, per-class precision, recall and F1-scores, and a confusion matrix that shows exactly where the classifier is confident and where it is not. Every value on this site is read from stored experiment output; anything not yet measured is shown as Not evaluated yet.
For a student and their evaluator, the benefit is a working, traceable pipeline: from image upload through analysis to a predicted class and recommended next steps, with the model's reasoning exposed as class-wise probabilities. For the wider goal of early disease identification, a model that flags a likely problem early can support a more timely response — providing its limits are understood as clearly as its strengths.
No comments yet. Be the first!