Projectworlds > Blog > Machine Learning Projects With Source Code

Build Your Own Text-to-Image Generator Using Python and AI

Posted on July 12, 2025July 12, 2025 by Yugesh Verma

Have you ever wanted to transform words into stunning, photorealistic images — all with the power of AI? In this tutorial, we’ll show you how to build your own Text-to-Image Generator using Python and the latest Realistic Vision model, completely offline and with no paid API.

Whether you're building a portfolio project or just experimenting with AI creativity, this is a must-try.

Project Highlights:

✅ Text-to-image and image-to-image generation
✅ Uses the latest Realistic Vision V6.0 (v51 Hyper VAE)
✅ 100% Offline – No API keys or internet needed after setup
✅ Supports both GUI (Tkinter) and Web (Flask) interfaces
✅ Generates high-quality 512x512 PNG images
✅ Progress bar, output path display, and download support

Warning: Unfiltered Image Generation

This project uses unfiltered AI models and disables the safety_checker.
You may generate NSFW (Not Safe For Work), violent, or biased content depending on your prompts.

Use responsibly.
This tool is meant for educational and research purposes only.
Always monitor and moderate outputs before sharing them publicly.

What is Realistic Vision?

Realistic Vision is one of the most popular and powerful Stable Diffusion models known for its:

Hyper-realistic facial rendering
High detail in skin, lighting, clothing
Outstanding results for both artistic and photographic styles

We're using:
📦 realisticVisionV60B1_v51HyperVAE.safetensors

This version includes Hyper VAE for better detail and contrast in generations.

Model Download

Prerequisites

OS: Windows, Linux, or macOS
Python: 3.10.x (Recommended)
A CUDA-capable GPU (Optional, but highly recommended for faster generation)
At least 8GB RAM (16GB+ preferred for stable performance)
Git (optional, for cloning)

Step 1: Install Python 3.10

If not already installed, download and install Python 3.10 from:

https://www.python.org/downloads/release/python-3100/

During installation, ensure:

"Add Python to PATH" is checked

Step 2: Install Requirements

Step 3: Download the Model File

Download the model file manually:

File: realisticVisionV60B1_v51HyperVAE.safetensors
Source: https://civitai.com/models/4201/realistic-vision-v60

Place the file in your project root (same folder as app.py or gui.py).

Step 4: Run the App

Run EXE Directly – No Setup Needed

Download EXE Version (Includes AI Model)

Just double-click the EXE file – no installation required
Works offline using your system’s power (no internet or API needed)
Supports Text to Image generation
Total Size: ~4.8 GB
Minimum: 8 GB RAM required for smooth performance
🔗 Download EXE Version

AI Resume Analyzer Using RoBERTa – Match Your Resume to Job Descriptions with Skill Gap Analysis

Posted on May 26, 2025May 26, 2025 by Yugesh Verma

In today's job market, resumes need to be tailored to each job. This AI Resume Analyzer automates that process using semantic matching, allowing job seekers to upload their resume and see how well it matches a given job description — just like a recruiter might do using an ATS (Applicant Tracking System).

What This Project Does

✅ Upload any PDF resume
✅ Paste the job description
✅ AI calculates a semantic match score using RoBERTa
✅ Shows you:
- ✅ Matched skills
- ❌ Missing keywords
- 🛠 Smart improvement suggestions
✅ Clean, modern UI built with Tailwind CSS
✅ AI model info shown for credibility

🔍 How It Works

This tool uses RoBERTa (stsb-roberta-large) from the SentenceTransformers library. Unlike simple keyword matching, it evaluates how well your resume matches the meaning of the job description.

We also use a Named Entity Recognition (NER) model to extract skills and experience from the resume, and compare it with the JD to identify skill gaps.

💡 Why It's Better Than Keyword Matching

Traditional resume checkers just look for exact matches. But this tool understands:

Synonyms (e.g. “REST API” vs “backend service”)
Job roles vs responsibilities
Skill clusters

