DEV Community: Seth Bang

Bulk Object Detection and Cropping with DETR

Seth Bang — Thu, 20 Jul 2023 22:41:09 +0000

The Python file, main.py, is an object detection application that uses the DEtection TRansformer (DETR) model from Facebook's Hugging Face library. It allows users to identify and crop images of detected objects, storing these cropped images in a specified output directory.

The application provides a Graphical User Interface (GUI) developed with the tkinter library, where users can specify the input directory of images, the output directory for the cropped images, and a confidence level for the model to use in object detection.

Now, let's break down the script into sections and explain each part in detail.

Importing Required Libraries

The script begins by importing the necessary libraries. These include:

tkinter: a standard Python interface to the Tk GUI toolkit, used for developing desktop applications.
filedialog: a tkinter module for displaying dialog boxes that let the user select files or directories.
PIL (Pillow): a library for opening, manipulating, and saving many different image file formats.
transformers: a state-of-the-art Natural Language Processing (NLP) library that provides pre-trained models for various tasks, including the DETR model used here for object detection.
torch: a Python library for scientific computing, especially deep learning, providing tensors that can run on either a CPU or a GPU.
requests and os: standard Python libraries for handling HTTP requests and interacting with the operating system, respectively.

Initializing the Model and Processor

The DetrImageProcessor and DetrForObjectDetection classes are imported from the transformers library. These are initialized with the pretrained DETR model from Facebook, "facebook/detr-resnet-50".

Defining the Image Crop Function

def image_crops(input_directory, output_directory, confidence):

    # Loop through every file in the input directory
    for filename in os.listdir(input_directory):
        # Get the path to the current file
        curr_path = os.path.join(input_directory, filename)

        # Open the current file as an image
        image = Image.open(curr_path)

        # Pass the image to the model to detect objects
        inputs = processor(images=image, return_tensors="pt")
        outputs = model(**inputs)

        # Get the dimensions of the image
        target_sizes = torch.tensor([image.size[::-1]])

        # Post process the model outputs to get the detected objects
        results = processor.post_process_object_detection(
            outputs, target_sizes=target_sizes, threshold=confidence)[0]

        # Loop through the detected objects
        with Image.open(curr_path) as im:
            for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
                # Round the coordinates of the detected object
                box = [round(i, 2) for i in box.tolist()]
                # Get the label of the detected object
                label_text = model.config.id2label[label.item()]
                print(
                    f"Detected {model.config.id2label[label.item()]} with confidence "
                    f"{round(score.item(), 3)} at location {box}"
                )

                # Create a directory for the label if it does not exist
                if not (os.path.exists(f"{output_directory}/{label_text}")):
                    os.mkdir(f"{output_directory}/{label_text}")
                counts[label_text] = counts.get(label_text, 0) + 1
                remote_region = im.crop(box)
                remote_region.save(
                    f"{output_directory}/{label_text}/{label_text}_{counts[label_text]}.jpg")

The image_crops function takes three arguments: input_directory, output_directory, and confidence. This function iterates through all the images in the input_directory, performs object detection on each image, and saves the cropped images in the corresponding output_directory. The confidence parameter is a threshold for the model to determine if an object is present or not.

The function performs the following steps:

Loops through each image file in the input directory.
Opens the image file and processes it using the DetrImageProcessor.
Passes the processed image to the DetrForObjectDetection model.
Gets the dimensions of the image and post-processes the model outputs to get the detected objects and their bounding boxes.
Loops through each detected object and crops the image based on the bounding box coordinates.
Saves the cropped image to the output directory, creating new directories for each detected object type if necessary.

GUI Functions

Several functions are defined to interact with the GUI:

select_input_dir: Lets the user choose the input directory.
select_output_dir: Lets the user choose the output directory.
submit: Gets the selected directories and confidence level, calls the image_crops function with these parameters, and closes the application after processing.

Building the GUI

The tkinter library is used to create the GUI. The application window is created using tk.Tk(). The GUI contains buttons for selecting the input and output directories, a slider for setting the confidence level, and a submit button to start the processing. The grid function is used to position these elements in the application window.

The mainloop function is called to start the tkinter event loop, which waits for user interaction and responds accordingly.

The final script is a complete application that allows users to perform object detection and image cropping tasks easily. It is a great example of how powerful machine learning models can be combined with user-friendly interfaces to create practical tools.

10 Impressive Machine Learning Projects to Add to Your Python Portfolio

Seth Bang — Wed, 05 Apr 2023 20:41:04 +0000

