# Efficient search of optimal Flower Constellations

Martín Avendaño  CUD-AGM (Zaragoza), Crtra Huesca s/n, Zaragoza, 50090, Spain
<EMAIL_ADDRESS>David Arnas<EMAIL_ADDRESS>Richard Linares
<EMAIL_ADDRESS>Miles Lifson<EMAIL_ADDRESS>Massachusetts Institute of
Technology, Cambridge, MA, 02139, USA

###### Abstract

We derive an analytical closed expression to compute the minimum distance
(quantified by the angle of separation measured from the center of the Earth)
between any two satellites located at the same altitude and in circular
orbits. We also exploit several properties of Flower Constellations (FCs)
that, combined with our formula for the distance, give an efficient method to
compute the minimum angular distance between satellites, for all possible FCs
with up to a given number of satellites.

###### keywords:

Flower Constellations , Satellite constellation design , Collision avoidance

###### MSC:

[2010] 70F15, 85-04

††journal: arxiv.org

##  1 Introduction

A reasonable slotting system for the Low Earth Orbit (LEO) region can be
obtained from a series of concentric Flower Constellations (FCs) with circular
orbits, but orbit inclination and number of satellites varying between layers
[1, 2]. The main constraint imposed to these FCs is that their dynamics must
guarantee that no collisions can occur (i.e. the satellites are always
separated by a given minimum distance) at any instant of time. The distance
between satellites that belong to one such FC depend directly on the altitude
of the layer (orbit radius) and the angle of separation between them. For this
reason, and to allow for a layer-independent design, we decided to evaluate
FCs based only on two criteria: number of satellites $N_{sat}$, and minimum
angular separation $\alpha_{min}$ between any two satellites during a complete
orbital period. In this paper, we propose an efficient way to tabulate all
possible FCs with up to a maximum number of satellites, including columns for
each of the parameters that define the FC and two extra columns for $N_{sat}$
and $\alpha_{min}$.

A FC, more precisely, a 2D Lattice Flower Constellation [3], is defined by
three integer parameters: the number of orbits $N_{o}\geq 1$, the number of
satellites per orbit $N_{so}\geq 1$, and a configuration number $0\leq
N_{c}<N_{o}$. It also requires the orbital elements of a reference satellite
$a,e,i,\omega,\Omega,M_{0}$, which are six real numbers. In our case, we are
interested in FCs with circular orbits, so the eccentricity $e$ and the
argument of the perigee $\omega$ can both be assumed to be zero. Since the two
evaluation criteria for FCs, namely $N_{sat}$ and $\alpha_{min}$, are
invariant with respect to rotations about the axis of rotation of the Earth
and shifts of the time-scale, we can also assume that $\Omega$ and $M_{0}$ are
zero. Finally, we have agreed on using the separation angle $\alpha_{min}$
instead of the actual distance between satellites, so we have no dependence on
the orbit radius $a$ either. This means that the only real (continuous)
parameter of interest is the orbit inclination $i\in[0,\pi]$, which we propose
to discretize in small increments, so that we reduce the problem to studying a
finite number of possible inclinations.

We prove that the number of FCs with $N_{sat}\leq k$ is between $k^{2}/2$ and
$k^{2}$. In particular, a database with all such FCs with the inclination
discretized in $l$ possible values will have at most $k^{2}\cdot l$ rows. Each
row contains the integers $N_{o},N_{so},N_{c},N_{sat}$, which are all bounded
by $k$ and the reals $i,\alpha_{min}$, which are both between $0$ and $\pi$.
Each integer occupies at most $\lceil\log_{10}(k)\rceil+1$ characters, and
each real occupies $10$ characters assuming one for the integer part, one for
the decimal point, and eight for the fractional part. If the values are
separated by one space character, and each line is terminated by a new-line
character, we have rows of length $4\lceil\log_{10}(k)\rceil+30$ characters.
This means that the whole database fits into a file of size

$k^{2}\cdot l\cdot(4\lceil\log_{10}(k)\rceil+30).$

For $k=10^{4}$ and $l=180$, this gives about $828$ gigabytes, which is
feasible with current technology.

Computing the value of $\alpha_{min}$ for a given FC is not an easy task. For
each pair of satellites in the FC, we have to propagate their position during
an orbital period, find out when they are at their closest distance, and then
take the minimum of all those values. To help with this process, we have
proven a series of results that reduces the computation time significantly.
The first is a simple formula that, given the orbital parameters of two
satellites moving in circular orbits of the same radius, provides the value of
their minimum angular distance. No propagation is needed. The second is a
theorem that shows that only the distances between the reference satellite of
the FC and the others have to be computed. This reduces the number of pairs
from $N_{sat}\cdot(N_{sat}-1)/2$ to $N_{sat}-1$. A third result reduces the
number of pairs to $\lfloor N_{sat}/2\rfloor$. Combining these three results,
the amount of computation that has to be done per FC is about $C\cdot
N_{sat}/2$, where $C$ is the number of floating-point operations in our first
formula. Summing over all possible FCs with $N_{sat}\leq k$ and $l$ possible
values for the inclination, we get about $C/4\cdot k^{3}\cdot l$ operations.

Our final result is a characterization of all FCs with satellite collisions.
In general, the condition for having collisions depends on the inclination.
However, we found a family of FCs (those with both $N_{o}$ and $N_{so}+N_{c}$
even integers), accounting for $25\%$ of the search space, that can be proven
to have collisions regardless of the value of the inclination. Pruning those
FCs out from our database, since they clearly have $\alpha_{min}=0$, reduces
the computation time and the size of the database by a factor of $0.75$.

We have implemented all these techniques in OpenCL, and a preliminary result
(on a laptop with an Intel Gen9 HD Graphics NEO GPU) shows that for $k=10^{4}$
and $l=180$, the $0.75\cdot 828=621$ gigabytes database can be computed in
$45.5$ hours. On an Nvidia Tesla K40c GPU, this time reduces to $3.35$ hours,
disregarding the I/O time required to save th data to the hard drive.

The techniques developed in Section 3 can be extrapolated easily to the more
general case of 2D Necklace Flower Constellations [4].

##  2 Fast computation of the minimum angular distance

In this section, we derive a closed formula (no propagation needed) to compute
the minimum angular distance between two satellites $Sat_{1}$ and $Sat_{2}$,
moving in circular orbits of the same radius $R$. The orbital elements of
these satellites are

$\displaystyle Sat_{1}$
$\displaystyle\rightsquigarrow(a=R,e=0,i_{1},\omega=0,\Omega_{1},M_{01})$
$\displaystyle Sat_{2}$
$\displaystyle\rightsquigarrow(a=R,e=0,i_{2},\omega=0,\Omega_{2},M_{02})$

where $i_{1},i_{2}\in[0,\pi]$ and
$\Omega_{1},\Omega_{2},M_{01},M_{02}\in[0,2\pi]$. The mean motion and period
of the satellites are

$T=2\pi\sqrt{\frac{R^{3}}{\mu}}\qquad
n=\frac{2\pi}{T}=\sqrt{\frac{\mu}{R^{3}}}$

where $\mu\approx 3.986\cdot 10^{14}m^{3}/s^{2}$ is the standard gravitational
parameter of the Earth. The positions $\vec{r}_{1}(t)$ and $\vec{r}_{2}(t)$ of
the satellites are given by

$\displaystyle\vec{r}_{1}(t)$ $\displaystyle={\rm R}_{z}(\Omega_{1}){\rm
R}_{x}(i_{1}){\rm R}_{z}(M_{01})\left(\begin{array}[]{c}R\cos(nt)\\\
R\sin(nt)\\\ 0\end{array}\right)$ $\displaystyle\vec{r}_{2}(t)$
$\displaystyle={\rm R}_{z}(\Omega_{2}){\rm R}_{x}(i_{2}){\rm
R}_{z}(M_{02})\left(\begin{array}[]{c}R\cos(nt)\\\ R\sin(nt)\\\
0\end{array}\right)$

in the ECI (Earth Centered Inertial) reference frame. The unit vectors
$\hat{r}_{1}(t)$ and $\hat{r}_{2}(t)$ are given by the same expressions, but
setting $R=1$. The convention used here for the rotation matrices is

${\rm R}_{x}(\alpha)=\left(\begin{array}[]{ccc}1&0&0\\\
0&\cos(\alpha)&-\sin(\alpha)\\\
0&\sin(\alpha)&\cos(\alpha)\end{array}\right)\qquad{\rm
R}_{z}(\alpha)=\left(\begin{array}[]{ccc}\cos(\alpha)&-\sin(\alpha)&0\\\
\sin(\alpha)&\cos(\alpha)&0\\\ 0&0&1\end{array}\right)$

for any angle $\alpha\in[0,2\pi]$. At any instant of time $t$, the angle
$\gamma(t)$ between $\hat{r}_{1}(t)$ and $\hat{r}_{2}(t)$ satisfies

$\displaystyle\cos$
$\displaystyle(\gamma(t))=\hat{r}_{2}^{T}(t)\hat{r}_{1}(t)=$
$\displaystyle=(\cos(nt),\;\sin(nt),\;0){\rm R}_{z}(-M_{02}){\rm
R}_{x}(-i_{2}){\rm R}_{z}(-\Omega_{2}){\rm R}_{z}(\Omega_{1}){\rm
R}_{x}(i_{1}){\rm R}_{z}(M_{01})\left(\begin{array}[]{c}\cos(nt)\\\
\sin(nt)\\\ 0\end{array}\right)=$ $\displaystyle=(\cos(nt),\;\sin(nt),\;0){\rm
R}_{z}(-M_{02}){\rm R}_{x}(-i_{2}){\rm R}_{z}(\Delta\Omega){\rm
R}_{x}(i_{1}){\rm R}_{z}(M_{01})\left(\begin{array}[]{c}\cos(nt)\\\
\sin(nt)\\\ 0\end{array}\right)$