That’s why it’s ideal for students, job seekers, or HR teams who want deeper, smarter analysis.

🛠 Tech Stack

Component	Tech Used
Frontend	Tailwind CSS, HTML, Jinja2 Templates
Backend	Flask (Python)
PDF Parsing	PyMuPDF
NLP Model	RoBERTa (stsb-roberta-large)
Skill Extraction	Transformers NER Model
Suggestions Engine	Rule-based system

📦 Download Source Code

🎯 Download Resume Analyzer with AI Matching
💡 Includes full project: Code + HTML + Models + Suggestions Engine

Customer Segmentation for E-commerce using KMeans (Python Flask)

Posted on May 26, 2025May 26, 2025 by Yugesh Verma

Understanding your customers is key to growing your online business. This project leverages KMeans Clustering, a machine learning algorithm, to automatically segment your customers based on shopping behavior like spending score, income, and shopping frequency.

Built using Python, Flask, and Tailwind CSS, this project is perfect for:

Final-year students in Data Science or Machine Learning
E-commerce startups or marketers looking to understand customer types
Beginners learning Flask web apps + ML integration

📥 Download Customer Segmentation Project

✅ Click Here to Download Full Project with Source Code (ZIP)

Features of This Project:

🧮 Customer Clustering using KMeans Algorithm
📊 Interactive Dashboards with visualizations:
- Elbow Method Plot
- PCA 2D and 3D Graphs
- Pie Chart & Bar Chart for Customer Type Distribution
🔍 Silhouette Score to measure clustering performance
🧑‍💼 Easy-to-understand UI for shop owners
👨‍💻 Toggle for Data Science View (Detailed technical plots)
⬇️ CSV Export of clustered customers with segment labels:
- Budget Shoppers
- High Spenders
- Occasional Buyers
- Loyal Customers

Technologies Used:

Python 3.x
Flask Web Framework
Pandas, NumPy, Scikit-learn
Matplotlib, Seaborn
Tailwind CSS (for UI)
HTML5 / Jinja2

📝 How It Works:

User uploads a CSV file with customer data.
Backend preprocesses it and applies KMeans clustering.
Results are shown visually with charts and segment labels.
Optionally, users can download the analyzed data for marketing insights.

What You Get in the ZIP:

Complete source code (app.py, templates, static files)
Pre-built HTML with Tailwind UI
Dataset and sample input
Readme + setup instructions
Labeled output CSV
Project Report + PPT

Download Full Project with Source Code (ZIP)

Ai Face Shape Detection Project Python with Source Code

Posted on May 3, 2025May 3, 2025 by Yugesh Verma

Buy Now Source Code ₹1501

This project involves a Flask-based web application for real-time face detection and face shape. It leverages MediaPipe for facial landmark detection and Random Forest for face shape classification. Users can upload images to get annotated results or view real-time face detection through their webcam.

Features :-

Real-Time Face Detection: Detect and annotate faces in real-time using your webcam.
Image Upload and Annotation: Upload an image to get it processed and annotated with detected facial features.
Face Shape Classification: Classify face shapes based on detected landmarks using a pre-trained model.

Data and Model Information :-

Face Shape Classification Model

Model File:: Best_RandomForest.pkl
Description:: This model is trained using Random Forest on a dataset of facial landmarks. It classifies face shapes into categories such as Heart, Oval, Round, and Square.
Training Data: The model was trained on a dataset of labeled face shapes with corresponding landmark features extracted using MediaPipe.

Face Landmarker Model

Model File:: face_landmarker_v2_with_blendshapes.task
Description:: This MediaPipe model detects facial landmarks and provides blendshapes for facial expressions.
Training Data: Used to detect key facial landmarks required for both face shape classification and real-time annotations.

Technology Used in the project :-

We have developed this project using the below technology
HTML : Page layout has been designed in HTML
CSS : CSS has been used for all the desigining part
JavaScript : All the validation task and animations has been developed by JavaScript
Python : All the business logic has been implemented in Python
Flask: Project has been developed over the Flask Framework

Supported Operating System :-

