The challenge the team set out to solve is one familiar to anyone who manages a vast heritage site. Pompeii covers roughly 44 excavated hectares and contains approximately 1,500 buildings, and every one of them, along with its frescoes, statues, and structural elements, is slowly deteriorating under the open sky. Continuous monitoring is essential, but human inspection of every roof is slow, expensive, and sometimes dangerous. Drones offer a solution: they can fly over inaccessible areas and capture high-resolution, georeferenced photographs. Yet the raw images are only the beginning. Someone, or something, must interpret thousands of aerial photographs and decide which roofs need urgent attention.

HydraML’s answer is a two-stage pipeline that blends the strengths of deep learning with the efficiency of classical machine learning. In the first stage, a deep neural network, selected automatically by a deep AutoML process built on Amazon’s AutoGluon framework, examines each drone image and extracts a rich numerical representation, or embedding, of what it sees. Rather than using this network to make the final decision, HydraML passes those embeddings through a mathematical compression step based on the Fuzzy-Transform, a technique rooted in fuzzy set theory that reduces the dimensionality of the feature space while preserving the information that matters for classification. The compressed features then feed into a second AutoML system, which automatically selects and trains the best traditional classifier for the task.

This hybrid design is what sets HydraML apart from earlier approaches. Previous combinations of deep and classical methods required researchers to manually choose and tune both the feature extractor and the final classifier, a laborious process involving extensive hyperparameter optimization. By bringing both stages into the AutoML paradigm, HydraML becomes something close to plug-and-play: users specify only a training time budget for the deep component and a few parameters for the fuzzy compression, and the system handles the rest. The Fuzzy-Transform compression also pays dividends before training even begins, because smaller images mean less energy spent transmitting data from drone to cloud.

The mathematical heart of the compression step is elegant in its simplicity. The Fuzzy-Transform partitions an image or feature matrix using overlapping basic functions, which can be sinusoidal, Gaussian, or pi-shaped, each covering a neighborhood of the data. By projecting the original matrix onto these functions, the method produces a much smaller compressed representation. Crucially, prior theoretical work has shown that under reasonable conditions, a learning system trained on Fuzzy-Transform-compressed data can achieve error rates of the same order as one trained on the original data. In HydraML’s experiments, compressing 768-dimensional deep embeddings down to a 12-by-16 grid roughly halved both classifier training time and CPU energy consumption on the Pompeii datasets, with almost no loss in predictive performance.

To test the system, the researchers built two novel datasets from orthophotos of Pompeii captured between June 2023 and September 2024 by a DJI Matrice 300 RTK drone flying at 80 meters, equipped with a Zenmuse L1 camera. Nine orthophotos, each roughly 10 gigabytes, were georeferenced so that any pixel could be traced back to its exact location on the ground. With the help of domain experts, the team curated PompeiiTile, containing 1,327 images of tiled roofs labeled as normal, broken, or covered in weedy vegetation, and PompeiiFlat, containing 922 images of flat roofs labeled as normal, broken conduits, stained, or weedy. Careful data augmentation, applied separately to each cross-validation fold to avoid leakage, balanced the training and validation sets.

The results were striking. On PompeiiTile, HydraML using a cosine fuzzy partition achieved an F1-score of 0.9406, with an accuracy of 0.9404 and the lowest variance among all tested methods, signaling unusual stability. On PompeiiFlat it reached an F1-score of 0.9117. To probe generalization beyond cultural heritage, the team also evaluated HydraML on RescueNet, a publicly available dataset of 8,354 aerial images collected after Hurricane Michael struck Florida in 2018, categorized by FEMA-inspired damage grades from no damage to total destruction. There, HydraML achieved an F1-score of 0.8686, outperforming a DenseNet201-based hybrid approach and a VGG16-based transfer learning method, and beating the standalone deep AutoML system by 1.30 percentage points.

The energy savings may prove even more consequential than the accuracy gains. On the urban dataset, HydraML cut GPU energy consumption by about 62.5 percent compared with a DenseNet201-SVM hybrid, dropping from roughly 139,000 joules to 52,000 joules. On PompeiiTile, reducing training from 480 to 300 seconds saved around 40.92 percent of GPU energy, and on PompeiiFlat the system saved 43.64 percent of GPU energy and 12.28 percent of CPU energy relative to the standalone deep AutoML baseline. Notably, HydraML beat that baseline even though it added just 20 seconds for compression and classical classifier training. The team measured power directly, sampling CPU and GPU draw every 100 milliseconds during training and integrating over time, giving the comparison unusual rigor.

