G AUGE E QUIVARIANT S PHERICAL CNN S
Anonymous authors
Paper under double-blind review
A BSTRACT
Spherical CNNs are convolutional neural networks that can process signals on the sphere, such as global climate and weather patterns or omnidirectional images.
Over the last few years, a number of spherical convolution methods have been proposed, based on generalized spherical FFTs, graph convolutions, and other ideas.
However, none of these methods is simultaneously equivariant to 3D rotations, able to detect anisotropic patterns, computationally efﬁcient, agnostic to the type of sample grid used, and able to deal with signals deﬁned on only a part of the sphere.
To address these limitations, we introduce the Gauge Equivariant
Spherical CNN.
Our method is based on the recently proposed theory of Gauge
Equivariant CNNs, which is in principle applicable to signals on any manifold, and which can be computed on any set of local charts covering all of the manifold or only part of it.
In this paper we show how this method can be implemented efﬁciently for the sphere, and show that the resulting method is fast, numerically accurate, and achieves good results on the widely used benchmark problems of climate pattern segmentation and omnidirectional semantic segmentation.
I NTRODUCTION
In many disciplines of science and engineering, spherical signals emerge naturally.
In the earth and climate sciences, globally distributed sensor arrays collect measurements like temperature, pressure, wind directions, and many other variables.
Cosmologists are interested in identifying physical model parameters from real and simulated cosmic microwave background measurements sampled on spherical sky maps.
In robotics, especially in applications like SLAM and visual odometry, omnidirectional and ﬁsh-eye cameras are widely used.
Thus, it is clear that efﬁcient CNNs that can directly operate on spherical signals are necessary.
When designing Spherical CNNs for these applications, there are a number of practical considerations that need to be taken into account.
Firstly, whereas planar images are always sampled on a square grid, there is a wide variety of spherical grids, and the choice of sampling grid is usually dictated by hardware or task-dependent requirements.
Secondly, several applications require the analysis of very high resolution spherical maps.
Most existing algorithms cannot handle this scale.
Thirdly, in some cases data is only available on a part of the sphere.
Fourthly, whereas several graph-based and spectral methods can only learn isotropic blob-like ﬁlters, some problems require the detection of anisotropic patterns.
Finally, in almost all cases, equivariance to rotations is a sought-after property since results should never depend on how we orient the sphere.
The method we propose in this paper is based on the recently proposed theory of Gauge CNNs (Cohen et al., 2019).
This framework has several appealing properties: (i) it provides a principled way to achieve spatial and rotational weight-sharing on the sphere, (ii) it naturally allows for processing geometric features such as scalar, vector and tensor ﬁelds in an anisotropic and equivariant manner, and (iii) it makes it possible in principle to process a signal on overlapping local charts, in case data is not available for the whole sphere or when the whole signal does not ﬁt in memory.
To the best of our knowledge, we present the ﬁrst implementation of a Gauge CNNs on a manifold with non-trivial curvature.
We describe an efﬁcient implementation which is, in principle, applicable to any grid on the sphere.
Experiments on spherical segmentation of climate patterns and omnidirectional images demonstrate the effectiveness of our method.
We show that our method is scalable and fast while being as numerically accurate as the best existing Spherical CNNs.
R ELATED W ORK
Conventional CNNs for Spherical Images.
A line of prior work (Su & Grauman, 2017; Coors et al., 2018) considers using planar CNNs on intrinsically spherical tasks such as omnidirectional image segmentation.
These approaches represent the spherical data on R 2 via equirectangular projection which introduces position-dependent distortion rates due to curvature.
In order to counteract the varying distortion rates, Su & Grauman (2017) uses kernels with increasing support towards the poles thus limiting parameter-sharing to only longitudes.
Contrastingly, Coors et al.
(2018) use ﬁxed-sized kernels sampled on the tangent plane of spherical signal for better parameter-sharing and distortion invariance.
Both methods assume a preferred orientation and are not SO(3) equivariant.
Spherical CNNs.
Another line of work operates directly on S 2 alleviating the issues related to distortions caused by projection.
Boomsma & Frellsen (2017) proposes spherical convolutions for molecular modeling in both volumetric and mesh representations.
Perraudin et al.
(2018) proposes a graph-based spherical convolution for cosmological model classiﬁcation.
A subset of this line (Kondor et al., 2018; Cohen et al., 2018; Esteves et al., 2018) extends group equivariance (Cohen &
Welling (2016)) over SO(3).
Esteves et al.
(2018) uses spherical convolutions computed by spherical
FFTs.
Similarly, Cohen et al.
(2018) proposes a spherical correlation operation based on the SO(3) -
FFT.
As a result both methods have inbuilt rotation equivariance property.
However, the Generalized
FFT algorithms used only work on inhomogeneous grids that over-sample the poles, and in practice the FFT-based methods are slow.
Recently, a number of spherical CNNs that parametrize the sphere with icosahedral tiling have been proposed (Jiang et al., 2019; Zhang et al., 2019; Liu et al., 2019;
Cohen et al., 2019).
These methods are tailored for the icosphere grid since this grid is quite regular and its charts can be easily mapped on R 2 allowing highly optimized convolution routines to be used.
Out of these methods, Gauge
Equivariant Icosahedral CNN of Cohen et al.
(2019) is the most similar to our method.
However, their model operates on the icosahedron, which is only an approximation of the sphere, while ours operates on the sphere.
Even though their method is fast and accurate, it is only equivariant to discrete icosahedral symmetries, while our method is fully SO(3)-equivariant.
In comparison to all methods in this category, our method is agnostic to sampling grid used and better suited for larger scale problems.
Geometric Deep Learning.
There have been a number of attempts to generalize convolution operator to manifolds in the geometric deep learning ﬁeld (Bronstein et al., 2017).
The key issue with manifold convolution is the lack of globally consistent reference frames attached to points over a manifold.
Therefore, unlike shifting a ﬁlter over a ﬂat image grid with a clear sense of up/down and left/right, it is not clear how to place the convolution kernel.
To overcome this issue, Bruna et al.
(2014); Boscaini et al.
(2015) have used isotropic ﬁlters at the expense of kernel expressivity.
Masci et al.
(2015) have applied ﬁlters in ﬁxed number of orientations and accumulated the responses via max pooling, losing the orientation information.
Recently proposed Gauge Equivariant CNNs (Cohen et al., 2019) have shown that it is possible to have both expressive kernels and orientation information by allowing the network response change equivariantly with respect to arbitrarily chosen local reference frames (i.e. gauges).
C ONTINUOUS T HEORY OF G AUGE CNN S
In this section we will review the mathematical theory of gauge CNNs on general manifolds, as presented in Cohen et al.
Speciﬁcally, we will deﬁne a mathematical model of feature spaces as ﬁelds, and show how one can deﬁne a convolution-like operation that only makes use of the intrinsic structure of the manifold.
3. G EOMETRICAL F EATURES & G AUGE T RANSFORMATIONS
The feature spaces in Gauge CNNs are modelled as ﬁelds f over a manifold M .
For example, the input data could be a vector ﬁeld of wind directions on earth, or a scalar ﬁeld of intensity values on the plane (a grayscale image), or a ﬁeld of diffusion tensors on R 3 .
We will refer to such quantities (scalars, vectors, tensors, and others) as geometrical features and speak of a ﬁeld of geometrical features or geometrical feature ﬁeld.
Even if the input data consists only of scalars, one might want to use other kinds of ﬁelds for the internal representation learned by the network, so we will describe Gauge CNNs for general ﬁelds.
Because we are primarily interested in the 2-sphere S 2 , we will specialize to the case of d = 2 dimensional Riemannian manifolds.
In computer science it is common to think of a vector or tensor as a list or array of numbers, but from a physical or mathematical perspective these are geometrical quantities that exist independent of a coordinatization / choice of basis.
To represent a geometrical feature numerically however, we need to choose a frame for the tangent space T p M at each position p ∈ M .
A smooth choice of frame is also known as a gauge .
Mathematically, a gauge can be deﬁned as a smoothly parameterized set of linear maps w p : R d → T p M (see Fig. 1).
takes a tangent vector V ∈ T p M and the geodesic starting at p with speed (cid:107) V (cid:107) for one unit of time to arrive at q v = exp p
Since the choice of gauge is arbitrary, we should consider what happens to the coefﬁcients of geometric features if we change it (i.e. apply a gauge transformation ).
Consider ﬁrst the coefﬁcients f ( p )
= v of a tangent vector V in the tangent space T p M at p ∈ M , expressed as a pair of numbers v = ( v 1 , v 2 ) relative to an orthogonal frame ( w p ( e 1 ) , w p ( e 2 )) at p .
If we rotate the frame at p by r ∈ SO(2) , i.e. w p (cid:55)→ w p ◦ r , then the coefﬁcient vector transforms as v (cid:55)→ r − 1 v .
The vector itself is an abstract geometrical quantity, invariant to gauge transformations: V = ( w p r ) r − 1 v = w p v .
Note that we are free to change the gauge not just at one point, but at all positions simultaneously in an arbitrary (smooth) way.
However, since we will only want to work with right-handed orthogonal frames, we only need to consider rotations of the frames.
Thus, for our purposes we can deﬁne a gauge transformation as a smoothly varying choice of rotation
r p ∈ SO(2) .
Beyond scalars (which are invariant to gauge transformations) and vectors (which transform like f ( p ) (cid:55)→ r − 1 p f ( p ) ), we will want to consider more general kinds of geometrical features.
A (2 , 0) - tensor, for instance, is (a linear combination of) tensor products V ⊗ W of vectors V, W ∈ T p M .
Given a frame, such a tensor is represented as a d × d matrix.
Under a change of frame, a matrix f ( p ) will transform like f ( p ) (cid:55)→ r p f ( p ) r − 1 p .
We can also ﬂatten the matrix into a d 2 -dimensional coordinate vector f ( p ) , and write the transformation as f ( p ) (cid:55)→ ( r p ⊗ r p ) f ( p ) , where r p ⊗ r p is the
Kronecker product.
The tensor product ρ ( r ) =
r ⊗ r is an example of a group representation.
This is a map ρ : G →
GL( C, R ) taking each element r of G (the rotation group SO(2) in our case) to an invertible matrix ρ ( r ) that acts on an C -dimensional feature vector.
To be called a representation, it has to satisfy ρ ( rr (cid:48) )
=
ρ ( r ) ρ ( r (cid:48) ) , which is easily checked for the tensor / Kronecker product.
Thus, we can generalize to geometric feature ﬁelds that transform like f ( p ) (cid:55)→ ρ ( r − 1 p ) f ( p ) under gauge transformations, for any group representation ρ of SO(2) .
We will refer to such ﬁelds as a ρ -ﬁeld or a ﬁeld of type ρ .
In a gauge equivariant CNN, one chooses for each feature space of the network such a representation ρ that determines the kind of features learned by that layer.
The network is constructed such that a gauge transformation applied to the input will result in a corresponding gauge transformation in each feature space.
The dimension C of ρ is equal to what is normally called the number of channels in the feature space.
Typically, one would choose ρ to be block-diagonal, containing for instance a number of scalar ﬁelds ( 1 × 1 blocks ρ i ( r ) = 1 ), a number of vector ﬁelds, etc.
The number of copies of each type of feature is called its multiplicity.
3. G AUGE E QUIVARIANT C ONVOLUTION
For each layer of the network, we want to interpret both the input and output as ﬁelds of geometrical features.
If we apply a gauge transformation, the input coefﬁcients change ( f ( p ) (cid:55)→ ρ ( r − 1 p ) f ( p ) ), and we want the same to happen to the output ( gauge equivariance ), so that we may interpret it as the coefﬁcients of a geometrical quantity relative to a gauge.
In this section we will deﬁne a convolution-like operation that has this property.
The classical convolution operation involves summing or integrating the product of a ﬁlter and the input signal over a local region.
If we want to generalize this to ﬁelds on a manifold, we run into a difﬁculty: the geometric feature f ( p ) and f ( q ) at different points p and q in M live in a different vector space, and so we cannot directly compare them or add them up.
For instance, if we have two tangent vectors V ∈ T p M and W ∈ T q M , how can we say that they are “the same” or add them up?
Having chosen a frame for T p M and T q M we could add the coordinate vectors v ∈ R 2 and w ∈ R 2 , but because we can change the gauge of both tangent spaces independently, the result is not the coefﬁcient vector of any invariant geometrical quantity.
The solution is to apply parallel transport to the feature vectors before adding them up.
Given a curve from q to p , we can transport a vector W ∈ T q M to T p M by applying a rotation r p ← q ∈ SO(2) to its coefﬁcient vector w .
Since we can interpret r p ← q w as a vector in T p M , the quantity v + r p ← q w is well-deﬁned.
In general, for other kinds of geometrical features, parallel transport acts via ρ , i.e. we can add v + ρ ( r p ← q ) w .
We will use this in the deﬁnition of the gauge equivariant convolution.
Following Masci et al.
, we parameterize a local neighborhood around p ∈ M by the tangent plane T p M (cid:39) R 2 via exponential map (see Fig. 1).
That is, we index nearby points q by tangent vectors using the exponential map, by deﬁning q v = exp p
w p v for v ∈ R 2 (“Riemannian normal coordinates”).
The convolution is then deﬁned by transporting for each nearby point q v the feature vector f ( q v ) to p by computing ρ ( r p ← q v ) f
( q v ) , transforming the resulting features at p using a learned kernel K : R 2 → R C out × C in , and integrating the result over the support of K in R 2 :
[Equation]
As shown by Cohen et al.
, this operation is gauge equivariant if and only if K ( v ) satisﬁes
[Equation]
In section 4.2 we show how we can parameterize such a kernel via rotational weight-sharing.
3. E QUIVARIANCE TO SO(3)
In addition to gauge equivariance, SO(3) equivariance is a desirable property for a Spherical CNN (Cohen et al., 2018).
This means that if we apply a 3D rotation to the input of the network, the output is also rotated.
In this section we show that the gauge equivariant convolution as deﬁned is also equivariant to SO(3) .
Consider a local patch on the sphere (e.g. the support of the kernel), and the signal deﬁned there.
When we rotate the sphere, the patch is moved to another place, and it may change its orientation.
Moving the patch is not a problem: at the new position we apply the same kernel K , so one expects that the convolution result at the new position equals the convolution result of the original signal at the old position.
However, since the orientation of the kernel is determined by the gauge (which is arbitrary but ﬁxed) and because we can arbitrarily change the orientation of the patch by rotating around its center, the kernel and the patch may be matched in a different relative orientation after applying the rotation.
Fortunately, because the kernel satisﬁes Eq. 2, the result will be equivalent up to a gauge transformation acting by ρ out , and so we have SO(3) equivariance.
Thus, in the continuous theory, the gauge equivariant convolution is also SO(3) equivariant.
However, as we will see, making sure that this holds in a discrete implementation is not entirely trivial.
D ISCRETE I MPLEMENTATION OF S PHERICAL G AUGE CNN S
The theory covered so far tells us how, mathematically, we can deﬁne a convolution-like operation that is gauge equivariant.
However, it does not tell us exactly how to implement it on a computer, in order to process discretely sampled signals on a manifold.
How we do this exactly can have a large effect on the efﬁciency and numerical accuracy of the method.
A signal is represented as a list of values f i
= f ( p i ) associated with a ﬁnite number of points
p i ∈ V ⊂ S 2 (see Sec. 4.1).
We assume that the kernel K ( v ) has local support, so K ( v )
=whenever (cid:107) v (cid:107) >
R for some radius R .
Equivalently, we can say that q ∈ S 2 only contributes to the convolution result at p ∈ S 2 if the geodesic distance between p and q is smaller than R .
Accordingly, we deﬁne the set of neighbors N ( p ) of p as the set of points q within radius R from p .
A simple way of discretizing the gauge convolution (Eq. 1) is to replace the integral over R 2 (identiﬁed with T p M ) by a sum over neighbors of p .
Each neighbor can be associated with a tangent vector via the logarithmic map: v pq = log p q .
This yields the following approximation:
[Equation]
At this point it is worth comparing Eq.
3 to the simplest form of message-passing based graph convolution (Kipf & Welling, 2017; Gilmer et al., 2017).
In both cases, the result of convolution is computed as a sum of messages comming from neighbors.
In the case of graph CNNs, these messages are computed as Af ( q ) , where A is a weight matrix that is shared by all neighbors.
So graph convolutions use isotropic ﬁlters that cannot distinguish where the message comes from.
The gauge convolution sums messages of the form K ( v pq ) ρ in ( r p ← q ) f ( q ) .
Thus, the feature vectors f ( q ) of neighbors q are transformed in a way that depends i) on the intrinsic geometry of the manifold via r p ← q and v pq , and ii) by a non-isotropic (but gauge-equivariant) learnable kernel K ( v pq ) .
We can thus think of gauge convolutions (implemented in this way) as a more powerful version of graph convolution that leverages the additional topological and metric structure of a Riemannian manifold to process geometrical data in a more ﬂexible manner.
The discrete gauge convolution is computed in a few steps, some of which are done during precomputation and some during the forward pass: i) the logarithmic map v pq = log p q , ii) the parallel transporter r p ← q , iii) the construction / parameterization of the kernel K ( v ) iv) the linear contraction of
the
kernel and
the signal. Steps (i) and (ii) can be complicated for a general manifold or mesh, but for the sphere are easily and exactly computable in closed form with standard operations, which are detailed in Appendix B. We will discuss our method for selecting the ﬁnite number of points on the sphere, as well as steps (iii) and (iv) in the following sections.
4. T HE I COSPHERE G RID
Even though our method uses the exact geometry of the sphere, a grid of points on the sphere must nevertheless be chosen on which the features will live.
The sphere does not admit perfectly symmetrical and homogeneous high resolution grids.
A grid that is fairly homogeneous and has been used successfully in Spherical CNNs before is what we call the icosphere grid (Jiang et al., 2019; Liu et al., 2019; Cohen et al., 2019).
The icosphere grid can be computed at different levels of resolution.
The lowest resolution s =has as points
p i the 12 corners of the icosahedron.
Higher resolutions are obtained by repeated subdivision of the triangular faces of the icosahedron into 4 sub-triangles, followed by a projection of all points to the sphere.
The result is a grid H s with 5 × 2 2 s +1 +points at subdivision level s .
We emphasize that our method is not in any way tailored to this grid, and other options such as HEALPix (G´orski et al., 2005) could easily be substituted
4. P ARAMETERIZATION OF THE KERNEL
The kernel K ( v ) is deﬁned as a continuous matrix-valued function of R 2 that satisﬁes the kernel constraint (Eq. 2).
In a classical CNN, where we are dealing with a homogeneous grid of pixels in R 2 , we can deﬁne a small (e.g. 3 × 3 ) set of neighboring pixels N ( p ) =
{ p + v ( i ) } i so that we only ever need to evaluate the kernel at a small number (e.g. 9 ) of points v ( i ) .
This results in a parameterization of K as an array with C out × C in × 3 × 3 learnable coefﬁcients.
On the sphere there are no perfectly homogeneous grids, so depending on the point p ∈ V where we are evaluating the convolution ψ (cid:63) f , the neighborhood structure N ( p ) may look quite different.
Hence, the points v pq ∈ R 2 where we need to evaluate K will differ as well.
For this reason, we parameterize K as a linear combination of analytically determined continuous basis kernels.
The linear coefﬁcients will be learned.
We assume that ρ in and ρ out are block-diagonal with irreducible representations (irreps) as blocks (any SO(2) representation can be brought to this form by a change of basis).
In this case the kernel takes on a block structure as well, with each block corresponding to a particular input/output irrep (Cohen & Welling, 2017), with irreps labelled by integer frequency n ≥
(Worrall et al., 2017)
(see
Appendix D).
So we will focus on the case where both input and output representation consist of a single irrep, and construct the full kernel block-wise as described in Appendix A.
As derived in Appendix D, the analytical solutions to Eq.
2 can be split in a independent radial part and angular part.
The solutions for the angular part K ( θ ) are shown in Table 1, while the radial part is unconstrained.
So if a set of radial functions { R a ( r ) } are chosen, and { K b ( θ ) } is the complete set of angular solutions, the parameterized kernel is: K ( r, θ ) =
(cid:80) ab w ab R l ( a ) K b ( θ ) for weights w .
Hereafter, we denote one such solution as K i , so that the parameterized kernel is (cid:80) i
w i
K i .
The number of basis-kernels is called num_basis .
[Table]
We denote
[Equation]
Since the geometry and grid are ﬁxed, we can precompute the basis kernels evaluated at all required points.
That is, for each p ∈ V and q ∈ N ( p ) we evaluate each basis kernel contracted with the input representation K i ( v pq ) ρ in ( r p ← q ) where r p ← q and v pq are as computed in Section B. and B.2.
The result of this precomputation is an array of shape num_basis × num_v × num_neigh × c_out × c_in , where c_in and c_out are the dimensionality of ρ in and ρ out and also the number of channels of the input and output signals.
4. C OMPUTING THE CONVOLUTION
Having computed the basis kernels at each v pq , we can compute the discretized gauge convolution (Eq. 3) as a linear contraction.
This is done in two steps.
Initially, we expand the signal f ( p ) , which has shape num_v × c_in , to ˆ f of shape num_v × num_neigh × c_in .
This is done so that ˆ f pq is the value of the signal at the q -th neighbor of p .
Subsequently, we contract the signal ˆ f with basis kernels K i ( v pq ) ρ in ( r p ← q ) and weights w i to obtain the convolution result ψ (cid:63) f of shape num_v × c_out .
Since a basis-kernel K i only acts on one in/out irrep pair, it is mostly zero.
In Appendix A, we detail how this block-sparsity can get exploited for computational efﬁciency.
We note that ψ (cid:63) f can easily be computed for a subset V ⊂ V .
4. N ONLINEARITIES
For the network to be gauge equivariant, every layer should be gauge equivariant, including nonlinearities.
Irrep features do not commute with pointwise nonlinearities (Worrall et al., 2017;
Thomas et al., 2018; Weiler et al., 2018; Kondor et al., 2018).
However, we can perform a basis transformation to a basis in which pointwise non linearities are approximately gauge equivariant.
Afterwards, we transform the basis back to the irreps.
For simplicity, we assume that the representation is U copies of ρ 0 ⊕ ρ 1 ⊕ ... ⊕ ρ M .
One such copy can be treated as the discrete Fourier modes of a circular signal with band limit M .
An inverse Discrete
Fourier Transform (DFT) matrix can map these modes to N spatial samples.
Under a gauge transformation of a multiple of 2 π/N , the samples are cyclically shifted.
The resulting representation can thus be called a regular representation and hence our procedure a RegularNonlinearity .
Non linearities that act pointwise on these samples, such as the ReLU, commute with such gauge transformations.
The procedure is however only approximately gauge equivariant under gauge transformations of angles that are not multiples of 2 π/N .
Nevertheless, we prove in Appendix E that in [Figure]
[Figure] [Figure] [Figure] [Figure]
[Figure] p interpolation qqc c o n v o l u t i o n the limit N → ∞ , exact equivariance is restored and we provide a ﬁnite error bound, which can help selecting N .
Q UADRATURE I NTEGRATION
The implementation described in the previous section satisﬁes gauge equivariance exactly.
In addition to gauge symmetry, the sphere has global rotational / SO(3) symmetry, and like previous methods we would like our method to be equivariant to 3D rotations as well.
In the continuous case, gauge equivariance implies SO(3) equivariance, but the scheme above is not exactly SO(3) equivariant due to discretization (see Figure 3a).
In this section we describe a numerical method that improves SO(3) equivariance at no additional computational cost during training.
Our general approach for computing ψ (cid:63) f ( p ) will be to interpolate the sample values at N ( p ) to obtain a continuous function on R 2 , and then use quadrature integration to get a more precise value for the integral.
Quadrature is a general numerical technique for approximating integrals with ﬁnite sums.
For some region A and function g , the integral (cid:82) A g ( x ) dx can be approximated by (cid:80) x ∈I ω x g ( x ) , where I ⊂ A is some ﬁnite set of quadrature points , each with a weight ω x .
The goal is selecting I and ω x such that the approximation is accurate (or even exact), for functions g satisfying some regularity assumptions (e.g. being band-limited).
In our case, the region A is a disk with as radius the support radius R of the kernel.
The quadrature rule is described in Appendix C.
The signal at c ∈
I is inferred from the signals at N ( p ) by interpolation:
[Equation]
where k ( c, q ) =
exp ( −|| c − log p ( q ) || 2 /σ 2 ) is a Gaussian kernel with scale σ , measuring distance between c and q in the tangent space, and Z ( p, c )
= (cid:80) q ∈N ( p ) k
( c, q ) is a normalizing constant.
We can now compute the integral over R 2 by quadrature integration:
[Equation]
The convolution Eq.
5 sums over a homogenized neighborhood and is thus more equivariant to rotations of the sphere.
See Figure 3b for an illustration.
Equivariance improves if a large number of quadrature points are used, which increases the computational cost.
Luckily, since the composition of linear operations is linear, we simplify:
[Equation]
for a new kernel ˆ K ( p, q ) = (cid:80) c
∈I p ω c k ( c,q ) Z ( p,c ) K ( c ) ρ in ( g p ← q ) .
The new kernel ˆ K can be pre-computed once, so that the convolution during run-time involves only a sum over the neighbors, just as in the naive convolution (Eq. 3).
The interpolation thus does not affect computational cost.
E XPERIMENTS
In this section, we present experimental results on three benchmark problems.
Throughout this section, we will refer to the gauge equivariant convolutions described in 4.3 as IrrepConvolution and similarly refer to tailored batch normalization and nonlinearities as IrrepBatchNorm (normalizing irreps instead of channels) and RegularNonlinearity as we name in our implementation.
An IrrepConvolution and other operations are deﬁned by specifying the number of input and output multiplicities for each irrep order, in analogy to number of channels in regular CNNs.
In addition, we need to specify the types of irreps by their angular frequency.
We do that by max freq argument which determines the cutoff frequency.
We will describe ρ by a parameter max freq and multiplicity, and include each frequency 0 , . .
max freq with the same multiplicity.
6. S PHERICAL MNIST
We perform a series of experiments on a toy dataset to validate the equivariance and generalization properties of our gauge-equivariant spherical CNN.
Speciﬁcally, we compare our method with different ﬁlter sizes (1-ring, 2-ring) with and without interpolation, to three prior methods, as well as an isotropic baseline.
The isotropic baseline uses only scalar features and isotropic kernels, but is similar in number of parameters to our model.
We follow a setup similar to that of Cohen et al.
and generate Spherical MNIST in randomly
Rotated (R) and Non-rotated (N) conditions.
For all experiments, we represent the signals on an icospherical grid at level s = 4 .
For network architecture and training procedure, see Appendix F.1.
We present our results in Table 2 on three conﬁgurations of the Spherical MNIST dataset: N/N, N/R and R/R, where X/Y means we train on X and test on Y.
In addition, we run an ablation study to test the effect of quadrature integration on equivariance.
Whether interpolation is used or not, our method performs similarly to two relevant spherical CNN baselines in terms of classiﬁcation score on N/N.
We observe that our method automatically generalizes to 3D rotations without data augmentation and thus compares favorably against IcoCNN in the N/R condition.
However, in the ablation study, we observe that our method’s generalization capability against 3D rotations drops in the absence of interpolation, particularly when smaller (1-ring) ﬁlters are used.
This result shows the usefulness of quadrature integration when using small ﬁlters.
Our model outperforms FFS2CNN in all categories.
Furthermore, it performs better than the isotropic baseline, which illustrates the importance of anisotropic ﬁlters and non-scalar features for the MNIST dataset.
This is to be expected, as detection of line direction is naturally expressed in anisotropic ﬁlters.
As a ﬁnal note, our results conﬁrm the theoretical result that gauge equivariance implies SO(3) - equivariance (Sec. 3.3).
6. C LIMATE P ATTERN S EGMENTATION
We put our model to the test on a climate pattern segmentation dataset proposed by Mudigonda et al.
The dataset is collection of simulated climate variables over 20 years from the Community
Atmosphere Model CAM-5.
(Neale et al., 2010).
The task is to segment out regions of Atmospheric
Rivers (AR) and Tropical Cyclones (TC) from background (BG).
We use the preprocessed data [Table] Isotropic (2-ring, interpolation) [Table]
Ours (1-ring, interpolation)
[Table] Ours (2-ring, interpolation) [Table] Ours (1-ring, no interpolation)
[Table]
Ours (2-ring, no interpolation)
[Table]
released by Jiang et al.
(2019) as is. The data consist of 16 channels sampled on an icospherical grid at level s = 5 (i.e. 10242 vertices).
For this experiment, we use a residual U-Net architecture.
Our residual blocks contain two blocks of [ IrrepConvolution , IrrepBatchNorm , RegularNonlinearity ] and a skip connection.
We set the multiplicity to 2 at the input resolution s = 5 and ﬁx max freq = 2 throughout.
The rest of the encoder stream progressively reduces the grid resolution down to s = 0 while doubling the multiplicities (and thus the number of channels) every time the resolution is decreased, resulting in 196 channels.
The decoder stream is mirror-symmetrical to the encoder, replacing downsampling layers with upsampling layers.
We use 2 residual blocks at each resolution level.
The network is trained for 60 epochs with an initial learning rate of 0 .
01 which is reduced by a factor of 0 .
4 every 30 epochs.
Batch size is 64.
We use a weighted cross-entropy loss, due to class imbalance following the setup of Jiang et al.
(2019), with Adam optimizer (Kingma & Ba, 2015).
In Table 3, we present our results.
Our model compares favorably against the two spherical CNNs that have reported results on this dataset (Jiang et al., 2019; Zhang et al., 2019).
Both methods operate on the same icospherical grid as our method.
Our method is on par with the Icosahedral
CNN of Cohen et al.
on accuracy while signiﬁcantly outperforming on the more relevant mAP metric.
We attribute this gain to the fact that our model reﬂects the geometry of the signal more faithfully than IcoCNN which operates on an approximated sphere, namely, icosahedron.
6. O MNIDIRECTIONAL S EMANTIC S EGMENTATION
Next, we run our model in omnidirectional semantic segmentation task.
For this experiment, we use Stanford 2D3DS dataset which consists of 1413 omnidirectional RGBD images acquired indifferent locations with labels of 13 semantic categories.
We are following the experimental setups in (Jiang et al., 2019; Cohen et al., 2019) and report averages over 3 cross-validation splits.
We use a residual U-Net similar to what is described in 6.2.
The only difference is that we use 4 residual blocks per resolution instead of 2.
We train the network using weighted cross-entropy loss and Adam optimizer for 100 epochs.
We set batch size to 16 and initial learning rate to 0 .
Learning rate is reduced by a factor of 0.7 every 20 epochs.
We report our results in Table 4.
We observe that our rotation equivariant network performs similar to the orientation-aware network of Zhang et al.
(2019) while outperforming IcoCNN which is only equivariant up to discrete subgroup, A5 (i.e. icosahedral group), of SO(3).
We note that 2D3DS is acquired with a preferred camera orientation rendering an additional challenge to our equivariant model which assumes no preferred orientation.
Yet, the comparison against orientation-aware model of Zhang et al.
(2019) reﬂects the expressive capability of ours despite the disadvantage [Table]
[Table]
6. A TOMIZATION E NERGY P REDICTION
In this experiment, we test our method on molecular energy regression task given the molecular geometry and charges associated with each atom.
To this end, we use QM7 dataset (Blum &
Reymond, 2009; Rupp et al., 2012) which consists of molecules with varying number of atoms
N ( ≤ 23 ).
The molecules considered in this dataset are made up of T = 5 different elements (i.e.
H, C, N, O and S).
Each molecule is deﬁned by a tuple ( p i , z i ) with i indexing the atoms.
We follow the setup for signal representation outlined in Cohen et al.
and represent geometry of molecules with spheres, s i , of constant radius centered at atomic positions, p i , in a careful arrangement such that no two spheres intersect in a molecule.
Finally, each atom i is associated with
T -channel spherical potential functions describing atomic interactions within the molecule with U [Equation] We use a similar architecture to that of Cohen et al.
in terms of parameters.
The details of network and training is available in Appendix F.2.
Our method achieves the lowest RMSE error in comparison to the spherical baselines as shown in Table 5.
[Table]
[Table]
6. C OSMOLOGICAL M ODEL C LASSIFICATION
We test our model on cosmological model classiﬁcation task which is an interesting test bed to demonstrate our algorithm’s ﬂexibility in admitted sampling scheme and scalability aspects.
To this end, we use a dataset released by Perraudin et al.
This dataset consists of cosmological convergence maps which are generated by whole-sky N-body simulations for two different parameter settings of Λ CDM cosmological model.
Both cosmological models are simulated 30 times.
For testing, 20 simulations are held out.
The remaining 40 simulations are further split into training and validation sets of size 32 and 8, respectively. The signals are represented on HEALPix grid. We refer the reader to the original article for more information. We follow the experimental setup described in (Perraudin et al., 2018) for evaluation.
We split the maps into 12 × o 2 patches where o = 4 indexes the hierarchical level of the patches in HEALPix sampling scheme.
We then obtain signals of dimensionality ( N side /o ) 2 where N side , i.e. number of pixels on one side of HEALPix patch, is set to 2 10 . During training, we apply additive Gaussian noise with varying standard deviation, σ noise ∈ { 0 , 0 . 5 , 1 , 1 . 5 , 2 } and report results separately on each setting. The details of network architecture and training are available in Appendix F.3. The results in Table 6 show that our model performs similarly to the graph-based approach.
C ONCLUSION
We have introduced the gauge equivariant spherical CNN, which is simultaneously efﬁcient, numerically accurate, ﬂexible with respect to the pixel grid used, and which can in principle be applied to data that is deﬁned on local parts of the sphere only.
Additionally, it is the ﬁrst implementation of the theory of gauge CNNs for a manifold that is not locally ﬂat.
Our experimental results show that the method is accurate and achieves strong performance on various benchmark problems.
Moreover, our method can be adapted to work on meshes, and we plan to work on this in the future.
A I MPLEMENTATION OUTLINE
This section outlines how the Gauge equivariant convolution is implemented.
PyTorch notation is used and some details are omitted.
During pre-computation, the kernel tensor is constructed, which is used during runtime to perform the convolution.
A naive implementation would construct for each basis kernel a large matrix mapping from all input channels to all output channels.
The parametrized kernel is then obtained from contracting these with a weight vector, which has a weight for each basis kernel.
However, this stack of basis kernels would be very large for two reasons.
Firstly, since the grid is irregular, a separate copy needs to be stored for each point on the sphere.
Secondly, it is common to use irreps of low orders, but use many copies of those (so with a multiplicity larger than one), each having the same set of basis kernels.
We prevent creation of this large stack of basis kernels by exploiting the fact that each basis kernel is a very sparse linear transformation, as it only has one irrep as input and one as output, making it block-sparse.
This allows us to group the basis kernels mapping from and to the same irrep.
So we can exploit the block-sparsity and also prevent allocating a kernel basis for each multiplicity.
The kernels between two irreps can be constructed as follows.
Arguments are the orders of the input and output irreps, a set of radial activation functions, and for each point p and neighbor q , the radius and angle of the log map from p to q in the gauge at p , the parallel transport angle.
def build_kernel(order_in, order_out, radial_functions, log_map_r, log_map_angle, transport, mask): """Last four arguments are [num_v, num_neigh].
Return [num_basis, num_v, num_neigh, dim_out, dim_in]."
"" a_in = order_in * (log_map_angle - transport) a_out = order_out * log_map_angle cos_min = np.cos(a_out-a_in) cos_plus = np.cos(a_out+a_in) sin_min
= np.sin(a_out-a_in) sin_plus = np.sin(a_out+a_in) if order_in =
= 0 or order_out =
=
: ... else : angular_part
= np.array([
[[cos_min, -sin_min], [sin_min, cos_min]], [[sin_min, cos_min], = np. (log map_r) for in radial_functions]) kernel = np.einsum( 'rpq,pq,bijpq->brpqij', radial_part, mask, angular_part)
Given such kernels for all irrep orders, we subsequently can deﬁne the gauge equivariant convolution.
Basically, we iterate over each irrep in the in dimension and each irrep in the out dimension.
For each block, we have m in ∗ dim ( order in ) input dimensions and m out ∗ dim ( order out ) output dimensions.
x = ...
# [num_batch, num_v, c_in]
# The layout of the channels is: # cat(flatten((irrep order, irrep multiplicity, irrep dimension)))
neighbors = ...
# [num_v, num_neigh] reps_in =
# 4 irreps of order 0, 4 of order reps_out =
# 4 irreps of order 0, 3 of order kernels = ...
# {(order_out, order_in): [num_basis, num_v, num_neigh, d_out, d_in]}  # One weight for each: # in/out irrep * number of basis kernels * multiplicities in/out weights = torch.randn(sum( len(kernels[(order_out, order_in)])
* m_out * m_in for order_out, m_out in reps_out for order_in, m_in in reps_in))
# Neighborhood expansion x_e
= x[:, neighbors] num_batch, num_v, num_neigh, c_in =
x_e.shape  # Dimension of representation of order l dim =
lambda order: 1 if order =
= 0 else  c_out = sum(dim(l) * m for l, m in reps_out)
y = torch.zeros(num_batch, num_v, c_out) y_idx
= w_idx =
# Iterate over in irreps. Concatenate over out irreps for order_out, m_out in reps_out: x_idx = for order_in, m_in in reps_in: # Sum over in irreps k = kernels[(order_out, order_in)]
x_rep =
x_e
[:, :, :, x_idx:x_idx + m_in * dim(order_in)] \ .view(num_batch, num_v, num_neigh, m_in, dim(order_in))
w_rep =
weights[w_idx:w_idx + len(k) * m_out * m_in] \ .view(len(k), m_out, m_in)
y[:, :, y_idx:y_idx + dim(order_out) * m_out] += torch.einsum( 'uvb,bpqij,npqvj >npui _rep, x_rep) x_idx m_in dim order_in) idx len m_out m_in y_idx dim order_out) * m_out return y
B S PHERICAL G EOMETRY
To compute the logarithmic map at p whose exponential map lands at q , and to compute the parallel transporter from q to p along a geodesic, we do the following. B. P ARALLEL TRANSPORTERS Since r p ← q is a planar rotation, it is determined by where it sends a single (non-zero) vector. We take
the ﬁrst basis vector b q 1 = w q ((1 , 0)) and express it in 3D Euclidean coordinates. We then rotate this vector by the angle ∠ ( p, q ) =
arccos (cid:104) p, q (cid:105) between p and q around the axis p × q which is orthogonal to the pq plane.
The resulting vector lies in the tangent plane at p .
Then r p ← q is determined as the angle between this vector and the ﬁrst basis vector b p 1 = w p ((1 , 0)) in T p S 2 .
We precompute the transport angles for every point p in the grid V and every q ∈ N ( p ) .
This results in an array of angles of size num_v × num_neigh where num_v = |V| and num_neigh =
max p ∈V |N ( p ) | is the maximum neighborhood size.
For nodes with a non-maximal number of neighbors, we pad with zeros.
B. L OGARITHMIC MAPS
For each p ∈ V and q ∈ N ( p ) we need to compute v pq = log p q , which is the vector in T p S 2 that points in the direction of q and has length equal to the geodesic distance between p and q .
One way to compute the log map is to project the 3 dimensional vector pointing from p to q to the tangent plane.
This is done by subtracting from q − p the component parallel to the p vector, as the p vector is orthogonal to the tangent plane at p .
This produces a vector ˜ v ∝ ( q − p ) − (cid:104) p, q − p (cid:105) p = q − (cid:104) p, q (cid:105) p which has the right direction.
Then one can scale the length of ˜ v so that it matches the geodesic distance d ( p, q ) (the arclength):
[Equation]
We express the result v pq = log p q in polar coordinates relative to the gauge at p .
This gives two arrays log_map_r (the length / radial coordinate of v ) and log_map_angle (the angular part of v , relative to the gauge at p ).
Both are shaped num_v × num_neigh as before.
Since the geometry and grid are ﬁxed, these arrays are computed only once before training.
C Q UADRATURE
The goal of selecting the quadrature points and weights is to approximate an integral (cid:82) D g ( x ) dx , where D ⊂ R 2 is the unit disk, with a ﬁnite sum (cid:80) x ∈I w x g ( x ) , for a set of points I ⊂ D and each with weight w x .
We use a simple method of selecting I and w x .
We desire a rotational symmetry, so the points lie on N R radial rings, each with N Θ points.
First, we use Gauss-Legendre quadrature (Hildebrand, 1987) to obtain N R quadrature points u with weights w u over the interval [ − 1 , 1] .
We map this to radial weights and points by r = (cid:112) ( u + 1) / 2 , w r = w u / 2 .
For the angular component, we take a uniform grid of N Θ points on ( − π, π ] .
The integration points on the disk are then x = ( r, θ ) with weights w x = w r /N Θ .
This gives accurate integration, because points ( u + 1) / 2 and weights w u / 2 create a quadrature scheme on [0 , 1] .
The square root creates a uniform polar grid, as the integration measure for the disk is rdrdθ = dudθ/ 2 .
D S OLVING THE SO(2) K ERNEL C ONSTRAINT
m, n d ( ρ m ⊗ ρ n ) Linearly independent solutions for K ( θ ) 0,  0, n (cid:18) [Equation] n n
[Equation]
) m [Equation] [Equation] m m
[Equation]
(cid:18)
[Equation] (cid:19) , (cid:18) [Equation] (cid:19) m, n  
[Equation]
m n [Equation] m m [Equation]
n m n   (cid:18) c
[Equation]
s
[Equation]
c
[Equation]
(cid:19)
[Equation]
(cid:18)
[Equation]
c
[Equation]
c
[Equation]
s − (cid:19) , (cid:18) c
+ s + s + − c
+ (cid:19) , (cid:18) − s + c + c
+ s + (cid:19)
Consider a kernel K a function on the tangent space T p M , such that for all v ∈ T p M , K ( v ) is a linear map from features in representation ρ out to features in a representation ρ out .
This kernel is equivariant if ∀ v ∈ T p M and ∀ g ∈ SO(2) the following kernel constraint is satisﬁed:
[Equation]
We immediately see that this constraint is independent for each radius, so we can solve the constraint independently for each radial ring, giving rise to the angular constraint on each ring:
[Equation]
where we note that the circle equals SO(2) and the action of SO(2) on itself is simply an addition of angles.
Any representation ρ can be written as equivalent to a direct sum of the irreducible representations (irreps) of SO(2) , which are the following, indexed by their order n ∈ N :
[Equation]
This means that for any representation ρ , we can always ﬁnd an invertible matrix A such: ∀ g : ρ ( g ) =
A − 1 block diag( ρ n 1 , ...ρ n N ) A , where { n 1 , ..., n N } indicate the orders of the constituent irreps.
Hence, we can solve the angular kernel constraint (Eq. 9) for two irreps, ρ in = ρ n and ρ out = ρ m , and construct the solution for general representations ρ in and ρ out from the obtained solutions.
Noting that all irreps are orthogonal in our chosen basis are orthogonal, so that ρ n ( g ) T = ρ ( − g ) , we see that, introducing explicit indices:
[Equation]
As this equation is ought to be satisﬁed for any g ∈ SO(2) and SO(2) is a one-dimensional Lie group, we can equivalently require it to be satisﬁed by an inﬁnitesimal element of SO(2) close to the identity, creating an ordinary differential equation:
[Equation]
n ) K ( θ ) , where d ( ρ m ⊗ ρ n ) :=
[Equation]
For various m, n , we can construct ( ρ m ⊗ ρ n )( g ) , take the derivative with respect to g and set g to 0 to obtain the matrix d ( ρ m ⊗ ρ n ) .
Subsequently, any computer algebra system can solve the ODE.
The solutions can be found in Table 7.
Now, for a general ρ in ( g ) =
A − 1 block diag( ρ n 1 , ...ρ n N )( g ) A , ρ out ( g ) =
B − 1 block diag( ρ m 1 , ...ρ m M )( g ) B , a general solution has the form:
[Equation]
where K m,n ( θ ) is a solution from Table 7 mapping from irrep ρ n to ρ m .
For each in/out irrep pair, we get a linear solution space of 1, 2 or 4 dimensions.
For general ρ in , ρ out , the solution space is the product of the solution spaces of each in/out irrep pair.
A parameterized kernel can thus be constructed by assigning a weight to each independent solution of each in/out irrep pair.
E E QUIVARIANCE E RROR B OUNDS ON R EGULAR N ON -L INEARITY
The regular non-linearity acts on each point on the sphere in the following way.
For simplicity, we assume that the representation is U copies of ρ 0 ⊕ ρ 1 ⊕ ... ⊕ ρ M .
One such copy can be treated as the discrete Fourier modes of a circular signal with band limit M . We map these Fourier modes to N spatial samples with an inverse Discrete Fourier Transform (DFT) matrix. Then apply to those samples a point-wise non-linearity, like ReLU, and map back to the Fourier modes with a Discrete
Fourier Transform Matrix.
This procedure is exactly equivariant for gauge transformation with angles multiple of 2 π/N , but approximately equivariant for small rotations in between.
In equations, we start with Fourier modes x 0 , ( x α ( m ) , x β ( m ))
Bm =1 at some point on the sphere and result in Fourier modes z 0 , ( z α ( m ) , z β ( m ))
Bm =1 .
We let t = 0 , ..., N − 1 index the spatial samples.
[Equation]
Note that Nyquist’s sampling theorem requires us to pick N ≥ 2 B + 1 , as otherwise information is always lost.
The normalization is chosen so that z α ( m ) =
x α ( m ) if f is the identity.
Now we are interested in the equivariance error between the following two terms, for small rotation δ ∈ [0 , 1) .
Any larger rotation can be expressed in a rotation by a multiple of 2 π/N , which is exactly equivariant, followed by a smaller rotation.
We let z FTα ( m ) be the resulting Fourier mode if ﬁrst the input is gauge-transformed and then the regular non-linearity is applied, and let z TFα ( m ) be the result of ﬁrst applying the regular non-linearity, followed by the gauge transformation.
[Equation]
where we deﬁned for convenience
c m ( t ) = cos(2 πmt/N ) .
We deﬁne norms
|| x
|| 1 =
| x 0 | + (cid:80) m
( | x α ( m ) | + | x β ( m ) | ) and || ∂x
{+|| 
+}
= (cid:80) m m ( | x α ( m ) | + | x β ( m ) | ) .
Theorem 1.
If the input x is band limited by B , the output z is band limited by B (cid:48) , N samples are used and the non-linearity has Lipschitz constant L f , then the error to the gauge equivariance of the regular non-linearity bounded by:
[Equation]
which goes to zero as N → ∞ .
Proof.
First, we note, since the Lipschitz constant of the cosine and sine is 1:
[Equation]
Then:
[Equation]
So that ﬁnally:
[Equation]
The sinus component | z FTβ ( m ) − z TFβ ( m ) | has the same bound, while | z
FT−
[Equation]
| = | y ( t + δ ) − y ( t ) | , which is derived above.
So if z is band-limited by B (cid:48) :
[Equation]
{+Since || ∂x || 
+}
= O
( B || x || 1 ) , we get ||
{+z FT − z TF || 
+}
= O ( BB (cid:48)
+ B (cid:48)
2 N || x
|| 1 ) , which obviously vanishes as N → ∞ .
F E XPERIMENTAL D ETAILS
In the following subsections, we provide with more details regarding experiments on MNIST, Atomization Energy Prediction and Cosmological Model Classiﬁcation.
For the MNIST experiments, we disambiguate two variants, both used with interpolation and without.
The ﬁrst variant uses only the 1-ring of 7 nearest neighbors and representations ρ 0 ⊕ ρ 1 .
This version uses three radial functions: one that covers the self-interaction and one that covers the other neighbors.
The second variant uses the 2-ring of 19 nearest neighbors and representations ρ 0 ⊕ ρ 1 ⊕ ρ 2 .
[-c − − s − s − c − (cid:19) , (cid:18) s − c − − c − s − (cid:19) , (cid:
 ) c + s + s + − c + (cid:19) , (cid:18) − s + c + c-]This version uses three radial functions: one for the self-interaction, one for the neighbors on the 1-ring and one for the neighbors on the 2-ring.
For either variant, we build a network consisting of 8 convolutional layers, with stride after eachlayers.
A stride layer selects the vertices that are present in the IcoSphere with one fewer subdivision, and divides the number of vertices by roughly 4.
The input is a scalar feature.
After convolution, the irrep features with multiplicity after each layer: [16, 16, 32, 32, 64, 64, 64, 64].
The last convolution layer maps to a scalar feature of multiplicity 64.
Then the signal is averaged over the vertices, creating a gauge invariant network.
This is then processed by 2 layer of MLP mapping to multiplicity 50 and then to the 10 classiﬁcation logits.
Nonlinearities are ReLU for scalar features and the RegularNonlinearity for all other features.
Batchnorm is used, as well as dropout with drop probability 10%.
F. A TOMIZATION E NERGY P REDICTION
Our network architecture used in this experiment is depicted in Table 8.
We use four blocks of gauge equivariant convolutions followed by batchnorm and regular nonlinearities.
We also deploy pooling / downsampling layers in blocks (1-3) to reduce the resolution of the spherical maps progressively.
Rest of the network consists of linear layers followed by batchnorm and ReLU.
We sum-pool over the atoms before the loss function (see block-7) to become invariant against permutations of them.
We train the model with batch size 32 and an initial learning rate of 1e − 3 for 30 epochs using mean-squared-error (MSE) as loss function.
The learning rate is reduced by 0 .
1 every tenth epoch.
[Table]
[Table]
[Table]
F. C OSMOLOGICAL M ODEL C LASSIFICATION
For this experiment, we use HEALpix sampling on split level o = 4 following Perraudin et al.
(2018) which covers 0 .
5% of the spherical manifold and has signal dimensionality of 65k.
For the experiments, we use a network architecture identical to the one described in (Perraudin et al., 2018) by replacing their graph convolutions with our gauge equivariant convolutions.
We elaborate the architecture in Table 9.
For each noise factor, we train an instance of this model with batch size 16 and an initial learning rate of 1e − 4 for 120 epochs.
Finally, we use Binary Cross Entropy as the loss function.
block
Operators
[Table]
[Table]
[Table]
[Table]
[Table]
[Table]
[Table]