We can configure this project on following operating system.
Windows : This project can easily be configured on windows operating system. For running this project on Windows system, you will have to install
Python 3.8, PIP, Django.
Linux : We can run this project also on all versions of Linux operating systemMac : We can also easily configured this project on Mac operating system.

Installation Step : -

python 3.8
command 1 - python -m pip install --user -r requirements.txt
command 2 - python app.py

Flight Delay Prediction using Machine Learning Project

Posted on January 16, 2025January 16, 2025 by Yugesh Verma

Buy Source Code ₹1501

Delay is one of the most remembered performance indicators of any transportation system. Notably, commercial aviation players understand delay as the period by which a flight is late or postponed. Thus, a delay may be represented by the difference between scheduled and real times of departure or arrival of a plane. Country regulator authorities have a multitude of indicators related to tolerance thresholds for flight delays. Indeed, flight delay is an essential subject in the context of air transportation systems. In 2013, 36% of flights delayed by more than five minutes in Europe, 31.1% of flights delayed by more than 15 minutes in the United States. This indicates how relevant this indicator is and how it affects no matter the scale of airline meshes. To better understand the entire flight ecosystems, vast volumes of data from commercial aviation is collected every moment and stored in databases. Submerged in this massive amount of data produced by sensors and IoT, analysts and data scientists are intensifying their computational and data management skills to extract useful information from each datum. In this context, the procedure of comprehending the domain, managing data and applying a model is known as Data Science, a trend in solving challenging problems related to Big Data. In this project, we’ve performed an extensive data analysis in order to extract the important attributes/factors that are responsible for the delay of flight. Also, there will other factors that may influence the delay of the flight such as climate, natural calamities, pandemic, or technical issues, etc. in the airplane which has not been considered in this project as this factors varying depend on the location and such problems occurring have very less frequency.

Problem Statement

Flight delays are quite frequent (19% of the US domestic flights arrive more than 15 minutes late), and are a major source of frustration and cost for the passengers. As we will see, some flights are more frequently delayed than others, and there is an interest in providing this information to travellers.
Flight prediction is crucial during the decision-making process for all players of commercial aviation. Moreover, the development of accurate prediction models for flight delays became cumbersome due to the complexity of air transportation system, the number of methods for prediction, and the deluge of flight data. Based on data, we would like to analyse what are the major cause for flight delays and assign a probability on whether a particular flight will be delayed.

Objective

The objective of the project is to perform analysis of the historic flight data to gain valuable insights and build a predictive model to predict whether a flight will be delayed or not given a set of flight characteristics. Questions to be answered post analysis: • Does the month of flight have any impact on flight delays? • Flights to which destination have seen the most delays? • Which day of the week sees the least and most flight delays? • Which time of day is most suitable for preventing flight delays? • Which airline has the most number of flights delayed? • What are the primary causes for flight delays? The objective of the predictive model is to build a model to predict whether a flight will be delayed or not based on certain characteristics of the flight. Such a model may help both passengers as well as airline companies to predict future delays and minimize them.

Dataset Details

Dataset obtained from Kaggle:
https://www.kaggle.com/lampubhutia/nyc-flight-delay

Technologies Used

Python
HTML
CSS
Bootstrap
Numpy
Pandas
Matplotlib
Seaborn
Flask

Steps to get started

Setup the virtual environment and turn it on
>> source Flight-Delay-Prediction/bin/activate (For Mac and Linux)
>> .\Flight-Delay-Prediction\Scripts\activate (For Windows)

Run the script
>> python app.py

Phishing Web Sites Detection Using Machine Learning Project

Posted on December 19, 2024December 19, 2024 by Yugesh Verma

The Internet has become an indispensable part of our life, However, It also has provided opportunities to anonymously perform malicious activities like Phishing. Phishers try to deceive their victims by social engineering or creating mockup websites to steal information such as account ID, username, password from individuals and organizations. Although many methods have been proposed to detect phishing websites, Phishers have evolved their methods to escape from these detection methods. One of the most successful methods for detecting these malicious activities is Machine Learning. This is because most Phishing attacks have some common characteristics which can be identified by machine learning methods.

