An Interactive Prototyping Framework for AI-Driven Wound Care Education.

Abstract

The integration of Artificial Intelligence (AI) into medical education holds transformative potential, yet its practical application often lags behind theoretical discourse. A recent comprehensive review highlighted a significant gap in wound care education: a scarcity of functional, validated AI tools for educators and students.This paper documents the end-to-end development of a prototype AI-powered educational toolkit designed to directly address this gap.Leveraging two public datasets for Pressure Ulcers and Diabetic Foot Ulcers (DFU), we detail a complete workflow encompassing data preprocessing, model training via transfer learning with the MobileNetV2 architecture, and the development of an interactive web application using Streamlit.The resulting models achieved high validation accuracies (≈99.05%) on their respective classification tasks. The final deliverable is a functional, deployable toolkit featuring a “Student View” for real-time analysis and an “Educator View” with a dashboard for simulating and tracking class performance.This work serves as a practical proof-of-concept, demonstrating a complete pipeline from identifying a research gap to building a high-fidelity, user-centric educational prototype.

1. Introduction

Wound care represents a critical and financially significant domain within global healthcare. The effective management of chronic wounds, such as pressure ulcers and diabetic foot ulcers, is contingent upon the robust training and continued education of healthcare professionals. In recent years, Artificial Intelligence (AI) has emerged as a promising pedagogical tool across medical disciplines, offering novel approaches for skill development and knowledge acquisition. Despite this potential, a 2025 scoping review by Encarnação et al. in Nurse Education Today systematically analyzed the landscape of AI in wound care education and identified a critical disconnect. The authors concluded that “most studies lacked empirical validation, highlighting significant gaps in integrating artificial intelligence into wound care education”. The literature is replete with conceptual frameworks, but there remains a profound lack of tangible, interactive tools that educators and students can utilize in a practical learning environment.

This project was conceived to directly address this identified gap. The primary objective is to develop and document a complete, end-to-end prototype of an AI-powered educational toolkit. This work is not intended for clinical diagnosis but serves as a high-fidelity proof-of-concept that demonstrates the feasibility and utility of such a tool. It chronicles the entire project lifecycle: from sourcing and cleaning disparate public datasets to training high-performance classification models and deploying them in a polished, interactive, and user-friendly web application designed for both student and educator use cases.

2. Methods and Materials

The methodology followed a structured, three-step process: (1) curation and preprocessing of datasets, (2) development and training of deep learning models, and (3) development of the interactive user interface.

2.1. Dataset Curation and Preprocessing

The project utilized two distinct, publicly available datasets sourced from Kaggle:

• Pressure Ulcers (Stages) Dataset: A collection of images categorized by the medically recognized stages of pressure ulcers.
• Diabetic Foot Ulcer (DFU) Dataset: A dataset containing patches of images classified as either containing an ulcer or representing healthy skin.

The initial state of the data presented significant organizational challenges, particularly the DFU dataset, which contained redundant subfolders and inconsistently named files. To create a clean, reliable foundation for model training, a preprocessing script was developed. This script automates the organization by creating a new, structured Clean_Dataset directory, copying only the valid and well-organized data, and renaming folders for programmatic clarity.

Code 1: organize_data.py

This script standardizes the project’s data structure, preparing it for the training pipeline.

# organize_data.py
import os
import shutil
# This script automatically detects its location (the Sandbox folder)
# and looks for the source data in a subfolder named 'dataset'.
workspace_path = os.path.dirname(os.path.abspath(__file__))
source_dataset_path = os.path.join(workspace_path, "dataset")
clean_dataset_path = os.path.join(workspace_path, "Clean_Dataset")
print("Starting data organization...")
# Create the main clean directory, removing the old one if it exists
if os.path.exists(clean_dataset_path):
    print(f"'{clean_dataset_path}' already exists. Removing old version.")
    shutil.rmtree(clean_dataset_path)
os.makedirs(clean_dataset_path)
print(f"Created clean dataset folder at: {clean_dataset_path}")
# Organize the Pressure Ulcer Dataset
print("\nProcessing Pressure Ulcer dataset...")
pressure_source = os.path.join(source_dataset_path, "Pressure_ulcer")
pressure_dest = os.path.join(clean_dataset_path, "pressure_ulcer_staging")
.............[Rest of the code]
    for source_name, dest_name in source_folders.items():
        source_folder_path = os.path.join(dfu_source, source_name)
        dest_folder_path = os.path.join(dfu_dest, dest_name)
        if os.path.exists(source_folder_path):
            shutil.copytree(source_folder_path, dest_folder_path)
            print(f"  - Copied and renamed '{source_name}' to '{dest_name}'.")
    print("Successfully organized DFU images.")
