# Dynamical heterogeneities of thermal creep in pinned interfaces

Tom W.J. de Geus  Institute of Physics, École Polytechnique Fédérale de
Lausanne (EPFL), Switzerland  Alberto Rosso  LPTMS, CNRS, Univ. Paris-Sud,
Université Paris-Saclay, 91405 Orsay, France  Matthieu Wyart  Institute of
Physics, École Polytechnique Fédérale de Lausanne (EPFL), Switzerland

###### Abstract

Disordered systems under applied loading display slow creep flows at finite
temperature, which can lead to the material rupture. Renormalization group
arguments predicted that creep proceeds via thermal avalanches of activated
events. Recently, thermal avalanches were argued to control the dynamics of
liquids near their glass transition. Both theoretical approaches are markedly
different. Here we provide a scaling description that seeks to unify dynamical
heterogeneities in both phenomena, confirm it in simple models of pinned
elastic interfaces, and discuss its experimental implications.

## Introduction

The physical properties of a material are often controlled by the interfaces
embedded in it. This is the case for dislocations in crystalline materials
Miguel et al. (2001); Madec et al. (2003); Zaiser (2006), crack fronts in
fracture Bouchaud (1997), frictional interfaces Scholz (1998), or domain walls
in magnets Zapperi et al. (1998). Pinned by impurities, they dramatically
increase the material’s strength, toughness, or hysteresis. At the critical
force (or stress, or magnetic field) $f_{c}$, the interfaces undergo a
_depinning transition_ Kardar (1998); Fisher (1998) and move via large
reorganizations, called avalanches. Their maximal linear extent diverges
approaching the critical point, $\ell_{\text{dep}}(f)\sim|f-f_{c}|^{-\nu}$ and
their size is power law distributed, $P(S)\sim S^{-\tau}$. Moreover, the
interface shape is a self-similar shape with a roughness exponent $\zeta$.
These exponents $\tau,\zeta,\nu,\ldots$ are now well understood and related by
scaling relations summarized in Table 1.

The dynamics below $f_{c}$, in the so-called creep regime, is more
controversial. Here, the motion is controlled by the thermal activation over
the pinning potential Ferrero et al. (2021). Creep is fundamental for a
variety of phenomena, ranging from the failure of materials Leocmach et al.
(2014); Divoux et al. (2011); Siebenbürger et al. (2012); Rosti et al. (2010)
to the rupture of frictional interfaces and faults Baumberger et al. (1994);
Bureau et al. (2001); Bar-Sinai et al. (2013); Harris (2017); Vincent-Dospital
et al. (2020). In Chauve et al. (2000), a study of pinned interfaces based on
the functional renormalization group (FRG), predicted the existence of two
distinct length scales:

(i) The first length, $\ell_{\text{opt}}(f)$, corresponds to the extent of the
elementary excitations. Elementary excitations correspond to the minimal
motion in the direction of the applied force that brings the interface to a
new local minimum with smaller energy. They can be treated as being
irreversible, since the probability of going backward once an excitation is
triggered is small. $\ell_{\text{opt}}(f)$ grows as $\ell_{\text{opt}}(f)\sim
f^{-\nu_{\text{eq}}}$ when the force $f$ vanishes. Below this scale, the
interface is at equilibrium with a roughness exponent $\zeta_{\text{eq}}$
Ioffe and Vinokur (1987); Nattermann (1987); Agoritsas et al. (2012).

(ii) The second, much larger length, $\ell_{c}(T,f)$, identifies with the cut-
off of the thermal avalanches induced by the interaction between elementary
excitations. Below this length, the roughness exponent is $\zeta$ and
avalanches are depinning-like. This cut-off also diverges, as

$\ell_{c}(T,f)\sim T^{-\sigma}f^{-\lambda}.$ (1)

The FRG equations cannot be solved exactly. In Chauve et al. (2000) an ansatz
was proposed that leads to $\sigma=\nu/\beta$ and
$\lambda=\nu_{\text{eq}}+\mu_{\text{eq}}\nu/\beta$ 111 The depinning exponent
$\beta$ controls, at zero temperature, the velocity of the interface, which
vanishes as $v\sim(f-f_{c})^{\beta}$ at $f_{c}$. The equilibrium exponent
$\mu_{\text{eq}}$ appears in the creep formula $\ln v\sim
f^{-\mu_{\text{eq}}}$. This behaviour has been confirmed experimentally in
Lemerle et al. (1998). .

Efficient optimization algorithms at vanishing temperature $T=0^{+}$ have
studied the case of a one-dimensional domain wall moving in a medium in two
dimensions Kolton et al. (2006, 2009); Ferrero et al. (2017). They confirmed
the scaling of $\ell_{\text{opt}}(f)$, the crossover of the roughness
exponents from equilibrium to depinning, as well as the presence of thermal
depinning avalanches. Experiments on a one-dimensional domain wall in a
ferromagnetic film showed the validity of the creep formula for the wall
velocity, which is an indirect check for the scaling of $\ell_{\text{opt}}(f)$
Lemerle et al. (1998); Metaxas et al. (2007). Recently, depinning thermal
avalanches have been observed via Magneto-optic Kerr effect (MOKE) techniques
Grassi et al. (2018); Durin et al. (2023) and in crumpled paper Lahini et al.
(2023); Shohat et al. (2023). However, the determination of $\ell_{c}(T,f)$
remains an open problem – finite temperature simulations using Langevin
dynamics were inconclusive Kolton et al. (2009).

Recently, it was proposed that the concept of thermal avalanches extends
beyond driven systems, and explains the dynamical heterogeneities observed in
supercooled liquids Tahaei et al. (2023). In that case, it was argued that
$\ell_{c}(T)\sim T^{-\sigma}$ with $\sigma\geq(1+\theta)/d$, whereby $\theta$
is an exponent that characterizes the distribution of excitations Lin et al.
(2014); Lin and Wyart (2016). In the context of the depinning transition
$\theta=0$. In two dimensions, this inequality was found to be saturated in
mesoscopic models of liquids Tahaei et al. (2023). Arguments in Tahaei et al.
(2023) should also go through in the depinning context, yet the bound
$\sigma\geq 1/d$ is much below the FRG predictions.

In this Letter, we propose a scaling theory of dynamical heterogeneities for
both phenomena. We introduce a stylized model for creep of depinning
interfaces, where the optimized elementary excitations are coarse-grained at
the scale of a single block. At zero temperature, the model reduces to the
cellular automata used to study the depinning transition and its exponents. At
finite temperature, a similar model was discussed in Vandembroucq et al.
(2004); Purrello et al. (2017), but not used to study the creep regime. We
provide theoretical arguments indicating that

$\sigma=\nu$ (2)

both for depinning and for the glass transition (see below for a definition of
$\nu$ in the latter case). Moreover, we argue that in the depinning case, the
relationship between the age $t$ of an avalanche and its spatial extent
follows, as for liquids Tahaei et al. (2023):

$\ell_{c}(t)\sim T^{-\nu}\left[\ln(\tau_{\alpha}/t)\right]^{-\nu}$ (3)

where $\tau_{\alpha}$ is a characteristic timescale at which a fraction of the
interface has moved. We find that all our predictions hold quantitatively in a
mesoscopic model of depinning.

Table 1:  Critical exponents of the depinning transition of an elastic manifold with short-range interactions in $d$ dimensions, embedded in $d+1$ dimensions. Exponent values correspond to $d=2$.  Name | Expression | Scaling | Value
---|---|---|---
$\tau$ | $P(S)\sim S^{-\tau}$ | $2-2/(d+\zeta)$ | $1.27$
$\zeta$ | $S\sim\ell^{d+\zeta}$ |  | $0.753$
$\nu$ | $\ell_{c}\sim|f_{c}-f|^{-\nu}$ | $1/(2-\zeta)$ | $0.80$

(a)

(b)

(c)

Figure 1:  At $T=0^{+}$: LABEL:sub@fig:extremal:pdf_x Distribution of
activation barriers $P(E)$ at random snapshots, for different system sizes
$L^{d}$ as specified by the color bar. As $L\rightarrow\infty$, $P(E)$
displays a gap at $E_{c}\approx 0.6284\pm 0.0001$.
(LABEL:sub@fig:extremal:pdf_s, LABEL:sub@fig:extremal:ellc) Failure events are
segmented into avalanches as sequences for which the activation barrier of the
failing block $E_{\min}<E_{0}$. LABEL:sub@fig:extremal:pdf_s Inset: avalanches
distribution $P(S)$ for $E_{0}=E_{c}$. The prediction $P(S)\sim
S^{-\tau}f(S/L^{d+\zeta})$ where $f$ is a scaling function, is tested in the
main panel by rescaling the axis: a collapse is apparent with the depinning
exponents of Table 1. LABEL:sub@fig:extremal:ellc Main panel: linear extent of
avalanches $\ell_{c}$ as a function of the threshold $E_{0}<E_{c}$, for
different system size $L$. The scaling behavior,
$\ell_{c}=(E_{c}-E_{0})^{-\nu}g((E_{c}-E_{0})^{-\nu}/L)$ is confirmed in the
inset for $\nu=1/(2-\zeta)\approx 0.80$.

## Model

We model an elastic interface in a mesoscopic manner, coarse-grained on the
excitation scale $\ell_{\text{opt}}(f)$. Such a model is the basis of both our
theoretical arguments, and of our numerical study below. The system is a
lattice of $L^{d}$ blocks. The block $i$ is characterized by an applied force
$f_{i}$ (the sum of the driving force $f$ and elastic forces coming from
neighboring blocks), and by a yielding threshold $f_{i}^{y}$. Its stability is
governed by the distance to yielding $x_{i}\equiv|f_{i}|-f_{i}^{y}$,
corresponding to an activation barrier
$E_{i}\equiv|x_{i}|^{\alpha}\,\mathrm{sign}(x_{i})$ with some $\alpha>0$. Our
arguments below do not depend on the value of $\alpha$.

At a finite temperature $T>0$ (that we express in the units of the Boltzmann
constant $k_{B}$), the time to failure $\tau$ of a block is exponentially
distributed $P(\tau)=\exp(-\tau/\tau_{i})/\tau_{i}$. Here the characteristic
time is $\tau_{i}=\tau_{0}\exp(E_{i}/T)$ if $E_{i}\geq 0$ and
$\tau_{i}=\tau_{0}$ otherwise, where $\tau_{0}$ is a fixed microscopic
timescale. After failure, the force $f_{i}$ drops to a small random value, and
a fresh value of the yield force $f_{i}^{y}$ is sampled from a fixed
distribution. The force drop is redistributed equally to the nearest
neighboring blocks, as follows from the presence of elastic interactions.
Finally, the position of the interface at block $i$, $u_{i}$, is increased by
the value of the force drop (using an elastic constant of one).

It is well known that such a cellular automaton has a threshold force $f_{c}$,
such that if the applied force $f=\sum_{i}f_{i}/L^{d}$ is larger than a
depinning threshold $f_{c}$, the dynamics does not stop even if $T=0$. In our
arguments we consider that $f<f_{c}$ and $T>0$, while numerics are performed
with $f=f_{c}/2$, $d=2$ and $\alpha=3/2$. We express forces in units of
average yield threshold $\bar{f}^{y}$, time in units of $\tau_{0}$,
temperature in units of $k_{B}(\bar{f}^{y})^{\alpha}$, and length in units of
the lattice spacing. Further numerical details are specified in Appendix A.

## Extremal dynamics