Installation

The Code is written in Python 3.6.8. If you don't have Python installed you can find it here. If you are using a lower version of Python you can upgrade using the pip package, ensuring you have the latest version of pip. To install the required packages and libraries, run this command in the project directory after downloading the project:

pip install -r requirements.txt --user

Result

Accuracy of various model used for URL detection

	ML Model	Accuracy	f1_score	Recall	Precision
0	Gradient Boosting Classifier	0.974	0.977	0.994	0.986
1	CatBoost Classifier	0.972	0.975	0.994	0.989
2	XGBoost Classifier	0.969	0.973	0.993	0.984
3	Multi-layer Perceptron	0.969	0.973	0.995	0.981
4	Random Forest	0.967	0.971	0.993	0.990
5	Support Vector Machine	0.964	0.968	0.980	0.965
6	Decision Tree	0.960	0.964	0.991	0.993
7	K-Nearest Neighbors	0.956	0.961	0.991	0.989
8	Logistic Regression	0.934	0.941	0.943	0.927
9	Naive Bayes Classifier	0.605	0.454	0.292	0.997

Conclusion

The final take away form this project is to explore various machine learning models, perform Exploratory Data Analysis on phishing dataset and understanding their features.
Creating this notebook helped me to learn a lot about the features affecting the models to detect whether URL is safe or not, also I came to know how to tuned model and how they affect the model performance.
The final conclusion on the Phishing dataset is that the some feature like "HTTTPS", "AnchorURL", "WebsiteTraffic" have more importance to classify URL is phishing URL or not.
Gradient Boosting Classifier currectly classify URL upto 97.4% respective classes and hence reduces the chance of malicious attachments.

Download Link

Ai Black and white image colorization with OpenCV Project Free Download

Posted on December 13, 2024December 13, 2024 by Yugesh Verma

Image colorization is an intriguing task in the field of computer vision that involves adding color to black and white images. This process transforms historical photographs, enhances low-quality video footage, and brings new life to vintage images. The advent of deep learning, particularly Convolutional Neural Networks (CNNs), has significantly improved the accuracy and realism of automated colorization.

In traditional image processing, colorization required manual effort and expertise, making it a time-consuming and labor-intensive task. However, with the development of AI and deep learning, we now have models that can learn from large datasets of color images and predict the appropriate colors for grayscale images. This not only saves time but also produces remarkably realistic results.

OpenCV (Open Source Computer Vision Library) is a powerful tool for computer vision and image processing. It provides a wide range of functions for manipulating images, making it an excellent choice for implementing AI-based image colorization. By leveraging OpenCV along with deep learning models, we can automate the process of colorizing black and white images with impressive accuracy.

This report delves into the methodology and implementation of AI-based black and white image colorization using OpenCV. We will discuss the conversion of images to different color spaces, the training of neural networks to predict color channels, and the application of these models to achieve vibrant and realistic colorization of grayscale images.

Technology Overview

Image colorization using AI and OpenCV is a fascinating blend of deep learning and computer vision technologies. Here's an overview of the key technologies and concepts involved:

Deep Learning and Convolutional Neural Networks (CNNs):
- Deep learning is a subset of machine learning that uses neural networks with many layers to model complex patterns in data.
- CNNs are a type of deep learning model particularly effective for image processing tasks. They consist of layers that automatically and adaptively learn spatial hierarchies of features from input images.
Color Space Conversion:
- Images are typically processed in RGB color space but for colorization, conversion to Lab color space is common.
- In Lab color space, the L channel represents lightness, while the a and b channels represent color information (chromaticity). This separation makes it easier for the model to predict color components.
Training the CNN Model:
- The model is trained on a large dataset of color images, learning to predict the a and b channels given the L channel.
- Training involves feeding the network pairs of grayscale (L channel) and color (a and b channels) images, and optimizing the network to minimize the difference between predicted and actual color channels.
Implementation with OpenCV:
- OpenCV is a widely-used library in computer vision for image manipulation and processing. It provides tools for tasks like loading images, converting color spaces, and applying transformations.
- OpenCV's dnn module can be used to load and run pre-trained CNN models, making it possible to integrate deep learning models into applications for tasks like colorization.
Application Process:
- Load the grayscale image.
- Convert the image to Lab color space.
- Use the trained CNN model to predict the a and b channels.
- Combine the predicted a and b channels with the original L channel.
- Convert the image back to RGB color space to get the final colorized image.