Beyond simply detecting damage, HydraML can grade its severity. Using the same deep embeddings without retraining the expensive neural stage, the system trains additional classifiers to sort each detected problem into small, medium, or high severity. It distinguished broken-tile severity with an F1-score of 0.97, and performed well on vegetation and conduit issues, though it struggled with damp patches on flat roofs, where F1 barely exceeded 0.75. Most classification errors occurred between adjacent severity levels, a difficulty the researchers note also plagues human experts defining the ground truth. This severity information matters because heritage managers use vulnerability indices to prioritize interventions, and accurate severity grading feeds directly into maintenance planning.

The system is not infallible, and the researchers are candid about its failure modes. Dirt and mold on tiles can mimic missing tiles, shadows on flat roofs can be mistaken for damp stains, and dry, reddish vegetation is harder to spot than lush green growth. In one telling example, a clearly broken roof section at the edge of an image was classified as normal because the model focused on the center. The team also acknowledges that the Pompeii datasets contain relatively few original samples and that the approach has not yet been tested at other archaeological sites. Still, the researchers point out that false positives are the safer error: a wrongly flagged roof gets checked by an expert, whereas a missed problem can quietly destroy irreplaceable frescoes and structures. With the code released openly and the Pompeii datasets available on request, HydraML offers heritage sites worldwide a template for monitoring that is simultaneously smarter, faster, and greener.

Subject of Research: A hybrid automated machine learning approach using deep learning, Fuzzy-Transform compression, and UAV imagery to classify damaged roofs at the archaeological site of Pompeii

Article Title: HydraML: a hybrid damaged roofs automated machine learning classifier for cultural heritage

Article References: Colace, F., De Santo, M., Gaeta, R., & Zuchtriegel, G. (2026). HydraML: a hybrid damaged roofs automated machine learning classifier for cultural heritage. Neural Computing and Applications, 38(19), Article 798. https://doi.org/10.1007/s00521-026-12499-w

Image Credits: AI Generated

DOI: 10.1007/s00521-026-12499-w

Keywords: HydraML, automated machine learning, cultural heritage, Pompeii, deep learning, Fuzzy-Transform, roof damage classification, UAV imagery, sustainable AI, AutoGluon, energy efficiency, archaeological site monitoring

QualiGuard was developed by Batın Mert Kocakaplan, Emin Borandağ, Yusuf Özçevik, Fatih Yücalar, and Osman Altay, and is released under an MIT license with its trained model artifacts and derived metric dataset available under Creative Commons CC BY 4.0. The tool is built in Python 3.10 and integrates a remarkable range of established components: the Radon library for static complexity metrics, PyDriller for mining Git commit history, scikit-learn, LightGBM, XGBoost, TensorFlow, AutoGluon, and H2O AutoML for predictive modeling, and the GitHub REST API for large-scale repository collection. Rather than delivering disconnected fragments of analysis, the system assembles the entire chain, from raw repository to actionable verdict, into a single deployable package.

The premise underlying the tool is that software quality risk can be modeled as a supervised learning problem, in which measurable properties of source code and its development history are associated with observed quality outcomes. For every source file, QualiGuard extracts static size and complexity metrics, cognitive-complexity measurements derived from the abstract syntax tree, and process metrics from the Git history, including code churn, author entropy, and commit cadence. Defect labels are generated through the Śliwerski–Zimmermann–Zeller (SZZ) algorithm, a classic repository-mining technique that identifies lines deleted by bug-fixing commits and traces them back to the changes that introduced them. This combination of structural and historical evidence allows the assessment to account not only for how a file looks today but also for how it has evolved.

Beyond defect prediction, the tool detects seven classical code smells, including long methods, large classes, long parameter lists, deep nesting, god functions, high complexity, and low maintainability, using deterministic abstract-syntax-tree analysis. A second, predictive model complements this detector: using 28 code metrics, it estimates the probability that a file belongs to the high-smell-burden group, defined as the files at or above the project-specific 80th percentile of detected smells. This project-relative labeling avoids applying the same absolute smell-count threshold to repositories of very different sizes and structures. The deterministic detector identifies specific known flaws, while the predictive model provides a broader risk signal that can prioritize files for investigation, and the two components deliberately serve distinct, complementary roles.

To select its predictive models, the team benchmarked nine standalone candidates, spanning conventional machine learning, deep learning, and automated machine learning, plus one hybrid stacking configuration, on a dataset of 62,207 files mined from 1,000 public Python repositories. The evaluation used a cross-project five-fold GroupKFold protocol in which repository identity serves as the grouping variable, preventing files from the same project from leaking between training and test folds. This design matters because inflated accuracy from project-level leakage is a well-known pitfall in defect-prediction research. For defect prediction, the winning configuration was a hybrid stacking ensemble combining LightGBM with AutoGluon through an isotonic-calibrated logistic-regression meta-learner, achieving a mean F1 score of 0.64 while reducing fold-to-fold performance variability by roughly 38 percent compared with the strongest single model.