For finite $L$, if $T$ is vanishingly small, the site with the smallest
activation barrier $E_{\min}\equiv\min_{i}(E_{i})$ always relaxes first. It is
an example of extremal dynamics noted here as $T=0^{+}$. It is well studied in
the context of self-organized criticality Paczuski et al. (1996); Vandembroucq
et al. (2004); Purrello et al. (2017). As $L\rightarrow\infty$, the
distribution of energy barriers $P(E)=\sum_{i}\delta(E-E_{i})/L^{d}$ must have
a compact support, and be zero below a force-dependent value $E_{c}$ 222 The
probability to trigger to instability a block with $E_{i}>E_{c}$ is vanishing
as $L\rightarrow\infty$. Because the number of blocks is extensive in the
energy range $[E_{c},E_{i}]$, $E_{i}>0$ can never be the extremal, minimum,
energy among all blocks. . $E_{c}$ must grow as the applied force decreases,
and vanishes at the depinning threshold $f=f_{c}$. Thus in the case $f<f_{c}$
considered here one has $E_{c}>0$.

For finite $L$, $E_{c}$ in not sharply defined but displays sample to sample
fluctuations illustrated in Fig. 1a. After averaging the distribution of
$E_{c}$ over various configurations, $P_{L}(E)$ has a standard deviation
$\Delta E_{c}$ that decays algebraically with $L$ as

$\Delta E_{c}\sim L^{-1/\nu}.$ (4)

Note that for elastoplastic models used to study the glass transition Tahaei
et al. (2023); Ozawa and Biroli (2023), Eq. 4 defines $\nu$, which will take a
different value than for the elastic interface.

For extremal dynamics, avalanches can be defined as a sequence of $S$ fast
events where the most unstable site $E_{\min}$ always satisfies
$E_{\min}<E_{0}$, where $E_{0}$ is some chosen threshold Paczuski et al.
(1996); Purrello et al. (2017). In the thermodynamic limit, it is clear that
the sequence never stops if $E_{0}>E_{c}$. It is critical at $E_{0}=E_{c}$,
and falls in the depinning universality class with $P(S)\sim S^{-\tau}$, with
a cut-off $S_{c}\sim L^{d+\zeta}$ at finite $L$. It is confirmed in Fig. 1b
with exponents indeed given by Table 1 (see Appendix C for an illustration on
the method and Appendix B for further supporting measurements).

Figure 2:  Left column: number of times $s_{i}$ that a block yielded during a
time interval $t$ (increasing from top to bottom) for our lowest temperature
$T=0.002$ and our biggest system $L=2^{9}=512$. Right column: same quantity
for different temperatures (increasing from top to bottom) at
$t=\tau_{\alpha}$, defined as the time for which half of the sites yielded at
least once.

For $E_{0}<E_{c}$, avalanches will be cut off once they reach some spatial
extent $\ell_{c}$. $\ell_{c}$ must be the length scale where the local
fluctuations of the gap $\Delta E_{c}(\ell_{c})$ are of order of the
difference $E_{c}-E_{0}$: clearly, on a smaller scale, this difference is
irrelevant. Using Eq. 4 yields:

$\ell_{c}\sim(E_{c}-E_{0})^{-\nu}.$ (5)

This result is confirmed numerically in Fig. 1c. Here, we define the linear
extent of an avalanche as $\ell\equiv A^{1/d}$, where the ‘area’ $A$ is the
number of sites that yielded at least once. The cut-off $\ell_{c}$ is then
defined as the ratio of moments
$\ell_{c}\equiv\langle\ell^{2}\rangle/\langle\ell\rangle$ where the average
$\langle\dots\rangle$ is made over avalanches. We define $E_{c}$ to provide
the best collapse of Eq. 5 in the inset of Fig. 1c.

## Finite temperature

At a finite but small enough (to be specified below) temperature $T$ and fixed
$L$, the above picture remains true, but the dynamics now occur on a finite
time scale. The duration $t$ of an avalanche defined with threshold $E_{0}$
will be of order of the longest waiting time between events within it, of
order $\exp(E_{0}/T)$, thus $t\sim\exp(E_{0}/T)$. The largest avalanches
filling up the system occur on some time $\tau_{\alpha}\sim\exp(E_{c}/T)$. We
extract numerically $\tau_{\alpha}$ as the time at which half of the system
fails at least once, which indeed is proportional to $\exp(E_{c}/T)$ as we
test in Appendix E. Injecting these definitions in Eq. 5, one gets for
$t\leq\tau_{\alpha}$:

$\ell_{c}(t,T)\sim T^{-\nu}\left[\ln(\tau_{\alpha}/t)\right]^{-\nu}.$ (6)

A similar argument was proposed for supercooled liquids, and matched the
growth of dynamical heterogeneities with time in molecular dynamics
observations well Tahaei et al. (2023). This prediction can be tested in the
depinning case by considering the pattern of relaxations occurring in some
time interval $t$, as illustrated in the left panel of Fig. 2. We extract
avalanches from these figures as connected clusters, and
$\ell_{c}(t,T)\equiv\langle\ell^{2}(t)\rangle_{T}/\langle\ell(t)\rangle_{T}$.
Here the average $\langle\ldots\rangle_{T}$ is made on all clusters observed
at temperature $T$ in intervals of duration $t$, and the extent $\ell$ is
defined as above (the square root of the cluster area in our $d=2$ numerics).
Our prediction is confirmed in Fig. 3 (see Appendix C for illustration of the
method, and Appendix D for further supporting measurements on both the
avalanche exponents as well as our prediction in Eq. 6).

(a)

(b)

Figure 3:  LABEL:sub@fig:thermal:time Extent of connected clusters
$\ell_{c}(t)$ after some time interval $t$, for different temperatures, as
indicated in the color bar. LABEL:sub@fig:thermal:time_collapse The prediction
$\ell_{c}(t)\sim T^{-\nu}\left[\ln(\tau_{\alpha}/t)\right]^{-\nu}$ is tested
by rescaling the axis, which indeed approximately collapses the different
curves. The straight green line indicates the prediction
$\ln(\tau_{\alpha}/t)^{-\nu}$.

We now focus on our central question: the correlation length $\ell_{c}(T)$ in
an infinite system. The right panel of Fig. 2 shows the interface motion
during a time interval of $\tau_{\alpha}$ (where half of the sites relaxed),
for different temperatures. Clearly, the dynamics is more and more correlated
under cooling. To explain these observations, we perform a finite size scaling
argument. Consider an infinite system cuts into subsystems of size $L$. The
fluctuations $\Delta E_{c}$ of the gaps in different subsystems follows
$\Delta E_{c}(L)\sim L^{-1/\nu}$. If $T\gg\Delta E_{c}$, these subsystems
relax essentially at the same speed, while if $T\ll\Delta E_{c}(L)$ their pace
is very different. Thus, dynamical heterogeneities should exist up to a length
$\ell_{c}$ such $T\sim\Delta E_{c}(\ell_{c})$, implying:

$\ell_{c}(T)\sim T^{-\nu}.$ (7)

Note that this result also identifies $\ell_{c}(T)$ with the avalanche extent
occurring on a timescale $\cal{O}(\tau_{\alpha})$, according to Eq. 6.

In the case of elastic interfaces, dynamical correlations also affect the
structural correlations in the interface geometry. In particular, we expect
the depinning roughness exponent $\zeta$ to hold up to a scale
$\ell_{c}(T)\sim T^{-\nu}$. Above this length scale, avalanches become
independent and they are randomly triggered. As in the Edwards-Wilkinson
model, the roughness becomes $\zeta_{EW}=(2-d)/2$ for $d<2$ and logarithmic
for $d=2$.

This prediction is verified by considering the structure factor
$\hat{S}(q)\equiv\langle\hat{u}(\vec{q})\hat{u}({-\vec{q}})\rangle$, with
$u(\vec{x})$ the position of the interface at location $\vec{x}$;
$\hat{u}(\vec{q})$ is its Fourier transform and $q$ the Euclidean norm of wave
vector $\vec{q}$. The average $\langle\ldots\rangle$ is taken on independent
snapshots taken at random times. For a self-affine interface with roughness
exponent $\zeta$, the structure factor scales as $\hat{S}(q)\sim
q^{-(d+2\zeta)}$ (e.g. Ramasco et al. (2000); Schmittbuhl et al. (1995)) and
as $\hat{S}(q)\sim q^{-d}$ for a logarithmic roughness. The crossover between
the two regimes occurs at a scale $q_{c}(T)\sim 1/\ell_{c}(T)$. We verify such
scaling in Fig. 4a and find that the crossover scale from Eq. 7 indeed
collapses data for different $T$ in Fig. 4b.

(a)

(b)

Figure 4:  LABEL:sub@fig:thermal:structure Structure factor of the position of
the interface $u(x)$ at location $x$ (see main text), for different
temperatures (see color bar). All results for our largest system size
$L=2^{9}$. At small distances (large $q$) we find a fast decay, $\sim
1/q^{d+2\zeta}$, consistent with the depinning exponent $\zeta$ in Table 1
(solid blue line). At large distances (small $q$) we observe a slower decay
$\sim 1/q^{d}$ (dashed green line) consistent with a logarithmic roughness.
LABEL:sub@fig:thermal:structure_collapse The collapse of data indicates that
the crossover scale is $\ell_{c}(T)\sim T^{-\nu}$.

## Conclusion

We have provided a description of thermal avalanches which may characterize
dynamical heterogeneities in both the creep flows of pinned interfaces and in
supercooled liquids. As proposed for liquids Tahaei et al. (2023), we argued
in the context of depinning that the growth of avalanche size with time is
logarithmic, and tested this prediction in a simple model. This prediction
could be tested in experiments monitoring the domain wall dynamics Grassi et
al. (2018); Durin et al. (2023) or by the motion of dislocations in
crystalline materials Rodney et al. (2023).

Our central prediction concerns the correlation length $\ell_{c}(T)$. The
scaling of the correlation length $\ell_{c}(T)\sim T^{-\nu}$ differs from the
FRG prediction of Chauve et al. (2000). The latter was obtained from an Ansatz
solution, it will be interesting to see if our prediction can be derived from
the original FRG equations. It will also be important to verify Eq. 7 from
direct simulations of a continuous elastic line at finite temperature, or in
experiments by recording the dynamics at different temperatures using a
cryostat, as in Grassi et al. (2018).

For supercooled liquids, we have argued that $\ell_{c}(T)\sim T^{-\nu}$, which
should be, in general, distinct from the bound $(1+\theta)/d$ proposed in
Tahaei et al. (2023). In two dimensions, an elastoplastic model of the glass
transition predicted $(1+\theta)/d\approx 0.8$ and $\nu\approx 0.9$ 333$\nu$
is noted $1/{\tilde{d_{f}}\tilde{\sigma}}$ in that reference, where it is
extracted from Eq. 5., and both predictions are consistent with the
observation $\ell_{c}(T)\sim T^{-0.8}$. We expect the similarity between these
exponents to be a coincidence, which for example does not occur for the pinned
interface investigated here. We expect this similarity to disappear in the
practically relevant case of three-dimensional liquids. This point can now be
tested in three-dimensional elastoplastic models, by extracting both exponents
$\nu$ and $\theta$. Measuring $\nu$ would lead to quantitative prediction for
the temporal or thermal behavior of dynamical heterogeneities that could be
tested in experiments Weeks et al. (2000).

## Acknowledgements

E. El Sergany is thanked for exploratory numerical tests, and L. Berthier, G.
Biroli, C. Brito, C. Gavazzoni, D. Korchinski, W. Ji, Y. Lahini, M. Müller, M.
Ozawa, M. Pica Ciamarra, M. Popović, D. Shoat, and A. Tahei for discussions.
T.G. acknowledges support from the Swiss National Science Foundation (SNSF) by
the SNSF Ambizione Grant PZ00P2_185843. M.W. acknowledges support from the
Simons Foundation Grant (No. 454953 Matthieu Wyart).

