11institutetext: University of Cincinnati 22institutetext: Stanford University
33institutetext: Princeton University

# Advances in developing deep neural networks for finding primary vertices in
proton-proton collisions at the LHC

Simon Akar 11 Mohamed Elashri 11 Rocky Bala Garg 22<EMAIL_ADDRESS>Elliott Kauffman 33 Michael Peters 11 Henry Schreiner 33 Michael Sokoloff 11
<EMAIL_ADDRESS>William Tepe 11 Lauren Tompkins 22

###### Abstract

We are studying the use of deep neural networks (DNNs) to identify and locate
primary vertices (PVs) in proton-proton collisions at the LHC. Earlier work
focused on finding primary vertices in simulated LHCb data using a hybrid
approach that started with kernel density estimators (KDEs) derived
heuristically from the ensemble of charged track parameters and predicted
âtarget histogramâ proxies, from which the actual PV positions are extracted.
We have recently demonstrated that using a UNet architecture performs
indistinguishably from a âflatâ convolutional neural network model. We have
developed an “end-to-endâ tracks-to-hist DNN that predicts target histograms
directly from track parameters using simulated LHCb data that provides better
performance (a lower false positive rate for the same high efficiency) than
the best KDE-to-hists model studied. This DNN also provides better efficiency
than the default heuristic algorithm for the same low false positive rate.
âQuantizationâ of this model, using FP16 rather than FP32 arithmetic, degrades
its performance minimally. Reducing the number of UNet channels degrades
performance more substantially. We have demonstrated that the KDE-to-hists
algorithm developed for LHCb data can be adapted to ATLAS and ACTS data using
two variations of the UNet architecture. Within ATLAS/ACTS, these algorithms
have been validated against the standard vertex finder algorithm. Both
variations produce PV-finding efficiencies similar to that of the standard
algorithm and vertex-vertex separation resolutions that are significantly
better.

##  1 Introduction

Reconstruction of proton-proton collision points, referred to as primary
vertices (PVs), is critical for physics analyses conducted by all experiments
at the Large Hadron Collider (LHC) and for triggering in LHCb. The precise
identification of the PV locations, and their other characteristics, enables
the complete reconstruction of final states under investigation. Moreover, it
provides crucial information about the collision environment, which is
essential for obtaining accurate measurements. The task of PV reconstruction
poses a significant challenge across the experiments conducted at the LHC.

The LHCb detector has been upgraded for Run 3 of the LHC so that it can
process a five-fold increase in its instantaneous luminosity compared to Run 2
and it has removed its hardware-level trigger in favor of a pure software
trigger Aaij:2019zbu . The average number of visible PVs detected in the
vicinity of the beam crossing area has increased from 1.1 to 5.6. In contrast,
the ATLAS experiment has observed an average of 40-60 simultaneous collisions
(known as pile-up, $\mu$) during Run 3 in 2023 and is expected to see 140-200
simultaneous collisions during the coming high-luminosity phase of the LHC.
These demanding conditions invite development of new PV reconstruction
algorithms to address these challenges.

This document presents the implementation and performance of a family of
machine learning PV reconstruction algorithms known as PV-Finder for both LHCb
and ATLAS. Conceptually, these algorithms compute one-dimensional Kernel
Density Estimators (KDEs) that describe where charged track trajectories
overlap in the vicinity of the beamline and use these as input feature sets
for convolutional neural networks (CNNs) that predict target histograms that
are proxies for the PV positions. LHCb has traditionally used heuristically
computed KDEs with its CNNs; in this papers it reports merging a fully
connected neural network for KDE computation with a CNN to produce an "end-to-
end" tracks-to-hist deep neural network (DNN) model and compares its
performance with that of older models. ATLAS currently uses an analytical
approach for KDE computation (referred to as a KDE-to-hist model) and compares
the performance with the Adaptive Multi-Vertex Finder (AMVF) algorithm
ATLAS:2019jmx , the heurustic PV identification algorithm currently used in
ATLAS.

##  2 PV-Finder in LHCb

The original LHCb DNN for reconstructing PVs used a single kernel density
estimator (KDE) calculated using a heuristic algorithm as the input feature
set for each event (each beam crossing) and produced a target histogram from
which PV positions were deduced. We refer to this class of algorithms as KDE-
to-hist algorithms. The results of the initial proof-of-principal project, and
some details of the “toy Monte Carlo" and KDE used for that study are reported
in Ref. Fang:2019wsd . Using track parameters produced by the LHCb Run 3
Vertex Locator (VELO) tracking algorithm Hennequin:2019itm  leads to
significantly better performance akar2020updated . Since then, our research
has advanced in several directions. We replaced our original input feature set
with four input feature sets: a first KDE based on summed probabilities in
voxels projected onto the beam axis, a second KDE based on summed
(probability-squared values) in voxels projected onto the beam axis, plus the
$x-$ and $y-$ coordinates of the maximum summed probability at each value of
$z$ (along the beam axis). We found that using a modified U-Net architecture
ronneberger2015unet  in place of our original CNN architecture provided
equally good fidelity and trained much more quickly. We also investigated
using a fully connected network to calculate a KDE from track parameters (a
tracks-to-KDE model) and merging this model with a KDE-to-hist model to
produce an “end-to-end" tracks-to-hist neural network. The fidelity of the
tracks-to-hist studied then was inferior to that of the KDE-to-hist models.
The results of these studies were presented at CHEP-2021 Akar:2021gns .

A major advance reported at this conference (CHEP-2023) is that we have
produced a tracks-to-hist model that produces efficiencies very similar to the
best produced by our KDE-to-hist models and produces significantly lower false
positive (FP) rates. These results were reported previously at ACAT-2022
Akar:2023zhd . Below, we summarize the most salient features. Brand new for
this conference are results using FP16 arithmetic rather than FP32 arithmetic
for the tracks-to-hist model and results using smaller U-Net components in the
FP16 tracks-to-hist models.

Figure 1:  This diagram illustrates the end-to-end, tracks-to-hist, DNN Each
event is now sliced into 40 independent 100-bin intervals. Six fully connected
layers populate 8 100-bin channels in sixth layer, for each track. These
contributions are summed and processed by a U-Net model with 5 convolutional
layers to construct the final 100-bin histogram.

The current tracks-to-hist model, whose architecture is shown in Fig. 1,
includes a few updates relative to the original version described in Ref.
Akar:2021gns : the tracks-to-KDE part of the model consists of 6 fully
connected layers that are initially trained to produce a KDE and the weights
of the first 5 layers are temporarily frozen; a variation with 8 latent
feature sets is merged to a KDE-to-hist-like DNN where the classical CNN
layers are replaced by a U-Net model. Critically, we also updated the
structure of the input data for training and inference. In the earlier
approach Akar:2021gns , the target histograms consisted of 4000 bins along the
z-direction (beamline), each $100\,{\rm\mu m}$ wide, spanning the active area
of the VELO around the interaction point, such that $z\in[-100,300]\,{\rm
mm}$. Parameters describing all tracks served as input features. In place of
describing the true PVs using a single 4000-bin histogram, we now slice each
event into 40 intervals of 100 bins each. For each interval, parameters of
tracks whose points of closest approach to the beamline lie within 2.5 mm of
the interval edges are used as input features. This approach is motivated by
the fact that the shapes of the target histogram are expected to be invariant
as a function of the true PV position and it is easier for a DNN to learn to
predict target histograms over a smaller range of bins. In particular, the
fully connected layers that calculate the KDE-like latent features used as
input features by the U-Net layers predict heuristic KDEs as the ground truth
much more effectively when training 100-bin intervals rather than the full
4000-bin range. Additionally, the depth of the U-Net part of the DNN can be
lower when processing a 100-bin feature set rather than a 4000-bin feature
set. With an average of $\sim 5$ PVs per event, most of the bins in both the
KDE and target histograms have no significant activity. We expect this will
allow us to eventually build a more performant inference engine in the LHCb
software stack. The 40 intervals of 100 bins are independent and homogeneous
between events. Each interval is treated independently, after which the
predicted 4000-bin histogram is stitched back together. As in past studies, an
asymmetry parameter between the cost of overestimating contributions to the
target histograms and underestimating them Fang:2019wsd  is used as a
hyperparameter to allow higher efficiency by incurring higher false positive
rates.