else:
    print(f"ERROR: DFU 'Patches' folder not found at '{dfu_source}'")
print("\nData organization complete!")

2.2. Model Architecture and Training

To achieve high performance without requiring massive computational resources, a transfer learning approach was adopted. The MobileNetV2 architecture, pre-trained on the ImageNet dataset, was s…(truncated 8555 characters)…

2.3. Interactive User Interface Development

The final application features a dual-view interface: a “Student View” for direct image analysis and an “Educator View” which includes a dashboard to simulate and review class performance. Model loading is optimized using Streamlit’s caching mechanism (@st.cache_resource). Custom CSS was injected to provide a polished, professional user interface with a centered layout, pastel color scheme, and shadowed result cards.

Code 3: app.py

# app.py

import streamlit as st
import tensorflow as tf
import numpy as np
from PIL import Image
import os
import random
import time

# app.py (Phase 2 Version with Educator Dashboard)

import os
import streamlit as st
import tensorflow as tf
from PIL import Image
import numpy as np
import pandas as pd
import plotly.express as px
import random

# --- PAGE CONFIGURATION ---
st.set_page_config(
    page_title="AI Wound Care Toolkit",
    page_icon="🎓",
    layout="wide"
)

# --- CUSTOM STYLING (CSS) ---
st.markdown("""
<style>
    .main-container { max-width: 900px; margin: auto; padding: 2rem; border: 2px solid #e0e0e0; border-radius: 15px; background-color: #f9f9f9; }
    .result-card { background-color: #e7f3ff; border: 1px solid #cce0ff; padding: 1.5rem; border-radius: 10px; box-shadow: 0 4px 8px 0 rgba(0,0,0,0.1); margin-top: 1rem; }
    h1, h2, h3 { color: #0d47a1; }
    .st-expander { border-color: #cce0ff !important; }
</style>
""", unsafe_allow_html=True)

# --- PATH AND MODEL CONFIGURATION ---
workspace_path = os.path.dirname(os.path.abspath(__file__))
models_path = os.path.join(workspace_path, "models")
demo_images_path = os.path.join(workspace_path, "demo_images")

.............[Rest of the code]
)

# -------------------------------------------------------------------
# --- STUDENT VIEW ---
# -------------------------------------------------------------------
if view_mode == "Student View":
    st.title("AI Wound Analysis Tool 🩺")
    st.write("")

    st.subheader("1. Select the Analysis Type")
    analysis_type = st.selectbox("Choose which AI model to use:", list(MODEL_INFO.keys()))
    st.info(MODEL_INFO[analysis_type]['description'], icon="ℹ️")

    st.subheader("2. Upload Your Image")
    uploaded_file = st.file_uploader("Upload an image", type=["jpg", "png", "jpeg"], label_visibility="collapsed", key=f"student_{analysis_type}")

    if uploaded_file is not None:
        st.markdown('<div class="result-card">', unsafe_allow_html=True)
        model = load_model(analysis_type)
        if model is not None:
            col1, col2 = st.columns(2)
            with col1:
                image = Image.open(uploaded_file).convert('RGB')
                st.image(image, caption="Uploaded Image", use_container_width=True)
            with col2:
                with st.spinner("Analyzing..."):
                    img_resized = image.resize((224, 224))
                    img_array = np.array(img_resized)
                    img_array = np.expand_dims(img_array, axis=0)
                    predictions = model.predict(img_array)
                    scores = tf.nn.softmax(predictions[0])
                    class_names = MODEL_INFO[analysis_type]["class_names"]
                    predicted_class = class_names[np.argmax(scores)]
                    confidence = 100 * np.max(scores)
                    st.subheader("Analysis Results")
                    st.metric("AI Prediction", predicted_class)
                    st.metric("Confidence", f"{confidence:.2f}%")
            
            st.subheader("Prediction Confidence Scores")
            df = pd.DataFrame({'Class': class_names, 'Confidence (%)': [s * 100 for s in scores.numpy()]})
            fig = px.bar(df, x='Class', y='Confidence (%)', text_auto='.2f', color_discrete_sequence=['#42a5f5'])
            st.plotly_chart(fig, use_container_width=True)
        else:
            st.error(f"Model for {analysis_type} not found.")
        st.markdown('</div>', unsafe_allow_html=True)