where $\Delta\Omega=\Omega_{1}-\Omega_{2}$. Finding the minimum $\gamma(t)$
over an orbital period is equivalent to maximizing $\cos(\gamma(t))$ for
$t\in[0,T]$, or more simply, to maximizing

$\displaystyle\left(\cos(\beta),\;\sin(\beta),\;0\right){\rm
R}_{z}(-M_{02}){\rm R}_{x}(-i_{2}){\rm R}_{z}(\Delta\Omega){\rm
R}_{x}(i_{1}){\rm R}_{z}(M_{01})\left(\begin{array}[]{c}\cos(\beta)\\\
\sin(\beta)\\\ 0\end{array}\right)=$
$\displaystyle\quad\,=\left(\cos(\beta+M_{02}),\;\sin(\beta+M_{02}),\;0\right){\rm
R}_{x}(-i_{2}){\rm R}_{z}(\Delta\Omega){\rm
R}_{x}(i_{1})\left(\begin{array}[]{c}\cos(\beta+M_{01})\\\
\sin(\beta+M_{01})\\\ 0\end{array}\right)$

for $\beta=nt\in[0,2\pi]$. Changing variables $\beta^{\prime}=\beta+M_{02}$,
this expression becomes

$\displaystyle\left(\cos(\beta^{\prime}),\;\sin(\beta^{\prime}),\;0\right){\rm
R}_{x}(-i_{2}){\rm R}_{z}(\Delta\Omega){\rm
R}_{x}(i_{1})\left(\begin{array}[]{c}\cos(\beta^{\prime}+M_{01}-M_{02})\\\
\sin(\beta^{\prime}+M_{01}-M_{02})\\\ 0\end{array}\right)=$ (4)
$\displaystyle\qquad\,=\left(\cos(\beta^{\prime}),\;\sin(\beta^{\prime}),\;0\right){\rm
R}_{x}(-i_{2}){\rm R}_{z}(\Delta\Omega){\rm R}_{x}(i_{1}){\rm R}_{z}(\Delta
M_{0})\left(\begin{array}[]{c}\cos(\beta^{\prime})\\\ \sin(\beta^{\prime})\\\
0\end{array}\right)$ (8)

where $\Delta M_{0}=M_{01}-M_{02}$. Assume that the product of the four
rotation matrix in the expression above is

${\rm R}_{x}(-i_{2}){\rm R}_{z}(\Delta\Omega){\rm R}_{x}(i_{1}){\rm
R}_{z}(\Delta M_{0})=\left(\begin{array}[]{ccc}a&b&*\\\ c&d&*\\\
&*&*\end{array}\right)$

for some $a,b,c,d\in\mathbb{R}$. The entries marked with an asterisk are not
relevant, since they will later be multiplied by zeros. The expression (8)
that we want to maximize can be rewritten as

$\displaystyle\left(\cos(\beta^{\prime}),\;\sin(\beta^{\prime}),\;0\right)\left(\begin{array}[]{ccc}a&b&*\\\
c&d&*\\\ &*&*\end{array}\right)\left(\begin{array}[]{c}\cos(\beta^{\prime})\\\
\sin(\beta^{\prime})\\\ 0\end{array}\right)=$ (15)
$\displaystyle\qquad\,=a\cos^{2}(\beta^{\prime})+(b+c)\cos(\beta^{\prime})\sin(\beta^{\prime})+d\sin^{2}(\beta^{\prime})=$
$\displaystyle\qquad\,=\frac{a+d}{2}+\frac{a-d}{2}\cos(2\beta^{\prime})+\frac{b+c}{2}\sin(2\beta^{\prime})$
(16)

where $\beta^{\prime}$ ranges from $0$ to $2\pi$.

In general, the maximum of an expression of the form
$x\cos(\theta)+y\sin(\theta)$ for $\theta\in[0,2\pi]$ happens when the unit
vector $(\cos(\theta),\sin(\theta))$ is aligned (same direction) with $(x,y)$,
i.e. when

$\left(\cos(\theta),\;\sin(\theta)\right)=\left(\frac{x}{\sqrt{x^{2}+y^{2}}},\;\frac{y}{\sqrt{x^{2}+y^{2}}}\right).$

At this particular point, the value of the function is

$x\cdot\frac{x}{\sqrt{x^{2}+y^{2}}}+y\cdot\frac{y}{\sqrt{x^{2}+y^{2}}}=\sqrt{x^{2}+y^{2}}.$

Applying this idea to our maximization problem, we get

$\max_{t\in[0,T]}\cos(\gamma(t))=\frac{a+d}{2}+\frac{\sqrt{(a-d)^{2}+(b+c)^{2}}}{2}$

which translates into

$\min_{t\in[0,T]}\gamma(t)=\arccos\left(\frac{a+d}{2}+\frac{\sqrt{(a-d)^{2}+(b+c)^{2}}}{2}\right)$
(17)

for the minimum angular distance between the two satellites. The expressions
for $a,b,c,d$ in terms of $i_{1},i_{2},\Delta\Omega,\Delta M_{0}$ can be
easily obtained by multiplying the four rotation matrices. The following
pseudocode shows all these formulas.

Algorithm 1 Minimal angular distance between satellites in circular orbits of
equal radius

1:the orbital parameters $(i_{1},\Omega_{1},M_{01})$ and
$(i_{2},\Omega_{2},M_{02})$ of the two satellites.

2:the minimum angular distance $\alpha_{min}$ between the satellites in an
orbital period.

3:procedure MinAngDist($i_{1},\Omega_{1},M_{01},i_{2},\Omega_{2},M_{02}$)

4: $\Delta\Omega=\Omega_{1}-\Omega_{2}$

5: $\Delta M_{0}=M_{01}-M_{02}$

6: $a=\cos(\Delta\Omega)\cos(\Delta
M_{0})-\sin(\Delta\Omega)\cos(i_{1})\sin(\Delta M_{0})$

7: $b=-\cos(\Delta\Omega)\sin(\Delta
M_{0})-\sin(\Delta\Omega)\cos(i_{1})\cos(\Delta M_{0})$

8: $c=\cos(i_{2})\sin(\Delta\Omega)\cos(\Delta
M_{0})+\cos(i_{2})\cos(\Delta\Omega)\cos(i_{1})\sin(\Delta M_{0})+$
$+\sin(i_{2})\sin(i_{1})\sin(\Delta M_{0})$

9: $d=-\cos(i_{2})\sin(\Delta\Omega)\sin(\Delta
M_{0})+\cos(i_{2})\cos(\Delta\Omega)\cos(i_{1})\cos(\Delta M_{0})+$
$+\sin(i_{2})\sin(i_{1})\cos(\Delta M_{0})$

10: $e=0.5\left(a+d+\sqrt{(a-d)^{2}+(b+c)^{2}}\right)$ $\triangleright$ $e$ is
guaranteed to be in $[-1,1]$

11: $\alpha_{min}=\arccos(e)$ $\triangleright$ $\arccos()$ returns a value in
$[0,\pi]$

12: return $\alpha_{min}$

13:end procedure

The total count of floating point operations used in algorithm 1 is: $8$
standard trigonometric functions ($\sin$ and $\cos$), $1$ inverse
trigonometric ($\arccos$), $1$ square root, $23$ multiplications, and $13$
additions and subtractions.

The operation count above is a bit naive, since it is clear that many
computations are repeated in several places. For instance, the product
$\sin(i_{1})\sin(i_{2})$ is computed in lines $6$ and $7$. A clever reordering
of the operations, as shown in Algorithm 2, can reduce the number of
multiplications to only $17$.

The method can also be easily parallelized. On a powerful enough machine, the
lines 2–3, 4–11, 12–17, 18–21 of Algorithm 2 can be processed in parallel (see
the annotations in the pseudocode), since there are no dependencies in either
group. We have left all this kind of parallelization (which depends strongly
on the type of processor used) to the compiler.

An implementation in C of Algorithm 2 on a modern computer (Asus UX430, Ubuntu
18.04.4 LTS) compiled with gcc $7.5.0$ runs, on a single core, at a rate of
$4.79\cdot 10^{6}$ calls per second (double precision) and $1.24\cdot 10^{7}$
calls per second (single precision). The processor of this machine is an Intel
Core i5-7200U.

A OpenCL implementation, without any special optimization, running on the GPU
of the same machine (Intel Gen9 HD Graphics NEO), can process approximately
$4.90\cdot 10^{7}$ calls per second (double precision) and $6.58\cdot 10^{7}$
calls per second (single precision). The timing not only includes the
computation time, but also the time needed to move the data from the main
memory to the GPU memory and vice versa. In double precision, the GPU is more
than 10 times faster than a CPU core. A hand optimized version runs
approximately four times faster.

Algorithm 2 Minimal angular distance between satellites in circular orbits of
equal radius – Optimized – Annotated for parallelization

1:the orbital paramet ers $(i_{1},\Omega_{1},M_{01})$ and
$(i_{2},\Omega_{2},M_{02})$ of the two satellites.

2:the minimum angular distance $\alpha_{min}$ between  the satellites in an
orbital period.

3:procedure MinAngDist($i_{1},\Omega_{1},M_{01},i_{2},\Omega_{2},M_{02}$)

4: $\Delta\Omega=\Omega_{1}-\Omega_{2}$

5: $\Delta M_{0}=M_{01}-M_{02}$

6: $C\Omega=\cos(\Delta\Omega)$

7: $S\Omega=\sin(\Delta\Omega)$

8: $CM_{0}=\cos(\Delta M_{0})$

9: $SM_{0}=\sin(\Delta M_{0})$

10: $CI_{1}=\cos(i_{1})$

11: $SI_{1}=\sin(i_{1})$

12: $CI_{2}=\cos(i_{2})$

13: $SI_{2}=\sin(i_{2})$

14: $aux_{1}=C\Omega\cdot CM_{0}$