Image recognition: Build an image recognition system that can identify objects in images. You could use the popular ImageNet dataset and a pre-trained neural network like VGG or ResNet, or train your own model.
Sentiment analysis: Create a sentiment analysis system that can classify text as positive, negative or neutral. You could use a dataset of movie reviews or tweets to train your model.
Chatbot: Build a chatbot using natural language processing and machine learning. You could use a framework like TensorFlow or PyTorch to create a neural network that can understand and respond to user queries.
Recommendation engine: Create a recommendation engine that can suggest products or content to users based on their browsing or purchase history. You could use a collaborative filtering approach or a content-based approach to build your model.
Fraud detection: Build a fraud detection system that can detect anomalies in financial transactions. You could use a variety of machine learning algorithms, such as logistic regression or random forests, to train your model.
Spam filtering: Create a spam filtering system that can classify emails as spam or not spam. You could use a dataset of emails and apply techniques like Naive Bayes or SVM to train your model.
Time series forecasting: Build a time series forecasting system that can predict future values based on historical data. You could use a variety of techniques, such as ARIMA, LSTM or Prophet, to build your model.
Object detection: Create an object detection system that can identify and locate objects in images or videos. You could use a pre-trained model like YOLO or Mask R-CNN, or train your own model.
Style transfer: Build a style transfer system that can apply the style of one image to another image. You could use a pre-trained model like Neural Style Transfer, or train your own model.
Voice recognition: Create a voice recognition system that can identify speakers and transcribe their speech. You could use a pre-trained model like DeepSpeech, or train your own model.

These are just a few ideas to get you started. The possibilities are endless when it comes to machine learning projects, so feel free to get creative and come up with your own ideas.

Best Minors to Pair with a Computer Science Degree: Enhance Your Expertise and Marketability

Seth Bang — Fri, 31 Mar 2023 23:27:53 +0000

Mathematics - Computer Science and Mathematics are closely related fields, as many computer science problems require a strong foundation in mathematical concepts such as algorithms, logic, and discrete mathematics.
Statistics - Computer Science and Statistics are also closely related, as data analysis and machine learning algorithms rely heavily on statistical models and methods.
Physics - Physics provides a strong foundation in problem-solving and analytical thinking, which can be applied to computer science problems involving complex algorithms and simulations.
Business Administration - A minor in Business Administration can provide a strong foundation in business management and entrepreneurship, which can be useful for computer science professionals who want to start their own businesses or work in technology startups.
Cognitive Science - Cognitive Science provides insights into the workings of the human mind and how people interact with technology, which can be useful for designing user-friendly computer interfaces and developing artificial intelligence systems.
Digital Media - A minor in Digital Media can provide practical skills in graphic design, web development, and multimedia production, which can be useful for computer science professionals working in fields such as web development, video game design, and virtual reality.
Data Science - Data Science provides a strong foundation in data analysis, machine learning, and statistical modeling, which are all critical skills for computer science professionals working with large data sets and developing predictive algorithms.
Cybersecurity - Cybersecurity provides practical skills in protecting computer systems and networks from cyber threats, which is becoming an increasingly important concern for businesses and organizations in today's digital age.
Economics - Economics provides insights into how markets and businesses function, which can be useful for computer science professionals working in fields such as financial technology and e-commerce.
Linguistics - Linguistics provides insights into how human language works, which can be useful for computer science professionals working on natural language processing and speech recognition systems.
Psychology - Psychology provides insights into human behavior and cognition, which can be useful for computer science professionals working on user interfaces and artificial intelligence systems.
Robotics - Robotics provides practical skills in building and programming robotic systems, which is becoming an increasingly important field in areas such as manufacturing, healthcare, and space exploration.
Game Design and Development - A minor in Game Design and Development can provide practical skills in game programming, graphic design, and game theory, which can be useful for computer science professionals working in the video game industry.
Graphic Design - Graphic Design provides practical skills in visual communication, which can be useful for computer science professionals working in areas such as web design, user interface design, and multimedia production.
Information Systems - Information Systems provides practical skills in database design, network management, and systems analysis, which can be useful for computer science professionals working in fields such as information technology and software engineering.

15 Engaging Python Projects to Elevate Your Personal Portfolio

Seth Bang — Fri, 31 Mar 2023 19:58:11 +0000

