Building an Iris Flower Classification App with Streamlit and Random Forest


In this project, we dive into creating a **machine learning web app** using **Streamlit** and the **Random Forest Classifier** to predict the species of an Iris flower. Streamlit is a Python library that makes it super easy to build interactive web applications without needing a lot of front-end development skills. We combined that with the power of machine learning to deliver a functional, real-time classification tool.
### Overview of the Project
The **Iris dataset**, one of the most famous in the world of machine learning, contains three types of Iris flowers:
- Iris Setosa
- Iris Versicolor
- Iris Virginica
Each flower is described by four features:
1. **Sepal length**
2. **Sepal width**
3. **Petal length**
4. **Petal width**
Using these features, we built an app that allows users to input the values of these features through a simple web interface and predict which type of Iris flower it is.
### Key Technologies
1. **Streamlit**: This library simplifies the creation of interactive web apps in Python. It handles UI elements like sliders, buttons, and dynamic text with ease, making it a perfect choice for displaying data science projects.
   
2. **Scikit-learn**: A go-to library for machine learning in Python. We used its Random Forest Classifier to train a model that accurately predicts flower species based on input features.
3. **Iris Dataset**: A popular dataset used for classification tasks, which consists of 150 observations and 3 flower species, each described by 4 numerical features.
### How It Works
1. **Input Features via Sliders**: The user selects values for the flower’s sepal length, sepal width, petal length, and petal width using sliders in the app.
2. **Prediction**: After selecting these values, the app runs a prediction using the trained **Random Forest** model, outputting the predicted flower species.
3. **Real-time Interaction**: Users can change the slider values, and the app will immediately update with a new prediction, providing instant feedback.
### Why This Project is Useful
This project is a practical demonstration of how machine learning models can be integrated into real-world applications. By using **Streamlit**, we enable users to interact directly with the model without writing code. This app shows how quickly and easily we can build a functional machine learning app to solve classification problems. 
### Next Steps
- **Model Improvement**: Tuning the model for better accuracy.
- **Deployment**: Hosting the app on platforms like **Heroku** or **Streamlit Cloud** so anyone can access it.
- **Additional Features**: Expanding the app with more datasets, prediction models, or visualization features.

If you’re looking to learn how machine learning models can be deployed in web applications, this project is a perfect hands-on example. It combines the best of **data science** and **front-end development**, making it an ideal showcase of your Python skills!

Here is the code of this project:

import streamlit as st
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier

def load_data():
    iris = load_iris()
    df = pd.DataFrame(iris.data, columns=iris.feature_names)
    df['species'] = iris.target
    return df, iris.target_names

df, target_names = load_data()

model = RandomForestClassifier()
model.fit(df.iloc[:, :-1], df['species'])

st.title("Input Features")

# Correct column names as they are in the dataset
sepal_length = st.slider("Sepal length (cm)", float(df['sepal length (cm)'].min()), float(df['sepal length (cm)'].max()))
sepal_width = st.slider("Sepal width (cm)", float(df['sepal width (cm)'].min()), float(df['sepal width (cm)'].max()))
petal_length = st.slider("Petal length (cm)", float(df['petal length (cm)'].min()), float(df['petal length (cm)'].max()))
petal_width = st.slider("Petal width (cm)", float(df['petal width (cm)'].min()), float(df['petal width (cm)'].max()))

input_data = [[sepal_length, sepal_width, petal_length, petal_width]]

# Prediction
prediction = model.predict(input_data)
predicted_species = target_names[prediction[0]]

st.write("Prediction")
st.write(f"The predicted species is: {predicted_species}")

Comments

Post a Comment

Popular posts from this blog

Building an AI-Powered Search Engine Using LangChain and Agents

The rise of Generative AI has transformed how we interact with information. Large Language Models (LLMs) like Llama3-8b-8192 can process complex queries, but they lack real-time search capabilities. To address this, I built an AI-powered search engine using LangChain Agents , integrating Wikipedia, Arxiv, and DuckDuckGo search tools to provide real-time, context-aware responses . This project not only improves search accuracy but also showcases the power of Retrieval-Augmented Generation (RAG) —a technique that enhances LLMs by fetching live information before generating responses. 💡 How This Search Engine Works 🔹 Core Components Used This project integrates multiple AI and search technologies: Component Purpose LangChain Framework to build AI applications with LLMs Streamlit Web interface for interactive AI search DuckDuckGo API Fetches real-time web results Wikipedia API Retrieves encyclopedic knowledge Arxiv API Fetches academic research pap...
Read more

Heart Failure Outcome Prediction: A Machine Learning Approach

 Introduction Heart disease is one of the leading causes of death worldwide, and heart failure (HF) is a critical condition that often leads to fatal outcomes if not managed properly. Early detection and preventive measures can significantly reduce the risk of heart failure-related complications. With the advancement of machine learning (ML), we can now use patient data to predict heart failure outcomes, helping healthcare providers make better decisions and improve patient care. In this project, I have developed a **Heart Failure Outcome Prediction** model using machine learning algorithms to predict whether a patient is at risk of heart failure based on key factors like age, blood pressure, cholesterol levels, and other medical data. Let me walk you through the process step by step. You can find the full project on my [GitHub repository]: Hearth-failure-outcome-prediction/Hearth_failure_outcome_prediction.ipynb at main · Faraz6180/Hearth-failure-outcome-prediction (github.com) --...
Read more

Building detecting SMS Spam Using Text Classification Project

  In today’s world, spam messages flood our inboxes, making it difficult to distinguish between important and irrelevant texts. Companies often lose customers because they can't properly filter spam, which frustrates users. What if we could build a system that automatically identifies spam messages and flags them? This project solves that problem by building an SMS Spam Classifier that uses Natural Language Processing (NLP) techniques to automatically label SMS messages as spam or ham (not spam). Solution: Text Classification Using Bag of Words To solve this problem, we’ll break down the solution into several key steps: Data Preprocessing : We’ll clean the text data by converting everything to lowercase, removing unnecessary characters, and applying stopwords filtering (to remove common English words that don’t add much meaning, like “the”, “is”, “in”). Stemming will be used to reduce words to their root forms (e.g., "running" becomes "run"). Bag of Words M...
Read more