Figure 2:  (left) Comparison between the performances of models reported in
previous years and the new tracks-to-hist model (magenta diamonds). A cost
asymmetry parameter described in Ref. Fang:2019wsd  is varied to produce the
families of points observed. (right) Comparison between tracks-to-hist models.
The magenta diamonds here are the same as in the plot on the left. The other
models have U-Net architectures but use FP16 arithmetic rather than FP32. Two
of the FP16 models have smaller U-Net components than the FP32 model. NB: the
horizontal and vertical scales on the right cover more limited ranges than
those on the left.

Performance is evaluated using a heuristic algorithm, based on the PV
positions along the beam axis, $z$. Exactly how efficiencies and FP rates are
calculated is described in Ref. Akar:2021gns . The left-hand plot in Fig. 2
shows how the performance of the DNN algorithms have evolved over time. The
efficiency is shown on the horizontal axis and the false positive rate per
event is shown on the vertical axis. The solid blue circles show the
performance of any early KDE-to-hist model described at ACAT-2019 Fang:2019wsd
. The green squares show the performances of a KDE-to-hist described at
Connecting-the-Dots in 2020 akar2020updated . Both of the above models were
trained using “toy Monte Carloâ with proto-tracking. All subsequent DNN models
were trained using full VELO tracking algorithm Hennequin:2019itm , leading to
significantly better performances (red triangles to be compared to green
squares). The cyan circles and the yellow squares correspond to the best
achieved performances for KDE-to-hist models using either a classical CNN
architecture or the U-Net model described at CHEP-2021

The performances of all above models were obtained using an “older" matching
procedure with a fixed search window of $0.5\,{\rm mm}$. The magenta diamonds
show the performance of the tracks-to-hist model described above using the
matching procedure described in Ref. Akar:2021gns . The new tracks-to-hist
model enables the DNN to simultaneously reach high efficiencies ($>97\%$) and
low false positive rates ($0.03$ per event or $0.6\%$ per reconstructed PV).

Running an inference engine inside a software stack adds another “knob to
turn" – throughput versus fidelity. Computing resources are finite, especially
in LHCb’s first level software trigger which processes 30 MHz of beam crossing
data, about 40 Tbit/s, in a GPU application Aaij:2019zbu . Modern GPUs provide
FP16 performance that can be about twice as fast as FP32 arithmetic, so it is
interesting to investigate whether using FP16 arithmetic degrades performance
significantly. It similarly interesting to investigate how performance
degrades as the size of the convolutional network inside our DNN is reduced.
The right-hand plot in Fig. 2 shows the efficiency versus FP rate for four DNN
configurations. The magenta diamonds correspond to the default tracks-to-hist
configuration. These points are exactly the same as those in the left-hand
plot; the ranges of the axes have been modified to focus on the region of
interest. The purple "$\times$" markers correspond to the same logical
configuration, but using FP16 arithmetic rather than FP32. Near 96%
efficiency, the FP rate has increased marginally. Near 97% efficiency, the FP
rate has increased much more substantially. Reducing the number of U-Net
channels from 64 to 32 or 16, while using FP16 arithmetic, (the darker and
lighter crosses in the plot) additionally additionally increases the FP rate
near 96% efficiency by a small amount, but increases the FP rate much more
significantly near 96.5%. We have begun to code an inference engine to run in
LHCb’s first level software trigger. The details of the model to be
instantiated will balance fidelity of the model against throughput.

##  3 PV-Finder in ATLAS

The ATLAS experiment at the LHC is a versatile particle detector designed with
a symmetric cylindrical geometry and near-complete coverage of 4$\pi$ in solid
angle atlascollaboration2023atlas . It has a multi-layer structure with many
sub-detector systems including an inner tracking detector, superconducting
magnets, electromagnetic and hadronic calorimeters, and a muon spectrometer.
An extensive software suite ATL-SOFT-PUB-2021-001  facilitates its various
functions such as data reconstruction and analysis, detector operations,
trigger and data acquisition systems etc.

The input dataset used for studying PV-Finder in ATLAS has been generated
using POWHEG BOX[v2] Alioli:2010xd  interfaced with PYTHIA[8.230]
Sjostrand:2014zea  and processed through the ATLAS detector simulation
framework ATL-SOFT-PUB-2021-001 , using the GEANT4 toolkit GEANT4:2002zbu .
The hard-scatter (HS) process involves the production of semi-leptonically
decaying top quark pairs ($t\bar{t}$) from proton-proton collisions at a
center-of-mass energy of 13 TeV, overlaid with simulated minimum-bias events
with an average pile-up of 60.

3.1 PV-Finder algorithm and model architecture

The flowchart representing work-flow of the PV-Finder algorithm for ATLAS is
shown in figure 3. More details about the architecture can be found at the
ATLAS PubNote ATLAS_pvfinder_pubnote . Truth-matched reconstructed tracks
passing tight quality selection cuts ATL-PHYS-PUB-2015-051  and
p${}_{\textrm{T}}$ $>$ 500 MeV are used for the preparation of input features
for the neural network. A track’s signed radial and longitudinal impact
parameters, $d_{0}$ and $z_{0}$, measured at the point of closest approach
(POCA) to the beamline, and their uncertainties, $\sigma(d_{0})$ and
$\sigma(z_{0})$, are used as input to generate KDEs. Each KDE feature is a
one-dimensional binned histogram with 12,000 bins in $z\in[-240,240]\,{\rm
mm}$, corresponding to a bin-size of 40 $\mu$m.

Figure 3: Flowchart representing work-flow of the PV-Finder algorithm from
left to right.

To compute these features, each track is modeled as a correlated radial and
longitudinal Gaussian probability distribution $\mathbb{P}(d,z)$ centred at
($d_{0},z_{0}$) which is defined as follows:

$\mathbb{P}(r)=\mathbb{P}(d,z)=\frac{1}{2\pi\sqrt{|\Sigma}|}\text{exp}\bigg{(}-\frac{1}{2}\Big{(}(d-d_{0}),(z-z_{0})\Big{)}^{T}\Sigma^{-1}\Big{(}(d-d_{0}),(z-z_{0})\Big{)}\bigg{)}$
(1)

where $d$ and $z$ are coordinates in the radial and longitudinal directions
and $\Sigma$ =
$\left({\begin{array}[]{cc}\sigma^{2}(d_{0})&\sigma(d_{0},z_{0})\\\
\sigma(d_{0},z_{0})&\sigma^{2}(z_{0})\end{array}}\right)$ is the covariance
matrix. The sum of probabilities from all the contributing tracks is
considered in each $z$-bin and four KDE features are constructed: KDE-A (sum
of track probability values), KDE-B (sum of the squares of track probability
values), XMax (YMax) (location of the maximum summed track probability in
$x$($y$) (mm)). An example illustrating these four features for a random event
is shown in Fig. 4. The vertical grey lines in the upper plot mark the
locations of true primary vertices while horizontal grey line in the lower
plot denotes the position of the beam spot in the radial direction. A
restricted range of the luminous region is shown so that details can be seen.