## References

  * Miguel et al. [2001] M. C. Miguel, A. Vespignani, S. Zapperi, J. Weiss, and J.-R. Grasso.  Intermittent dislocation flow in viscoplastic deformation.  _Nature_ , 410(6829):667–671, 2001.  10.1038/35070524.  arxivid: cond-mat/0105069.
  * Madec et al. [2003] R. Madec, B. Devincre, L. Kubin, T. Hoc, and D. Rodney.  The Role of Collinear Interaction in Dislocation-Induced Hardening.  _Science_ , 301(5641):1879–1882, 2003.  10.1126/science.1085477.
  * Zaiser [2006] M. Zaiser.  Scale invariance in plastic flow of crystalline solids.  _Adv. Phys._ , 55(1–2):185–245, 2006.  10.1080/00018730600583514.
  * Bouchaud [1997] E. Bouchaud.  Scaling properties of cracks.  _J. Phys. Condens. Matter_ , 9(21):4319–4344, 1997.  10.1088/0953-8984/9/21/002.
  * Scholz [1998] C. H. Scholz.  Earthquakes and friction laws.  _Nature_ , 391(6662):37–42, 1998.  10.1038/34097.
  * Zapperi et al. [1998] S. Zapperi, P. Cizeau, G. Durin, and H. E. Stanley.  Dynamics of a ferromagnetic domain wall: Avalanches, depinning transition, and the Barkhausen effect.  _Phys. Rev. B_ , 58(10):6353–6366, 1998.  10.1103/PhysRevB.58.6353.  arxivid: cond-mat/9803253.
  * Kardar [1998] M. Kardar.  Nonequilibrium dynamics of interfaces and lines.  _Phys. Rep._ , 301(1–3):85–112, 1998.  10.1016/S0370-1573(98)00007-6.  arxivid: cond-mat/9704172.
  * Fisher [1998] D. S. Fisher.  Collective transport in random media: From superconductors to earthquakes.  _Phys. Rep._ , 301(1–3):113–150, 1998.  10.1016/S0370-1573(98)00008-8.  arxivid: cond-mat/9711179.
  * Ferrero et al. [2021] E. E. Ferrero, L. Foini, T. Giamarchi, A. B. Kolton, and A. Rosso.  Creep Motion of Elastic Interfaces Driven in a Disordered Landscape.  _Annu. Rev. Condens. Matter Phys._ , 12(1):111–134, 2021.  10.1146/annurev-conmatphys-031119-050725.
  * Leocmach et al. [2014] M. Leocmach, C. Perge, T. Divoux, and S. Manneville.  Creep and Fracture of a Protein Gel under Stress.  _Phys. Rev. Lett._ , 113(3):038303, 2014.  10.1103/PhysRevLett.113.038303.  arxivid: 1401.8234.
  * Divoux et al. [2011] T. Divoux, C. Barentin, and S. Manneville.  From stress-induced fluidization processes to Herschel-Bulkley behaviour in simple yield stress fluids.  _Soft Matter_ , 7(18):8409, 2011.  10.1039/C1SM05607G.  arxivid: 1012.0693.
  * Siebenbürger et al. [2012] M. Siebenbürger, M. Ballauff, and Th. Voigtmann.  Creep in Colloidal Glasses.  _Phys. Rev. Lett._ , 108(25):255701, 2012.  10.1103/PhysRevLett.108.255701.
  * Rosti et al. [2010] J. Rosti, J. Koivisto, L. Laurson, and M. J. Alava.  Fluctuations and Scaling in Creep Deformation.  _Phys. Rev. Lett._ , 105(10):100601, 2010.  10.1103/PhysRevLett.105.100601.  arxivid: 1007.4688.
  * Baumberger et al. [1994] T. Baumberger, F. Heslot, and B. Perrin.  Crossover from creep to inertial motion in friction dynamics.  _Nature_ , 367(6463):544–546, 1994.  10.1038/367544a0.
  * Bureau et al. [2001] L. Bureau, T. Baumberger, and C. Caroli.  Jamming creep of a frictional interface.  _Phys. Rev. E_ , 64(3):031502, 2001.  10.1103/PhysRevE.64.031502.  arxivid: cond-mat/0101357.
  * Bar-Sinai et al. [2013] Y. Bar-Sinai, R. Spatschek, E. A. Brener, and E. Bouchbinder.  Instabilities at frictional interfaces: Creep patches, nucleation, and rupture fronts.  _Phys. Rev. E_ , 88(6):060403, 2013.  10.1103/PhysRevE.88.060403.  arxivid: 1306.3658.
  * Harris [2017] R. A. Harris.  Large earthquakes and creeping faults.  _Rev. Geophys._ , 55(1):169–198, 2017.  10.1002/2016RG000539.
  * Vincent-Dospital et al. [2020] T. Vincent-Dospital, R. Toussaint, S. Santucci, L. Vanel, D. Bonamy, L. Hattali, A. Cochard, E. G. Flekkøy, and K. J. Måløy.  How heat controls fracture: The thermodynamics of creeping and avalanching cracks.  _Soft Matter_ , 16(41):9590–9602, 2020.  10.1039/D0SM01062F.  arxivid: 1905.07180.
  * Chauve et al. [2000] P. Chauve, T. Giamarchi, and P. Le Doussal.  Creep and depinning in disordered media.  _Phys. Rev. B_ , 62(10):6241–6267, 2000.  10.1103/PhysRevB.62.6241.  arxivid: cond-mat/0002299.
  * Ioffe and Vinokur [1987] L. B. Ioffe and V. M. Vinokur.  Dynamics of interfaces and dislocations in disordered media.  _J. Phys. C_ , 20(36):6149–6158, 1987.  10.1088/0022-3719/20/36/016.
  * Nattermann [1987] T. Nattermann.  Interface Roughening in Systems with Quenched Random Impurities.  _Europhys. Lett._ , 4(11):1241–1246, 1987.  10.1209/0295-5075/4/11/005.
  * Agoritsas et al. [2012] E. Agoritsas, V. Lecomte, and T. Giamarchi.  Disordered elastic systems and one-dimensional interfaces.  _Phys. B_ , 407(11):1725–1733, 2012.  10.1016/j.physb.2012.01.017.  arxivid: 1111.4899.
  * Lemerle et al. [1998] S. Lemerle, J. Ferré, C. Chappert, V. Mathet, T. Giamarchi, and P. Le Doussal.  Domain Wall Creep in an Ising Ultrathin Magnetic Film.  _Phys. Rev. Lett._ , 80(4):849–852, 1998.  10.1103/PhysRevLett.80.849.
  * Kolton et al. [2006] A. B. Kolton, A. Rosso, T. Giamarchi, and W. Krauth.  Dynamics below the Depinning Threshold in Disordered Elastic Systems.  _Phys. Rev. Lett._ , 97(5):057001, 2006.  10.1103/PhysRevLett.97.057001.  arxivid: cond-mat/0603297.
  * Kolton et al. [2009] A. B. Kolton, A. Rosso, T. Giamarchi, and W. Krauth.  Creep dynamics of elastic manifolds via exact transition pathways.  _Phys. Rev. B_ , 79(18):184207, 2009.  10.1103/PhysRevB.79.184207.  arxivid: 0902.4557.
  * Ferrero et al. [2017] E. E. Ferrero, L. Foini, T. Giamarchi, A. B. Kolton, and A. Rosso.  Spatiotemporal Patterns in Ultraslow Domain Wall Creep Dynamics.  _Phys. Rev. Lett._ , 118(14):147208, 2017.  10.1103/PhysRevLett.118.147208.  arxivid: 1604.03726.
  * Metaxas et al. [2007] P. J. Metaxas, J. P. Jamet, A. Mougin, M. Cormier, J. Ferré, V. Baltz, B. Rodmacq, B. Dieny, and R. L. Stamps.  Creep and Flow Regimes of Magnetic Domain-Wall Motion in Ultrathin Pt / Co / Pt Films with Perpendicular Anisotropy.  _Phys. Rev. Lett._ , 99(21):217208, 2007.  10.1103/PhysRevLett.99.217208.  arxivid: cond-mat/0702654.
  * Grassi et al. [2018] M. P. Grassi, A. B. Kolton, V. Jeudy, A. Mougin, S. Bustingorry, and J. Curiale.  Intermittent collective dynamics of domain walls in the creep regime.  _Phys. Rev. B_ , 98(22):224201, 2018.  10.1103/PhysRevB.98.224201.  arxivid: 1804.09572.
  * Durin et al. [2023] G. Durin, V. M. Schimmenti, M. Baiesi, A. Casiraghi, A. Magni, L. Herrera-Diez, D. Ravelosona, L. Foini, and A. Rosso.  Earthquake-like dynamics in ultrathin magnetic film.  _arXiv preprint: 2309.12898_ , 2023.  10.48550/arXiv.2309.12898.
  * Lahini et al. [2023] Y. Lahini, S. M. Rubinstein, and A. Amir.  Crackling Noise during Slow Relaxations in Crumpled Sheets.  _Phys. Rev. Lett._ , 130(25):258201, 2023.  10.1103/PhysRevLett.130.258201.
  * Shohat et al. [2023] D. Shohat, Y. Friedman, and Y. Lahini.  Logarithmic aging via instability cascades in disordered systems.  _Nat. Phys._ , 19(12):1890–1895, 2023.  10.1038/s41567-023-02220-2.  arxivid: 2306.00567.
  * Tahaei et al. [2023] A. Tahaei, G. Biroli, M. Ozawa, M. Popović, and M. Wyart.  Scaling Description of Dynamical Heterogeneity and Avalanches of Relaxation in Glass-Forming Liquids.  _Phys. Rev. X_ , 13(3):031034, 2023.  10.1103/PhysRevX.13.031034.  arxivid: 2305.00219.
  * Lin et al. [2014] J. Lin, A. Saade, E. Lerner, A. Rosso, and M. Wyart.  On the density of shear transformations in amorphous solids.  _EPL Europhys. Lett._ , 105(2):26003, 2014.  10.1209/0295-5075/105/26003.
  * Lin and Wyart [2016] J. Lin and M. Wyart.  Mean-Field Description of Plastic Flow in Amorphous Solids.  _Phys. Rev. X_ , 6(1):011005, 2016.  10.1103/PhysRevX.6.011005.
  * Vandembroucq et al. [2004] D. Vandembroucq, R. Skoe, and S. Roux.  Universal depinning force fluctuations of an elastic line: Application to finite temperature behavior.  _Phys. Rev. E_ , 70(5):051101, 2004.  10.1103/PhysRevE.70.051101.  arxivid: cond-mat/0311485.
  * Purrello et al. [2017] V. H. Purrello, J. L. Iguain, A. B. Kolton, and E. A. Jagla.  Creep and thermal rounding close to the elastic depinning threshold.  _Phys. Rev. E_ , 96(2):022112, 2017.  10.1103/PhysRevE.96.022112.  arxivid: 1704.01489.
  * Paczuski et al. [1996] M. Paczuski, S. Maslov, and P. Bak.  Avalanche dynamics in evolution, growth, and depinning models.  _Phys. Rev. E_ , 53(1):414–443, 1996.  10.1103/PhysRevE.53.414.  arxivid: adap-org/9510002.
  * Ozawa and Biroli [2023] M. Ozawa and G. Biroli.  Elasticity, Facilitation, and Dynamic Heterogeneity in Glass-Forming Liquids.  _Phys. Rev. Lett._ , 130(13):138201, 2023.  10.1103/PhysRevLett.130.138201.  arxivid: 2209.08861.
  * Ramasco et al. [2000] J. J. Ramasco, J. M. López, and M. A. Rodríguez.  Generic Dynamic Scaling in Kinetic Roughening.  _Phys. Rev. Lett._ , 84(10):2199–2202, 2000.  10.1103/PhysRevLett.84.2199.  arxivid: cond-mat/0001111.
  * Schmittbuhl et al. [1995] J. Schmittbuhl, J.-P. Vilotte, and S. Roux.  Reliability of self-affine measurements.  _Phys. Rev. E_ , 51(1):131–147, 1995.  10.1103/PhysRevE.51.131.
  * Rodney et al. [2023] D. Rodney, P.-A. Geslin, S. Patinet, V. Démery, and A. Rosso.  Does the Larkin length exist?  working paper or preprint, December 2023.  URL https://hal.science/hal-04355482.
  * Weeks et al. [2000] E. R. Weeks, J. C. Crocker, A. C. Levitt, A. Schofield, and D. A. Weitz.  Three-Dimensional Direct Imaging of Structural Relaxation Near the Colloidal Glass Transition.  _Science_ , 287(5453):627–631, 2000.  10.1126/science.287.5453.627.