Benefits and Challenges

Benefits:

Automates the colorization process, saving time and effort.
Produces realistic and high-quality colorized images.
Can be applied to various fields like film restoration, historical photo enhancement, and more.

Challenges:

Requires a large and diverse dataset for training to achieve good results.
May struggle with complex images where the grayscale cues alone are insufficient to infer accurate colors.
Computationally intensive, requiring powerful hardware for both training and inference.

This combination of deep learning and computer vision techniques has opened up new possibilities in image colorization, making it more accessible and effective. Would you like to explore any of these technologies in more detail?

Download Link

Lung Cancer Detection Using CNN Project with Source Code

Posted on August 27, 2024August 27, 2024 by Yugesh Verma

Lung cancer is one of the most prevalent and deadly forms of cancer worldwide. According to the World Health Organization (WHO), lung cancer accounts for approximately 2.1 million new cases annually and is responsible for 1.8 million deaths. The high mortality rate is largely due to the fact that lung cancer is often detected at an advanced stage when treatment options are limited, and survival rates are low. Early detection of lung cancer significantly improves the chances of successful treatment and long-term survival. However, traditional diagnostic methods, such as X-rays, CT scans, and biopsies, are time-consuming, require significant expertise, and are not always effective at detecting early-stage tumors.

This project aims to detect lung cancer using a Convolutional Neural Network (CNN) model deployed with Flask. It includes a Jupyter notebook (lung_cancer_detection.ipynb) for model training and a Flask app (app.py) for making predictions. Additionally, an HTML template (index.html) is provided for the web interface.

Data Preprocessing

Data Acquisition: The CT-Scan images and their labels were obtained from this Kaggle dataset. It provides a diverse set of chest cancer images, crucial for training a robust model.
Data Augmentation: To enhance the model's ability to generalize and to mitigate overfitting, I used TensorFlow's ImageDataGenerator. This tool allowed for augmenting the images in various ways (like rotation, zoom, flip) to artificially expand the dataset.
Normalization and Resizing: Each image was resized to a standard dimension and normalized to ensure uniformity in the input data, which is important for effective training of the CNN.
Train-Test Split: The dataset was split into training and test sets. The training set is used to train the model, while the test set helps in evaluating its performance on unseen data.

Model Structure

The CNN model used in this project is a sequential model composed of several Convolution2D and MaxPooling2D layers, carefully structured for effective image classification:

Convolution Layers: The model includes multiple Conv2D layers with 128 and 256 filters. These layers are responsible for extracting features from the images. The first two convolution layers have 128 filters each, followed by another set of two with the same number. The next four convolution layers have 256 filters each.
Pooling Layers: MaxPooling2D layers are used after certain convolution layers to reduce the spatial dimensions (width and height) of the output volume, helping to reduce the number of parameters and computation in the network.
Output Layer: The final layer of the model is a Dense layer with neurons equal to the number of classes, using a 'softmax' activation function for multi-class classification. This allows the model to output a probability distribution over the classes.
Optimization and Loss Function: The model is compiled with the Adamax optimizer and categorical cross-entropy loss function. This combination is chosen for effective learning and generalization in multi-class classification tasks.
Parameters and Size: The total number of parameters in the model is 3,763,940 (14.36 MB). All these parameters are trainable, ensuring that the model can learn complex patterns in the data.

This structure is designed to effectively capture the intricate patterns in CT-Scan images, leading to accurate classification of Lung Cancer.