DEV Community: OMOTAYO OMOYEMI

Strengthening Open-Source Integrity: My First Contribution to spaCy

OMOTAYO OMOYEMI — Tue, 28 Oct 2025 09:55:46 +0000

Open-source software thrives on collaboration, trust, and shared responsibility. Recently, one of my contributions to spaCy, a leading open-source Natural Language Processing (NLP) library developed by Explosion was successfully merged into the main branch. 🎉

🔗 Pull Request: #13877 — Remove spaCy Quickstart from Universe/Courses due to spam redirect

🧩 Identifying the Issue

While exploring spaCy’s educational resources, I discovered that one of the links listed in the Universe/Courses section “spaCy Quickstart” had become compromised. Instead of pointing to genuine learning content, it redirected users to spam and ad-filled pages.

This posed a potential security and credibility risk for the spaCy documentation, which is widely accessed by developers, researchers, and students across the world. The issue was formally logged as #13853

🛠️ Implementing the Fix

My contribution involved a targeted cleanup of the file website/meta/universe.json. I:

Removed the “spaCy Quickstart” object referencing the broken external link.
Verified that the JSON structure remained valid and fully functional.
Ensured no other content or metadata was affected.

Though a small change in lines of code, it played a vital role in preserving the integrity of spaCy’s learning ecosystem and maintaining the trust of its global user community.

💡 Why It Matters

Open-source excellence is not just about writing new features, it’s about protecting quality, reliability, and user trust.

By identifying and resolving a spam redirect, I helped ensure that developers accessing spaCy’s resources are directed only to safe, verified, and relevant learning materials. This contribution reinforces the professionalism and security standards that make open-source projects sustainable and credible.

In essence, small fixes like this have a large cumulative impact, they keep global developer communities safe, confident, and engaged.

🤝 Collaboration and Reflection

Having this PR merged by Matt Honnibal, spaCy’s co-creator, was a rewarding moment. It underscored how open-source collaboration connects developers and researchers worldwide, regardless of scale or geography.

This experience strengthened my commitment to contributing to responsible, human-centered AI projects ensuring that as we advance technology, we also protect the people and communities who use it.

💬 Have you ever fixed or reported a broken or unsafe link in an open-source project? It’s a small step that keeps the ecosystem strong. I’d love to hear about your experience in the comments!

OpenSource #Python #NLP #spaCy #AI #Documentation #Accessibility

Updating ASR examples in Hugging Face Transformers Hub datasets, clearer args, smoother Windows setup

OMOTAYO OMOYEMI — Tue, 30 Sep 2025 18:17:22 +0000

I merged a docs/examples update to 🤗 Transformers that:

Pins CTC training commands to Hub datasets (instead of deprecated local scripts)
Clarifies dataset_name vs dataset_config_name help (matches 🤗 Datasets docs)
Adds small Windows setup notes Merged PR: https://github.com/huggingface/transformers/pull/41027

The problem (why this change was needed)

Some users following the Automatic Speech Recognition (ASR) examples hit setup errors because older instructions referenced local dataset scripts. Modern datasets expects Hub datasets (e.g., Common Voice by version and language), so commands like --dataset_name="common_voice" were fragile or ambiguous—especially on Windows.

What changed (at a glance)

Use explicit Hub dataset IDs in CTC commands
Example: mozilla-foundation/common_voice_17_0(versioned, reproducible)
Clarify arguments in the example script help
dataset_name → the dataset ID on the Hub
dataset_config_name → the subset/language (e.g., en, tr, clean)
Tiny Windows notes
How to activate venv in PowerShell
How to run formatters without make

Before vs After (one line that mattered)

Before

--dataset_name="common_voice" \
--dataset_config_name="tr" \

After

--dataset_name="mozilla-foundation/common_voice_17_0" \
--dataset_config_name="tr" \

This small change prevents the “dataset scripts are no longer supported” error and makes runs reproducible.

Quickstart: CTC finetuning (Common Voice, Turkish)