# -------------------------------------------------------------------
# --- EDUCATOR VIEW ---
# -------------------------------------------------------------------
elif view_mode == "Educator View":
    st.title("Educator Dashboard 📊")
    st.write("This dashboard simulates a classroom activity to demonstrate how an instructor could track student performance using the AI tool.")

    if st.button("Simulate Class Submissions", key="demo_button"):
        with st.spinner("Generating demo data..."):
            student_names = ["Alex", "Ben", "Chloe", "David", "Eva", "Frank", "Grace", "Henry"]
            demo_files = [f for f in os.listdir(demo_images_path) if f.endswith(('.png', '.jpg', '.jpeg'))]
............[Rest of the code]
        st.plotly_chart(fig, use_container_width=True)
    else:
        st.error(f"Model for {analysis_type} not found.")
    st.markdown('</div>', unsafe_allow_html=True)

st.markdown('</div>', unsafe_allow_html=True)

3. Results

3.1. Model Performance

Upon completion of the 10-epoch training cycle, both models demonstrated exceptional performance on the held-out validation set. The final reported metrics were a validation accuracy of approximately 99.05% and a validation loss of approximately 0.0406. These results indicate that the models are not only highly accurate but also generalize well to new, unseen data. The detailed performance and learning characteristics are visualized in the following figures.

3.2. Prototype Educational Toolkit

The final result of the development phase is a fully functional, interactive web application. The toolkit successfully integrates the two trained models into a user-friendly interface that caters to both students and educators, fulfilling the primary objective of the project.

4. Discussion

The results strongly support the viability of using transfer learning with the MobileNetV2 architecture for developing high-accuracy classifiers for wound care education, even with modestly sized public datasets. The near-perfect validation accuracy and the clear, interpretable confusion matrices demonstrate that the models are robust for their intended educational purpose. This project directly addresses the gap identified by Encarnação et al. by moving beyond a theoretical framework to produce a tangible, interactive prototype. The “Educator View” with its simulation dashboard is a particularly novel feature that demonstrates a deeper understanding of the pedagogical workflow, allowing instructors to not only present the tool but also to structure and evaluate learning activities around it. While the prototype is successful, its limitations must be acknowledged. It is an educational tool, not a clinical diagnostic device. The models were trained on a limited set of public images and have not been validated in a clinical setting against a diverse patient population. Future work would involve expanding the dataset, conducting rigorous pilot testing with real users (Phase 3), and further refining the user interface based on their feedback.

5. Conclusion

This paper has detailed the complete, end-to-end process of creating an AI-powered wound care educational toolkit, from identifying a gap in academic literature to deploying a functional prototype. The project successfully demonstrates the integration of data preprocessing, deep learning model training, and interactive web development to create a valuable portfolio piece and a strong proof-of-concept. It serves as a practical blueprint for how modern AI tools can be rapidly developed to create meaningful, high-impact solutions for challenges in medical education.

6. Pilot Testing, Feedback, and Iteration 🧪

The goal of this phase is to test the toolkit with real users to get feedback, prove its effectiveness, and identify areas for improvement. This is what you would do in a real-world academic or commercial setting after building a successful prototype. Here are the typical steps involved:

• 🎯 Define Pilot Study Goals: Before testing, you’d establish what you want to learn. For example:
  • Usability: Is the interface intuitive for end-users?
  • Efficacy: Does using the tool lead to a measurable improvement in users’ wound assessment skills compared to traditional methods?
  • Feedback: What features are most valuable? What’s missing?
• 섭 Recruit Participants: You would recruit a small, controlled group, such as 1-2 expert reviewers and a class of 5-10 test participants, to participate in the pilot test.
• 🚀 Conduct the Pilot Test: An expert reviewer would be given instructions and asked to integrate the live Toolkit into a short, mock testing session. Participants would use the tool to analyze a set of pre-selected images.
• 📝 Gather Feedback: After the session, you would collect feedback through:
  • Surveys: Asking participants to rate the tool’s ease of use and perceived value.
  • Interviews: Having brief conversations to gather more detailed qualitative insights and suggestions.
• 💡 Analyze and Iterate: Finally, you would analyze all the feedback to identify key takeaways. This analysis would form the basis for a future version of the toolkit, with improvements and new features driven directly by user data.

7. References

1. Encarnação, R., Alves, J., Marques, A., Neves-Amado, J., & Alves, P. (2025). Artificial intelligence in wound care education: Scoping review. Nurse Education Today, 155, 106872. https://doi.org/10.1016/j.nedt.2025.106872
2. Gökozan, S. (2022). Pressure Ulcers (Stages) Dataset. Kaggle. https://www.kaggle.com/datasets/sinemgokoz/pressure-ulcers-stages
3. J.J., L. (2022). Diabetic Foot Ulcer (DFU) Dataset. Kaggle. https://www.kaggle.com/datasets/laithjj/diabetic-foot-ulcer-dfu