15: $aux_{2}=S\Omega\cdot CM_{0}$

16: $aux_{3}=C\Omega\cdot SM_{0}$

17: $aux_{4}=S\Omega\cdot SM_{0}$

18: $aux_{5}=CI_{1}\cdot CI_{2}$

19: $aux_{6}=SI_{1}\cdot SI_{2}$

20: $a=aux_{1}-aux_{4}\cdot\cos(i_{1})$

21: $b=-aux_{3}-aux_{2}\cdot\cos(i_{1})$

22: $c=aux_{2}\cdot\cos(i_{2})+aux_{3}\cdot aux_{5}+SM_{0}\cdot aux_{6}$

23: $d=-aux_{4}\cdot\cos(i_{2})+aux_{1}\cdot aux_{5}+CM_{0}\cdot aux_{6}$

24: $e=0.5\left(a+d+\sqrt{(a-d)^{2}+(b+c)^{2}}\right)$ $\triangleright$ $e$ is
guaranteed to be in $[-1,1]$

25: $\alpha_{min}=\arccos(e)$ $\triangleright$ $\arccos()$ returns a value in
$[0,\pi]$

26: return $\alpha_{min}$

27:end procedure

parallel group 1

parallel group 2

parallel group 3

parallel group 4

To our knowledge, the best method known up to now for computing the minimum
angular distance $\alpha_{min}$ between two satellites in circular orbits of
the same radius without propagation is a formula proven by Speckman, Lang, and
Boyce in [5].

$\displaystyle\alpha_{min}$
$\displaystyle=2\left|\arcsin\left(\sqrt{\frac{1+\cos(i_{1})\cos(i_{2})+\sin(i_{1})\sin(i_{2})\cos(\Delta\Omega)}{2}}\sin\left(\frac{\Delta
F}{2}\right)\right)\right|$ (18) $\displaystyle\Delta F$ $\displaystyle=\Delta
M_{0}-2\arctan\left(-\tan\left(\frac{\Delta\Omega}{2}\right)\frac{\cos\left(\frac{i_{1}+i_{2}}{2}\right)}{\cos\left(\frac{i_{1}-i_{2}}{2}\right)}\right)$

This formula uses $9$ trigonometric functions ($\sin$, $\cos$, $\tan$), $2$
inverse trigonometric ($\arcsin$, $\arctan$), $1$ square root, $9$
multiplications and divisions, and $5$ additions and subtractions. In
comparison, our method uses fewer trigonometric functions and inverse
trigonometric functions, but more arithmetic operations. On a machine where
the trigonometric functions dominate the computation, it is reasonable to
expect that our method would be faster. Indeed, an implementation in C of the
formula above can process approximately $3.69\cdot 10^{6}$ calls per second
(double precision) and $7.11\cdot 10^{6}$ calls per second (single precision),
under the same conditions we tested our formula. Compared to that, our method
can process $30\%$ more calls per second in double precision and $74\%$ more
in single precision. Finally, to validate the accuracy of our method, we
tested formulas (17) and (18) on a random sample of $10^{7}$ cases and
verified that they return values within $2.15\cdot 10^{-10}$ of each other in
double precision and $5.79\cdot 10^{-4}$ in single precision.

##  3 Fast evaluation of Flower Constellations

A 2D Lattice Flower Constellation (see [3]) is defined by three integer
parameters $N_{o}\geq 1$, $N_{so}\geq 1$, and $0\leq N_{c}<N_{o}$, and the
orbital parameters of a reference satellite $(a,e,incl,\omega,\Omega,M_{0})$.
The constellation has $N_{sat}=N_{o}N_{so}$ satellites denoted $Sat_{ij}$
whose orbital elements are $(a,e,incl,\omega,\Omega_{ij},M_{0,ij})$, where

$\Omega_{ij}=\Omega+2\pi\frac{i}{N_{o}}\qquad
M_{0,ij}=M_{0}+2\pi\frac{jN_{o}-iN_{c}}{N_{sat}}$

for $i=0,\ldots,N_{o}-1$ and $j=0,\ldots,N_{so}-1$. The indices $i$ and $j$
will always be regarded as integers modulo $N_{o}$ and $N_{so}$, respectively.
For instance $Sat_{N_{o}+3,4}=Sat_{3,4}$. The first four orbital elements
$(a,e,incl,\omega)$ are common to all satellites. The reference satellite is
$Sat_{00}$. In this section, we show how to evaluate efficiently the minimum
angular distance between any pair of satellites of a FC.

The number of possible FCs with a maximum given number of satellites $k$ is

$\sum_{N_{o}=1}^{k}N_{o}\left\lfloor\frac{k}{N_{o}}\right\rfloor$

since for any possible $N_{o}$, the possible values of $N_{so}$ are the
positive integers such that $N_{o}N_{so}\leq k$, and the possible values for
$N_{c}$ are the integers from $0$ to $N_{o}-1$. Each term of the sum above is
bounded above by $k$ and below by $k/2$. Therefore, the number of FCs with
$N_{sat}\leq k$ is between $k^{2}/2$ and $k^{2}$.

A simple but inefficient method to evaluate a FC is to compute the value of
$\alpha_{min}$ for each pair of satellites of the constellation and return the
minimum of those values. This method requires $N_{sat}(N_{sat}-1)/2$ calls to
the formula to compute $\alpha_{min}$. While this method might work well for a
single FC, it becomes too costly when one needs to evaluate all FCs with
$N_{sat}\leq k$. Indeed, the number of calls to the formula for $\alpha_{min}$
would be

$\sum_{N_{o}=1}^{k}\sum_{N_{so}=1}^{\lfloor
k/N_{o}\rfloor}\frac{N_{o}(N_{o}N_{so})(N_{o}N_{so}-1)}{2}\approx\frac{k^{4}}{6}.$

Even for FCs with circular orbits, where we can use Algorithm 2, it will take
more than three months to process the case $k=10^{4}$ using the same computer
and the optimized OpenCL code mentioned in Section 2. Nevertheless, as we show
below, it is possible to use properties of the FCs to reduce this time
significantly.

The main properties of FCs are their symmetries. If constellations are
regarded as “3d-movies” showing the motion of the satellites, FCs are
invariant under the following two operations:

  * 1.

$R_{t}(T/N_{so})$: shifting the time scale of the movie by $T/N_{so}$, where
$T$ is the period of the satellites. If the original movie and the movie with
the time scale shifted are projected together, a viewer will see exactly the
same frame. Of course, each satellite will occupy the position of another, but
the overall configuration will be the same. Under this operation, the
satellite $Sat_{i,j}$ of the original FC will occupy the location of the
satellite $Sat_{i,j+1}$ of the other.

  * 2.

$R_{z}(2\pi/N_{o})R_{t}(N_{c}T/N_{sat})$: this operation combines a rotation
about the $z$-axis and a shift of the time scale. Under this operation, the
satellite $Sat_{i,j}$ of the original FCs corresponds to $Sat_{i+1,j}$ of the
rotated FCs.

These symmetries can be combined to create more complicated ones. For
instance, for any $\delta_{i}$ and $\delta_{j}$, there is an operation that
maps $Sat_{i,j}$ of the initial FC into $Sat_{i+\delta_{i},j+\delta_{j}}$ of
the transformed FC.

A nice consequence of the symmetries of a FC is that it is possible to
evaluate a FC by only considering the angular distances between the reference
satellite and the other $N_{sat}-1$. Indeed, the minimum angular distance
between $Sat_{i_{1},j_{1}}$ and $Sat_{i_{2},j_{2}}$ is exactly the same as
between $Sat_{0,0}$ and $Sat_{i_{2}-i_{1},j_{2}-j_{1}}$. Applying this trick,
we can evaluate all FCs with $N_{sat}\leq k$ with

$\sum_{N_{o}=1}^{k}\sum_{N_{so}=1}{\lfloor
k/N_{o}\rfloor}N_{o}(N_{o}N_{so}-1)\approx\frac{k^{3}}{2}$

calls to the routine that computes $\alpha_{min}$ between a pair of
satellites. For FCs with circular orbits, the case $k=10^{4}$ requires $40$
minutes of computation.

The notion of distance is clearly symmetrical, i.e. the distance between
$Sat_{i_{1},j_{1}}$ and $Sat_{i_{2},j_{2}}$ is the same as between
$Sat_{i_{2},j_{2}}$ and $Sat_{i_{1},j_{1}}$. However, according to the result
of the previous paragraph, these two distances correspond to the ones from the
reference satellite to $Sat_{i_{1}-i_{2},j_{1}-j_{2}}$ and
$Sat_{i_{2}-i_{1},j_{2}-j_{1}}$, respectively. Therefore, these two distances
must be equal, so only one has to be computed. Due to the modular nature of
the indices $i$ and $j$, only the distances from the reference satellite to
satellites $Sat_{ij}$ with $i\leq\lfloor N_{o}/2\rfloor$ have to be computed.
A pseudocode showing how to implement this idea is given in Algorithm 3. This
trick reduces the computation time in half, i.e. to $k^{3}/4$ calls, so the
case $k=10^{4}$ would only take $20$ minutes.

Algorithm 3 Minimal angular distance for a FC with circular orbits

1:the parameters $N_{o}$, $N_{so}$, $N_{c}$ that define the FC.

2:the orbit inclination $incl$.

3:the minimum angular distance $\alpha_{min}$ between any pair of satellites
of the FC in an orbital period.

4:procedure FCMinAngDist($N_{o},N_{so},N_{c},incl$)

5: $N_{sat}=N_{o}\cdot N_{so}$

6: $\alpha_{min}=2\pi$

7: for $i=0,\ldots,\lfloor N_{o}/2\rfloor$ do

8: for $j=0,\ldots,N_{so}-1$ do

9: if $i=0$ and $j=0$ then $\triangleright$ do not compare the reference
satellite to itself

10: go to line 18

11: end if