python run_speech_recognition_ctc.py \
  --dataset_name="mozilla-foundation/common_voice_17_0" \
  --dataset_config_name="tr" \
  --model_name_or_path="facebook/wav2vec2-large-xlsr-53" \
  --output_dir="./wav2vec2-common_voice-tr-demo" \
  --overwrite_output_dir \
  --num_train_epochs="15" \
  --per_device_train_batch_size="16" \
  --gradient_accumulation_steps="2" \
  --learning_rate="3e-4" \
  --warmup_steps="500" \
  --eval_strategy="steps" \
  --text_column_name="sentence" \
  --length_column_name="input_length" \
  --save_steps="400" \
  --eval_steps="100" \
  --layerdrop="0.0" \
  --save_total_limit="3" \
  --freeze_feature_encoder \
  --gradient_checkpointing \
  --fp16 \
  --group_by_length \
  --push_to_hub \
  --do_train --do_eval

Change dataset_config_nameto your language (e.g., en, hi, …).

Windows notes (PowerShell)

# activate venv
.\.venv\Scripts\Activate.ps1

# if 'make' isn't available, run formatters directly
python -m black <changed_paths>
python -m ruff check <changed_paths> --fix

Impact

Fewer setup failures (no local script pitfalls)
Reproducible examples (pinned, versioned datasets)
Better cross-platform DX (Windows included)
Consistency with current 🤗 Datasets guidance

Proof (validation)

Reviewed and approved by maintainers; merged to main
All CI checks green (quality + example tests)
PR: https://github.com/huggingface/transformers/pull/41027

Thanks to the Transformers maintainers for the review and merge!

If you try the example or want to improve the docs further drop a comment or open a PR. 🙌

Building an Accessible School Management Portal: Lessons from My Web Dev Journey

OMOTAYO OMOYEMI — Fri, 18 Jul 2025 20:44:45 +0000

In today’s world, accessibility in web applications isn’t just a nice-to-have it’s essential. When I set out to build a School Management Portal for teachers, students, and administrators, my goal was not just functionality, but inclusivity.

In this post, I’ll walk you through how I approached the design and development of an accessible school portal using PHP, MySQL, and responsive web technologies. Whether you’re a beginner or a seasoned developer, these lessons can help you build user-friendly systems for real-world impact.

Why Accessibility Matters in School Portals

A school portal serves a diverse community: students with different learning abilities, parents accessing from mobile devices, and administrators managing sensitive data.

Making the system accessible ensures:

🌐 Equal access for all users.
📱 Compatibility across devices.
🔐 Secure management of confidential data.

🛠️ Step 1: Planning the System Architecture

Before writing any code, I drafted the core features:

Student Information System (SIS)
Attendance Tracking
Grade Management
Role-based User Authentication (Admin, Teacher, Student)

I created a simple ER diagram to design the database schema using MySQL. Key tables included users, students, classes, and grades.

ER Diagram Snapshot:
Users (user_id, name, email, role, password_hash) Students (student_id, user_id, class_id, DOB) Classes (class_id, name, teacher_id) Grades (grade_id, student_id, subject, score)

🌐 Step 2: Building the Backend with PHP and MySQL
I chose PHP for server-side scripting and MySQL for the database.
Here’s a simple PHP snippet for user authentication:

<?php
// login.php
session_start();
include('db_connect.php');

$email = $_POST['email'];
$password = $_POST['password'];

$query = "SELECT * FROM users WHERE email = ?";
$stmt = $conn->prepare($query);
$stmt->bind_param("s", $email);
$stmt->execute();
$result = $stmt->get_result();

if ($row = $result->fetch_assoc()) {
    if (password_verify($password, $row['password_hash'])) {
        $_SESSION['user_id'] = $row['user_id'];
        header("Location: dashboard.php");
        exit;
    } else {
        echo "Invalid credentials.";
    }
} else {
    echo "User not found.";
}
?>

Security Note: Always hash passwords with password_hash() and use prepared statements to prevent SQL injection.

📱 Step 3: Designing a Responsive Frontend
I implemented the frontend using HTML5, CSS3, and Bootstrap to ensure mobile compatibility.

Key Accessibility Practices:

Use semantic HTML tags (like <nav>, <main>, <footer>).
Ensure proper colour contrast for readability.
Add ARIA labels for assistive technologies.

Example: Accessible Login Form

<form action="login.php" method="POST">
  <label for="email">Email:</label>
  <input type="email" id="email" name="email" required aria-label="Email address">
  <label for="password">Password:</label>
  <input type="password" id="password" name="password" required aria-label="Password">
  <button type="submit">Login</button>