Web Scraper: Create a web scraper using libraries like Beautiful Soup and requests to extract and analyze data from websites, such as news articles, product listings, or job postings.
Personal Blog: Use Flask or Django to build a personal blog with features like user authentication, commenting, and a simple content management system (CMS).
Chatbot: Develop a chatbot using natural language processing (NLP) libraries like NLTK or spaCy for simple question-answering or customer support.
To-Do List App: Create a to-do list app with a GUI using Tkinter or PyQt, allowing users to add, edit, and delete tasks, as well as set deadlines and priorities.
Expense Tracker: Develop an expense tracker that records and categorizes expenses, generates reports, and provides visualizations using libraries like pandas and Matplotlib.
Cryptocurrency Price Tracker: Build an app that retrieves and displays real-time cryptocurrency prices using APIs, and allows users to set price alerts.
Social Media Sentiment Analyzer: Use NLP and machine learning libraries like TextBlob or VADER to analyze sentiment in tweets or other social media posts related to a specific topic or brand.
Image Classification: Implement a simple image classifier using machine learning libraries like TensorFlow or PyTorch to identify objects or animals in images.
Weather App: Create a weather app that retrieves and displays current weather data and forecasts for a given location using APIs like OpenWeatherMap.
Portfolio Website: Design a portfolio website showcasing your projects, skills, and experiences, using Flask or Django as the back-end and integrating front-end technologies like HTML, CSS, and JavaScript.
File Organizer: Develop a script that organizes files on your computer based on file type, date, or other criteria, making it easier to manage and find files.
Quiz Application: Create a quiz application with a GUI that allows users to take quizzes, track their scores, and view statistics about their performance.
Data Visualization Dashboard: Use libraries like Plotly or Bokeh to create interactive data visualizations and dashboards for displaying and exploring datasets.
Password Manager: Build a secure password manager with encryption using libraries like cryptography, allowing users to store and retrieve their login credentials.
Machine Learning Model Deployment: Train a machine learning model using libraries like Scikit-learn and deploy it as a RESTful API using Flask or FastAPI for real-world applications.

These projects will help you demonstrate your skills and proficiency in Python, as well as provide you with a diverse portfolio that showcases your abilities across various domains.

Web Scraping Tutorial with Python and Beautiful Soup

Seth Bang — Fri, 31 Mar 2023 19:40:34 +0000

In this tutorial, we will use Python and a popular web scraping library called Beautiful Soup to scrape a website. We will cover the basics of web scraping, including making requests, parsing HTML, and extracting data.

Prerequisites

Basic understanding of Python.
Familiarity with HTML.

Tools and Libraries

Python 3.x
Beautiful Soup 4
Requests

Step 1: Install Required Libraries

First, you need to install Beautiful Soup and Requests libraries. You can do this using pip:

pip install beautifulsoup4
pip install requests

Step 2: Import Required Libraries

In your Python script, import the required libraries:

import requests
from bs4 import BeautifulSoup

Step 3: Make an HTTP Request

To scrape a website, you first need to download its HTML content. You can use the Requests library to do this:

url = 'https://example.com'  # Replace this with the website you want to scrape
response = requests.get(url)

# Check if the request was successful (status code 200)
if response.status_code == 200:
    html_content = response.text
else:
    print(f"Failed to fetch the webpage. Status code: {response.status_code}")

Step 4: Parse the HTML Content

Now that you have the HTML content, you can parse it using Beautiful Soup:

soup = BeautifulSoup(html_content, 'html.parser')

Step 5: Extract Data

With the parsed HTML, you can now extract specific data using Beautiful Soup's methods:

# Find a single element by its tag
title_tag = soup.find('title')

# Extract the text from the tag
title_text = title_tag.text
print(f"The title of the webpage is: {title_text}")

# Find all the links on the webpage
links = soup.find_all('a')
for link in links:
    href = link.get('href')
    link_text = link.text
    print(f"{link_text}: {href}")

Step 6: Save Extracted Data

You can save the extracted data in any format you prefer, such as a CSV or JSON file. Here's an example of how to save extracted data to a CSV file:

import csv

# Assuming you have a list of dictionaries with the extracted data
data = [{'text': 'Link 1', 'url': 'https://example.com/link1'},
        {'text': 'Link 2', 'url': 'https://example.com/link2'}]

with open('extracted_data.csv', 'w', newline='') as csvfile:
    fieldnames = ['text', 'url']
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
    writer.writeheader()
    for row in data:
        writer.writerow(row)

And that's it! This basic tutorial should help you get started with web scraping using Python and Beautiful Soup. Remember to always respect the website's terms of service and robots.txt file, and avoid overloading the server with too many requests in a short period of time.