12: $\Omega=2\pi\cdot i/N_{o}$

13: $M_{0}=2\pi\cdot(j\cdot N_{o}-i\cdot N_{c})/N_{sat}$

14: $\alpha=\textsc{MinAngDist}(incl,\,0.0,\,0.0,\,incl,\,\Omega,\,M_{0})$

15: if $\alpha<\alpha_{min}$ then

16: $\alpha_{min}=\alpha$

17: end if

18: end for

19: end for

20: return $\alpha_{min}$

21:end procedure

The condition in line 9 of Algorithm 3 can be improved a little bit.

$\textbf{if}\;(i=0\;\text{and}\;j\leq\lfloor
N_{so}/2\rfloor)\;\text{or}\;(i=N_{o}/2\;\text{and}\;j>\lfloor
N_{so}/2\rfloor)\;\textbf{then}$ (19)

Instead of only removing the reference satellite, it is possible to remove all
the satellites such that $i=0$ and $j\leq\lfloor N_{so}/2\rfloor$. The
distance between any such satellite $Sat_{0,j}$ and the reference satellite is
equal to the distance between $Sat_{0,-j}=Sat_{0,N_{so}-j}$ and the reference
satellite. It is clearly impossible that both $Sat_{0,j}$ and
$Sat_{0,N_{so}-j}$ are excluded from the search by the new condition.
Similarly, in the case where $N_{o}$ is an even integer, the satellites with
$i=N_{o}/2$ and $j>\lfloor N_{so}/2\rfloor$ can be excluded without losing any
information. Doing this replacement will bring down the number of calls to
Algorithm 2 to exactly $\lfloor N_{sat}/2\rfloor$.

So far, we have only dealt with the integer parameters of the FCs. In the case
of FCs with circular orbits, the reference satellite has orbital parameters
$(a,e=0,incl,\omega=0,\Omega,M_{0})$. The value of the semimajor axis $a$,
which in this case is the radius of the orbit, does not affect the angular
distance. The value of $\Omega$ and $M_{0}$ do not affect the distance either,
since a constellation with non-zero values of $\Omega$ and $M_{0}$ can be
transformed into one with $\Omega=M_{0}=0$ by applying the transformation
$R_{z}(\Omega)R_{t}(T\cdot M_{0}/(2\pi))$. The only parameter that matters is
the value of the inclination. Since the value is a real number, no exhaustive
search is possible. A discretization of this value in $l$ possibilities will
bring the running time to $C/4\cdot k^{3}\cdot l$, where $C$ is the average
time per call of the routine implementing Algorithm 2.

Assume now that $N_{o}$ and $N_{c}+N_{so}$ are both divisible by two. In this
case, Algorithm 3 always returns $\alpha_{min}=0$, i.e. the FC has collisions.
The reason is that in the main loop, when $i=N_{o}/2$ and
$j=(N_{c}+N_{so})/2$, the values of $\Omega$ and $M_{0}$ become

$\Omega=2\pi\frac{N_{o}/2}{N_{o}}=\pi\qquad
M_{0}=2\pi\frac{\frac{N_{c}+N_{so}}{2}N_{o}-\frac{N_{o}}{2}N_{c}}{N_{sat}}=\pi$

and $\textsc{MinAngDist}(incl,0,0,incl,\pi,\pi)=0$. If these FCs are
discarded, which represent about $25\%$ of the total number of FCs with
$N_{sat}\leq k$, then the total cost of computation reduces to $3C/16\cdot
k^{3}\cdot l$. For a single inclination, the case $k=10^{4}$ would take only
$15$ minutes.

##  4 Conclusions

Algorithm 2 computes the minimum angular distance, measured from the center of
the Earth, between two given satellites moving in circular orbits of the same
radius, during an orbital period. The method is easy to implement and does not
perform any propagation of the satellites. In terms of floating-point
operations, it uses $8$ trigonometric functions ($\sin$ and $\cos$), $1$
inverse trigonometric function ($\arccos$), $1$ square root, $17$
multiplications, and $13$ additions and subtractions. On a modern laptop, a
single CPU core is able to process up to $4.79\cdot 10^{6}$ calls per second
in double precision. The method is highly parallelizable, with a dependency
chain of length $6$.

Algorithm 3 computes the minimum angular distance between all satellites of a
FC with circular orbits. If the improved (19) is used instead of line 9, only
$\lfloor N_{sat}/2\rfloor$ pairs of satellites are evaluated with Algorithm 2.
This improves the naive method of testing every pair of satellites by a factor
of $2(N_{sat}-1)$.

The total number of FCs with $N_{sat}\leq k$ is between $k^{2}/2$ and $k^{2}$.
Running Algorithm 3 for all such FC and $l$ different inclinations requires
$k^{3}/4\cdot l$ calls to Algorithm 2.

FCs with $N_{o}$ and $N_{so}+N_{c}$ both divisible by two, always have
collisions, i.e. their minimum angular distance is zero. Pruning these cases
speeds up the computation of the previous paragraph to only $3k^{3}/16\cdot l$
calls to Algorithm 2. On a modern Nvidia Tesla K40c GPU, a hand optimized
implementation of this method can process the case $k=10^{4}$ and $l=180$ in
only $3.35$ hours.

## Acknowledgments

Martín Avendaño is partially supported by grant MTM2016-76868-C2-2-P (Ministry
of Science and Innovation, Spain). David Arnas is partially supported by grant
ESP2017-87113-R (Ministry of Science and Innovation, Spain). All authors are
also funded by MISTI Global Seed Funds (La Caixa Foundation).

## References

## References

  * [1] D. Arnas, M. Lifson, R. Linares, M. Avendaño, Low Earth Orbit slotting for Space Traffic Management using Flower Constellation Theory, in: AIAA Scitech 2020 Forum, 2020, p. 0721.  doi:10.2514/6.2020-0721.
  * [2] S. Lee, M. Avendaño, D. Mortari, Uniform and weighted coverage for large lattice flower constellations, in: Advances in the Astronautical Sciences Astrodynamics, Vol. 156, American Astronautical Society, Univelt, Incorporated, P.O. Box 28130, San Diego, California 92198, 2015, pp. 3633–3648, iSBN: 978-0-87703-629-6.
  * [3] M. Avendaño, J. Davis, D. Mortari, The 2d lattice theory of flower constellations, Celestial Mechanics and Dynamical Astronomy 116 (2013) 325––337.  doi:10.1007/s10569-013-9493-8.
  * [4] D. Arnas, D. Casanova, E. Tresaco, 2D Necklace Flower Constellations, Acta Astronautica 142 (2017) 18–28.  doi:10.1016/j.actaastro.2017.10.017.
  * [5] L. Speckman, T. Lang, W. Boyce, An analysis of the line of sight vector between two satellites in common altitude circular orbits, in: Astrodynamics Conference, Vol. 24, American Institute of Aeronautics and Astronautics Inc, AIAA, Portland, OR., 1990, pp. 866–874.  doi:10.2514/6.1990-2988.


# Accelerating Convolutional Neural Network Pruning via Spatial Aura Entropy

Muşat Bogdan
Transilvania University of Braşov, Romania,
Department of Electrical Engineering and Computer Science,
<EMAIL_ADDRESS>
&Andonie Răzvan
Central Washington University, USA,
Department of Computer Science
<EMAIL_ADDRESS>

###### Abstract

In recent years, pruning has emerged as a popular technique to reduce the
computational complexity and memory footprint of Convolutional Neural Network
(CNN) models. Mutual Information (MI) has been widely used as a criterion for
identifying unimportant filters to prune. However, existing methods for MI
computation suffer from high computational cost and sensitivity to noise,
leading to suboptimal pruning performance. We propose a novel method to
improve MI computation for CNN pruning, using the spatial aura entropy. The
spatial aura entropy is useful for evaluating the heterogeneity in the
distribution of the neural activations over a neighborhood, providing
information about local features. Our method effectively improves the MI
computation for CNN pruning, leading to more robust and efficient pruning.
Experimental results on the CIFAR-10 benchmark dataset demonstrate the
superiority of our approach in terms of pruning performance and computational
efficiency.

_K_ eywords Convolutional Neural Networks, Pruning, Mutual Information,
Spatial Aura Entropy, Visualization

##  1 Introduction

Deep Convolutional Neural Networks (CNNs) have achieved state-of-the-art
performance on a wide range of computer vision tasks, such as image
classification, object detection, and semantic segmentation [1, 2, 3]. These
models typically consist of a large number of parameters, making them
computationally expensive and memory-intensive to deploy on resource-limited
devices, such as mobile phones and embedded systems. Training these models
requires significant computational resources and time, which limits the
ability to explore large-scale architectures and hyperparameters [4].

One promising approach to alleviate these challenges is pruning, which refers
to the process of reducing the size of a neural network by removing
unimportant weights, neurons, or filters, without significant loss in accuracy
[5]. Pruning can result in more efficient models that require fewer
parameters, consume less memory, and have faster inference time. This can be
particularly important for real-time applications, where latency and energy
consumption are critical factors [6].

Pruning techniques can be classified into two main categories: weight pruning
and structured pruning. Weight pruning involves setting small weights to zero,
which can lead to sparse connectivity patterns [7]. On the other hand,
structured pruning removes entire neurons or filters, which preserves the
dense connectivity patterns but reduces the model size [8]. Several recent
works have explored different pruning methods, such as magnitude-based pruning
[7], sensitivity-based pruning [9], and filter pruning [8], among others.
These techniques can be applied during or after training and can be combined
with other compression methods, such as quantization, to further reduce the
model size [10].

Despite the potential benefits of pruning, there are also some challenges that
need to be addressed. For example, pruning can lead to a significant increase
in the number of training iterations required to recover the accuracy of the
original model, which can offset the benefits of the reduced model size [11].
Moreover, the choice of the pruning method, the pruning rate, and the fine-
tuning strategy can affect the final accuracy and the efficiency of the pruned
model [12]. Therefore, it is essential to carefully design and evaluate
pruning methods for different applications and network architectures.