Supplementary material

##  Appendix A Model details

We list the remaining details of our model.

## Interactions

The elastic interactions are such that if a block $i$ fails, it loses its
force up to a small random number, $\epsilon$, such that
$f_{i}(t+\tau_{i})=f_{i}(t)-\Delta f_{i}$ with $\Delta
f_{i}=f_{i}(t)-\epsilon$. Thereby, $\epsilon$ is a random number distributed
normally as $\mathcal{N}(0,0.01)$, whereby the notation is such that its mean
in $0$ and its standard deviation is $0.01$. The position of the interface
$u_{i}(t+\tau_{i})=u_{i}(t+\tau_{i})+\Delta f_{i}$ (using an elastic constant
of one). The force drop $\Delta f_{i}$ of the failing block $i$ is entirely
redistributed to the nearest neighbors, $j$, as shown in Fig. S1 for our case
in $d=2$ dimensions. Consequently, the applied force $f=\sum_{i}f_{i}/L^{d}$
is constant at all times.

Figure S1:  Stress redistribution among the nearest neighbors (outlined in
green) of a failing block in $d=2$ dimensions.

## Forces

We take $f=0.3\approx f_{c}/2$. We estimated $f_{c}$ by driving the interface
with a weak spring. Furthermore, the yield threshold $f_{i}^{y}$ of each block
$i$ is random according to a normal distribution
$f_{i}^{y}=\mathcal{N}(1,0.3)$, truncated at $0$.

## Preparation

The force in each block is initialized random according to a normal
distribution, $f_{i}=\mathcal{N}(f,0.1)$, which is convoluted once with the
elastic kernel from Fig. S1. Any unstable block $x_{i}=|f_{i}|-f_{i}^{y}<0$ is
then failed, and the stress is redistributed to its nearest neighbors. This is
repeated until all blocks are stable. The system is then driven for at least
$100L^{d}$ steps at the temperature used for the measurement (or using
“extremal dynamics” if $T=0^{+}$).

##  Appendix B Roughness exponents

The geometry of avalanches is consistent with a roughness exponent $\zeta$,
with its value predicted by the depinning theory recalled in Table 1. We
support this by two measurements at $T=0^{+}$. First, we measure the roughness
of the interface at random snapshots in the steady state. In particular, we
measure the structure factor and find that it is consistent with
$\hat{S}(q)\sim q^{-(d+2\zeta)}$ (see main text), as shown in Fig. S2 (see
e.g. Ramasco et al. [2000], Schmittbuhl et al. [1995] for discussions on the
use of the structure factor to measure the roughness exponent of a self-affine
interface). Second, we measure the fractal dimension of avalanches. We define
avalanches as a sequence for which the activation barrier $E_{\min}<E_{0}$
with $E_{0}=E_{c}$. We plot the total number of fails in each sequence, $S$
(the ‘duration’ of each sequence), as a function of spatial extent $\ell$
(with $\ell^{d}$ the number of unique blocks in the sequence) in Fig. S3. We
find that it is consistent with $S\sim\ell^{d+\zeta}$.

Figure S2:  At $T=0+$, the structure factor
$\hat{S}(q)\equiv\langle\hat{u}(\vec{q})\hat{u}({-\vec{q}})\rangle$, with
$u(\vec{x})$ the position of the interface at location $\vec{x}$ at random
snapshots (we consider an ensemble at random times in the steady state, for
random realizations). $\hat{u}(\vec{q})$ is the Fourier transform of the
position of the interface, with $\vec{q}$ the wave vector and $q$ its
Euclidean norm. In practice, we plot simply the subset $q_{x}>0$ and $q_{y}=0$
(whereby we work in $d=2$ dimensions). The interface is rough such that
$\delta u\sim r^{\zeta}$ with $r$ the Euclidean distance, corresponding to
$\hat{S}(q)\sim q^{-(d+2\zeta)}$ as shown in green for the depinning
prediction in Table 1.  Figure S3:  Fractal dimension of avalanches at
$T=0^{+}$. Avalanches are defined as a sequence for which the activation
barrier of the failing block $E_{\min}<E_{0}$. We take $E_{0}=E_{c}$ and show
$S$, the total number of fails in the sequence, and $\ell^{d}$, the number of
unique blocks in the sequence. The scaling, in green, $S\sim\ell^{d+\zeta}$ is
consistent with the depinning prediction in Table 1.

##  Appendix C Avalanche identification

## Extremal dynamics

We measure a sequence of failures starting from a random snapshot somewhere in
the steady state (for which each block already yielded many times since
preparation). We record the activation barrier $E_{\min}$ and the spatial
location of each failure. We define avalanches as sequences of failures for
which $E_{\min}<E_{0}$, with $E_{0}$ some threshold. We illustrate this in
Fig. S4 for a small subset of failures in a small system. These avalanches are
characterized by $S$, the total number of failures in sequence, and $A$ the
number of blocks that had at least one failure since the beginning of the
avalanche. Then, $\ell\equiv A^{1/d}$ is used as a proxy of the linear extent
of the avalanche.

Figure S4:  Identification of avalanches for extremal dynamics ($T=0^{+}$). An
avalanche is identified as a connected sequence of events for which the
activation barrier of the failing block $E_{\min}<E_{0}$ for some threshold
$E_{0}$. An example is shown for a small subset of failures in a system of
size $L=2^{5}=32$ with $E_{0}=0.85E_{c}$. The bottom panel shows $E_{\min}$ as
a function of the number of failures (starting from an arbitrary point $m$ in
the sequence). The identified avalanches based on the threshold $E_{0}$ are
indicated by different colors. The spatial organization of these five
avalanches is shown in the top panel. The linear extent of the largest
avalanche is also indicated, using $\ell$.

## Finite temperature

We again measure avalanches starting from an ensemble of independent snapshots
at random times in the steady state. As an example, we show a snapshot of the
position of the interface at a random time in the steady state in Fig. S5a.
Starting from this snapshot which marks a duration $t=0$ we record the number
of times $s_{i}$ that each block $i$ fails at different times $t$ (see example
in Fig. S5b).

(a)

(b)

Figure S5:  LABEL:sub@fig:snapshot:slip Snapshot of the position $u_{i}$ of
the interface at a random physical time $\tilde{t}$ in the steady state. The
average $\bar{u}=\sum_{i}u_{i}/L^{d}$ has been subtracted, whereby we note
that the values of both $\tilde{t}$ and $\bar{u}$ are irrelevant.
LABEL:sub@fig:snapshot:s Avalanches are then identified by taking the
interface entirely flat at $\tilde{t}$ (setting the duration $t=0$) and
recording the number of times $s_{i}$ that each block $i$ fails at different
durations $t$. As an example, we show $s_{i}$ at $t=\tau_{\alpha}/10$ (with
$\tau_{\alpha}$ the duration at which half of the blocks yielded at least
once). This example is taken for our lowest temperature $T=0.002$ and our
biggest system size $L=2^{9}$.

Individual avalanches are then identified as connected clusters of blocks that
failed at least once. An example is shown in Fig. S6. Fig. S6a shows a
projection of Fig. S5 with the same color bar. The identified clusters are
shown in Fig. S6b, whereby each cluster is assigned a different color, and a
black outline is drawn around each cluster. The connectedness of clusters is
decided using the same nearest-neighbor kernel as used for the elastic
interactions, see Fig. S1. Once identified, we extract for each cluster
(“avalanche”) the number of blocks $A$ in that cluster (resulting in
$\ell\equiv A^{1/d}$), and the total number of fails $S$ of all blocks in that
cluster. Note that the clusters are geometrically identified at each time $t$,
i.e. their identification is independent of previous times.

(a)

(b)

Figure S6:  LABEL:sub@fig:clusters:projection Projection of Fig. S5 with the
same color bar. LABEL:sub@fig:clusters:clusters Identified clusters (colors
with black outline), see text for details.

##  Appendix D Avalanche statistics

We measure the avalanche size distribution $P(S)$ and fractal dimension
$S\sim\ell^{d+\zeta}$ at our lowest temperature $T=0.002$, whereby avalanches
are defined as connected clusters (see Fig. S6b). The result is shown in Fig.
S7 for different $t$ up to $t=\tau_{\alpha}$ (see color bar). As observed,
$S\sim\ell^{d+\zeta}$ for any $t$ as shown in Fig. S7a. Furthermore, the
distribution is consistent with a power law $P(S)\sim S^{-\tau}$ with the
depinning prediction for $\tau$ (see main text), up to a cut-off $S_{c}(t)$
which monotonically increases with $t$ consistent with our prediction in Eq. 6
as supported by the data collapse in Fig. S7c.

(a)

(b)

(c)

Figure S7:  Statistics of avalanches at our lowest temperature $T=0.002$ and
biggest system size $L=2^{9}=512$. Each avalanche is defined as a connected
cluster in snapshots at different durations $t$ starting from an arbitrary
configuration at which the interface is taken flat, see color bar.
LABEL:sub@fig:thermal:fractal The fractal dimension $S\sim\ell^{d+\zeta}$
(binned in $\ell$). LABEL:sub@fig:thermal:pdf_s The avalanche size
distribution $P(S)\sim S^{-\tau}$. LABEL:sub@fig:thermal:pdf_s_collapse Our
prediction in Eq. 6 together with the fractal dimension collapses the data for
$t\leq\tau_{\alpha}/2$. The depinning predictions (recalled in Table 1) are
indicated by green dashed lines.

##  Appendix E Stability at finite temperature

At finite temperature $T$, the dynamics no longer result in an absorbing
boundary condition at $E_{c}$. Consequently, the distribution of activation
barriers $P(E)$ is no longer gapped at $E_{c}$, as shown in Fig. S8a. The
macroscopic barrier, however, is still set by $E_{c}$. This is shown in Fig.
S8b whereby we measure $\tau_{\alpha}$, the time at which half of the blocks
yielded at least once, as a function of temperature $T$. We indeed find that
$\tau_{\alpha}\sim\exp(E_{c}/T)$ in Fig. S8b.

(a)

(b)

Figure S8:  LABEL:sub@fig:thermal:pdf_x Distribution of activation barriers
$P(E)$ at finite temperatures. At $T\rightarrow 0$ (and $L\rightarrow\infty$)
the distribution displays a gap at $E_{c}$, as measured in Fig. 1. This gap
corresponds to a characteristic time $\sim\exp(E_{c}/T)$.
LABEL:sub@fig:thermal:tau_alpha We find that $\tau_{\alpha}\sim\exp(E_{c}/T)$
as indicted by the fit in green, whereby $\tau_{\alpha}$ is defined as the
duration at which half of the blocks failed at least once since a random
snapshot. The values of the temperature $T$ are listed in the color bar. All
results for our largest system of $L=2^{9}$.

##  Appendix F Statistics

For completeness, we document the extent of our statistics for our largest
system of $L^{d}=(512)^{2}$ blocks in Table 2.