</form>

Tested with screen readers to verify usability.

📝 Lessons Learned
🔒 Data Security: Encryption and role-based permissions are vital.
📱 Mobile First: Many parents and students access portals via mobile devices.
♿ Accessibility: Small changes like ARIA labels make a big difference.

🚀 Next Steps

This project gave me a deeper appreciation for inclusive design. Here’s what I plan to add next:
📧 Email notifications for parents.
📊 Data visualization for teachers (attendance, grades).
🌐 API endpoints for mobile app integration.

Building accessible systems isn’t just good practice, it’s our responsibility as developers.

A Beginner’s Guide to Prompt Engineering: Making GPT Models Do What You Want

OMOTAYO OMOYEMI — Wed, 16 Jul 2025 01:03:06 +0000

Prompt engineering is one of the most important skills for anyone working with AI today. Whether you’re building chatbots, integrating GPT models into apps, or just exploring AI tools like ChatGPT, understanding how to write effective prompts can make all the difference.

In this guide, we’ll explore how prompts work, why they matter, and how you can start crafting them to get consistent, reliable results from GPT models.

What is Prompt Engineering, and Why Does It Matter?

At its core, prompt engineering is the art of communicating effectively with a large language model (LLM). Instead of just typing random text and hoping for the best, you design prompts that:

Give clear instructions.
Include context or examples.
Reduce ambiguity and bias.

Why does this matter? Because LLMs like GPT are probabilistic, they predict the next word based on input. Slight differences in your prompt can produce vastly different results.

Zero-Shot vs. Few-Shot Prompting
There are two key strategies to know:

🔹 Zero-Shot Prompting
This is when you give no examples—just instructions.

Example:
Translate this sentence into French: “I am learning Python.”
The model understands and outputs:
Je suis en train d’apprendre Python.
This is very Useful for straightforward tasks.

🔹 Few-Shot Prompting
Here you provide a few examples in your prompt to show the model what you expect.