For code smell prediction, the story was different. Stacking yielded no consistent benefit, so the researchers retained a threshold-optimized LightGBM model, which attained a mean F1 score of 0.69. The lesson, the authors note, is that the optimal predictive configuration differs between tasks: defect labels and smell labels carry different class distributions, and assuming one configuration fits both would be unjustified. Operating thresholds were tuned per task, with files flagged as defect-prone at a calibrated probability of 0.42 and as smelly at 0.34. The calibrated probabilities are then mapped onto a three-tier decision policy: files below 0.30 defect probability pass automatically, those between 0.30 and 0.70 are routed to human review, and those at or above 0.70 are blocked from progressing without further inspection.

The user-facing side of QualiGuard is a Flask web application designed for local, single-user execution. A practitioner can paste the URL of a public GitHub repository or upload a compressed project archive of up to 100 megabytes, provided the archive retains its .git directory, since the process metrics and SZZ labeling depend on commit history. The analysis runs asynchronously in a background thread while a progress bar reports each milestone, from cloning through metric extraction, smell detection, and model inference. The resulting dashboard presents project-level health indicators such as defect density per thousand lines of code, refactor ratio, and recent activity, visualizes detected DevOps practices like GitHub Actions workflows, Dockerfiles, and Jenkins pipelines, and lists every analyzed file with its complexity, maintainability index, calibrated probabilities, and color-coded quality-gate tier.

Security received explicit attention, because the tool parses untrusted third-party code. Uploaded archives are validated against their central directory before extraction, with limits on entry count, total uncompressed size, and compression ratio to mitigate decompression bombs, and absolute paths or path-traversal components are rejected. Repository source code is parsed as text only and is never imported or executed. Before any Git command runs, a sanitization step removes repository-local hooks and rewrites the repository configuration using an allowlist, eliminating configuration options that could cause Git to execute external programs such as hooks, diff filters, or credential helpers. GitHub tokens, which are optional and used only to raise API rate limits, are verified before storage, masked in the interface, and excluded from logs. The software is accompanied by 266 automated tests covering metric extraction, labeling, prediction workflows, and web-tier security.

The authors are candid about the limits of the current evaluation. The practical assessment covers predictive performance and execution on a single workstation, and continuous deployment in production environments has not yet been tested. CI/CD integration, execution time across repositories of varying sizes, false-alarm burden, developer acceptance, and the impact of automated gate decisions on real merge outcomes all remain to be empirically assessed. The quality-gate tiers themselves use fixed probability boundaries, making QualiGuard better characterized as a learned, risk-based gate than a fully adaptive one, and the authors flag project-specific threshold adaptation and temporal recalibration as future work. Platform independence is a design characteristic rather than an experimentally validated result, since development and testing took place on Windows 11.

Even with those caveats, QualiGuard represents a meaningful step toward evidence-driven software quality assessment. It bridges two research threads, defect prediction and code smell detection, that are usually studied in isolation but speak to the same underlying notion of file-level risk, and it wraps both in a reproducible pipeline that researchers can reuse to build language-specific metric datasets. By replacing arbitrary fixed thresholds with calibrated, learned estimates of risk, and by making every verdict explainable down to the individual detected smell, the tool offers a glimpse of what continuous quality control in DevOps pipelines could look like when the gate itself has been taught, rather than merely configured. The code, dataset, and trained models are publicly available, inviting both practitioners and researchers to put the approach to the test.

Subject of Research: AI-driven risk-based quality gates for software defect prediction and code smell detection in DevOps pipelines

Article Title: QualiGuard: An AI-driven risk-based quality gate for defect prediction and code smell detection in DevOps pipelines

Article References: Kocakaplan, B. M., Borandağ, E., Özçevik, Y., Yücalar, F., & Altay, O. (2026). QualiGuard: An AI-driven risk-based quality gate for defect prediction and code smell detection in DevOps pipelines. SoftwareX, 36, Article 103090. https://doi.org/10.1016/j.softx.2026.103090

Image Credits: AI Generated

DOI: 10.1016/j.softx.2026.103090

Keywords: QualiGuard, DevOps, defect prediction, code smells, machine learning, quality gates, SZZ algorithm, LightGBM, AutoGluon, software quality, repository mining, cross-project validation