Table 2:  Statistics for our largest system of $L^{d}=(512)^{2}$ blocks. Note that “sequences” lists the number of sequences times the number of fails per sequence.  Temperature | Snapshots | Sequences
---|---|---
$0^{+}$ | $391$ | $40\times 600L^{d}$
$0.002$ | $1262$ | $1149\times 20L^{d}$
$0.003$ | $1102$ | $992\times 20L^{d}$
$0.005$ | $1231$ | $1129\times 20L^{d}$
$0.007$ | $1125$ | $1017\times 20L^{d}$
$0.01$ | $1167$ | $1057\times 20L^{d}$
$0.02$ | $1232$ | $1124\times 20L^{d}$
$0.03$ | $1235$ | $1123\times 20L^{d}$
$0.05$ | $1132$ | $1018\times 20L^{d}$
$0.07$ | $1125$ | $1005\times 20L^{d}$
$0.1$ | $287$ | $241\times 20L^{d}$
$0.2$ | $399$ | $333\times 20L^{d}$
$0.3$ | $214$ | $167\times 20L^{d}$
$0.5$ | $275$ | $224\times 20L^{d}$
$0.7$ | $220$ | $179\times 20L^{d}$


# Machine learning models for DOTA 2 outcomes prediction

Kodirjon Akhmedov and Anh Huy Phan Kodirjon Akhmedov is with the Department of
Center for Computational and Data-Intensive Science and Engineering (CDISE),
Skolkovo Institute of Science and Technology, Moscow, Russia, 121205 (e-mail:
Kodirjon.Akhmedov@skoltech.ru). Anh Huy Phan is with the Department of Center
for Computational and Data-Intensive Science and Engineering (CDISE), Skolkovo
Institute of Science and Technology, Moscow, Russia, 121205 (e-mail:
<EMAIL_ADDRESS>
###### Abstract

Prediction of the real-time multiplayer online battle arena (MOBA) games’
match outcome is one of the most important and exciting tasks in Esports
analytical research. This research paper predominantly focuses on building
predictive machine and deep learning models to identify the outcome of the
Dota 2 MOBA game using the new method of multi-forward steps predictions.
Three models were investigated and compared: Linear Regression (LR), Neural
Networks (NN), and a type of recurrent neural network Long Short-Term Memory
(LSTM). In order to achieve the goals, we developed a data collecting python
server using Game State Integration (GSI) to track the real-time data of the
players. Once the exploratory feature analysis and tuning hyper-parameters
were done, our models’ experiments took place on different players with
dissimilar backgrounds of playing experiences. The achieved accuracy scores
depend on the multi-forward prediction parameters, which for the worse case in
linear regression 69% but on average 82%, while in the deep learning models
hit the utmost accuracy of prediction on average 88% for NN, and 93% for LSTM
models.

###### Index Terms:

Esports analytics; Machine learning in Esports; Dota 2 match outcome; Real-
time data analytics; User experience (UX)

##  I Introduction

The term Esports is extended as electric sports, which is a form of
competition using video games. It is often organized in teams with multiple
players, and it can be played by any individual online/offline. In world
competitions, we witness professional players or ”pro players” who have gained
more experience in particular video games. Esports is not just playing on the
computer, but nowadays, it is also considered one of the trending research
areas in the scientific community with its predictions and improvement in
players’ performance [5]. There has been much analysis over the several types
of the games such as CS:GO, and Dota 2 the top games under the observation of
many Esports researchers [9]. However, there are yet many methods to
investigate the games and their outcomes. Finding the best model for
predicting the real-time game results is one of the main tasks in Esport [6].
Prediction models are at a high level in many terms. For example, for coaches
to improve their players’ performance level or for business enterprises, the
confident high-level models bring much profit to their budget.

There have been past competitions and investigations over the Dota 2 game
prediction. For example, Kaggle’s Dota 2: Win Probability Prediction in
collaboration with OpenDataScience is being organized almost every year. We
investigated those contests. The most popular articles close to our research
area were Win Prediction in Multi-Player Esports: Live Professional Match
Prediction [6], To win or not to win? A prediction model to determine the
outcome of a Dota 2 match [8], Performance of Machine Learning Algorithms in
Predicting Game Outcome from Drafts in Dota 2 [10]. Predicting the winning
side of Dota 2 [11] and other articles have been collected and analyzed their
results, that still lack some specific proper and easy methodologies which we
will discuss them in the related works section.

We can confidently state that scientific research in Dota 2 is still not fully
discovered in the science community; therefore, the gap in the knowledge needs
more breakthroughs to bring brand new outcomes. While the market is rising at
a high rate expected to 1.62 billion USD and 291.6 million people are
forecasted to be occasional viewers of Esports by 2024. Thus, the paper has
strongly motivated and covered the Dota 2 game analysis. The project covers
Esports’ area: develops a real-time data collection process for tracking the
in-game data of the gamer using game state integration (GSI), the research
focuses upon the Dota 2 Esports Steam game, investigates the multi-forward
steps prediction approach using the target that characterizes the success of a
player throughout the game process. Real-time prediction of the game or the
post-game predictions will be possible with our real-time data collection
python tool or GUI and machine and deep learning predictive models to analyze
the match result in advance.

The paper has the exact current and long-term goals to achieve for handling
the problem statement. We discuss the contemporary state-of-the-art works in
Dota 2 match outcome prediction and investigate the possibility of developing
machine learning models for the current plans. The following aims of the
research are implemented in this paper:
Contributions

  * •

Investigating how the real-time data can be collected and creating a tool for
collecting data from players.

  * •

Implementing machine learning and deep learning models to predict the outcome
of the match.

  * •

Data analysis, investigating features and defining most essential variables,
testing models accuracy, and finding considerable features.

  * •

Experimenting with players on different occasions and recording results for
comparison among several machine learning models.

The following section will give an overall outline of the Dota 2 video game
and Steam gaming platform. In section III, we focus on the literature review,
where we discuss and explain the limitations of existing papers. In section
IV, we propose our new method of collecting real-time data and analyze
shortcomings of the data tracking. Section V will be dedicated to theory and
algorithms where all explanations of the hypothesis, sensitivity analysis,
feature engineering, data prepossessing will be fully explained. Section VI
will be dedicated to methodology and experiment setups that define machine
learning predictive models and their parameters, compare models, and discuss
certain performance levels. Section VII will run through the experimenting
where real-time data collection and LR, NN, and LSTM experiments will be
presented in tables and graphs and discussed. Section VIII demonstrates how
the graphical user interface works and built using PyQt designer and some
examples of working GUI. Finally, in the last section, we will conclude what
outcomes we got from this paper and tell about long-term future goals and the
paper’s impact on the innovation.

##  II Dota 2 video game and Steam gaming platform

###  II-A Dota 2 video game

A Dota 2 (Short for ”Defense of the Ancients”) is a MOBA video game developed
by Valve. The game has ten players in two teams called ‘Dire’ (represented in
red color) and ‘Radiant’(represented in green color); there are five players
per team, and the idea is to defend your ancient tower and do not let the
enemy come towards your side. Each match is played on a map split into two
sides by a river. Each player chooses a hero from 115 possible heroes (the
number of heroes changes depending on Valve’s updates). Heroes are the main
characteristics of how the game goes. If the five players have chosen the
right combination of the hero, they have a high chance of winning or vice
versa; the good gamers specifically take into account the combinations of
their hero [8]. The heroes are defined by the strength, agility, and
intelligence. There are five couriers (flying horses) which can help five
heroes to deliver some items during the game from the your shops and a secret
shop (which you can buy many valuable items by visiting with your hero or
sending your courier and asking your courier to bring where you want but if
courier seen by the enemy during the way to delivery it can be killed and you
need to wait to re-spawn your courier and vice versa) as heroes gain more
golds during the game. There are not only heroes but creeps that come every
half minute in the game; each wave has three Melee creeps and one Ranged
creep, and every $10^{th}$ wave Siege creep will also spawn. During the
attack, buildings can also throw a fire for the closest enemy to the building;
therefore, bearing in mind that not coming close to the tower unless the
player does not have extraordinary power. We can see the full illustration of
all heroes, creeps, buildings, maps in a screenshot taken from our live game
in Figure 1.

Figure 1: Battlefield of the Dota 2. Bottom left corner is the current map, in
the center “Radiant” creeps and heroes fighting against “Dire” and tower
throwing fire to “Radiant.”

###  II-B Steam gaming platform

Steam is a video game digital distribution service which is also developed by
Valve, where it enables players to connect with each other and play online
games at the same time. Steam enables several possibilities for instance video
streaming, and social networking, together with updating feature of the games.
Each player in the Steam has the ability to have a Steam Token where we use in
identifying particular player id. Our research’s data collection process is
also integrated with Steam Token where we need to get the user’s token to our
game state integration (GSI) configuration.

##  III Related works

We have researched over the related works, several SOTA articles and different
competitions based on Dota 2 win predictions, data tracking, and other related
fields have been selected and reviewed for our literature. The authors in [6],
used standard machine learning models, feature engineering, and optimization.
Which the method give up to 85% accurate after 5 minutes of gameplay used 5.7k
data from the international 2017 Dota 2 tournament. [12] proposed methods in
two steps, in the first step, Heroes in Dota 2 were quantified from 17 aspects
more accurately. In the second step, they proposed a new method to represent a
draft of heroes. A priority table of 113 heroes was created based on prior
knowledge to support this method. The evaluation indexes of several machine
learning methods on this task have been compared and analyzed.

Another article [8] discussed to improve the prediction results of the
existing model, i.e., data collection, feature extraction, and feature
encoding. Their idea using augmented regression was defining success
probability = (heros picked and success heroes)/(heroes picked) and final
success probability = (regression probability + success probability)/2. If the
final success probability $>0.5$, they predict a ”Radiant” win; otherwise,
”Dire” win, the metrics they used include how an individual hero contributed
and how heroes complemented each other in a match. The results show that the
pure logistic regression accuracy, asymptotically approaches 69.42%, and they
conclude that just hero selection plays a vital role in winning or losing the
game. In augmented logistic regression, the test accuracy score approached
74.1%, and authors compared the both models.

Conley and Perry were the first to demonstrate the importance of information
from the draft stage of the game with Logistic Regression and k-Nearest
Neighbors (kNN) [2]. They got 69.8% test accuracy on an 18,000 training
dataset for Logistic Regression, but it could not capture the synergistic and
antagonistic relationships between heroes inside and between teams. To address
that issue, the authors used kNN with custom weights for neighbors and
distance metrics with 2-fold cross-validation on 20,000 matches to choose d
dimension parameters for kNN. For optimal d-dimension = 4 they got 67.43%
accuracy on cross-validation and 70% accuracy on 50,000 test datasets [2].

The article [10] was also taken into consideration, where authors discussed
the comparison of several ML models: Naive Bayes classifier, Logistic
Regression chosen to replicate the results of the previous works on their
collected datasets and Gradient Boosted Decision Trees, Factorization Machines
and Decision Trees were chosen for their ability to work with spare data. AUC,
and Log-Loss measured the quality of prediction (Cross-Entropy) on ten-fold
cross-validation, the result of AUC was 70% in XGBoost and 68% in LogRess and
Naive Bayes, the results compared in three normal, high, very high skill sets.
Kuangyan Song, Tianyi Zhang, Chao Ma [11] have tried logistic regression to
predict the winning side of Dota 2 games based on hero lineups. They collected
data using an API provided by the game developer. The results were illustrated
using training and testing errors, and a conclusion has been made.

Paper [7] used the replays in Dota 2 was tested in different classifiers .
These articles and our research are in completely different concerning
methods. In contrast, we have the ML models, and they have the other methods
to analyze their project.

The interesting article [1] used the ARMA model for investigating time series
of change in the health of hero also implemented feature exploration analysis;
they achieved slightly greater than 80% accuracy in predicting the sign of
significant changes in health and reasonably accurate results with linear and
logistic regression models.

The paper [4] predicted match results with xpm, gpm, kpm, lane efficiency, and
solo competitive rank, authors compared SVM and NN. The [3] discussed zone
changes, team members distribution, and time series methods. They concluded
that MOBA teams behaviour is applicable to team skills. [9] was from the HSE
university researchers did consider game statistics and True Skills, which is
the similar to Elo rating for chess and they have done for CSGO and Dota 2
with AUC, recall, precision values and compared the results. Wang, W.
demonstrated predicting the match outcome depending on the hero draft, with
the help of neural networks on GPU, and logistic regression methods with hero
drafts [13]. Yifan Yang, Tian Qin, and Yu-Heng Lei tried to predict the
matches using logistic regression with replay of data and improved their
accuracy from 58.5% to 71.5% [14].

From the previous researches, we have found the following shortcomings:

  * •

There is a need for developing deep learning models for better accuracy
prediction.

  * •

The need for the novel theoretical approach is important to implement most
reliable models.

  * •

Authors have not thought of developing their own data collection tool.

  * •

Authors only limited with source codes while players are not scientists to use
codes, thus there is a need for developing user-friendly GUI.

Hence our contribution is filling the knowledge gap in the discussed
researches and proposing our novel approaches to bring more light to the
Esport’s Dota 2 win prediction scientific area.

##  IV Data Collection and Analysis

Identifying the player’s reaction, movements, real-time interactions could
reveal more about the player’s results over time. Therefore, it is essential
to track such significant information as the game progresses; the D2API python
library is useful tool. For example, the following command in python:

  * •

$import$ $d2api$

  * •

$api=d2api.APIWrapper(api$ $key="Your$ $Steam$ $Token")$

could give us match details when we have the id of the played match.

  * •

$match$ $details=api.get$

  * •

$match$ $details(You$ $Match$ $ID)$

will load that many details in the variable or the same $api.get$ $heroes()$
can give the details about the match hero. In practice, it was not possible to
store in a file in preferred format. For this particular case, we tried to
observe other players’ data, and it was not our expectation while we were
planning to investigate and view changes of data variable features of our
games and extract data in the ”CSV” format for further research purposes.

The idea about writing our codes and integrating between Anaconda and Steam
gaming platform was our predominant priority. We discovered the game state
integration (GSI) where it could help developers pull data from live Dota 2
games. Python programming language has been selected by our side as a
programming language for the development of the data collection tool. We have
created a tool that returns us results of real-time data in CSV, JSON, and
TEXT files. We have experimented with a quite a lot of our games and
successfully collected real-time data using Python as a back-end server. The
idea of implementing is vital in researching player’s predictive machine
learning and deep learning models or general analysis of players throughout
the game. Our practical experiments show that we have developed a tool for
collecting data from the Dota 2 MOBA game. The importance of this part of the
work is that many researchers want to implement different applications and
models for Esports. In contrast, their models could differ, but the tool for
collecting data will remain very beneficial for everyone who has a curiosity
in in-game and real-time data collection. Thus, this section can also help
researchers and our models by providing a ready and reliable real-time data
collection tool. The codes are available at our Github Repository.111
https://github.com/KodirjonAkhmedov/Real-Time-Data-Collection-Dota-2

###  IV-A Game State Integration (GSI) in Dota 2

Game State Integration (GSI) links the game events that are happening with
computer, and it is an advantageous method for tracking the real-time data of
the playing game. To be more precise, in the case of Dota 2, game state
integration has been developed using Python and required configuration files
by provided by Valve corporation. Configuration file was the one we need to
put inside installed folder of the Dota 2 in our device, for example, in Linux
directory has following path address: $/home/test/.steam/debian-
installation/steamapps/common/Dota2beta/game/Dota/$
$cfg/gamestateintegration$, where we need to specify our .cfg file inside
configurations files of the game. The GSI consists of an end point section
setting which was done for CS:GO but we have created our own endpoint setting
for Dota 2 using the Valve’s website.222
https://developer.valvesoftware.com/wiki/Counter-
Strike:_Global_Offensive_Game_State_Integration:

  * •

”uri” which represents the server and port which the game will make post
request to this uri: http://127.0.0.1:8080

  * •

”timeout” ”5.0” The game expects an HTTP 2XX response code from its HTTP POST
request, and the game will not attempt submitting the following HTTP POST
request while a previous request is still in flight. The game will consider
the request to be timed out if a response is not received within so many
seconds and re-heartbeat next time with the whole state omitting any delta-
computation. If the setting is not specified, then a default short timeout of
1.1 sec will be used.

  * •

”buffer” ”0.1” Because multiple game events tend to occur one after another
very quickly, it is recommended to specify a non-zero buffer. When buffering
is enabled, the game will collect events for so many seconds to report a more
significant delta. Setting 0.0 is to disable buffering completely. If the
setting is not specified, then default buffer of 0.1 seconds will be used.

  * •

”throttle” ”0.1” For high-traffic endpoints, this setting will make the game
client not send another request for at least this many seconds after receiving
the previous HTTP 2XX response to avoid notifying the service when the game
state changes too frequently. If the setting is not specified, then a default
throttle of 1.0 sec will be used.

  * •

”heartbeat” ”0.5” Even if no game state change occurs, this setting instructs
the game to request so many seconds after receiving the previous HTTP 2XX
response. The service could be configured to consider a game as offline or
disconnected if it did not get a notification for a significant period
exceeding the heartbeat interval.

###  IV-B Real-time data collection and Steam integration

For Steam platform integration and for collecting data, there is a need to
launch Dota 2 game from the Steam gaming platform. Here the server is the
python where it works as the “third party” between the game and the computer
to enable us to store the data inside the computer directory. The following
quick steps can describe the process:

  * •

In the initial step, we define a class called real-time Dota 2 parser. Parser
of Dota 2 in real-time takes as input a JSON request and has as output a CSV
file. Following that, we define a dictionary for buildings that contains
information about buildings, and a function for that variables will be saved
all the values and keys pairs given by JSON file to create a dictionary.

  * •

In the second step, we took the seven GSI values and their keys, namely,
Provider, Map, Player, Hero, Building, Abilities, and Items.

  * •

In the third step, we save a list of values and column names for each arrived
request in the dictionary but not buildings because we will save the building
values separately and update information about buildings in each post request.

  * •

In the fourth step, we save the tracked data to the CSV data. Initially, we
create CSV file in our current directory. If it exists, then we renew the data
and start writing a new CSV file. An important part to notice there are two
cases when our server starts, let us explain with Dota 2 state: the Dota 2 has
game states: “pre-game”, “in-progress” and “post-game,” and we define them in
our condition when we have these two “pre-game” and “in-progress,” conditions,
then our server starts writing real-time data of the game.

  * •

In this fifth step, we define Server Handler by defining several functions of
set response and doget and dopost which we will get the size of the data and
get the data itself, and we will use the real-time parser that we have defined
earlier.

  * •

In the sixth step, we begin to write on three different data files: JSON, CSV,
and TEXT in each step by making a post request.

  * •

In the final seventh stage of our work, we define the HTTP request starting
and stopping points where the server works until the user terminates it
manually by their kernel inside their environment. In our case was Jupyter
Notebook’s stop kernel button. However, this process has been integrated with
the Graphical User Interface section, and there is no need to interact with
python code. Only start, stop and view buttons enable us to track data easily.

###  IV-C Data features

Once we tracked the data we started learning the exciting features and their
importance in our machine and deep learning models. The data collection tool
enabled us to collect more than real time 160 data features. Lists of game
state integration are following, ”buildings”, ”provider”, ”map”, ”player”,
“hero”, ”abilities”, ”items”, ”draft”, ”wearables” where the data has been
joined to those main game states including:

  * •

“Player”represents a person who is playing the game and his ability to play
the game.

  * •

“Hero” represents the player’s choice of hero for the game and hero statistics
during the game.

  * •

“Abilities” represents the hero’s list of abilities used or how they
fluctuated over the time.

  * •

“Items” represents the hero’s items and their usage over time.

  * •

“Buildings” represents “Dires” or “Radiants” towers (bottom, middle, and top)
towers’ statistics.

  * •

“Provider” represents what is the game which name that is currently in process
and what is the game’s id Etc.

  * •

“Map” represents the current map, and map states such as does the winner
exists or the map is paused Etc.

It is noteworthy that, the columns of our collected data are fixed in all of
the games. On the contrary, the rows of the data are in ascending order
depending on the game progress. For instance, if the gamers play the game more
time, the data capacity will be more, and the row of the data will be greater
in length compared to games that are finished in a short period of time.

###  IV-D Sensitivity analysis

Before starting the analysis on the game data features, we need to extract the
statistical data from more than 160 features, not all the values are in
numerical. More precisely, the collected data could have data types, objects,
and integers; therefore, we need to get only the numerical values of data to
fit in our model. Thus, we have taken data features whose data values are
either ’int16’, ’int32’, ’int64’, ’float16’, ’float32’, or ’float64’,
extracted statistical data could change depending on how long the game takes
place.

Let us define the target variable as y and some independent variables as x.
Based on our scientific hypothesis, we have taken the variable that primarily
symbolizes the player’s success during the game, that is PLAYER.GOLD, the
distribution of the target variable for one game can be seen in Figure 2. Gold
is the currency used to buy items or instantly revive a hero. Gold can be
earned from killing heroes, creeps, couriers, buildings, additional enemies
that only stay still in some specific corners of the team’s map side, or by
taking bonuses that appear at certain places on the map. It is also passively
gained periodically throughout the game. For the input parameter x, we defined
ten fixed features with the most considerable correlation to our target
variable, Figure 3 illustrates those ten input features’ distribution over the
game.

Figure 2:  Player gold change for one particular game during the game  Figure
3: Chosen fixed independent features’ change throughout the game in line plot.

##  V Theory and Algorithms

There has been a hypothesis for predicting the final match result using
different techniques and analyses that lacks some decent and easy mechanisms.
This section will describe our novel approach, and how the method and
algorithms we have tried could be differentiable and important in prediction.
As we have seen in our previous section, we have developed a real-time data
collection tool using Python as a server for Dota 2 for model implementations,
which means our theories and algorithms will be based on our collected data.
Depending on our data, we developed our models initially simple linear
regression, then the neural network and long short-term memory were trained
and calculated the accuracy scores of the models. Moreover, so far, we have
done sensitivity analysis on features and their importance. We defined that
player.gold feature represents the success of the player. With that in mind,
we developed a new raw dataset by composing highly correlated $x$ independent
features to target $y$ and predicted multi-forward steps. We introduced them
as $L$ (time-lagged correlation) and $d$ (multi-forward steps).

###  V-A Time-lagged correlation and multi-forward step prediction

The method we propose in this paper is dependent on the time-lagged
correlation to rows $(L)$ and multi-forward steps $(d)$. Those parameters can
manually be adjusted by users, for example, to predict 20 steps ahead of the
game while our real-time data is being collected; users can set the $d=20$,
then the models will give the results accordingly. Likewise, users can edit
the time-lagged correlation $L$ to define the number of composing rows. Let us
describe both parameters in detail:

  * •

Multi-forward step prediction (d) \- represents the number of steps ahead of
predicting the game. The parameter plays a crucial role in defining a model’s
bounds and constructing raw data described in the following subsection during
the preprocessing period.

  * •

Time-lagged (L) \- represents the number of joining rows, imagine the user is
tracking data, and user will have initial data which our data tracker is
collecting. Imagine each row of that data as variable $x$, which has columns
of independent variables $x_{1},x_{2},...,x_{n}$ and target $y$ then depending
on the $L$, let us set $L=3$, we create a new dataset by composing three rows
of the $x$ in one value defined as $X$ in a single row, after that three rows
composed, we join next three rows and process continues until $(number$ $of$
$rows(NRow)-(L+d-1))$. In the case of target variable $y$, we add that multi-
forward step prediction $d$ to the time-lagged number and write that value to
the new dataset and create a raw dataset based on parameters.

###  V-B Data construction using model parameters

We construct new data set using model parameters time-lagged $(L)$ and multi-
forward step ahead prediction $(d)$, independent features, target, start
indexing, and get our final working data set, consider Table 1 then we have
the following data set:

TABLE I: Model construction process using independent variables Vector of features | $x_{1}$ | $x_{2}$ | $x_{3}$ | $x_{4}$ | $x_{5}$ | … | $x_{m}$
---|---|---|---|---|---|---|---
x(1) | * | * | * | * | * | * | *
x(1) | * | * | * | * | * | * | *
x(1) | * | * | * | * | * | * | *
x(1) | * | * | * | * | * | * | *
… | * | * | * | * | * | * | *
x(L) | * | * | * | * | * | * | *
x(L+1) | * | * | * | * | * | * | *
… | * | * | * | * | * | * | *
x(NRow-d) | * | * | * | * | * | * | *

$Dataset=\left(\begin{array}[]{lcr}X(1)&|&y(L+d)\\\ X(2)&|&y(L+1+d)\\\
X(3)&|&y(L+2+d)\\\ X(4)&|&y(L+3+d)\\\ \ldots&\ldots&\ldots\\\ X(NRow-
d-L+1)&|&y(NRow)\end{array}\right)$

where,

$X(1)=\left(x(1),x(2),\ldots,x(L)\right)$

$X(2)=\left(x(2),x(3),\ldots,x(L+1)\right)$

$X(3)=\left(x(3),x(4),\ldots,x(L+2)\right)$

$X(4)=\left(x(4),x(5),\ldots,x(L+3)\right)$

$\ldots$

$X(k)=\left(x(k),x(k+1),\ldots,x(L+k-1)\right)$

$\ldots$

Eventually, we have $datasetX$ with composed independent variables and
$datasetY$ with the target variable. The shape of our data are entirely depend
on the game but for this particular case, $datasetX$ is 3833 rows and 70
columns, and $datasetY$ consists of 3833 rows and a column with a target.

##  VI Methodology and Experimental Setup

In this section, we will enumerate the languages and programs used in the
research, present the metrics and model parameters, describe the
implementation of our machine and deep learning models, and compare the
different models and several reasons why some models did better compared to
others. All models and Graphical User Interface were implemented using Python
in Linux Operating System.

###  VI-A Machine Learning models and their parameters

Three machine learning models have been chosen:

  * •

Linear Regression is a supervised machine learning algorithm used to predict
values within a continuous range. The idea of the regression problem is
dependent on our predicting target variable. The dependent variable is player
gold and this parameter is not stable during the game, and there are very good
linear correlations among certain features therefore, the regression problem
has been chosen to predict. We built a linear regression model by splitting
our constructed $datasetX$ and $datasetY$ into train and test data, Test size
has a 20% partition, and the rest was dedicated to the training part. We fit
the model and take the prediction value from our regressor. The experiments
have been done for different datasets, and results were compared in the
experiments section.

  * •

Neural Networks one of the leading models in time-series forecasting and
Esports. Working with artificial neural networks, we could acquire better
results due to its ability to train the model through the hidden layers, where
each layer takes the input data and processes in the activation functions and
passes to the successive layer that can reduce its loss function with forward
and backward propagation where biases and weights will be updated and adjusted
back and forth during the training process until the number of epochs unless
and until the loss value is completely reduced can lead to achieving better
model performance.

  * •

Long Short-Term Memory (LSTM) is a type of recurrent neural network (RNN). The
output from the previous step feed as an input and the other inputs for the
next step and process continues. In LSTM, nodes are recurrent, but all have an
internal state. The node uses the internal states as a working memory space
that enables information flow over many time steps. Input value, previous
output value, and the internal state are all used in the node calculations;
the results of the calculations are not only the output value but also used to
update the states. Neural networks have parameters that determine how the
inputs are used in the calculations, but LSTM has the parameters known as
gates that control the node’s information. LSTM nodes are rather complicated
than regular recurrent nodes, making them learn complex interdependencies and
sequences of the input data that results in better outcomes.

Several metrics were used to evaluate the performance of the all models. For
the accuracy of the linear regression model, we have used the Sklearn library
and calculated the $R^{2}$ but we took final accuracy score as $adjusted$
$R^{2}$, while NN and LSTM models accuracy scores were taken as $R^{2}$.
Why adjusted $R^{2}$, when we have more input variables or predictors are
added to a regression model it may surge the $R^{2}$ value, which entice
model’s markers to add even more. This is called over-fitting and result in
unexpected high $R^{2}$. Whereas, adjusted $R^{2}$ is used to identify how
trustworthy the correlation and how much is identified by the addition of
input features. $R^{2}$ adjusted accuracy score is evaluated using the sum of
squares error (SSE) and the total sum of squares (SST):

$R^{2}=1-\frac{SSE}{SST}$

where,

$SSE=\sum(y_{test}-y_{predicted})^{2}$ $SSE=\sum(y_{testmean}-y_{test})^{2}$

then,

$R^{2}_{adjusted}=1-(1-R^{2})*\frac{N-1}{N-p-1}$

where, p is a number of input features and N is a number of rows.

For tuning the optimizers, we chose Adam in NN and LSTM models. We used Adam
because it is a replacement optimization algorithm for stochastic gradient
descent for training deep learning models. Adam combines the best properties
of the AdaGrad and RMSProp algorithms. We used the Adam parameters with
learning $rate=0.01$, $beta_{1}=0.9$, and $betta_{2}=0.999$, which were the
standard values for the Adam optimization for better performance. The loss
function of the LSTM was chosen as the same MSE as the neural network. The
model has been trained over 100 epochs since it can update weights and biases
of the long training process during 100 epochs, while one epoch means that the
optimizer has used every training example once. The batch size was 64, which
fits the model in the fastest way possible and returns the output while
training with batch size equals to one will take many hours to train our
models; therefore, we took the normal value of batch size and evaluated the
model performances. The number of total parameters for LSTM training was
622,209, and there were no non-trainable parameters. As for NN, there were a
total of 438,913 with 436,225 trainable parameters and 2,688 non-trainable
parameters.

###  VI-B Architectures of NN and LSTM

We have tested several architectures for the Neural Network model and
calculated the accuracy score for each particular experiment, and we have
concluded choosing the architecture that returned us the best performance of
the models. We used a sequential model where we can add layers easily. We
imported different types of layers to use in our models from the Keras library
such that: In our neural networks architecture there are four layers which is
performed in Figure 4.

Figure 4: Illustration of Neural Network architecture.

In the LSTM model, we used the same sequential model. We standardized the
$xtrain$, $ytrain$, $xtest$, $ytest$ with standard and mean and standard
deviation as we did in NN. When splitting, we used standard 20% testing to 80%
training respectively. In comparison with neural networks, we need to reshape
the input for enabling the correct working process of the LSTM model. Bearing
in mind that, we always have to give a three-dimensional array as an input to
the LSTM network, the first dimension represents the samples, the second
dimension represents the time-steps, and the third dimension represents the
number of features in one input sequence. We imported the LSTM model from
TensorFlow Keras layers, and the different architecture of the LSTM has been
tested several times, and when the accuracy score performed better results, we
chose that architecture as the final working architecture demonstrated in
Figure 5.

Figure 5: Illustration of LSTM architecture.

##  VII Results of the Experiments

This section will describe the result of all tests and experiments that we
have done using our models, theory, and algorithms. We would to show the
outcomes of the working models and their comparisons in different situations.
Overall the experiment process took the final six months of the project period
where we were mainly involved in the experiments with different players and
collecting their gaming data.

###  VII-A Real-time data collection experiments and results

Real-time data collection tools were tested in more than 100 games, and all
the data has been collected and trained on the models and evaluated the match
results. Figure 6 demonstrates the CSV format data that has been collected
using our tool. The experiments were done on different values of the $L$ and
$d$ where we predicted the low time steps then we increased multi-forward
steps respectively, we can see in Table II comparison of three models accuracy
performances. Table III describes the increasing $d$ multi-forward steps and
fixed $L$ time-lagged correlation experiments on three models.

Figure 6: Illustration of real-time CSV data collected for a Dota 2 game.
TABLE II: Accuracy scores comparisons of predictive models

Models | d=2, L=5 | d=10, L=7 | d=15, L=10 | d=20,L=15 | d=25, L=20
---|---|---|---|---|---
LR | 0.98 | 0.93 | 0.90 | 0.90 | 0.88
NN | 0.99 | 0.94 | 0.93 | 0.93 | 0.91
LSTM | 0.99 | 0.95 | 0.94 | 0.95 | 0.94

TABLE III: Accuracy scores comparisons of predictive models with fixed L=15
and increasing multi-forward steps

Models | d=30 | d=40 | d=50 | d=60 | d=70 | d=80 | d=90 | d=100
---|---|---|---|---|---|---|---|---
LR | 0.86 | 0.92 | 0.74 | 0.67 | 0.64 | 0.68 | 0.67 | 0.70
NN | 0.90 | 0.92 | 0.90 | 0.89 | 0.93 | 0.86 | 0.94 | 0.95
LSTM | 0.93 | 0.98 | 0.92 | 0.91 | 0.98 | 0.96 | 0.95 | 0.92

TABLE IV: Testing our model on 10 different new game data sets and accuracy
scores are following: when d=20, L=15 with 10 fixed input features on all
experiments

Models | Exp1 | Exp2 | Exp3 | Exp4 | Exp5 | Exp6 | Exp7 | Exp8 | Exp9 | Exp10
---|---|---|---|---|---|---|---|---|---|---
LR | 0.81 | 0.69 | 0.75 | 0.72 | 0.84 | 0.82 | 0.96 | 0.87 | 0.85 | 0.87
NN | 0.87 | 0.82 | 0.87 | 0.79 | 0.88 | 0.88 | 0.97 | 0.92 | 0.91 | 0.92
LSTM | 0.92 | 0.91 | 0.91 | 0.88 | 0.91 | 0.92 | 0.98 | 0.96 | 0.94 | 0.94

TABLE V: Testing our model on 10 different new game data sets and accuracy
scores are following: when d=20, L=15 with 10 highly correlated input features
on all experiments

Models | Exp1 | Exp2 | Exp3 | Exp4 | Exp5 | Exp6 | Exp7 | Exp8 | Exp9 | Exp10
---|---|---|---|---|---|---|---|---|---|---
LR | 0.80 | 0.75 | 0.78 | 0.70 | 0.67 | 0.80 | 0.96 | 0.82 | 0.87 | 0.88
NN | 0.90 | 0.88 | 0.86 | 0.78 | 0.86 | 0.87 | 0.96 | 0.83 | 0.90 | 0.92
LSTM | 0.94 | 0.94 | 0.88 | 0.83 | 0.92 | 0.90 | 0.98 | 0.92 | 0.90 | 0.93

###  VII-B Graphical visualization of results

We have performed graphical visualization of our results of predicted and
actual values using different types of graphical representations for our
consideration, Q-Q plots for viewing the distributions and bar plots and
comparison in the separate and merged plots were used to analyse the
performances. We can see the plots for different model performances for linear
regression in Figure 8.

Linear Regression Results
First, let us consider linear regression results. In Figure 7, we have
performed Q-Q plot of the linear regression to see the distribution, and as we
can see, the distribution is almost skewed-right. we have achieved accuracy
scores depending on the multi-forward prediction parameters, which for the
worse case in linear regression 69% but on average 82% respectively.

Figure 7: LR Q-Q plot of the quantiles Figure 8: Plot of the difference
between predicted and actual values of Linear Regression model

Neural Network In the next experiment, we have tested our neural networks
model’s prediction results. The experiment results show better performance for
neural network implementation comprising 88% of average accuracy score for the
same data set used in linear regression, which is 6% higher accuracy score
than the LR model.

Figure 9: Line plot of true sorted (orange) and predicted sorted (blue) values
of our target using NN

We can see some outliers in the data at the beginning and the end of the data
set. Considering we are working with large values, we could have such extremum
points despite standardization, but there was no considerable impact on the
model performance. In the case of neural networks, both predicted and actual
values are almost on the same points, representing the high accuracy score
with slight non stable values (Figure 9).
Long Term Short Memory Results The third experiment based on LSTM model, In
LSTM model the data for the experiment was the same. The results in this model
performed a much better average accuracy score than NN and LR, 93% accuracy
compare to 82% for LR and 88% for NN respectively, which means Long Short-Term
Memory results are 11% higher than the Linear Regression model. Reason for
such a significant change is that in the LSTM model, biases and weights are
updated during the training process over the epochs much sufficiently compared
to other two counterparts. There are still some outliers in the prediction
such that we have seen some predicted values below the actual values of the
target at some points but this model performed perfectly, Figure 10 represents
Q-Q plot of quantiles.

Figure 10: LSTM Q-Q plot of quantiles

Despite experimenting on models accuracy performance, we tested future
predictions of our target variable with multi-forward steps $d$ where future
values are predicted on three models and compared. We have verified that
future prediction values of the target was close to its previously gained
values. LSTM and LR were quiet ambitious to have increased prediction while NN
showed us slightly decreased prediction based on our experiments (Figure 11).

Figure 11: Comparison of three models’ on $d=20$ multi-forward steps future
prediction of target with $L=15$ time-lagged correlation.

###  VII-C Discussion of the results among compared models

Results show that we have achieved considerably decent accuracy scores in all
of the models, and the models we tried in some sense gave us a fulfillment
which we have attained to see the performance of several models. Initially, we
were concerned about the accuracy, but after several experiments, we had a
firm belief that the accuracy fluctuates over the range of datasets. However,
the range does not drop much from 70% despite altering several parameters of
the model and testing on varying data collected by our data collection tool.

For example, in deep learning models, LSTM and NN, We deduced that using
Neural Networks could give better accuracy than the linear regression model.
Moreover, we found that if $d$ and $L$ increase, accuracy decreases but not
below 80% based on our tests, where we have tested with the same dataset and
increasing multi-forward steps, and measured accuracy scores, which showed us
LSTM also did better performance over Linear Regression and Neural Networks
almost in all of the ten experiments except there was better performance in NN
when we had chosen fixed composing rows and multi-forward steps, for example,
the first experiment they both had the same performances (Table II), but
overall, the LSTM was the best compared to the other two models due to its
rather complicated nodes, making it learn complex interdependencies and
sequences of the input data that results in better results.

The experiments also included with optimal fixed $L$ model parameter and
predicting increasing $d$ multi-forward steps such that we tested from 30 to
100 steps prediction (Table III). We have deduced that Linear Regression can
be significantly affected with increase of $d$ where it showed low
performance, while NN and LSTM models could handle long steps ahead prediction
with accuracy not lower than 85%.

Our findings of real-time data collection aided us in implementing machine
learning models. Data consists of more than 160 columns and more rows
depending on game time. The applications of our current discussion are
essential in evaluating performance of machine learning models Dota 2 match
outcome prediction. In terms of the data collection process, the real-time
data collection python script could ease the job of most of the researchers to
have ready tool for their models and implement such machine learning models
for their different research to enhance the field of the research. There are
some limitations, such as research needing further development considering
more parameters and bringing some more methods and approaches which we
considered in long-term goals with grants, and publications.

##  VIII Real time GUI using PyQt

Once we have the working model and data collection tool, how can we make the
work more user-friendly was the primary question for us? We wanted the users
to click on the buttons and evaluate the accuracy scores of the models based
on their choice, and collect the data of their games. The main purpose of this
section is to reduce the interaction with source codes and interact with the
graphical user interface and evaluate everything using our GUI. For that
reason, we thought of creating GUI and connecting our source codes in the
backend. There were some more options for doing this task. For example,
between web-based and desktop-based GUI, we thought that the desktop-based
software is a good option, where we found a handy tool which enables
programmers to create user interfaces called PyQt, that is a set of Python
bindings for The Qt Company’s Qt application framework and runs on all
platforms supported by Qt, including Windows, macOS, Linux, iOS and Android.
PyQt6 supports Qt v6, PyQt5 supports Qt v5, and PyQt4 supports Qt v4. The
bindings are implemented as a set of Python modules and contain over 1,000
classes.

We created the GUI using the PyQt designer application for the Linux operating
system. Initially, we had several ideas for the creation of the user
interface, but finally, we have made a tool that will be easy to interact
with, the instruction of how to use the tool explained in the following
subsection.

###  VIII-A Instruction of the tool

In this section, we will go through each step of the usage of our GUI for data
collecting and evaluating the models’ performances, let us see each step in
the following stages:

  * •

GUI has three main sections: Data-Collection, Ml models, and Results.

  * •

GUI has nine buttons and three text browsers to view model performances.

  * •

The first part: data-collection, has “Start,” “Stop,” and “Go to the folder”
buttons. Once the game starts, click on it, and it will start collecting real-
time data. We can view current data in the “Go to the folder.” This button is
made to make sure that data is there and to show whether it is working. Once
the game finishes safely close the application and enjoy using collected data.

  * •

The second part: Consists of machine learning models that are three models:
Linear Regression, Neural Network, Long Term-Short Memory in order to use
them, click on the name of the models and wait sometimes while the two deep
learning models need time to train over the 100 epochs whereas, Linear
Regression will do the quick training.

  * •

The third part: results that give us accuracy scores. Once a model has done
its part, click one of the (See NN/LSTM/LR Result) buttons, and you can get
real-time model performances next to the models in a text box.

  * •

To close the GUI, click x safely and finish the work.

###  VIII-B Backend connection with data collection and models’ codes

For the backend connection of the GUI, we have used the libraries of the PyQt
widgets, QApplication, QMainWindow, QPlainTextEdit, QtCore, QtGui, and Tkinter
together with the file dialog. Those all the libraries enabled us to implement
the backend implementation process of the tool. For each model and data
collection section, we linked the main UI, for example, if
$pushButton_{1}.clicked.connect(button$ $name$ $of$ $the$ $GUI)$. Similarly
all the other subsections of the push buttons were connected.

The next stage of the process was creating functions for the .py file reading
process and integrating them into our GUI. Overall, nine functions were
created such that data collection start a simple $os$ library to read .py file
and for stopping the collection $sys.exit()$ was connected. In the case of the
models, the same procedure for data collection was implemented with $os$
library. However, each model has one additional function which is responsible
for reading the results, which means after the run stage of the model, it
returns us TXT file and stores it in a directory then this TXT with results
inside was read and performed in the text browser with
$ui.textBrowser.setText(file$ $name)$. The process was repeated for the other
two models, and this stage has been completed successfully. The final working
GUI was tested over the game. We can see an example of our games in Figure 12,
the data has been collected, and the models’ accuracy scores have been
evaluated.

Figure 12: Example of working GUI with the accuracy scores of the models on
the right bottom

##  IX Conclusion

In conclusion, all these results suggest that we have built efficient machine
learning models from the supervised linear regression model to deep learning
models of Neural Networks, and Long Short-Term Memory were implemented to
predict game outcomes of Dota 2. It can be stated that using recent
approaches, we defined one of the possible ways to achieve our goals.
Moreover, with the help of data collection, we successfully implemented our
algorithms and investigated essential variables in the Dota 2 game.

Though the experiments run, we have achieved accuracy scores depending on the
multi-forward prediction parameters, which for the worse case in linear
regression 69% but on average 82% while in the deep learning models hit the
utmost accuracy of prediction averagely ranging from 88% for NN to 93% for
LSTM respectively. We have seen that the LSTM model performed better over the
other two models in several experiments for flexible occasions of different
games. Besides, we have tested dataset on increasing multi-forward steps, and
measured accuracy scores, which showed us LSTM also did better performance
over Linear Regression and Neural Networks respectively. The performance of
the NN was instead relatively better than the linear regression, in which LR
was the model with low performance.

Besides, we had experimented with several steps ahead predictions, as we can
deduce that when we have fewer steps ahead prediction and time-lagged
correlation, we have high accuracy scores, and vice versa. The graphical user
interface section was also designed for the sake of user experience and we
illustrated some examples.

##  X References

[1] ZachCleghern,SoumendraLahiri,Osman Ozaltin,and David L Roberts. Predicting
future states in dota 2 using value-split models of time series attribute
data. In Proceedings of the 12th International Conference on the Foundations
of Digital Games, pages 1–10, 2017.

[2] Kevin Conley and Daniel Perry. How does he saw me? a recommendation engine
for picking heroes in dota 2. Np, nd Web, 7, 2013.

[3] Anders Drachen, Matthew Yancey, John Maguire, Derrek Chu, Iris Yuhui Wang,
Tobias Mahlmann, Matthias Schubert, and Diego Klabajan. Skill-based
differences in spatio-temporal team behaviour in defence of the ancients 2
(dota 2). In 2014 IEEE Games Media Entertainment, pages 1–8. IEEE, 2014.

[4] Petra Grutzik, Joe Higgins, and Long Tran. Predicting outcomes of
professional dota 2 matches. Technical report, Technical Report. Stanford
University, 2017.

[5] Juho Hamari and Max Sjoblom. What is esports and why do people watch it?
Internet research, 2017.

[6] Victoria J Hodge, Sam Michael Devlin, Nicholas John Sephton, Florian
Oliver Block, Peter Ivan Cowling, and Anders Drachen. Win prediction in multi-
player esports: Live professional match prediction. IEEE Transactions on
Games, 2019.

[7] Filip Johansson and Jesper Wikstrom. Result prediction by mining replays
in dota 2, 2015.

[8] Kaushik Kalyanaraman. To win or not to win? a prediction model to
determine the outcome of a dota2 match. Technical report, Technical Report.
Technical report, University of California San Diego, 2014.

[9] Ilya Makarov, Dmitry Savostyanov, Boris Litvyakov, and Dmitry I Ignatov.
Predicting winning team and proba- bilistic ratings in “dota 2” and “counter-
strike: Global offensive” video games. In International Conference on Analysis
of Images, Social Networks and Texts, pages 183–196. Springer, 2017.

[10] Aleksandr Semenov, Peter Romov, Sergey Korolev, Daniil Yashkov, and
Kirill Neklyudov. Performance of machine learning algorithms in predicting
game outcome from drafts in dota 2. In International Conference on Analysis of
Images, Social Networks and Texts, pages 26–37. Springer, 2016.

[11] Kuangyan Song, Tianyi Zhang, and Chao Ma. Predicting the winning side of
dota2. Sl: sn, 2015.

[12] Nanzhi Wang, Lin Li, Linlong Xiao, Guocai Yang, and Yue Zhou. Outcome
prediction of dota2 using machine learning methods. In Proceedings of 2018
International Conference on Mathematics and Artificial Intelligence, pages
61–67, 2018.

[13] Weiqi Wang. Predicting multiplayer online battle arena (moba) game
outcome based on hero draft data. PhD thesis, Dublin, National College of
Ireland, 2016.

[14] Yifan Yang, Tian Qin, and Yu-Heng Lei. Real- time esports match result
prediction. arXiv preprint arXiv:1701.03162, 2016.