To train the neural network, a one-dimensional target truth histogram, with
the same binning as the input features and calculated by considering Gaussian
probabilities around truth vertex locations, is also provided as input along
with the four KDE features. A CNN is trained on these features which then
outputs a distribution with approximately Gaussian peaks centered at the
predicted locations of PVs. An algorithm then takes this predicted
distribution and identifies the candidate PV locations on the $z$-axis by
finding the local maxima. Two NN architectures have been considered for these
studies: the UNet architecture is inspired from the original architecture
developed for biomedical image segmentation ronneberger2015unet  while the
UNet++ architecture is a variation of UNet with dense skip connections.

Figure 4: An example of the input KDE features. Upper plot shows KDE-A (green)
and KDE-B (purple) while lower plot shows XMax (blue) and YMax (red). See text
for details.

Figure 5: An example of correctly predicted PV-Finder output (in red) compared
with KDE-A (in green) and target truth (in blue).

3.2 Performance

The PV-Finder algorithm’s performance for UNet and UNet++ architectures has
been studied and a comparative analysis is conducted with the AMVF algorithm
using an independent test data sample. Figure 5 showcases an example of two
adjacent vertices accurately located by the PV-Finder algorithm. To
quantitatively evaluate the performance of the PV-Finder, vertex
classification is performed, and efficiency and false positive rates are
calculated. The classification assigns vertices into distinct categories,
namely clean, merged, split, and fake based on the distance between the center
of a predicted vertex and the $z$-location of truth vertices. The
classification is illustrated in Figure 6 and demonstrated in Figure 7 for the
three approaches.

The truth and reconstructed primary vertices are associated based on a vertex-
vertex resolution, $\sigma_{\textrm{vtx-vtx}}$, which is obtained by computing
the $z$-difference between pairs of nearby reconstructed vertices and fitting
the distribution with the fit function: $y$ =
$\frac{a}{1+\exp{(b\cdot(R_{cc}-|x|))}}+c$, where $a,b,c$ are free parameters,
and $R_{cc}$ is the clusterâcluster resolution referred to as
$\sigma_{\textrm{vtx-vtx}}$. The vertex-vertex resolution for PV-Finder UNet,
PV-Finder UNet++ and AMVF is presented in Figure 8 and Table 1.

The vertex finding efficiency is defined as the number of truth vertices
assigned to reconstructed vertices as “clean” and “merged” divided by the
total number of reconstructable truth vertices while the false positive rate
is defined as the average number of predicted vertices not matched to any
truth vertex. Figure 9 shows the vertex finding efficiency as a function of
the number of reconstructed tracks associated to a truth vertex and Table 1
shows the average efficiency and false positive rates obtained for three
cases.

Figure 6: Vertex Classification Scheme. The dashed line represents the
reconstructed vertex location, the solid line represents the truth vertex
location, and $\sigma_{\textrm{vtx}}$ represents $\sigma_{\textrm{vtx-vtx}}$.

Figure 7: Vertex Classification rates for PV-Finder and AMVF for a $t\bar{t}$
sample with $55$ $\leq$ $\mu$ $\leq$ $65$, comparing AMVF (red), PV-Finder
UNet (green) and PV-Finder UNet++ (blue).

Figure 8: ${\Delta}z_{\textrm{vtx-vtx}}$ for PV-Finder UNet++ (blue), PV-
Finder UNet (green) and AMVF (red). See text for discussion. More details at
ATLAS_pvfinder_pubnote .

Figure 9: PV efficiencies for AMVF and PV-Finder’s UNet++ and UNet
architectures vs the number of reconstructed tracks associated to truth
vertex. More details at ATLAS_pvfinder_pubnote .

Method |  $\sigma_{\textrm{vtx-vtx}}$ (mm) | Efficiency | FP Rate (per event)
---|---|---|---
PV-Finder UNet | $0.23\pm 0.01$ | 88.7% | 2.6
PV-Finder UNet++ | $0.37\pm 0.01$ | 94.2% | 1.5
AMVF | $0.76\pm 0.02$ | 93.9% | 0.8
Table 1: A comparison of the vertex-vertex separation resolutions, the
efficiencies, and the false positive (FP) rates of the algorithms.

##  4 Conclusion

The PV-Finder family of algorithms has been studied by both the LHCb and ATLAS
experiments. LHCb has demonstrated the performances of the end-to-end tracks-
to-hist approach for several configurations including those that use FP16
arithmetic rather than FP32. ATLAS has demonstrated that a hybrid KDE-to-hist
approach produces efficiencies comparable to the ATLAS AMVF algorithm while
also achieving significanty improved resolution. These enhanced efficiency and
resolution metrics hold significant importance, especially considering the
future High Luminosity LHC program. The results are promising and motivate
further studies and refinement of the PV-Finder algorithms across experiments.

[Copyright 2023 CERN for the benefit of the ATLAS and LHCb Collaborations. CC-
BY-4.0 license]

## References

  * (1) R. Aaij et al., Comput. Softw. Big Sci. 4, 7 (2020), arXiv:1912.09161
  * (2) The ATLAS collaboration, _Development of ATLAS Primary Vertex Reconstruction for LHC Run 3_ (2019), http://cds.cern.ch/record/2670380
  * (3) R. Fang, H.F. Schreiner, M.D. Sokoloff, C. Weisser, M. Williams, J. Phys. Conf. Ser. 1525, 012079 (2020), arXiv:1906.08306
  * (4) A. Hennequin, B. Couturier, V. Gligorov, S. Ponce, R. Quagliani, L. Lacassagne, JINST 15, P06018 (2020), arXiv:1912.09901
  * (5) S. Akar, T.J. Boettcher, S. Carl, H.F. Schreiner, M.D. Sokoloff, M. Stahl, C. Weisser, M. Williams, _An updated hybrid deep learning algorithm for identifying and locating primary vertices_ (2020), arXiv:2007.01023
  * (6) O. Ronneberger, P. Fischer, T. Brox, pp. 234–241 (2015), arXiv:1505.04597
  * (7) S. Akar, G. Atluri, T. Boettcher, M. Peters, H. Schreiner, M. Sokoloff, M. Stahl, W. Tepe, C. Weisser, M. Williams, EPJ Web Conf. 251, 04012 (2021), arXiv:2103.04962
  * (8) S. Akar, M. Peters, H. Schreiner, M.D. Sokoloff, W. Tepe (2023), arXiv:2304.02423
  * (9) The ATLAS Collaboration, _The ATLAS Experiment at the CERN Large Hadron Collider: A Description of the Detector Configuration for Run 3_ (2023), 2305.16623, https://arxiv.org/abs/2305.16623
  * (10) The ATLAS Collaboration, _The ATLAS Collaboration Software and Firmware_ (2021), ATL-SOFT-PUB-2021-001, https://cds.cern.ch/record/2767187
  * (11) S. Alioli, P. Nason, C. Oleari, E. Re, JHEP 06, 043 (2010), arXiv:1002.2581
  * (12) Sjöstrand, Torbjörn, et al., Comput. Phys. Commun. 191, 159 (2015), arXiv:1410.3012
  * (13) S. Agostinelli et al. (GEANT4), Nucl. Instrum. Meth. A 506, 250 (2003), https://cds.cern.ch/record/602040
  * (14) The ATLAS collaboration, _Primary Vertex identification using deep learning in ATLAS_ (2023), https://cds.cern.ch/record/2858348
  * (15) The ATLAS Collaboration, _Early Inner Detector Tracking Performance in the 2015 data at $\sqrt{s}$ = 13 TeV_ (2015), ATL-PHYS-PUB-2015-051, https://cds.cern.ch/record/2110140


