Agriculture is the backbone of many economies, yet farmers often struggle to decide which crop is most suitable for their land and what fertilizer should be applied to maximize yield. To address this challenge, I built an AI-Based Crop Recommendation and Fertilizer Suggestion System that combines Machine Learning, AI, and real-time APIs to provide intelligent agricultural insights.

In this blog, I'll walk through the complete development process, the technologies I used, the APIs integrated, and the lessons I learned.

Project Overview:

The application predicts the most suitable crop based on soil and environmental conditions. It also recommends appropriate fertilizers and provides farmers with weather updates, agriculture news, and an AI chatbot for answering farming-related questions.

The project was built using Python, Streamlit, Machine Learning, and Google Gemini API.

Features:

Crop Recommendation

The system predicts the best crop using parameters such as:

• Nitrogen (N)

• Phosphorus (P)

• Potassium (K)

• Temperature

• Humidity

• pH value

• Rainfall

A trained Machine Learning model processes these inputs and recommends the most suitable crop.

Fertilizer Suggestion:

After selecting a crop and entering soil information, the application recommends fertilizers that improve soil fertility and crop productivity.

Gemini AI Chatbot:

One of the exciting features of the project is the AI chatbot powered by the Google Gemini API.

Users can ask questions like:

• Which crop grows well during monsoon?

• How can I improve soil fertility?

• What causes yellow leaves?

• Best farming practices for rice?

The chatbot provides intelligent, natural-language responses.

Live Weather Information:

The application integrates the OpenWeather API to display real-time weather information, including:

• Temperature

• Humidity

• Weather conditions

• Wind speed

Weather plays an important role in crop selection, making this feature highly valuable.

Agriculture News:

To help users stay updated, the project fetches live agriculture-related news using:

• NewsAPI

• YouTube Data API

Users can read the latest farming news and discover relevant agriculture videos without leaving the application.

Machine Learning Model:

The crop recommendation system was trained using supervised machine learning.

Dataset:

The crop prediction dataset was obtained from Kaggle.

The fertilizer recommendation model was also trained using publicly available agricultural datasets.

Data Preprocessing:

Before training the models:

• Missing values were checked

• Categorical values were encoded

• Features were cleaned

• Data was prepared for training

Libraries Used:

• Pandas

• NumPy

• Scikit-learn

• Streamlit

The trained models were saved and loaded directly into the Streamlit application for fast predictions.

Tech Stack:

Programming Language

• Python

Framework

• Streamlit

Machine Learning

• Scikit-learn

Data Processing

• Pandas

• NumPy

APIs

• Google Gemini API

• OpenWeather API

• NewsAPI

• YouTube Data API

Dataset

• Kaggle Crop Recommendation Dataset

• Kaggle Fertilizer Dataset

Application Workflow:

1. User enters soil and environmental details.

2. The trained ML model predicts the most suitable crop.

3. The fertilizer model suggests appropriate fertilizers.

4. Weather information is retrieved using the OpenWeather API.

5. Agriculture news is fetched using NewsAPI and YouTube Data API.

6. Users can ask additional questions through the Gemini AI chatbot.

What I Learned:

This project strengthened my understanding of:

• Machine Learning model development

• Data preprocessing

• Streamlit application development

• REST API integration

• Environment variable management

• AI chatbot integration using Gemini

• Model deployment

• Git and GitHub workflows

Most importantly, I learned how to combine multiple technologies into a single real-world application.

GitHub Repository

You can explore the complete source code here:

https://github.com/devisri424/AI-based-Crop-recommendation-and-Fertilizer-suggestion-System

Live Demo

https://ai-based-crop-recommendation-and-fertilizer-suggestion-system.streamlit.app/

Conclusion

Building this project allowed me to combine Machine Learning, Artificial Intelligence, and real-time APIs into a practical solution for agriculture. From predicting crops to recommending fertilizers, displaying weather information, providing live agricultural news, and answering farming questions with Gemini AI, the project demonstrates how modern AI technologies can support smarter farming decisions.

I hope this project inspires others to explore AI-powered solutions for real-world challenges. Feedback and suggestions are always welcome!

Neural Networks are a part of Deep Learning that help computers learn patterns from data and make predictions. A neural network consists of layers of neurons, and each neuron applies an activation function to decide the output.

An activation function plays an important role in controlling the output of neurons. It helps the model learn from the given input data.

In this blog, we will explore the Linear Activation Function and implement it using a simple neural network model for classification using the Iris dataset.

What is Linear Activation Function?

The Linear Activation Function is one of the simplest activation functions used in neural networks.

It returns the same value that is given as input.

Formula:

f(x) = x

Example:

Input = 10

Output = 10

The output is directly proportional to the input value.

Linear activation is mostly used in simple problems and regression tasks where the relationship between input and output is linear.

Dataset Used

For this implementation, we are using the Iris Dataset from Scikit-Learn.

The Iris dataset is a popular dataset used for machine learning experiments.

It contains information about three types of iris flowers:

• Iris Setosa