Example:
Translate these sentences into French:
`“Hello” → “Bonjour”
“How are you?” → “Comment ça va?”
“I am learning Python” →

The model is more likely to match your desired format and style. This is Great for complex tasks or custom formats.

🛠Crafting Structured Prompts for API Calls
When working with GPT APIs, you’ll often structure your prompt as part of a JSON payload.

Example using OpenAI’s API:

`import openai response = openai.Completion.create( engine="text-davinci-003", prompt="Summarize the following text in 3 bullet points:\n{text}", max_tokens=150 ) print(response.choices[0].text.strip())`

Notice the clear instructions in the prompt field.
Here are some best practices:

Be explicit: Don’t assume the model “knows” what you mean.
Set constraints: e.g., word count, format.
Avoid ambiguity: If in doubt, clarify in the prompt

💻 Real-World Example: Getting GPT to Explain Code
Let’s ask GPT to explain a Python snippet.
Prompt:
Explain what this Python function does in simple terms:

def bubble_sort(arr): n = len(arr) for i in range(n): for j in range(0, n-i-1): if arr[j] > arr[j+1]: arr[j], arr[j+1] = arr[j+1], arr[j]

Expected Output:
This function sorts a list of numbers in ascending order using the bubble sort algorithm. It repeatedly compares adjacent elements and swaps them if they are in the wrong order.

So its very clear that GPT can act like a tutor if prompted well.

📝 Tips for Safer, More Reliable Prompts

✅ Keep it clear: Avoid ambiguous instructions.
✅ Guide the tone: Specify if you want a formal, casual, or technical answer.
✅ Test and iterate: Adjust and refine prompts based on model behaviour.
✅ Add safety checks: Use moderation or post-processing for sensitive use cases.

🚀 Conclusion
Prompt engineering isn’t just about getting “better” responses—it’s about unlocking the full potential of GPT models. Whether you’re building an app or just tinkering for fun, thoughtful prompting can save time and produce more consistent results.

Now it’s your turn: try experimenting with different prompts and see how GPT responds!

How I Built a Real-Time Gesture-to-Text Translator Using Python and MediaPipe

OMOTAYO OMOYEMI — Sun, 13 Jul 2025 20:04:15 +0000

Imagine being able to translate hand gestures into text in real-time. This isn’t just a fun project—it’s a step toward building accessible tools for people with speech or motor impairments.

In this tutorial, I’ll show you how I built a gesture-to-text translator using Python, MediaPipe, and a lightweight neural network. By the end, you’ll have your own system that captures hand gestures from a webcam and translates them into readable text.

Why Gesture-to-Text Matters

For millions of people who rely on sign or symbol-based communication (like Makaton or ASL), gesture recognition can help bridge communication gaps—especially in educational and accessibility settings.

This project demonstrates how computer vision and machine learning can work together to recognize gestures and translate them to text in real time.

What You’ll Need

Python 3.8+
MediaPipe (for real-time hand tracking)
OpenCV (for webcam integration and visualization)
NumPy
Scikit-learn (for a simple classifier)
A webcam Install the dependencies:

pip install mediapipe opencv-python numpy scikit-learn

Step 1: Setting Up MediaPipe for Hand Tracking
MediaPipe detects 21 hand landmarks in real time. Here’s a visual of how the landmarks are distributed across the hand:

Let’s initialize the webcam and draw these landmarks:

import cv2
import mediapipe as mp

mp_hands = mp.solutions.hands
hands = mp_hands.Hands()
mp_draw = mp.solutions.drawing_utils

cap = cv2.VideoCapture(0)

while True:
    success, frame = cap.read()
    if not success:
        break

    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    result = hands.process(rgb_frame)

    if result.multi_hand_landmarks:
        for hand_landmarks in result.multi_hand_landmarks:
            mp_draw.draw_landmarks(frame, hand_landmarks, mp_hands.HAND_CONNECTIONS)

    cv2.imshow("Hand Tracking", frame)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

Run this script and wave your hand in front of the webcam—you should see landmarks drawn in real time.

How the Gesture-to-Text Pipeline Works
Here’s the high-level workflow we’ll follow in this tutorial:

Capture video frames from the webcam.
Detect hand landmarks using MediaPipe.
Classify the gesture using a machine learning model.
Display the translated text in real time.

Step 2: Collecting Training Data
To recognize gestures, we first need to collect data. This involves recording hand landmarks and labelling them.

import numpy as np

data = []
labels = []

gesture_name = input("Enter gesture label (e.g., thumbs_up): ")

while True:
    success, frame = cap.read()
    if not success:
        break

    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    result = hands.process(rgb_frame)

    if result.multi_hand_landmarks:
        for hand_landmarks in result.multi_hand_landmarks:
            landmarks = []
            for lm in hand_landmarks.landmark:
                landmarks.extend([lm.x, lm.y, lm.z])
            data.append(landmarks)
            labels.append(gesture_name)

    cv2.imshow("Collecting Data", frame)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

# Save to disk
np.save('gesture_data.npy', np.array(data))
np.save('gesture_labels.npy', np.array(labels))

Run this script multiple times for different gestures (like “fist”, “peace”, “OK”). Press q to quit each session.

Step 3: Training a Gesture Classifier
Let’s train a simple K-Nearest Neighbors (KNN) classifier:

from sklearn.neighbors import KNeighborsClassifier

X = np.load('gesture_data.npy')
y = np.load('gesture_labels.npy')

knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X, y)

Now you’re ready to recognize gestures in real time!

Step 4: Real-Time Gesture Recognition
Load your trained model and make predictions:

while True:
    success, frame = cap.read()
    if not success:
        break

    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    result = hands.process(rgb_frame)

    if result.multi_hand_landmarks:
        for hand_landmarks in result.multi_hand_landmarks:
            landmarks = []
            for lm in hand_landmarks.landmark:
                landmarks.extend([lm.x, lm.y, lm.z])

            prediction = knn.predict([landmarks])
            cv2.putText(frame, f'Gesture: {prediction[0]}', (10, 50),
                        cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

    cv2.imshow("Gesture Recognition", frame)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

Conclusion: Challenges and Next Steps
This basic system works but has limitations:

Lighting, camera angles, and background noise can affect accuracy.
For more complex gestures, consider training a neural network (like a CNN or LSTM).
Always prioritize user privacy and accessibility when building assistive technologies.

What’s Next?

Replace KNN with a neural network for dynamic gestures.
Deploy the system in a browser using TensorFlow.js for wider accessibility.
Extend the project to support full sign language alphabets.

✅ You’ve just built the foundation for an inclusive communication tool.