Sarvani _et al._ [13] introduced an Information Bottleneck theory [14] based
filter pruning method that utilizes Mutual Information (MI) to determine
filter significance. Their method outperformed recent state-of-the-art pruning
methods and has been demonstrated on LeNet-5, VGG-16, ResNet-56, ResNet-110,
and ResNet-50 architectures using MNIST, CIFAR-10, and ImageNet datasets.
However, the kernel-based MI estimation used in [13] has several computational
issues, including kernel width selection and curse of dimensionality. These
issues can result in an inaccurate estimation of MI and limit the practical
application of kernel-based methods. This gave us the motivation for our
current research.

In this paper, we build on top of Sarvani _et al._ ’s work and propose a more
efficient method to compute the MI required for filter importance selection.
In our experiments, we reduced the execution time from almost a week of to a
single day. Our method computes MI using the spatial aura entropy, as defined
in our previous work [15]. The spatial aura entropy method is more efficient
and straightforward than kernel-based estimators and does not require the
selection of kernel width. Our method manages to preserve or improve the
results obtained by the original work, but at a much lower computational cost.

Visualization can be a useful tool for comparing various pruning techniques by
showcasing how they affect the model’s prediction accuracy. By providing a
visual representation of these impacts, users can gain a better understanding
of the effectiveness of different pruning strategies. This information can be
used to refine pruning strategies and improve the overall effectiveness of the
pruning process [16]. When it comes to pruning, visualization can integrate
the benefits of artificial intelligence, machine learning, and visual
analytics [17, 18]. Our experiments involve the visualization of the pruning
process, allowing us to gain a better understanding of the impact of the
pruning on the model’s performance.

The rest of the paper is structured as follows. Section 2 presents related
work. Section 3 summarizes how we compute MI using the spatial aura entropy.
In Section 4 we introduce our novel pruning method and in Section 5 we
describe experimental results. Section 6 contains the final remarks.

##  2 Related Work

CNNs have become the de facto standard for many computer vision tasks, thanks
to their impressive performance. However, CNNs are often computationally
expensive and memory-intensive, which limits their deployment on resource-
constrained devices such as mobile phones and embedded systems. Therefore,
various pruning techniques have been proposed to reduce the complexity of
CNNs, while maintaining their accuracy. In this section, we discuss some of
the most popular CNN pruning techniques.

The lottery ticket hypothesis proposed by Frankle and Carbin [12] suggests
that there exists a sparse subnetwork within an over-parameterized network,
which can be trained to achieve the same accuracy as the original network. The
lottery ticket hypothesis is based on the idea of iterative pruning and
retraining: a network is pruned, and the remaining weights are fine-tuned to
recover the accuracy. This process is repeated until the desired level of
sparsity is achieved. The authors showed that by using their method, the
number of parameters in a network can be reduced by up to 90% without loss of
accuracy.

Another popular pruning technique is magnitude pruning [7], which involves
pruning the weights with the smallest magnitude. This method is simple and can
be applied to any neural network, including CNNs. Han _et al._ showed that by
pruning 90% of the weights, the computational cost of a CNN can be reduced by
a factor of 10 with only a slight drop in accuracy.

Structured pruning is another pruning technique that aims to remove entire
filters, channels or even layers from the network. A popular structured
pruning method is channel pruning [19], where entire channels are pruned based
on their importance, which is typically measured by their L1-norm. Channel
pruning is particularly effective in reducing the computation cost of a
network, as it removes entire channels and their associated computations.
Another structured pruning method is filter pruning [20], where entire filters
are pruned based on their importance. Filter pruning is more aggressive than
channel pruning, as it removes entire filters and their associated weights,
which results in a more compact network. Ultimately, as demonstrated in one of
our prior studies [21], it is feasible to perform even whole layer pruning.
Specifically, layers can be removed if the spatial entropy of the saliency
maps remains unchanged from the previous layer.

The basis for our work is the paper of Sarvani _et al._ [13], which uses a
novel criterion for structured pruning. The method involves computing MI to
identify the most crucial feature maps in each layer and removing filters
associated with unimportant feature maps. High Relevance Filters (HRel)
filters (filters exhibiting higher MI when considering class labels) are
retained. This method (we will refer to it as the HRel method) uses a matrix-
based Rényi’s alpha entropy estimator [22] to approximate MI. This estimation
technique incurs a significant computational cost due to the need for
continuously updating the bandwidth required for the kernels used in MI
estimation.

Several other pruning methods were proposed, including weight-sharing pruning
[11], which shares weights among different neurons to reduce the number of
unique weights, and morphological pruning [23], which learns the topology of
the network in a resource-constrained manner. The Once-for-All method [24],
trains a large neural network that contains many subnetworks, sharing weights
and searches among them to find the most efficient one for a specific target
device.

Recently, there have been efforts to combine pruning with other techniques,
such as quantization and knowledge distillation. For instance, Liu _et al._
[25] introduced an automated framework for neural network compression, which
combines pruning with other compression techniques such as quantization and
low-rank factorization. Similarly, Cao _et al._ [26] proposed a sparsity
regularization technique that encourages the network to learn a compression-
agnostic representation.

In addition to these methods, there have been efforts to design CNN
architectures that are inherently more efficient, requiring fewer parameters
and less computation for inference. One such architecture is MobileNet [27],
which is designed for mobile devices with limited computing resources. Another
is EfficientNet [28], which uses a compound scaling method to optimize network
depth, width, and resolution to achieve state-of-the-art accuracy with
significantly fewer parameters.

##  3 Background: Mutual Information Computation using Spatial Entropy

To make the paper self-contained, we summarize in this section the MI
estimation technique used for quantifying the importance of convolutional
filters. The MI estimation technique used in this work is based on the
formulation of MI as defined in [15], and uses spatial aura entropy
estimation.

As in [13], we compute the MI between each activation map and the one-hot
encoded ground truths. The MI between two random variables $X$ and $Y$ is
computed as:

$I(X,Y)=H(X)+H(Y)-H(X,Y)$ (1)

where $H(\cdot)$ represents the entropy of a variable, and $H(\cdot,\cdot)$
represents the joint entropy between two variables. Since convolutional
feature maps have embedded into them the notion of spatiality, the univariate
formula of the Shannon entropy does not take into consideration this special
property. As such we make use of the spatial aura matrix entropy, as initially
defined in [29].

We define the joint probability of two features cells at spatial locations
$(i,j)$ and $(i+k,\>j+l)$ to take the values $g$, respectively $g^{\prime}$
as:

$p_{gg^{\prime}}(k,l)=P(X_{i,\>j}=g,X_{i+k,\>j+l}=g^{\prime})$ (2)

where $g$ and $g^{\prime}$ are discretized variables, obtained after binning
the values of the action maps. The probabilities are computed by dividing the
number of occurrences for $(g,g^{\prime})$ by the total number of possible
occurrences. To reduce the computational overhead, we assume that
$p_{gg^{\prime}}$ is independent of $(i,\>j)$ (the homogeneity assumption
[30]), and we define for each pair $(k,\>l)$ the entropy:

$H(k,\>l)=-\sum_{g}\sum_{g^{\prime}}p_{gg^{\prime}}(k,\>l)\log
p_{gg^{\prime}}(k,\>l)$ (3)

where the summations are over the number of possible binned values (128 in our
case). A standardized relative measure of bivariate entropy is [30]:

$H_{R}(k,\>l)=\frac{H(k,\>l)-H(0)}{H(0)}\in[0,\>1]$ (4)

The maximum entropy $H_{R}(k,\>l)=1$ corresponds to the case of two
independent variables. $H(0)$ is the univariate entropy, which assumes all
feature cells as being independent, and we have $H(k,\>l)\geq H(0)$.

Based on the relative entropy for $(k,\>l)$, the Spatial Disorder Entropy
(SDE) for an $m\times n$ image X was defined in [30] as:

$H_{SDE}(\textbf{X})\approx\frac{1}{mn}\sum_{i=1}^{m}\sum_{j=1}^{n}\sum_{k=1}^{m}\sum_{l=1}^{n}H_{R}(i-k,\>j-l)$
(5)

Since the complexity of SDE computation is high, we decided to use a
simplified version - the Aura Matrix Entropy (AME, see [29]), which only
considers the second order neighbors from the SDE computation:

$\displaystyle\begin{split}H_{AME}(\textbf{X})\approx\frac{1}{4}\bigg{(}H_{R}(-1,\>0)+H_{R}(0,\>-1)\\\
+H_{R}(1,\>0)+H_{R}(0,\>1)\bigg{)}\end{split}$ (6)

Putting it all together, starting from a discretized feature map, we compute
the probabilities $p_{gg^{\prime}}$ in equation (2), and finally the AME in
equation (6), which results in the spatial entropy quantity of the activation
map $X$.

The entropy of Y is guaranteed to be $0$ because Y is encoded using one-hot
encoding, which places all the magnitude on a single position. As such, in our
case, the MI formula becomes:

$I(X,Y)=H(X)-H(X,Y)$ (7)

We modify the simplified aura matrix entropy to be applicable for joint
entropy calculation by changing equation (2) to:

$\displaystyle
p_{gg^{\prime}g^{{}^{\prime\prime}}g^{{}^{\prime\prime\prime}}}(k,l)=P(X_{i,\>j}=g,X_{i+k,\>j+l}=g^{\prime},$
(8) $\displaystyle
Y_{i,\>j}=g^{{}^{\prime\prime}},Y_{i+k,\>j+l}=g^{{}^{\prime\prime\prime}})$

where $g$, $g^{\prime}$, $g^{{}^{\prime\prime}}$,
$g^{{}^{\prime\prime\prime}}$ are again discretized values. The upcoming
equations from the spatial entropy computation will use
$p_{gg^{\prime}g^{{}^{\prime\prime}}g^{{}^{\prime\prime\prime}}}$ instead of
$p_{gg^{\prime}}$. The final modification will be to equation (6), where we
take into consideration four spatial positions instead of two, the first two
from $X$ and the last two from $Y$:

$\displaystyle H_{AME}(\textbf{X},\textbf{Y})\approx\frac{1}{4}\bigg{(}$
$\displaystyle H_{R}(-1,\>0,-1,\>0)+H_{R}(0,\>-1,0,\>-1)$ (9)
$\displaystyle+H_{R}(1,\>0,1,\>0)+H_{R}(0,\>1,0,\>1)\bigg{)}$

As $Y$ is a one-dimensional vector with $c$ (classes) one-hot encoded values,
and an activation map $X$ is typically a $3D$ tensor $(C\times W\times H)$, it
is necessary to establish a common spatial dimensionality between the two
variables in order to compute the values in equation (8). To achieve this, we
first repeat the values of $Y$ for $c$ times to create a $c\times c$ grid and
convert it into a $2D$ matrix. We then use interpolation with constant values
to scale the newly obtained matrix to the same spatial dimensionality as
$X(W\times H)$. Once both variables share the same spatial size, we can
calculate the values in equation (8) by inputting each channel of $X$ with the
transformed $Y$ matrix. Finally, we use equation (9) to determine the joint
spatial entropy between $X$ and $Y$.

In order to calculate the value of equation (7), we utilize the outcome of
equation (6) for the entropy of $X$, as well as equation (5) for the joint
entropy of $X$ and $Y$.

##  4 Our Method

We introduce in this section our CNN filter pruning method. Primarily, it
follows the workflow of the HRel method.

First, we train a CNN until convergence. Then we compute the MI between the
activation maps and the ground truth labels for each layer in the network. The
activation maps represent the output of each filter in the layer when the
input is passed through the layer.

Next, we rank the filters in descending order of MI and remove a certain
percentage of filters with the lowest MI. After the filters are removed, we
perform a fine-tuning step to recover the network’s original performance.
Fine-tuning involves training the pruned network for some epochs using a
smaller learning rate than the original training rate.

Once the fine-tuning step is complete, we repeat the process of computing MI,
ranking filters, and MI. This process continues until the maximum number of
filters removed for each layer is achieved.

The advantage of using MI as a criterion for pruning is that it considers the
information content of each filter in the network, rather than just its weight
magnitude or gradient. Additionally, MI can capture the interactions between
filters and their contribution to the overall performance of the network.

In the HRel method, MI is estimated using Rényi’s alpha entropy estimator
[22], which relies on kernel functions and is highly sensitive to the optimal
kernel bandwidth of the dataset [31], as noted by the authors themselves. This
sensitivity results in a computationally expensive procedure, as the kernel
bandwidth needs to be updated continuously during training and fine-tuning,
making the pruning mechanism burdensome. As such, pruning a network using the
public code that the authors provided takes almost a week for a VGG-16 network
[32], rendering it impractical for real-life applications.

In contrast to the original HRel technique, our method employs a different
approach by using a MI estimation that does not rely on kernel functions.
Instead, we estimate MI using the spatial aura entropy (the AME simplified
version) described in Section 3. This allows for efficient computation of MI
using as few as 100 samples. We eliminate the computational burden of
continuously updating the kernel bandwidth during training and fine-tuning,
making it significantly faster and more practical for real-life applications.
Our method still preserves or even improves upon the results achieved by the
original HRel paper, demonstrating its effectiveness in efficient filter
selection.

##  5 Experiments

This section presents empirical proof of the effectiveness of our approach. We
evaluate our method on the widely used CIFAR-10 benchmark dataset [33]. We
modified the publicly available code provided by the HRel authors [13]
altering the MI estimation procedure. Although we observed some variations in
the baseline performance of ResNet architectures from what was reported in the
original paper, we compare our method and HRel employing on the same starting
baseline performance.

###  5.1 VGG-16

To evaluate the effectiveness of our proposed method, we apply it to the
popular VGG-16 architecture [32], which consists of 13 convolutional layers
and two fully connected layers. We prune filters from the convolutional layers
and train the network for 300 epochs with an initial learning rate of 0.1,
which we reduce by a factor of 10 at epoch numbers 80, 140, and 230, until the
baseline accuracy is achieved. Subsequently, we prune and retrain the network
for 90 epochs with a learning rate of 0.01, which we reduce by a factor of 10
at epochs 40 and 70.

Table 1 presents a comparison of the accuracy achieved by the original HRel
formulation and our proposed method for different configurations of the
remaining number of filters per layer on the CIFAR-10 test set. Our method
outperforms HRel for both configurations, demonstrating its effectiveness in
the pruning process. Specifically, the original VGG-16 network achieves a test
accuracy of 93.95%, while our proposed method yields test accuracies of 93.22%
and 93.4% for Configuration 1 and Configuration 2, respectively. These results
highlight the potential of our method in enhancing model efficiency and
accuracy.

Table 1: Comparison of accuracy achieved by HRel and our method on the CIFAR-10 test set across different pruning configurations. The table shows that our method outperforms HRel for both configurations, demonstrating its effectiveness in the pruning process. | HRel | Our Method
---|---|---
Original network: |  |
64-64-128-128-256-256-256 | 93.95% | 93.95%
-512-512-512-512-512-512 |  |
Configuration 1: |  |
19-48-64-64-95-107-107 | 93.15% | 93.22%
-175-71-71-44-44-56 |  |
Configuration 2: |  |
24-40-64-77-176-134-120 | 93.22% | 93.4%
-141-56-56-56-56-56 |  |

###  5.2 ResNet-56

ResNet-56 [2] is a more complex and deeper neural network architecture
compared to VGG-16. It consists of 55 convolutional layers and 1 fully
connected layer, with all convolutional layers (except the first one) grouped
into three blocks, each containing 18 convolutional layers. The first, second,
and third blocks have 16, 32, and 64 filters, respectively. To achieve the
baseline accuracy, the network is trained for 180 epochs with an initial
learning rate of 0.1, which is then decreased by a factor of 10 at epoch
numbers 91 and 136.

After pruning, the network is retrained for 200 epochs with a learning rate of
0.01, which is then decreased by a factor of 10 at epochs 100 and 150. We
observe that the ResNet-56 architecture requires twice the number of fine-
tuning epochs using our method compared to the original HRel framework.
However, the additional computational time is negligible when compared to the
overall runtime of the pruning process from the original HRel.

After pruning, the final remaining number of filters in the convolutional
layers of each block are 8, 15, and 30, respectively. Table 2 shows that our
method achieves the same accuracy as HRel. Specifically, the original HRel
framework achieves an accuracy of 92.74% with a filter configuration of
8-15-30, while our method achieves an accuracy of 92.76% with the same
configuration.

Table 2: Comparison of accuracy achieved by HRel and our method on the CIFAR-10 test set using the ResNet-56 architecture with the filter configuration of 8-15-30 after pruning. | HRel | Our Method
---|---|---
Original network: | 93.45% | 93.45%
16-32-64 |  |
Configuration: | 92.74% | 92.76%
8-15-30 |  |

###  5.3 ResNet-110

ResNet-110 [2] is a deep neural network architecture composed of 109
convolutional layers and a single fully connected layer. The structure of
ResNet-110 is similar to that of ResNet-56, where the convolutional layers are
grouped into three blocks, except for the first convolutional layer. However,
in ResNet-110, each block contains 36 convolutional layers with 16, 32, and 64
filters, respectively.

To achieve the baseline accuracy, the network is trained for 240 epochs with
an initial learning rate of 0.1, which is decreased by a factor of 10 at epoch
numbers 88, 160, and 190. The first convolutional layer is not pruned, similar
to other pruning methods. After pruning, the network is fine-tuned for 70
epochs with a learning rate of 0.01, which is decreased by a factor of 10 at
epochs 30 and 50. The number of remaining filters in each block’s
convolutional layer is 8, 15, and 30, respectively, after pruning.

Table 3 presents a comparison of the accuracy achieved by our proposed method
and HRel on the CIFAR-10 test set using the ResNet-110 architecture with a
filter configuration of 8-15-30 after pruning. The original network with a
filter configuration of 16-32-64 achieved an accuracy of 93.27%. Our method
achieved a high accuracy of 92.42%, which is slightly improved compared to
HRel’s accuracy of 92.36%, with a difference of 0.06%.

Table 3: Comparison between the accuracy achieved by HRel and our proposed method on the CIFAR-10 test set using ResNet-110 architecture with a filter configuration of 8-15-30 after pruning. | HRel | Our Method
---|---|---
Original network: | 93.27% | 93.27%
16-32-64 |  |
Configuration: | 92.36% | 92.42%
8-15-30 |  |

###  5.4 Visualization of the pruning process

Tables 4 and 5 display a graphical representation of the MI distributions for
both methods, allowing for a visual comparison. The two distributions exhibit
a comparable shape, albeit with distinct value ranges resulting from the
distinct MI computation methods employed. The visualization underscores that
while our approach differs from the original HRel, it still captures the
pertinent information necessary for filter pruning selection.

Table 4: MI distributions of VGG-16 for convolutional layer 5 during pruning: 256, 150, 101 filters. Top row is for original HRel, bottom row is for ours |  |
---|---|---
|  |
Table 5: MI distributions of VGG-16 for convolutional layer 12 during pruning: 512, 175, 71 filters. Top row is for original HRel, bottom row is for ours |  |
---|---|---
|  |

###  5.5 Discussion

The experiments demonstrate the effectiveness of our method in improving the
accuracy and efficiency of CNN pruning. The incorporation of spatial aura
entropy into MI calculation provides a more robust and efficient pruning
method. This is achieved by improving the accuracy of filter importance
selection criteria and reducing the optimization time required for MI
computation. Our method not only outperforms the baseline HRel method in terms
of pruning performance but also significantly reduces the computational cost,
making it a practical and scalable solution for deep learning model
compression.