# TrafPS: A Visual Analysis System Interpreting Traffic Prediction in Shapley

Yifan Jiang1, Zezheng Feng12, Hongjun Wang1, Zipei Fan3, Xuan Song1
1Department of Computer Science and Engineering,Southern University of Science
and Technology
Email: 1yifanjiang921<EMAIL_ADDRESS><EMAIL_ADDRESS>songx}sustech.edu.cn
2The Hong Kong University of Science and Technology
Email<EMAIL_ADDRESS>
3University of Tokyo
Email<EMAIL_ADDRESS>

###### Abstract

In recent years, deep learning approaches have been proved good performance in
traffic flow prediction, many complex models have been proposed to make
traffic flow prediction more accurate. However, lacking transparency limits
the domain experts on understanding when and where the input data mainly
impact the results. Most urban experts and planners can only adjust traffic
based on their own experience and can not react effectively toward the
potential traffic jam. To tackle this problem, we adapt Shapley value and
present a visualization analysis system , which can provide experts with the
interpretation of traffic flow prediction. TrafPS consists of three layers,
from data process to results computation and visualization. We design three
visualization views in TrafPS to support the prediction analysis process. One
demonstration shows that the TrafPS supports an effective analytical pipeline
on interpreting the prediction flow to users and provides an intuitive
visualization for decision making.

###### Index Terms:

Data Visualization, Interactive Data Exploration

##  I Introduction

As increasingly boost the volume of vehicles increases and the travel demand
of citizens, the traffic in the urban area has becoming more and more complex.
Traffic flow prediction has been an important problem to urban planners, which
can help them estimate the changes of the traffic so that they can respond in
time to possible traffic jams or congestion [2]. To get a more accurate
prediction, many approaches have been explored [1, 3, 4]. With its strong
forecasting performance, deep learning has proved sound in traffic flow
prediction and various complex models have been proposed to make traffic flow
prediction more accurate.

Even though selecting proper deep learning models may bring high accuracy to
the prediction, these complex models are always regarded as black boxes that
lack transparency, which leads to the experts having no idea how the models
impact the prediction. Without any interpretations of the model, domain
experts cannot react effectively to predictions such as when and where the
input data mainly impact the results.

To solve this problem, inspired by other urban analysis studies [7, 8, 9, 10],
we want to build a visual analysis system to provide prediction with
interpretation and additional related information. As the system needs an
interpretation method, we employ the Shapley value, proposed by Shapley [5]
and adopted in [6]. The Shapley value is widely considered a unique unbiased
approach to fairly allocating the total award a coalition to each input
feature. In the traffic flow prediction task, we use the Shapely value to
quantify the correlations between the prediction results in the selected
region and actual traffic flow or geography area. Then we propose TrafPS, a
visual analysis system interpreting traffic prediction in Shapley, to enhance
the urban expert on analyzing traffic prediction and reacting to potential
traffic jams.

TrafPS contains three layers with different functions to provide efficient
analysis: i) Data processing layer preprocess raw data and prepare for the
other layers (e.g., data partition and make division). ii) Prediction-
Interpretation layer consists of two computation models. Prediction Model
computes the traffic flow prediction in future timestamps, and Interpretation
Model calculates the corresponding interpretation. iii)Visualization
analytical layer visualizes results in former layers in several interactive
views to provide the visualization-assisted analysis (e.g., Map-Trajectory
View, Radar Glyph View, and Fine-grained Grid View).

We implement TrafPS on a real-world taxi data set in Chengdu and will present
the usage of TrafPS through demonstration. Our demonstration will invite ICDE
attendees to act as urban analysts to analyze current traffic flow and future
predictions. Attendees can operate on the Visualization analytical layer
interface to detect traffic jams and do appropriate reactions to prevent them
based on the interpretation provided by Prediction-Interpretation layer.

The contributions of this work are as follows:

  * •

We introduce Shapley value to the traffic flow prediction task to interpret
the prediction made by complex machine-learning models.

  * •

We proposed an interactive visual analytics system named _TrafPS_ provides six
visual components to support analysts in understanding the prediction and make
effective reaction.

  * •

We designed a radar glyph to simply and informatively summarize prediction
results and their interpretation in the Shapely value for the selected area.

We demonstrate the framework of TrafPS in Section II and introduce three
visualization views in Section III. Then we show TrafPS’s usage and how it
works in Section IV and conclude in Section V.

##  II Model

In this section, we describe the TrafPS system framework in Fig. 1. It
consists of three layers: (i) Data processing layer; (ii) Prediction-
Interpretation layer; and (iii) Visualization analytical layer. We build the
front-end of TrafPS on Vue111https://vuejs.org/. and the back-end on
Flask222https://flask.palletsprojects.com.