• Iris Versicolor

• Iris Virginica

The dataset contains 4 input features:

• Sepal Length

• Sepal Width

• Petal Length

• Petal Width

The goal is to build a neural network model that predicts the flower category based on these features.

Implementation

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
import matplotlib.pyplot as plt

# Load Dataset
iris = load_iris()
X = iris.data
y = iris.target.reshape(-1,1)

# Preprocessing
encoder = OneHotEncoder(sparse_output=False)
y = encoder.fit_transform(y)

scaler = StandardScaler()
X = scaler.fit_transform(X)

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Model
model = Sequential([
    Dense(10, activation='linear', input_shape=(4,)),
    Dense(8, activation='linear'),
    Dense(3, activation='softmax')
])

model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

history = model.fit(X_train, y_train,
                    epochs=50,
                    validation_split=0.2)

loss, accuracy = model.evaluate(X_test, y_test)

print("Linear Accuracy:", accuracy)

plt.plot(history.history['accuracy'], label='Train Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title('Linear Activation')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()
plt.show()

Output

Conclusion

In this blog, we implemented a neural network using the Linear Activation Function on the Iris dataset.

The model successfully learned patterns from the dataset and achieved around 93.37% accuracy.

The Linear Activation Function is simple and easy to understand, making it useful for learning the basics of neural networks. In upcoming blogs, we can explore other activation functions and understand how they improve neural network performance.

Have you ever wondered how email services automatically identify spam messages and move them to the spam folder?

Every day, millions of spam emails containing advertisements, scams, and phishing attempts are sent across the internet. To protect users, email providers use Machine Learning models that can distinguish between spam and legitimate emails.

But how do these models learn to make accurate decisions?

The answer lies in a learning algorithm called Backpropagation.

In this article, we will understand backpropagation using a simple and practical example: spam email detection.

What is Backpropagation?

Backpropagation is the process through which a neural network learns from its mistakes.

When a neural network makes a prediction, it compares the prediction with the correct answer. If the prediction is wrong, the network calculates the error and adjusts its internal weights to improve future predictions.

In simple terms:

1. Make a prediction.

2. Check whether it is correct.

3. Measure the error.

4. Learn from the mistake.

5. Improve the prediction.

This cycle repeats many times until the model becomes more accurate.

Spam Email Detection Example

Imagine we are training a neural network to identify spam emails.

Consider the following email:

"Congratulations! You have won a free iPhone. Click here to claim your reward."

This email is clearly spam.

Therefore:

Expected Output = Spam

Let's see what happens inside the neural network.

Step 1: Forward Pass

The email enters the neural network.

The model analyzes words such as:

• Congratulations

• Won

• Free

• Reward

Based on its current knowledge, the model predicts:

Prediction = Not Spam

Unfortunately, this prediction is incorrect.

Step 2: Calculate the Error

The correct answer is:

Actual Output = Spam

But the model predicted:

Predicted Output = Not Spam

Since the prediction is wrong, an error is generated.

The neural network now knows that something inside its decision-making process needs improvement.

Step 3: Backpropagation Begins

This is where backpropagation comes into action.

The error is sent backward through the network.

The model examines the connections and weights that contributed to the incorrect prediction.

Words like "free", "won", and "reward" should have received greater importance.

Backpropagation adjusts the weights associated with these features.

As a result, the network learns that such words are strong indicators of spam emails.

Step 4: Improved Prediction

After many training examples, the model becomes smarter.

Now consider a similar email:

"Win a free smartphone today. Click here now."

The model predicts:

Prediction = Spam

This time the prediction is correct because backpropagation helped the network learn from previous mistakes.

Practical Implementation in Python

To better understand how backpropagation is used in real-world applications, here's a simple spam email detection model built using Python and a neural network.

Implementation

Output

This model learns from training examples and improves its predictions using backpropagation.

Visualizing the Process

The following diagram shows how a neural network learns from its mistakes during spam email detection.

Each training cycle helps the model improve its accuracy.

Why Backpropagation Matters

Without backpropagation, neural networks would never improve.

The model would continue making the same mistakes because it would have no way of learning from them.

Backpropagation enables neural networks to:

• Learn patterns from data

• Reduce prediction errors

• Improve accuracy over time

• Solve complex real-world problems

It is one of the most important algorithms in modern Deep Learning.

Real-World Applications

Although we explored spam email detection, backpropagation is used in many other applications:

• Face recognition

• Handwriting recognition

• Medical diagnosis

• Recommendation systems

• Self-driving vehicles

• Voice assistants

• Language models and chatbots

In each case, the model learns by making predictions, measuring errors, and updating itself through backpropagation.

Conclusion

Backpropagation is the learning engine of neural networks. It allows models to learn from mistakes and continuously improve their performance.

Using spam email detection as an example, we saw how a neural network can initially make incorrect predictions, calculate its errors, and then adjust itself to make better decisions in the future.

Understanding backpropagation is an important step toward learning Deep Learning because it explains how neural networks become smarter over time.