##  6 Conclusion and Future Work

We introduced an alternative solution to the matrix-based Rényi’s alpha
entropy estimator used in the HRel method proposed in [13]. This improvement
significantly reduces the optimization time from almost a week to a single
day, making it a more practical and efficient method for large-scale model
pruning. Our method is an efficient and effective solution to reducing the
computational complexity and memory footprint of deep learning models,
providing a viable alternative to existing methods with improved pruning
performance and computational efficiency.

Future work could focus on exploring the applicability of our method on other
benchmark datasets and model architectures, as well as investigating its
potential in other areas of machine learning and computer vision.

## References

  * [1] A. Krizhevsky, I. Sutskever, and G. E. Hinton, “Imagenet classification with deep convolutional neural networks,” in _Advances in neural information processing systems_ , 2012, pp. 1097–1105.
  * [2] K. He, X. Zhang, S. Ren, and J. Sun, “Deep residual learning for image recognition,” in _Proceedings of the IEEE conference on computer vision and pattern recognition_ , 2016, pp. 770–778.
  * [3] J. Long, E. Shelhamer, and T. Darrell, “Fully convolutional networks for semantic segmentation,” in _Proceedings of the IEEE conference on computer vision and pattern recognition_ , 2015, pp. 3431–3440.
  * [4] C. Sun, L. Wang, X. Liu, and J. Shi, “Patient knowledge distillation for bert model compression,” in _Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP)_ , 2019, pp. 3873–3879.
  * [5] Y. LeCun, J. S. Denker, and S. A. Solla, “Optimal brain damage,” in _Advances in neural information processing systems_ , 1990, pp. 598–605.
  * [6] X. Wu, R. He, Z. Sun, and T. Tan, “A survey of compressing deep neural networks,” _IEEE Transactions on Pattern Analysis and Machine Intelligence_ , vol. 43, no. 3, pp. 705–723, 2021.
  * [7] S. Han, J. Pool, J. Tran, and W. J. Dally, “Learning both weights and connections for efficient neural networks,” in _Advances in neural information processing systems_ , 2015, pp. 1135–1143.
  * [8] H. Li, A. Kadav, I. Durdanovic, H. Samet, and H. P. Graf, “Pruning filters for efficient convnets,” in _Proceedings of the International Conference on Learning Representations_ , 2017.
  * [9] D. Molchanov, A. Ashukha, and D. Vetrov, “Importance-driven neural network pruning,” in _Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition_ , 2019, pp. 11 281–11 289.
  * [10] S. Han, X. Liu, H. Mao, J. Pu, A. Pedram, M. A. Horowitz, and W. J. Dally, “Eie: efficient inference engine on compressed deep neural network,” in _Proceedings of the 43rd ACM/IEEE Annual International Symposium on Computer Architecture_. IEEE, 2016, pp. 243–254.
  * [11] Z. Liu, M. Sun, T. Zhou, G. Huang, and T. Darrell, “Rethinking the value of network pruning,” in _Proceedings of the International Conference on Computer Vision_ , 2019, pp. 1070–1078.
  * [12] J. Frankle and M. Carbin, “The lottery ticket hypothesis: Finding sparse, trainable neural networks,” in _International Conference on Learning Representations_ , 2019. [Online]. Available: https://openreview.net/forum?id=rJl-b3RcF7
  * [13] C. Sarvani, M. Ghorai, S. R. Dubey, and S. S. Basha, “Hrel: Filter pruning based on high relevance between activation maps and class labels,” _Neural Networks_ , vol. 147, pp. 186–197, 2022. [Online]. Available: https://www.sciencedirect.com/science/article/pii/S0893608021004962
  * [14] N. Tishby, F. C. Pereira, and W. Bialek, “The information bottleneck method,” _arXiv preprint physics/0004057_ , 1999.
  * [15] B. M. sat and R. azvan Andonie, “Information bottleneck in deep learning - a semiotic approach,” _International Journal of Computers Communications & Control_, vol. 17, no. 1, 2022. [Online]. Available: http://univagora.ro/jour/index.php/ijccc/article/view/4650
  * [16] Z. Li, S. Liu, X. Yu, K. Bhavya, J. Cao, D. J. Daniel, P.-T. Bremer, and V. Pascucci, “”understanding robustness lottery”: A comparative visual analysis of neural network pruning approaches,” _arXiv preprint arXiv:2206.07918_ , 2022.
  * [17] B. Kovalerchuk, R. Andonie, N. Datia, K. Nazemi, and E. Banissi, “Visual knowledge discovery with artificial intelligence: Challenges and future directions,” in _Integrating Artificial Intelligence and Visualization for Visual Knowledge Discovery_ , B. Kovalerchuk, K. Nazemi, R. Andonie, N. Datia, and E. Banissi, Eds. Cham: Springer International Publishing, 2022, pp. 1–27.
  * [18] B. Kovalerchuk, K. Nazemi, R. Andonie, N. Datia, and E. Banissi, _Integrating Artificial Intelligence and Visualization for Visual Knowledge Discovery_. Springer, 2022.
  * [19] Y. He, X. Zhang, and S. Sun, “Channel pruning for accelerating very deep neural networks,” _International Conference on Computer Vision_ , pp. 1398–1406, 2017.
  * [20] H. Li, A. Kadav, I. Durdanovic, H. Samet, and H. P. Graf, “Pruning filters for efficient convnets,” _arXiv preprint arXiv:1608.08710_ , 2016.
  * [21] B. Mu¸sat and R. a. Andonie, “Semiotic aggregation in deep learning,” _Entropy_ , vol. 22, no. 12, 2020. [Online]. Available: https://www.mdpi.com/1099-4300/22/12/1365
  * [22] K. Wickstrøm, S. Løkse, M. Kampffmeyer, S. Yu, J. Principe, and R. Jenssen, “Information plane analysis of deep neural networks via matrix-based renyi’s entropy and tensor kernels,” _arXiv preprint arXiv:1909.11396_ , 2019.
  * [23] A. Gordon, E. Eban, O. Nachum, B. Chen, H. Wu, T. Yang, and E. Choi, “Morphnet: Fast & simple resource-constrained structure learning of deep networks,” in _Advances in neural information processing systems_ , 2018, pp. 10 205–10 215.
  * [24] S. Han, H. Zhu, J. Liu, and W. J. Dally, “Once-for-all: Train one network and specialize it for efficient deployment,” _Transactions on Pattern Analysis and Machine Intelligence_ , 2021.
  * [25] Z. Liu, M. Sun, T. Zhou, G. Huang, and T. Darrell, “Autocompress: An automated neural network compression framework,” in _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , 2020, pp. 9251–9260.
  * [26] Y. Cao, J. Xu, and W. Lin, “Learning a compression-agnostic representation with sparsity regularization,” in _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , 2019, pp. 10 930–10 938.
  * [27] A. G. Howard, M. Zhu, B. Chen, D. Kalenichenko, W. Wang, T. Weyand, M. Andreetto, and H. Adam, “Mobilenets: Efficient convolutional neural networks for mobile vision applications,” in _Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition_ , 2017, pp. 1382–1391.
  * [28] M. Tan and Q. V. Le, “Efficientnet: Rethinking model scaling for convolutional neural networks,” in _Proceedings of the IEEE international conference on computer vision_ , 2019, pp. 6105–6114.
  * [29] E. Volden, G. Giraudon, and M. Berthod, “Modelling image redundancy,” in _1995 International Geoscience and Remote Sensing Symposium, IGARSS ’95. Quantitative Remote Sensing for Science and Applications_ , vol. 3, 1995, pp. 2148–2150.
  * [30] A. G. Journel and C. V. Deutsch, “Entropy and spatial disorder,” _Mathematical Geology_ , vol. 25, no. 3, pp. 329–355, 1993.
  * [31] N. I. Tapia and P. A. Estévez, “On the information plane of autoencoders,” _CoRR_ , vol. abs/2005.07783, 2020. [Online]. Available: https://arxiv.org/abs/2005.07783
  * [32] K. Simonyan and A. Zisserman, “Very deep convolutional networks for large-scale image recognition,” in _Proceedings of the International Conference on Learning Representations (ICLR)_ , 2015.
  * [33] A. Krizhevsky, V. Nair, and G. Hinton, “Cifar-10 (canadian institute for advanced research).” [Online]. Available: http://www.cs.toronto.edu/ kriz/cifar.html


11institutetext: Lawrence Berkeley National Laboratory

# Light and strange hadron production and anisotropic flow measurement in
Au+Au collisions at ${\sqrt{s_{\rm NN}}=\rm{3\,GeV}}$ from STAR

Guannan Xie (for the STAR Collaboration) 11<EMAIL_ADDRESS>
###### Abstract

In this proceeding, we present on our first measurements of identified
particle ($\pi$, $K$, $p$, $K_{s}^{0}$, $\Lambda$, $\phi$, $\Xi^{-}$)
production and anisotropic flow ($v_{1}$, $v_{2}$) in Au+Au collisions at
${\sqrt{s_{\rm NN}}=\rm{3\,GeV}}$. Various models including thermal and
transport model calculations are compared to data, these results imply that
the matter produced in the 3 GeV Au+Au collisions is considerably different
from that at higher energies.

##  1 Introduction

Relativistic heavy ion physics is aiming at the detailed investigation of
phase structures of strongly interacting matter under extreme conditions.
Searching for the onset of Quark-Gluon Plasma (QGP), studying the properties
of the produced QCD matter, and locating the possible QCD phase boundary are
the focus of the RHIC Beam Energy Scan (BES) Program HotQCD_HeavyIon .