The input dataset of this work consists of the following data in Chengdu,
China. Traffic trajectory data contains the trajectory data in Chengdu city
(Data comes from Didi Chuxing GAIA Initiative333https://gaia.didichuxing.com.)
from 10/01/2016 to 11/31/2016. Road network data contains the traffic
intersection data in the same location of Chengdu city (Data comes from
OSMnx444https://www.openstreetmap.org/.).

Figure 1: An overview of the TrafPS system, which mainly consists of three
layers: Data processing layer, Prediction-interpretation layer and
visualization analytical layer

###  II-A Data processing layer

Data processing layer is the basic layer of TrafPS. It takes real-world
datasets and does necessary preparation for the Prediction-Interpretation
layer (e.g., data cleaning, data division, and data aggregation).

####  II-A1 Geographical Partition

When adopting ST-ResNet [2] as the prediction method, the input of the model
should be a sequence of fixed-sized matrices. Therefore, we should process the
data to fit the input of it. We first rasterize the city into grids to provide
enough spatial and temporal information of input data. Then we count the
passing trajectories for each grid to get the in-/out-flows.

####  II-A2 Division of Cluster

After partitioning the city into grids as the single unit, we then cluster
them based on the number of roads in each grid and match each grid with the
clusters it belongs to which reduce the imbalance caused by the great
difference of the number roads in different grids. Therefore, we run kmeans
algorithm to divided the intersections in groups. We eventually choose 21 as
the number of the cluster as we want more number of cluster to provide more
local and detailed information after trying 0 to 27. Moreover, we employ
Voronoi diagram to generate each intersection with a polygon which aims to get
the border of each cluster so that each grid can match their own clusters and
let visualization system exhibit the location of each cluster.

###  II-B Prediction-interpretation layer

Prediction-Interpretation layer is the core layer of TrafPS that runs
Prediction Model and Interpretation Model to support the system’s analysis
function. Interpretation Model takes the result of Prediction Model and
computes its corresponding interpretation.

####  II-B1 Prediction Model

In this task, Prediction Model use ST-ResNet [1] as our machine-learning model
to get the prediction. Data processing layer gets our flow matrix by dividing
data every 10 minutes, and the prediction task uses data in 5 continuous
timestamps to predict the timestamp next.

####  II-B2 Interpretation Model

Based on the Additive Feature Attribution Methods [6], Interpretation Model
assumes the flow prediction of one cluster as the summation of other areas’
contributions. Each time interpreting one cluster’s prediction, Interpretation
Model computes the correlation between the cluster’s neighbor area and the
prediction result. The larger the area’s correlation value, the more positive
the area contributes to the prediction result. For instance, an area with a
large correlation pushes the model to give a high value during the prediction
of the cluster being interpreted.

Traffic flow in grids tends to fluctuate, and sometimes several trajectories
can considerably impact its prediction. Thus, when interpreting the flow
prediction of one grid, Interpretation Model will compute the correlation
between the existing trajectories and the grid’s prediction.

Figure 2: The visualization view (c) of TrafPS consists of: A dashboard
($c_{1}$) on the left of TrafPS, which can select trajectory data (a) in a
specific timestamp and project heatmap (b); Radar glyphs ($c_{2}$) on each
cluster, and a magnified one on the left ($c_{1}$); A Square Chart ($c_{3}$)
and a Parallel Coordinates Plot ($c_{4}$) visualize the flow data in grids.
TrafPS will demonstrate the five most significant trajectories on the map with
a table list ($c_{5}$) and a Bi-directional Column Chart ($c_{6}$) at the
bottom after selecting a grid.

###  II-C Visualization analytical layer

Visualization analytical layer is the user interface of the TrafPS. It
visualizes data or model results from the former two layers with informative
and straightforward visualization views. Each view supports several
interactive operations, e.g., zoom to scale the size, keyboard input, or mouse
select. Users can switch between views and locate a specific target at ease.
We will introduce these views in this layer in the next section.

##  III Visualization Design

Figure 3: The design of (a) Radar Glyph View and (b) an example of how to find
key roads

This section introduces three interactive and interpretation-assisted
visualization views in TrafPS that ease and improve experts’ prediction
analysis process. For each View, we explain the purpose of visualization
design and present the visualization result.

###  III-A Map-Trajectory View

At the beginning of the analysis, having a global view of the current traffic
flow can be vital as experts can be aware of the moving trend of overall
traffic. An overview of traffic flow prediction is also helpful to show
experts where traffic jams may happen. Thus, Map-Trajectory View visualizes
the vehicle trajectory data on the geography map dynamically (Fig. 2($a$)). We
adapt heatmap to distinguish prediction from the current traffic flow and
presents data in high comparability (Fig. 2($b$)), where darker color means
more heavy traffic flow. Compared with other existing trajectory systems, our
Map-Trajectory View provides several operators in a dashboard (Fig.
2($c_{1}$)) to support the analysis process. Experts can pause at any
timestamp to analyze traffic flow in detail or switch to locate specific
timestamps.

###  III-B Radar Glyph View

In addition to gaining an insight into the entire traffic flow and prediction,
experts also need the interpretation of prediction to understand and react
effectively. Radar Glyph View places a newly designed radar glyph at the
centroid of each cluster area to summarize the traffic flow prediction of the
whole cluster and its corresponding interpretation (Fig. 2($c_{2}$)). Clicking
the cluster can magnify the glyphs and gain a clearer view (Fig. 2($c_{1}$)).

Traffic Flow Prediction: A line chart around the glyph visualizes the traffic
flow prediction in the future 50 minutes with every 10 minutes a dot point
clockwise (Fig. 3($a$)). Points far away from the glyph’s center represent a
large prediction value, and the radar glyph highlights the point of the
timestamp being interpreted. For example, the line chart in Fig. 3($a$) shows
that the traffic flow will increase in the following 30 minutes, and the
timestamps in 20 minutes later will be interpreted.

Corresponding Interpretation: In the inner part, two diverging polygon
distributions visualize the correlation between the cluster’s neighbor area
and the cluster’s traffic flow prediction by the geographical directions of
these surrounding areas—the bigger the polygon, the more powerful the positive
(red) or negative (blue) correlation. For instance, Fig. 3($a$) shows that the
traffic flow will increase 20 minutes later, and the surrounding area at the
west and the east may contribute to this increase. Experts can restraint the
traffic flow or adjust the traffic network in those areas tentatively to avoid
traffic jams. Analyzing radar glyphs in adjacent clusters can find some
significant areas related to these clusters’ traffic flow. For instance, the
interpretation part of three radar glyphs in Fig. 3($b$) indicates Road #101
may play an essential role in impacting local traffic flow.

###  III-C Fine-grained Grid View

Radar Glyph View gives interpretation in a general view based on surrounding
areas. Sometimes experts need to analyze the traffic flow prediction in
specific places and make reactions, e.g., the main intersection in urban. In
this view, we divide each cluster into grids and provide fine-grained grid-
based traffic flow analysis through several visualization components.

Square Chart (Fig. 2($c_{3}$)) visualizes grids in different colors based on
their current traffic value. Red color means large flow value, and blue means
small. Square Chart can reflect each grid’s spatial information and the
diversity of current traffic flow.

Parallel Coordinates Plot (Fig. 2($c_{4}$)) draws each grid’s traffic flow
change in future 60 minutes with the same color in Square Chart (Fig.
2($c_{3}$)). The plot can accurately reflect traffic flow trends, and clicking
the grid in Square Chart will highlight the corresponding time series.

Regarding reducing traffic flow in some specific places, adjusting the traffic
flow on several roads can be far more efficient than on an entire area. In
this view, experts can select a grid in Square Chart to analyze (highlighted
in Fig. 2($c_{3}$)), and the top five trajectories that have the most
correlation or impact on the traffic flow prediction of this grid will appear
on the map. Trajectory’s color means the nature of correlation, as same as the
color in radar glyph. A list containing each trajectory’s detailed data will
appear (Fig. 2($c_{5}$)), as long as a Bi-directional Column Chart aggregates
the correlation of each trajectory into time channels (Fig. 2($c_{6}$)).

##  IV The Demonstration

This demonstration aims to provide an interpretation view to understand
models’ predictions and extract the latent patterns from traffic data. User
can act as an urban analyst to analyze current traffic flow and future
prediction then react to potential traffic jams with the help of
interpretation provided by the demo. We perform the demo on a real-world
traffic dataset that contains one-week taxi trajectory data in Chengdu, China.
The demo presents the corresponding interpretation to the traffic flow
prediction of 20 minutes later.

The user first operates the dashboard (Fig. 2($c_{1}$)) to select which time
period to analyze. Assume the user selects an early morning on a hoilday. Map-
Trajectory View will generate moving trajectories of all real-time data (Fig.
2($a$)). Trajectories present a tendency to move towards the center of the
map, one of the main roads connecting the urban area and the suburban area,
indicating traffic jams may happen. Then he projects a heatmap (Fig. 2($b$))
to see traffic flow prediction 20 minutes later, which reveals several areas
with the darkest color will have congestions, including the center of the map
(Fig. 2($b_{1}$)).

Being aware that the center of the map will have a traffic jam, the user
observes the radar glyphs in Radar Glyph View to see which neighbor areas
contribute to the congestions. As shown in Fig. 2($d$), clusters #1 and #2 are
located in the center of the map. According to the radar glyphs (Fig.
2($c_{2}$)), the traffic flow will increase 20 minutes later, and the neighbor
areas at the north have the most effective correlation. The user can prevent
congestion roughly and temporarily by constraint the traffic flow in these
areas.

The user takes further steps and handles the latent traffic jam more
efficiently and precisely through the visualization and interpretation in
Fine-grained Grid View (Fig. 2($c_{3}$,$c_{4}$)) For example, from the
parallel coordinates plot (Fig. 2($e$)), he finds some yellow lines will get a
sharp increase 20 minutes later, which can be one of the main locations of
traffic jams. He then clicks the corresponding grids in Square Chart (Fig.
2($c_{3}$)) to project top five significant trajectories. The red trajectories
means they all promote traffic jams. The user realizes appropriate reaction
should be made on Road #107 and Road #110 to prevent traffic jam. Moreover,
Bi-directional Column Chart shows that trajectories 20-30 minutes before
affect prediction most, which means the user needs to pay more attention on
the trajectory in that time slot (highlight in Fig. 2($c$)).

As the demo can provide different predictions and corresponding
interpretations in three visualization views and easy switching between them,
the user is encouraged to customize the analysis workflow himself.

##  V Conclusions and Future Work

In this work, we present a visual analysis system, TrafPS, to interpret the
prediction made by complex models, which consists of three layers: Data
processing layer, Prediction-interpretation layer, and Visualization
analytical layer. We devise Map-Trajectory View, Radar Glyph View, and Fine-
grained Grid View in the Visualization analytical layer to support the
analysis and interpretation process interactively. In the demonstration, users
can operate TrafPS on real-world taxi data and analyze the effective way to
avoid traffic jams. Currently, our work still has some limitation that needs
improvement in future work. First, adding more interaction interfaces in the
TrafPS to let users adjust and understand interpretation intuitively. Second,
implement other division types based on more features with more data. Third,
further study is required to get feedback on the visualization system from
domain experts and normal users.

## References

  * [1] Zhang J, Zheng Y, Qi D. Deep spatio-temporal residual networks for citywide crowd flows prediction[C]//Thirty-first AAAI conference on artificial intelligence. 2017.
  * [2] Zeng W, Lin C, Lin J, et al. Revisiting the modifiable areal unit problem in deep traffic prediction with visual analytics[J]. IEEE Transactions on Visualization and Computer Graphics, 2020, 27(2): 839-848.
  * [3] Li Y, Yu R, Shahabi C, Liu Y. Diffusion convolutional recurrent neural network: Data-driven traffic forecasting. arXiv preprint arXiv:1707.01926. 2017 Jul 6.
  * [4] Liu Y, Zheng H, Feng X, Chen Z. Short-term traffic flow prediction with Conv-LSTM. In2017 9th International Conference on Wireless Communications and Signal Processing (WCSP) 2017 Oct 11 (pp. 1-6). IEEE.
  * [5] Shapley LS. 17. A value for n-person games. Princeton University Press; 2016 Mar 2.
  * [6] Lundberg SM, Lee SI. A unified approach to interpreting model predictions. InProceedings of the 31st international conference on neural information processing systems 2017 Dec 4 (pp. 4768-4777).
  * [7] Pi M, Yeon H, Son H, Jang Y. Visual cause analytics for traffic congestion. IEEE transactions on visualization and computer graphics. 2019 Sep 10.
  * [8] Weng D, Zheng C, Deng Z, Ma M, Bao J, Zheng Y, Xu M, Wu Y. Towards better bus networks: A visual analytics approach. IEEE Transactions on Visualization and Computer Graphics. 2020 Oct 13;27(2):817-27.
  * [9] He T, Bao J, Ruan S, Li R, Li Y, He H, Zheng Y. Interactive bike lane planning using sharing bikes’ trajectories. IEEE Transactions on Knowledge and Data Engineering. 2019 Mar 25;32(8):1529-42.
  * [10] Feng Z, Li H, Zeng W, Yang SH, Qu H. Topology density map for urban data visualization and analysis. IEEE transactions on visualization and computer graphics. 2020 Oct 13;27(2):828-38.


# Pediatric Wrist Fracture Detection in X-rays via YOLOv10 Algorithm and Dual
Label Assignment System

Ammar Ahmed1, Abdul Manaf2 Email<EMAIL_ADDRESS>amanaf.bscsf19@iba-
suk.edu.pk  1Department of Computer Science (IDI), Norwegian University of
Science & Technology (NTNU), Gjøvik, 2815, Norway 2Department of Computer
Science, Sukkur IBA University, Sukkur, 65200, Pakistan

###### Abstract

Wrist fractures are highly prevalent among children and can significantly
impact their daily activities, such as attending school, participating in
sports, and performing basic self-care tasks. If not treated properly, these
fractures can result in chronic pain, reduced wrist functionality, and other
long-term complications. Recently, advancements in object detection have shown
promise in enhancing fracture detection, with systems achieving accuracy
comparable to, or even surpassing, that of human radiologists. The YOLO
series, in particular, has demonstrated notable success in this domain. This
study is the first to provide a thorough evaluation of various YOLOv10
variants to assess their performance in detecting pediatric wrist fractures
using the GRAZPEDWRI-DX dataset. It investigates how changes in model
complexity, scaling the architecture, and implementing a dual-label assignment
strategy can enhance detection performance. Experimental results indicate that
our trained model achieved mean average precision (mAP@50-95) of 51.9%
surpassing the current YOLOv9 benchmark of 43.3% on this dataset. This
represents an improvement of 8.6%. The implementation code is publicly
available at https://github.com/ammarlodhi255/YOLOv10-Fracture-Detection

###### Index Terms:

wrist fracture detection, YOLOv10, YOLOv9, object detection, medical image
recognition, fracture localization

##  I Introduction

Wrist fractures are among the most common pediatric injuries, leading to
approximately 500,000 emergency department visits annually in the UK alone
[1]. This high frequency imposes a significant burden on healthcare systems.
Since children’s bones are still developing, fractures pose a risk of damaging
growth plates. This is particularly concerning for wrist fractures, where
damage to the distal radius growth plate can result in stunted growth and
discrepancies in bone length [2]. Initial X-rays may not always reveal these
fractures clearly, which can lead to delayed or missed diagnoses if not
thoroughly evaluated by specialists [3]. Additionally, managing pediatric
wrist fractures requires substantial healthcare resources, including emergency
care, imaging, follow-up visits, and potentially surgical interventions [1].
In response to these challenges, there has been growing interest in automating
fracture detection in trauma X-rays. Recent studies have shown that AI systems
can achieve high accuracy in detecting fractures, sometimes matching or even
surpassing the performance of human radiologists [4, 5, 6]. YOLO (You Only
Look Once) object detection algorithms, in particular, have demonstrated
significant advancements in this field [6, 7, 8, 9].

Recent advancements with YOLOv8 and YOLOv9 have shown these models
outperforming their predecessors [6, 7, 8, 10]. The high accuracy and speed of
YOLO models position them as valuable tools for supporting clinical decisions
in fracture diagnosis [11]. In this study, we provide a first comprehensive
analysis of YOLOv10 [12] and its variants using a large annotated GRAZPEDWRI-
DX dataset [9].

The main contributions of this paper are as follows:

  1. 1.

We thoroughly evaluate all YOLOv10 variants on the GRAZPEDWRI-DX dataset,
marking the first application of YOLOv10 to this dataset.

  2. 2.

We achieve state-of-the-art performance with the mAP@50-95 metric on the
GRAZPEDWRI-DX dataset, surpassing the results previously achieved with YOLOv9.

  3. 3.

We explore the relationship between the complexity of the YOLOv10 model and
its performance in fracture detection.

Figure 1: YOLOv10 Architecture depicting the input, backbone, neck, head, and
output.

##  II Related Work

The YOLO series has gained extensive application in fracture detection due to
its rapid inference speed and success across various detection tasks. Sha et
al. [13] employed YOLOv2 to detect fractures in a dataset of 5,134 spinal CT
images, achieving a mean average precision (mAP) of 0.75. Hržic et al. [14]
compared YOLOv4’s performance against U-Net segmentation and radiologists on
the GRAZPEDWRI-DX dataset. Their study involved two YOLOv4 models: one for
identifying the most probable fractured object and the other for counting
fractures. The first model attained an AUC-ROC of 0.90 and an F1-score of
0.90, while the second model achieved an AUC-ROC of 0.90 and an F1-score of
0.96. Further advancements were made with YOLOv5, as applied by the authors of
the GRAZPEDWRI-DX dataset [9], who achieved a fracture detection mAP of 0.93
and an overall mAP of 0.62 at an IoU threshold of 0.5 using the COCO pre-
trained YOLOv5m variant. Ahmed et al. [6] expanded this work by testing
YOLOv5, YOLOv6, YOLOv7, and YOLOv8 along with their various compound-scaled
variants on the GRAZPEDWRI-DX dataset. They found that the YOLOv8x variant
achieved the highest overall mAP of 0.77 and a fracture detection mAP of 0.95.
Ju et al. [8] used YOLOv8 for detecting fractures and other wrist pathologies
in the same dataset, reporting an mAP of 0.64, recall of 0.59, and precision
of 0.73. Chien et al. [10] extended this research by applying YOLOv9,
achieving the highest mAP@50 score of 0.66 and mAP@50-95 score of 0.44. They
also explored YOLOv8 with an attention mechanism, resulting in the YOLOv8-AM
model based on ResBlock and CBAM, which attained an overall mAP score of 0.66
[7]. Dibo et al. [15] enhanced performance on the GRAZPEDWRI-DX dataset by
integrating the GAM attention mechanism with the SwinTransformer backbone in
YOLOv7, achieving an overall mAP score of 0.65 and an average precision (AP)
of 0.94 for the fracture class. Despite these advancements, YOLOv10 has not
yet been applied for fracture detection on the GRAZPEDWRI-DX dataset. This
study aims to fill this gap by evaluating YOLOv10 and its variants on this
dataset.

##  III Material & Methods

###  III-A Dataset

A quantitative (experimental) study was conducted using data from 10,643 wrist
radiography studies of 6,091 unique patients collected by the Division of
Pediatric Radiology, Department of Radiology, Medical University of Graz,
Austria [9]. The dataset contains nine distinct objects shown in Table I. It
shows the number of X-ray images containing each object. Since the authors of
the dataset did not provide a split, we randomly partitioned the dataset into
a training set of 15,245 images (75%), a validation set of 4,066 images (20%),
and a testing set of 1,016 images (5%).

###  III-B Method

High computational requirements lead to increased latency and consumption of
more power which can delay real-time detection and response. This is
particularly problematic in critical applications such as medical diagnostics,
where timely decisions are crucial. YOLOv10 eliminates the need for non-
maximum suppression (NMS). Instead of NMS, a dual-label assignment system is
employed during training, which integrates one-to-many and one-to-one head
strategies. This modification reduces computational burden and latency, which
is crucial for real-time detection applications, especially in a clinical
setting. The model becomes more efficient in handling overlapping detections,
which is particularly useful for detecting small, closely located pathologies
or fractures. The model can focus on refining its bounding box predictions
during training, potentially leading to higher precision in detecting small
and subtle abnormalities in wrist X-rays or MRIs. The pipeline of YOLOv10 is
shown in Fig.1.

#### Compact Inverted Block (CIB) Structure

The architecture incorporates a Compact Inverted Block (CIB) structure that
leverages depthwise convolutions for spatial mixing and pointwise convolutions
for channel mixing. This design enhances efficiency while maintaining
performance, which is crucial for deployment on devices with limited
computational resources, such as portable X-ray or MRI machines.

Figure 2: Precision, recall, and PR curves of YOLOv10-M variant across increasing confidence scores.  Figure 3: Loss curves for YOLOv10-M variant.  TABLE I: Class Distribution Abnormality | Instances | Ratio
---|---|---
Boneanomaly | 192 | 0.94%
Bonelesion | 42 | 0.21%
Foreignbody | 8 | 0.04%
Fracture | 13550 | 66.6%
Metal | 708 | 3.48%
Periostealreaction | 2235 | 11.0%
Pronatorsign | 566 | 2.78%
Softtissue | 439 | 2.16%
Text | 20,274 | 99.74%

#### Lightweight Classification Head

YOLOv10 includes a decoupled classification head that separates the
classification task from other tasks, such as bounding box regression,
allowing each to be optimized independently. It employs depthwise separable
convolutions, which factorize a standard convolution into a depthwise
convolution followed by a pointwise convolution. This significantly reduces
the number of parameters and computations.

#### Spatial-Channel Decoupled Downsampling

This technique optimizes the processing of spatial and channel information,
enhancing the detection of wrist pathologies and fractures. By decoupling
spatial and channel downsampling, the method carefully manages information
loss typically associated with downsampling, preserving critical features
necessary for detecting small and subtle wrist pathologies. Spatial
downsampling focuses on reducing dimensionality while maintaining key spatial
structures, whereas channel transformation optimizes the mixing of feature
information across channels.

#### Rank-Guided Block Design

The Rank-Guided Block Design in YOLOv10 aims to improve model efficiency by
addressing redundancy in the architecture. It calculates an intrinsic rank by
analyzing the last convolution in the final basic block of each stage. The
singular values of the convolutional filters are computed, and the intrinsic
rank is determined by counting the number of singular values above a certain
threshold. A lower intrinsic rank indicates higher redundancy, meaning many
features do not contribute new information. A higher intrinsic rank signifies
more diverse and informative features. This design ensures essential features
are retained during optimization, enhancing the model’s ability to detect
subtle and small wrist pathologies and fractures.

Figure 4: Inferences made with YOLOv10-M variant.

#### Large-Kernel Convolutions

Large-kernel convolutions increase the receptive field of a model, which
enhances its ability to capture information from larger objects. However,
their indiscriminate use can lead to a loss of detail in smaller objects such
as wrist pathologies. YOLOv10 mitigates these issues by employing large-kernel
convolutions selectively: it uses 7×7 depthwise convolutions only in the
deeper layers of the network, adds an extra 3×3 depthwise convolution branch
during training for better optimization, and incorporates large kernels mainly
in smaller model scales to avoid inefficiencies at larger scales.

#### Partial Self-Attention (PSA)

Self-attention mechanisms are effective for modeling global features but are
often computationally expensive. YOLOv10 enhances efficiency with Partial
Self-Attention (PSA) by partitioning features after a 1×1 convolution and
applying self-attention to only part of these features. It efficiently fuses
the processed features with an additional 1×1 convolution. It reduces the
dimensions of the query and key vectors to half the size of the value vectors
in Multi-Head Self-Attention (MHSA). PSA is strategically applied only after
Stage 4 of the network, thereby minimizing computational overhead while still
benefiting from global feature modeling.

###  III-C Experimental Setup

The experiments in this study utilized NVIDIA A100-SXM4-80GB GPU, employing
Python with the PyTorch framework. All YOLO variants were pre-trained on COCO
before training on the GRAZPEDWRI-DX dataset. The models were trained for 100
epochs. Image resolution was set to 640 pixels, with a batch of 32. SGD
optimizer was utilized with an initial and final learning rate
($\eta=\eta_{f}=1\times 10^{-2}$), a momentum ($\mu=9\times 10^{-1}$), and a
weight decay ($\wp=5\times 10^{-4}$). During training, the “best” model was
saved based on the highest validation (not test) accuracy achieved so far.

##  IV Results & Discussion

To evaluate the performance of YOLOv10 and YOLOv9 using our experimental
design, this study compares several metrics: mean average precision at a 50%
IoU threshold (mAP@50), mean average precision across IoU thresholds from 50%
to 95% (mAP@50-95), F1 score (the harmonic mean of sensitivity and precision),
fracture sensitivity, number of parameters (Params), and floating-point
operations per second (FLOPs).

TABLE II:  Evaluation of YOLOv10 variants compared to YOLOv9 on all classes of GRAZPEDWRI-DX dataset.  Variant | mAP@50 (%) | mAP@50-95 (%) | F1 (%) | Params (M) | FLOPs (G)
---|---|---|---|---|---
YOLOv9-C [10] | 65.3 | 42.7 | 64.0 | 51.0 | 239.0
YOLOv9-E [10] | 65.5 | 43.3 | 64.0 | 69.4 | 244.9
YOLOv9-C’ | 66.2 | 45.2 | 66.7 | 25.3 | 102.4
YOLOv9-E’ | 67.0 | 44.9 | 70.9 | 57.4 | 189.2
YOLOv10-N | 59.5 | 39.1 | 63.0 | 2.7 | 8.2
YOLOv10-S | 76.1 | 51.7 | 67.5 | 8.0 | 24.5
YOLOv10-M | 75.9 | 51.9 | 69.2 | 16.5 | 63.5
YOLOv10-L | 70.9 | 46.6 | 68.7 | 25.7 | 126.4
YOLOv10-X | 76.2 | 48.2 | 69.8 | 31.6 | 169.9
TABLE III:  Evaluation of YOLOv10 variants on fracture class only. All values are shown in percentages (%). Variant | mAP@50 | mAP@50-95 | Sensitivity
---|---|---|---
YOLOv10-N | 93.8 | 56.9 | 88.8
YOLOv10-S | 93.7 | 56.9 | 88.1
YOLOv10-M | 94.0 | 58.4 | 92.5
YOLOv10-L | 94.9 | 58.8 | 89.1
YOLOv10-X | 94.0 | 57.8 | 91.4

Table II presents the evaluation results of the employed YOLO variants. The
top two rows show the benchmarked YOLOv9 results on the GRAZPEDWRI-DX dataset
[10], while the third and fourth rows display the same YOLOv9 variants trained
on our dataset split for a fair comparison. Thus, we highlight both the
benchmarked YOLOv9 results and those using our experimental design. The
remaining rows show the evaluation of YOLOv10 variants. Apart from the
YOLOv10-N variant, all other YOLOv10 variants outperform the YOLOv9 variants
across all metrics. Among the YOLOv10 variants, the X variant achieved the
highest mAP@50 score of 76.2%, while the M variant achieved the highest
mAP@50-95 score of 51.9%. Table III shows the performance evaluation of
YOLOv10 variants specifically for fracture pathology. The M variant performs
exceptionally well, achieving a mAP@50 score of 94% and the highest fracture
sensitivity of 92.5%. Therefore, we select the M variant for a thorough
analysis, as it provides a balanced performance across all metrics.

The training and validation loss curves for the YOLOv10-M variant are
illustrated in Fig.3. Fig.2 presents the precision, recall, and PR curves for
the YOLOv10-M variant on the test set, both overall and for individual
classes. Additionally, Fig.4 displays some inferences made by this variant
compared to the ground truth. The YOLOv10-M variant demonstrates the ability
to detect fractures with high confidence and efficiently identifies various
pathologies, as evidenced by the second, more challenging instance. However,
it should be noted that, although rare, the model can occasionally miss a
fracture, as shown in the fourth image.

As shown in Table II, increasing model complexity generally improves overall
performance. However, while transitioning from the Nano variant (N) to the
Small (S) and then to the Medium (M) variant significantly increased the
mAP@50-95 score, further increases in complexity beyond the M variant led to a
decrease in this score. The Large (L) and Extra-Large (X) variants may have
introduced redundant parameters or layers without substantially enhancing
pathology detection capabilities. The variant M of YOLOv10 achieves an optimal
performance across all metrics on all classes including fracture. The model
performs fewer floating point operations and has fewer parameters than its
predecessors while surpassing them in performance.

##  V Conclusion

In this study, we demonstrated the superiority of YOLOv10 variants over
YOLOv9, with the YOLOv10-M variant achieving optimal performance across all
classes, including fractures. Additionally, we showed that increasing the
model complexity beyond this variant resulted in a decreased mAP@50-95 score.
This study establishes a benchmark for YOLOv10 on the GRAZPEDWRI-DX dataset,
providing a foundation for future research and development.

## Acknowledgement

This work was supported by the Curricula Development and Capacity Building in
Applied Computer Science for Pakistani Higher Education Institutions (CONNECT)
Project NORPART-2021/10502, funded by the Norwegian Directorate for Higher
Education and Skills (DIKU).

## References

  * [1] Evidently Cochrane, “Wrist fractures in children: How are they best treated?” 2022. [Online]. Available: https://www.evidentlycochrane.net/wrist-fractures-children/
  * [2] M. John Erickson, “Wrist fractures in children,” 2024. [Online]. Available: https://www.johnericksonmd.com/patient-information/pediatric-distal-radius-fractures/
  * [3] scottishriteforchildren, “Wrist fractures and other wrist complaints you shouldnt ignore,” 2024. [Online]. Available: https://scottishriteforchildren.org/news-items/wrist-fractures-and-other-wrist-complaints-you-sho
  * [4] Gleamer, “Artificial intelligence effectivity in fracture detection,” 2024. [Online]. Available: https://www.gleamer.ai/evidence/artificial-intelligence-effectivity-in-fracture-detection
  * [5] A. Hussain, A. Fareed, and S. Taseen, “Bone fracture detection—can artificial intelligence replace doctors in orthopedic radiography analysis?” _Frontiers in Artificial Intelligence_ , vol. 6, 2023.
  * [6] A. Ahmed, A. S. Imran, A. Manaf, Z. Kastrati, and S. M. Daudpota, “Enhancing wrist abnormality detection with yolo: Analysis of state-of-the-art single-stage detection models,” _Biomedical Signal Processing and Control_ , vol. 93, p. 106144, 2024.
  * [7] C.-T. Chien, R.-Y. Ju, K.-Y. Chou, E. Xieerke, and J.-S. Chiang, “Yolov8-am: Yolov8 with attention mechanisms for pediatric wrist fracture detection,” 2024.
  * [8] R.-Y. Ju and W. Cai, “Fracture detection in pediatric wrist trauma x-ray images using yolov8 algorithm,” _Scientific Reports_ , vol. 13, no. 1, p. 20077, 2023.
  * [9] E. Nagy, M. Janisch, F. Hržić, E. Sorantin, and S. Tschauner, “A pediatric wrist trauma x-ray dataset (grazpedwri-dx) for machine learning,” _Scientific Data_ , vol. 9, no. 1, p. 222, 2022.
  * [10] C.-T. Chien, R.-Y. Ju, K.-Y. Chou, and J.-S. Chiang, “Yolov9 for fracture detection in pediatric wrist trauma x-ray images,” _arXiv_ , May 2024.
  * [11] P. Samothai, P. Sanguansat, A. Kheaksong, K. Srisomboon, and W. Lee, “The evaluation of bone fracture detection of yolo series,” in _2022 37th International Technical Conference on Circuits/Systems, Computers and Communications (ITC-CSCC)_. IEEE, 2022, pp. 1054–1057.
  * [12] A. Wang, H. Chen, L. Liu, K. Chen, Z. Lin, J. Han, and G. Ding, “Yolov10: Real-time end-to-end object detection,” 2024.
  * [13] G. Sha, J. Wu, and B. Yu, “Detection of spinal fracture lesions based on improved yolov2,” in _2020 IEEE International Conference on Artificial Intelligence and Computer Applications (ICAICA)_ , 2020, pp. 235–238.
  * [14] F. Hrži’c _et al._ , “Fracture recognition in paediatric wrist radiographs: An object detection approach,” _Mathematics_ , vol. 10, no. 16, p. 2939, 2022.
  * [15] R. Dibo, A. Galichin, P. Astashev, D. V. Dylov, and O. Y. Rogov, “Deeploc: Deep learning-based bone pathology localization and classification in wrist x-ray images,” in _Analysis of Images, Social Networks and Texts_ , D. I. Ignatov, M. Khachay, A. Kutuzov, H. Madoyan, I. Makarov, I. Nikishina, and A. Panchenko, Eds. Cham: Springer Nature Switzerland, 2024, pp. 199–211.