Particle production and collective flow have been used to investigate the
properties of the QCD matter produced in heavy-ion collisions. The RHIC BES
program covers a wide range of energies, including the transition from a
partonic dominated area to hadronic dominated area. Of particular interest is
the high baryon density region which is accessible through production and flow
measurements of particles including light and strange hadrons in the STAR
fixed-target program. In these proceedings, invariant yields and rapidity
density distributions of $\pi$, $K$, $\phi$ mesons and $\Xi^{-}$ hyperons as
well as the directed/elliptic flow of $\pi$, $K$, $p$, $K_{s}^{0}$, $\Lambda$,
$\phi$ are presented.

##  2 Experiment

The dataset used in this analysis consists of Au+Au collisions at
${\sqrt{s_{\rm NN}}=\rm{3\,GeV}}$ collected by the STAR experiment under the
fixed target (FXT) configuration in the year of 2018. The single beam was
provided by RHIC with total energy equal to 3.85 GeV/nucleon. The thickness of
the gold target is about 0.25 mm, corresponding to a 1% interaction
probability to minimize the pileup and energy loss effect in target. The
target is located at 200 cm to the west of the center of the STAR detector, it
is installed inside the vacuum pipe, 2 cm below the center of the beam axis.
The main detectors used for this analysis are the Time Projection Chamber
(TPC), the Time of Flight (TOF) detector, and the Beam-Beam Counter (BBC) STAR
. The trigger is provided by the signal in the east BBC detector and at least
five hits in the TOF detector. Tracking and particle identification (PID) are
done using the energy loss (dE/dx) information from TPC and time of flight
(1/$\beta$) information from TOF. In total, approximately 2.6$\times 10^{8}$
minimum bias triggered events are used in this analysis. Reconstruction of
short lived particles, $K_{S}^{0}\rightarrow\pi^{+}+\pi^{-}$,
$\Lambda\rightarrow p+\pi^{-}$ and $\Xi^{-}\rightarrow\Lambda+\pi^{-}$ is
performed using the KF Particle Finder package based on the Kalman Filter
method STAR . Those combinatorial backgrounds are obtained by rotating
daughter tracks. The $\phi$ mesons are reconstructed through the hadronic
decay channel, $\phi\rightarrow K^{+}+K^{-}$, where combinatorial background
is estimated using the mixed event technique. After corrected for the
acceptance and efficiency, the 4$\pi$ acceptance yield (dN) and anisotropic
flow ($v_{1},v_{2}$) are obtained.

##  3 Light and Strange Hadron Yields

Figure 1 left shows the $K^{-}/K^{+}$ ratio along with collision energy
${\sqrt{s_{\rm NN}}}$. The relative yield of $K^{-}$ is much smaller compared
to $K^{+}$ at 3 GeV which demonstrates the importance of $K^{+}$ production in
association with the $\Lambda$ ($N+N\rightarrow N+\Lambda+K$). Right plot
shows the $K^{+}/\pi^{+}$ ratio along with ${\sqrt{s_{\rm NN}}}$. The horn
structure around 7 GeV was proposed as a possible signal of onset of
deconfinement in early days, but later on the data are described well by the
statistics models. The measured $K^{-}/K^{+}$ and $K^{+}/\pi^{+}$ ratios at 3
GeV follow with the world trend pi2K_experiment .

Figure 1: $K^{-}/K^{+}$ (left) and $K^{+}/\pi^{+}$ (right) ratio as a function
of $\sqrt{s_{\rm NN}}$. The red star shows the measurements at 3 GeV with
statistical and systematic uncertainties added together, while other markers
are used for data from other energies pi2K_experiment .

Figure 2: $\phi/K^{-}$ (left) and $\phi/\Xi^{-}$ (right) ratio as a function
of $\sqrt{s_{\rm NN}}$. The solid color markers show the measurements at 3 GeV
from different centrality bins with vertical lines for statistical and bracket
symbols for systematic errors, while other markers are used for data from
various other energies and/or collision systems phi2K_experiment .

Statistical thermal models have often been used to characterize the thermal
properties of the produced media. In low energies, the strangeness production
is rare, therefore it has been argued that strangeness number needs to be
conserved locally on an event-by-event basis described by the Canonical
Ensemble (CE), which leads to a reduction in the yields of hadrons with non-
zero strangeness number. Figure 2 shows the $\phi/K^{-}$ (left) and
$\phi/\Xi^{-}$ (right) ratios from our measurements in different centralities
as a function of $\sqrt{s_{\rm NN}}$. The measured $\phi/K^{-}$ and
$\phi/\Xi^{-}$ ratios at 3 GeV are slightly higher than the values at high
energies for $\sqrt{s_{\rm NN}}\geqslant$ 7 GeV. There is a hint for both the
measured $\phi/K^{-}$ and $\phi/\Xi^{-}$ ratios in mid-central collisions are
larger than that in central collisions, and this need further statistics to
systematically study the centrality dependence in detail. The Grand Canonical
Ensemble (GCE) underestimates our data with $\sim$5$\sigma$ effect for
$\phi/K^{-}$ and $\sim$4$\sigma$ effect for $\phi/\Xi^{-}$, while the CE
calculation with strangeness correlation length ($r_{c}$) $\sim$3.2 fm can
reasonably describe our measurements. The precise determination of the thermal
parameters (including $T_{ch}$, $\mu_{B}$ and $r_{c}$) needs a global thermal
model fit with all the particle yields at 3 GeV. The modified transport models
(UrQMD and SMASH) calculations by including high mass resonances decay to
$\phi$ and $\Xi^{-}$ can also reasonably describe the data at low energies
phi2K_experiment . In the Au+Au collisions at 3 GeV, the observed strangeness
production mechanism may be different from that at high energy, and this may
indicate a change of EoS at this low energy.

##  4 Light and Strange Hadron Anisotropic Flow

Figure 3: NCQ scaled $v_{2}$ as a function of $(m_{T}-m_{0})/n_{q}$ for pions,
kaons and protons from Au+Au collisions in 10-40% centrality for positive
(left) and negative (right) charged particles.

Directed flow $v_{1}$ and elliptic flow $v_{2}$ are sensitive to the stiffness
of the nuclear Equation of State (EoS) at high baryon density region
v1v2_experiment . The number of constituent quark (NCQ) scaling of $v_{2}$ is
observed for particle or anti-particle for collision energy $\geq$ 7.7 GeV and
it is often argued as an evidence for the formation of a QGP phase with
partonic degrees of freedom. For 3 GeV collisions, the elliptic flow of all
charged hadrons measured at midrapidity are negative and the NCQ scaling is
absent as shown in Fig. 3, especially for positive charged particles. The
slope of the midrapidity directed flow of all measured hadrons are found to be
positive as shown in Fig. 4 v1v2_experiment . This is the first time observed
of positive $v_{1}$ slop for kaons and $\phi$ mesons. In addition, the UrQMD
model calculations with the baryonic mean-field potential qualitatively
reproduce our observations. Due to the formation of the QGP, at ${\sqrt{s_{\rm
NN}}}$ larger than 10 GeV, we observed the opposite behaviors, namely all
hadrons’ $v_{2}$ are positive while all slopes of $v_{1}$ are negative. In the
Au+Au collisions at 3 GeV, the observed opposite behavior implies the
vanishing of partonic collectivity and a new EoS dominated by the baryonic
interactions in these region.

Figure 4: $v_{1}$ slope $dv_{1}/dy|_{y=0}$ (left) and $v_{2}$ (right) along
with ${\sqrt{s_{\rm NN}}}$ in heavy-ion collisions v1v2_experiment .

##  5 Summary

In Au+Au collisions at 3 GeV, our result suggests that the strangeness
production mechanism may be different compared to that in high energies. The
collective flow behaviors show an opposite trend to that in high energies.
These results imply that the matter produced in the 3 GeV Au+Au collisions is
considerably different from those at higher energies.

## References

  * (1) Y. Akiba et al., (2005) arXiv:1502.02730 [nucl-ex]; W. Busza, et al., Ann. Rev. Nucl. Part. Sci. 68, 339 (2018).
  * (2) K. H. Ackermann et al., Nucl. Instrum. Meth. A 499, 624 (2003); M. Anderson, Nucl. Instrum. Meth. A 499, 659 (2003); W. J. Llope, Nucl. Instrum. Meth. A 661, S110 (2012); I. Kisel (CBM), J. Phys. Conf. Ser.1070, 012015 (2018).534
  * (3) A. Foerster et al., (KaoS), J. Phys. G 28, 2011 (2002); L. Ahle et al., (E866/E917), Phys. Lett. B 490, 53 (2000); Phys. Lett. B 476, 1 (2000); C. Alt et al. (NA49), Phys. Rev. C 77, 024903 (2008); Phys. Rev. C 66, 054902 (2002); L. Adamczyk et al., (STAR), Phys. Rev. C 96, 044904 (2017); (Theory) Acta Phys. Pol. B 30, 2705 (1999); Phys. Lett. B, 673, 142 (2009).
  * (4) B. B. Back et al., (E917), Phys. Rev. C 69, 054901 (2004); C. Alt et al., (NA49), Phys. Rev. C 78, 044907 (2008); J. Adam et al., (STAR), Phys. Rev. C 102, 034909 (2020); P. Gasik et al., Eur. Phys. J. A 52, 177 (2016); K. Piasecki et al., (FOPI), Phys. Rev. C 91, 054904 (2015); G. Agakishiev et al., (HADES), Phys. Rev. C 80, 025209 (2009); Phys. Lett. B 778, 403 (2018); Phys. Rev. Lett. 103, 132301 (2009).
  * (5) J. Brachmann et al., Phys. Rev. C 61, 024909 (2000); L. Adamczyk et al., (STAR) Phys. Rev. C 88 14902 (2013); Phys. Rev. C 103, 034908 (2021); J. Barrette et al., (E877) Phys. Rev. C 56, 3254-3264 (1997); P. Chung et al., (E895), Phys. Rev. Lett. 85, 940 (2000); A. Andronic et al., (FOPI) Phys. Lett. B 612, 173 (2005).