# The Classification of Optical Galaxy Morphology Using Unsupervised Learning
Techniques

Ezra Fielding  Department of Computer Science
University of the Western Cape
Cape Town, South Africa
0000-0002-7936-0222  Clement N. Nyirenda  Department of Computer Science
University of the Western Cape
Cape Town, South Africa
0000-0002-4181-0478  Mattia Vaccari  Department of Physics & Astronomy
University of the Western Cape
Cape Town, South Africa
0000-0002-6748-0577

###### Abstract

The advent of large scale, data intensive astronomical surveys has caused the
viability of human-based galaxy morphology classification methods to come into
question. Put simply, too much astronomical data is being produced for
scientists to visually label. Attempts have been made to crowd-source this
work by recruiting volunteers from the general public. However, even these
efforts will soon fail to keep up with data produced by modern surveys.
Unsupervised learning techniques do not require existing labels to classify
data and could pave the way to unplanned discoveries. Therefore, this paper
aims to implement unsupervised learning algorithms to classify the Galaxy Zoo
DECaLS dataset without human supervision. First, a convolutional autoencoder
was implemented as a feature extractor. The extracted features were then
clustered via k-means, fuzzy c-means and agglomerative clustering to provide
classifications. The results were compared to the volunteer classifications of
the Galaxy Zoo DECaLS dataset. Agglomerative clustering generally produced the
best results, however, the performance gain over k-means clustering was not
significant. With the appropriate optimizations, this approach could be used
to provide classifications for the better performing Galaxy Zoo DECaLS
decision tree questions. Ultimately, this unsupervised learning approach
provided valuable insights and results that were useful to scientists.

###### Index Terms:

unsupervised learning, clustering, feature extraction, galaxy morphology,
astronomy

##  I Introduction

The classification of galaxy morphology is an essential component in the
investigation of galaxy formation and evolution [1]. Historically, this has
been a process which scientists have performed by hand. However, with the
advent of modern astronomical surveys, more detailed images are being produced
than scientists can manually classify [1]. Projects such as Galaxy Zoo attempt
to solve this problem by collecting classifications from volunteers over the
internet [2]. So far, these projects have been largely successful, providing
great benefits to the scientific community [3]. However, the output of modern
astronomical surveys will soon exceed human intelligence based efforts [4].
Discoveries and insights could be missed due to scientists being unable to
process the massive volume of data produced by next generation surveys, such
as the Square Kilometer Array [5, 6].

A variety of approaches have been used to address the problem of classifying
galaxy morphology. The original Galaxy Zoo project, a human based approach,
resulted in more than $4\times 10^{7}$ individual classifications for nearly
one million galaxies from the Sloan Digital Sky Survey (SDSS), collectively
provided by approximately one hundred thousand volunteer participants [2].
Subsequent projects, such as Galaxy Zoo DECaLS and Radio Galaxy Zoo, have also
found success in making use of volunteers to inspect and visually classify
galaxies [7, 1]. The results of these projects have served as the basis for
many galaxy morphology studies [3].

Despite the successes of these projects which rely solely on human
classification and inspection, as the amount of survey data in need of
classification increases, human based efforts will fail to keep up and require
too much effort and time to remain viable [4]. It would have taken the recent
Galaxy Zoo DECaLS project, with its 311,488 suitable galaxies, approximately 8
years to collect the standard 40 classifications per galaxy with the current
number of volunteers [1]. This highlights the need for classification methods
which do not rely heavily on human input.

For this reason, a significant amount of research has been done towards
implementing supervised machine learning techniques to classify galaxy
morphology. The use of artificial neural networks makes up a large portion of
this research [6]. Recent literature has shown that, provided the sufficient
availability of labeled datasets, convolutional neural networks (CNNs) are
particularly accurate and useful in the classification of astronomical objects
[8, 9, 10, 11, 12, 13, 14, 15]. Bayesian CNNs have also been used to predict
volunteer responses to decision trees to classify galaxies [1].

However, these supervised machine learning methods still require labeled data
in order to optimize and produce a usable model [4]. While there is no
shortage of data in astronomy, relevant pre-labeled data is not always
available [6]. This leaves supervised classification methods dependent on, and
constrained by, the availability of human-generated labels. Recent work has
been done on utilizing transfer learning to transfer existing models to new,
unseen datasets, but it remains to be seen how successful these methods are
and how well they scale [16, 17].

Unsupervised machine learning is of particular interest concerning the problem
of galaxy morphology classification, as it does not require existing labeled
data. Instead, it identifies and classifies data by the structure of the data
itself [18]. However, there has been significantly less work done on applying
unsupervised machine learning algorithms to galaxy morphology classification
when compared to the work done on supervised classification [6]. This suggests
that there is a need for further research in this area. Notable works applying
unsupervised learning to the domain of galaxy morphology classification
include those done by Galvin et al [4] and Ralph et al [19]. Ralph et al
propose the use of a convolutional autoencoder in combination with a self-
organizing map to cluster radio astronomical survey data in an efficient and
unsupervised manner [19]. On the other hand, Galvin et al propose the use of
PINK, a rotationally-invariant self-organizing map algorithm, to associate
radio and infrared sources without the need of existing training labels [20,
4]. Due to the unsupervised nature of these approaches, they operate without
assumptions and labeled training data. This could result in unplanned, new and
exciting discoveries in the world of astronomy [19]. There has also been work
done towards feature extraction on galaxy images, which also falls under the
umbrella of unsupervised learning. Jiménez et al propose feature extractor
methods based on autoencoders and compare them to another state-of-the-art
feature extractor called WND-CHARM [21]. The fact that these approaches, as
with all unsupervised approaches, do not require existing labels, make them
ideal to handle and process the large streams of data produced by next
generation astronomical surveys.

The majority of existing work has focused on using unsupervised learning
methods to make new and unscheduled discoveries without the need for existing
labels. Therefore, this paper aims to determine the viability and merit of
using unsupervised techniques to create clusters which conform to existing
human generated galaxy morphology classifications. In other words,
unsupervised methods will be tested to see how well they can reproduce human
classifications given the same dataset and number of classes to produce.
Features will be extracted from images used in the recent Galaxy Zoo DECaLS
project using a convolutional autoencoder [1] . Three popular clustering
methods will be considered, namely k-means clustering [22], fuzzy c-means
clustering [23], and agglomerative clustering [24]. Clusters generated from
extracted features will be mapped to existing real-world classes using the
method proposed by Zha et al [25]. The three clustering algorithms will be
compared based on how well the clusters they produce match the real-world
classes. Accuracy metrics such as precision, recall and F1-score, as well as
training time will be evaluated to determine clustering performance.

The remainder of this paper is organized as follows. A brief overview of the
autoencoder feature extractor and clustering methods used in this work is
provided in Section II. The materials and methods used in this work are
presented in Section III, while Section IV presents the results and their
discussion. A conclusion is drawn in Section V.

##  II Autoencoder and Clustering Methods Used in this Work

This work makes use of a convolutional autoencoder as a feature extractor to
reduce the dimensionality of the optical-spectrum galaxy image data. The
clustering performance of three popular clustering methods were then tested
using the extracted features. The methods considered were k-means clustering,
fuzzy c-means clustering, and agglomerative clustering. The autoencoder and
clustering methods are briefly described in the following subsections.

###  II-A Autoencoder Feature Extractor

An autoencoder is an artificial neural network with a symmetric structure
which is trained to reconstruct its input onto the output layer [26]. The
output of the first half of the network represents an encoding of the input
data. A convolutional autoencoder makes use of convolutional neural network
mechanisms to complete this task. The convolutional autoencoder used in this
work was based on the one proposed in the work of Jiménez et al for extracting
features from galaxy images [21].

Table I: Autoencoder Model Summary Section | Layer (type) |  Output Shape | Param #
---|---|---|---
Encoder | Conv2D | (None, 224, 224, 16) | 448
| MaxPooling2D | (None, 112, 112, 16) | 0
| Conv2D | (None, 112, 112, 8) | 1160
| MaxPooling2D | (None, 56, 56, 8) | 0
| Conv2D | (None, 56, 56, 8) | 584
| MaxPooling2D | (None, 28, 28, 8) | 0
| Flatten | (None, 6272) | 0
Decoder | Reshape | (None, 28, 28, 8) | 0
| UpSampling2D | (None, 56, 56, 8) | 0
| Conv2DTranspose | (None, 56, 56, 8) | 584
| UpSampling2D | (None, 112, 112, 8) | 0
| Conv2DTranspose | (None, 112, 112, 8) | 584
| UpSampling2D | (None, 224, 224, 8) | 0
| Conv2DTranspose | (None, 224, 224, 16) | 1168
| Conv2D | (None, 224, 224, 3) | 435

Table I presents the layer configuration for this project’s implementation of
the convolutional autoencoder. The autoencoder was split into encoder and
decoder components, with the reverse structure of the encoder deployed for the
decoder. Tensoflow 2.5 and Python 3.8 were used to implement this autoencoder
[27]. A rectified linear activation (ReLU) function was used along the
network, except for the final output layer which applied the sigmoid
activation function.

For convolutional autoencoders, the number of features extracted depends on
the input image size [21]. In the case of the Galaxy Zoo DECaLS dataset, the
color images (3 channels) which had been cropped to 224 by 224 pixels,
resulted in an encoder which extracted 6272 features. Upon entry into the
decoder portion of the network, the flattened feature vector was reshaped to
the shape it held before flattening.

###  II-B K-means Clustering

The standard scikit-learn implementation of the k-means algorithm was used in
this paper [28]. The k-means clustering algorithm aims to partition $n$
objects into $k$ clusters in which each object belongs to the cluster with the
nearest mean [22]. The algorithm minimizes the total intra-cluster variance,
which is denoted as objective function $J$ and is defined by

$J=\sum_{j=1}^{k}\sum_{i=1}^{n}||x_{i}^{(j)}-c_{j}||^{2}$ (1)

where $k$ is the number of clusters, $n$ is the number of data points,
$x_{i}^{(j)}$ is the data point $i$, and $c_{j}$ is the centroid for cluster
$j$.

The steps taken by this algorithm are as follows:

  1. 1.

Randomly choose cluster centers.

  2. 2.

Assign each object to the closest cluster center by Euclidean distance.

  3. 3.

Calculate the centroid by taking the mean of all objects in each cluster.

  4. 4.

Repeat until the same points are assigned to each cluster in consecutive
rounds.

###  II-C Fuzzy C-means Clustering

The standard scikit-fuzzy implementation of the fuzzy c-means algorithm was
used in this paper [29]. The objective function $J_{m}$ for a fuzzy
c-partition matrix $\undertilde{\text{U}}$ for grouping a collection of $n$
data sets into $c$ classes is defined by [23]:

$J_{\text{m}}(\undertilde{\text{U}},\text{v})=\sum_{k=1}^{n}\sum_{i=1}^{c}(\mu_{ik})^{m^{\prime}}(\text{d}_{ik})^{2},$
(2)

where $\mu_{ik}$ is the membership of the $k$-th data point in the $i$th
cluster and

$\text{d}_{ik}=\text{d}(\text{x}_{k}-\text{v}_{i})=\left[\sum_{j=1}^{m}(x_{kj}-v_{ij})^{2}\right]^{1/2}$
(3)

denotes the distance measure between the $k$-th data point, $\text{x}_{k}$,
and the $i$-th cluster center, $\text{v}_{i}$.

To gain the optimum fuzzy c-partitions, the objective function $J_{m}$ is
minimized. The steps taken by this algorithm are as follows:

  1. 1.

Set values for $c$, the number of classes, select a fuzzifier value, $m$, and
initialise the partition matrix $\undertilde{\text{U}}^{(0)}$. Each step is
labeled $r$, where $r$ = 0,1,2,…

  2. 2.

Calculate the $c$ centers $\\{\text{v}_{i}^{(r)}\\}$ for each step.

  3. 3.

Update the $r$th partition matrix $\undertilde{\text{U}}^{(r)}$.

  4. 4.

Stop if $||\undertilde{\text{U}}^{(r+1)}-\undertilde{\text{U}}^{(r)}||$ is
less than or equal to the prescribed level of accuracy, otherwise increment
$r$ and return to step 2.

###  II-D Agglomerative Clustering

The standard scikit-learn implementation of the agglomerative clustering
algorithm was used in this paper [28]. Agglomerative clustering is a form of
hierarchical clustering. The algorithm builds a binary merge tree starting
from the leaves, which contain the data elements, to the root, which contains
the full data-set [24]. The Ward linkage function, which minimizes the sum of
squared differences within all clusters, was used in this implementation.

##  III Materials and Methods

The following method was used for this paper. First a convolutional
autoencoder was trained and then used to extract a number of features from the
galaxy images. These extracted features were then used to cluster the galaxies
using k-means clustering, fuzzy c-means clustering and agglomerative
clustering for each GZD-5 decision tree question. The generated clusters were
used to assign each galaxy to a class. Standard accuracy metrics were
generated using these classes so that the results could be evaluated.

###  III-A Dataset Description

The Galaxy Zoo DECaLS dataset includes 253,286 color images. These images are
424 by 424 pixels in size and feature 3 channels [1]. Volunteer responses are
provided for each galaxy. These responses include the total votes and vote
fractions for each question in the GZD-5 decision tree. Galaxies with less
than 3 volunteer classifications were removed from the dataset leaving a total
of 249,581 images. A random 80/20 train-test split was applied to the dataset.
The result was a training dataset comprised of 199,664 galaxies and a test
dataset comprised of 49,917 galaxies. The test dataset also served as the
validation dataset used during autoencoder training, as well as the dataset
used for clustering.

The GZD-5 decision tree features ten questions regarding the presence of
specific characteristics found in the galaxy being evaluated. Each question
has a different number of possible options to select [1].

A set of discrete classifications for each GZD-5 decision tree question was
produced by rounding the highest predicted volunteer vote fraction for a
question to 1, while the remaining fractions were rounded to 0. This process
was completed for each image. A galaxy was included for the evaluation of a
decision tree question, only if 50 percent or more of the volunteers shown
that galaxy answered that particular question.

In terms of pre-processing, galaxy images first had their pixel values
normalized to fall between 0 and 1 and were cropped to 224 by 224 pixels. The
color data for each image was preserved. A convolutional autoencoder was used
to reduce the dimensionality of the image data and produce a latent feature
vector for clustering purposes.

###  III-B Autoencoder Training and Testing

The convolutional autoencoder was trained over 100 epochs with a batch size of
256 using the stochastic gradient decent (SGD) optimizer, in line with the
method proposed by [21]. The mean squared error (MSE) loss function was used
during training. Training for the autoencoder took approximately 10.6 hours to
complete. Training was completed on a single NVIDIA V100 GPU.

Once the autoencoder was verified as having trained successfully, the 49,916
test images were fed into the encoder portion of the network for feature
extraction. These features were then saved in a CSV file for later use.

###  III-C Clustering

A set of 10 random seed values were used to ensure reproducible results for
clustering algorithms which randomly generate initial states. All clustering
was performed on a single compute node with access to 32 CPU cores.

#### K-means Clustering

K was set as the number of classes present for the question currently being
evaluated. Centroids were randomly generated for each run and the max
iterations parameter was set to 300. To account for random initialization, the
k-means clustering algorithm was run 10 times for each question. The 10 sets
of cluster assignments were used to calculate accuracy metrics.

#### Fuzzy C-means Clustering

C was set as the number of classes present for the question currently being
evaluated. The fuzzifier value, m, was set to 2 and the convergence value was
set to $1e-09$, in line with the input arguments proposed by [30]. The initial
fuzzy c-partition matrix was randomly set and the max iterations parameter was
set to 300. To account for random initialization, the fuzzy c-means clustering
algorithm was run 10 times for each question. The 10 sets of cluster
assignments were used to calculate accuracy metrics.

#### Agglomerative Clustering

The number of clusters to be found is set as the number of classes present for
the question currently being evaluated. The use of Ward linkage was specified
and the remaining parameters were left at their default values as specified by
scikit-learn [28]. The algorithm was only run once per question, as no random
initialization was performed.

###  III-D Class Assignment

The method proposed by Zha et al was used to map each cluster to a
corresponding ’real-world’ class [25]. First a confusion matrix was created
using the existing cluster labels and true class labels generated from the
Galaxy Zoo DECaLS discretized volunteer vote fractions. The sum of the
diagonal of this matrix was then maximized by considering each possible matrix
permutation and noting the configuration which results in the greatest sum
across its diagonal. The permutation that produced the confusion matrix with
the maximum sum of the diagonal was used to map each cluster to the ’real-
world’ class which it best fit.

###  III-E Generating Accuracy Metrics

The mapped labels were used along with the true class labels to produce
weighted average accuracy metrics for each question. These metrics included
precision, recall and F1-score. See formulae 4, 5 and 6 for these definitions.

$\text{precision}=\frac{\text{True Positives}}{\text{True
Positives}+\text{False Positives}}$ (4) $\text{recall}=\frac{\text{True
Positives}}{\text{True Positives}+\text{False Negatives}}$ (5)
$\text{F}_{1}=2\times\frac{\text{precision}\times\text{recall}}{\text{precision}+\text{recall}}$
(6)

To account for label imbalance, the weighted average metrics were calculated
for each question by taking the metrics for each question option, and finding
their average weighted by support. Table II shows the support for the metrics
of each decision tree question. This represents the number of galaxies
remaining for question evaluation in the test dataset after all galaxies which
fell below the 50 percent volunteer threshold were removed.

Table II: Question Support Question Name | Support
---|---
smooth or featured | 49917
disk edge on | 15445
has spiral arms | 11380
bar | 11380
bulge size | 11380
how rounded | 32526
edge on bulge | 2475
spiral winding | 7499
spiral arm count | 7499
merging | 49247

##  IV Results and Discussion

The following section presents the weighted average accuracy metrics for each
question produced by k-means, fuzzy c-means and agglomerative clustering. This
is followed by a discussion of the results. Table III shows the average time
in seconds taken to cluster each question by each clustering method.

Table III: Average Clustering Time (in Seconds) Question | Clustering Method
---|---
Name | K-means | Fuzzy C-means | Agglomerative
smooth or featured | 41.4 | 231.9 | 6643.6
disk edge on | 10.9 | 16.7 | 627.9
has spiral arms | 8.4 | 12.5 | 339.8
bar | 12.0 | 17.3 | 339.2
bulge size | 16.2 | 24.9 | 339.2
how rounded | 26.4 | 124.3 | 2792.4
edge on bulge | 3.0 | 3.1 | 15.4
spiral winding | 7.4 | 7.7 | 147.6
spiral arm count | 12.0 | 12.5 | 147.5
merging | 51.6 | 279.7 | 6384.5
Total Time | 189.2 | 730.4 | 17777.3

Tables IV, V and VI present a comparison of the precision, recall and
F1-score, respectively, of the classes generated by each of the three
clustering methods for each of the Galaxy Zoo DECaLS decision tree questions.
The best performing results are presented in bold, while the worst performing
results are underlined.

Table IV: Precision Comparison Question | Clustering Method
---|---
Name | K-means | Fuzzy C-means | Agglomerative
smooth or featured | 0.592 | 0.509 | 0.528
disk edge on | 0.654 | 0.711 | 0.671
has spiral arms | 0.728 | 0.714 | 0.736
bar | 0.445 | 0.385 | 0.460
bulge size | 0.377 | 0.303 | 0.266
how rounded | 0.435 | 0.422 | 0.457
edge on bulge | 0.608 | 0.457 | 0.687
spiral winding | 0.427 | 0.376 | 0.433
spiral arm count | 0.438 | 0.250 | 0.438
merging | 0.752 | 0.451 | 0.756
Table V: Recall Comparison Question | Clustering Method
---|---
Name | K-means | Fuzzy C-means | Agglomerative
smooth or featured | 0.395 | 0.409 | 0.497
disk edge on | 0.633 | 0.504 | 0.744
has spiral arms | 0.702 | 0.574 | 0.772
bar | 0.355 | 0.418 | 0.281
bulge size | 0.235 | 0.384 | 0.175
how rounded | 0.387 | 0.353 | 0.297
edge on bulge | 0.427 | 0.407 | 0.215
spiral winding | 0.384 | 0.410 | 0.470
spiral arm count | 0.197 | 0.267 | 0.189
merging | 0.262 | 0.295 | 0.232
Table VI: F1-Score Comparison Question | Clustering Method
---|---
Name | K-means | Fuzzy C-means | Agglomerative
smooth or featured | 0.430 | 0.414 | 0.509
disk edge on | 0.643 | 0.545 | 0.696
has spiral arms | 0.714 | 0.618 | 0.749
bar | 0.361 | 0.392 | 0.250
bulge size | 0.251 | 0.333 | 0.202
how rounded | 0.387 | 0.364 | 0.298
edge on bulge | 0.443 | 0.400 | 0.236
spiral winding | 0.382 | 0.384 | 0.442
spiral arm count | 0.241 | 0.240 | 0.236
merging | 0.329 | 0.332 | 0.318

As seen in Table IV, agglomerative clustering generally resulted in the
highest precision, while fuzzy c-means generally resulted in the lowest. It
should be noted, however, that in most cases agglomerative clustering only
narrowly outperformed k-means clustering. When considering the large
discrepancy in run time between k-means clustering and agglomerative
clustering, seen in Table III, the precision performance gains of
agglomerative clustering were not high enough to warrant the significantly
longer training time.

Tables IV and V clearly depict a discrepancy between the precision and recall
metric for each question for all three clustering methods. The precision was
often significantly higher than the recall. This was best illustrated by
considering the difference between precision and recall for the ’merging’
question. Taking the definition of both precision and recall into account, one
could conclude that the clustering methods considered resulted in a
proportionally high amount of false negative classifications. This means that
the produced clusters resulted in classes which excluded galaxies which should
have been included, for each question considered. This could be a result
amplified by the class assignment method used to map clusters to real world
classes, described in the previous section.

When looking at these results broken down by question, it was clear that the
accuracy performance for every clustering method considered was dependent on
the nature of the question being considered. For example, higher precision was
seen for questions with clear, distinct visual characteristics, such as ’disk
edge on’, ’has spiral arms’, ’edge on bulge’, and ’merging’. Questions with
fewer possible classes seemed to also exhibit higher precision, provided the
visual characteristics for each class were distinct enough. For questions with
only two possible classes, in this case ’disk edge on’ and ’has spiral arms’,
there was a smaller difference between the precision and recall, compared to
the difference for other questions. This could indicate that, given distinct
visual characteristics, the presence of fewer classes resulted in increased
recall, however, further investigation will be required before a conclusion
can be reached.

The F1-scores seen in Table VI, provided good insight into the accuracy of the
generated classes when both precision and recall were considered. For the
’merging’ question, which had significantly higher precision than recall, the
F1-score was low for all three clustering methods. While, on the other hand,
the ’has spiral arms’ question, which had a smaller difference between
precision and recall, had higher scores for all three clustering methods.

Throughout testing and evaluation, it was clear that the random seed value
used to initialize the k-means and fuzzy c-means functions heavily influenced
the results and accuracy metrics produced. With this in mind, it appeared as
though finding the optimal initial centroid positions and fuzzy c-partition
matrix could result in better classification accuracy overall.

Based on the accuracy results seen in Tables IV, V and VI, and the behavior of
the results observed during testing and evaluation, it seemed likely that,
given the proper optimizations, this unsupervised approach could produce good
results for the better performing questions. The insights produced by this
implementation make it clear that unsupervised techniques are, in fact, useful
in the field of classifying galaxy morphology. Even without comparing the
clusters produced to existing labels, this implementation could result in new,
unscheduled discoveries.

##  V Conclusion

In conclusion, a convolutional autoencoder feature extractor was implemented
and three popular clustering methods, namely k-means, fuzzy c-means, and
agglomerative, were evaluated in terms of their accuracy and performance.
Features were first extracted from the images in the Galaxy Zoo DECaLS
dataset. The features were then clustered and the clusters formed were
compared to existing human generated labels. Training time and accuracy
metrics such as precision, recall and F1-score were used to evaluate
performance. In terms of overall accuracy, agglomerative clustering appeared
to have performed the best. However, the performance gain seen over k-means
clustering was not significant considering the substantially longer clustering
time required. The accuracy metrics produced proved useful for determining the
best clustering method for each decision tree question. After undergoing the
appropriate clustering algorithm optimizations, this approach could prove
viable for classifying the better performing questions and could serve as the
basis for a novel approach to generating more ”human-like” galaxy morphology
classifications from unsupervised techniques. This approach in its current
form could still be used to make new and unscheduled discoveries from the
clusters which are formed. Ultimately, the results of this investigation have
shown that unsupervised learning techniques do, in fact, generate useful
results and that they could be used to create clusters which conform to human
generated galaxy morphology classifications.

## Acknowledgment

The authors would like to acknowledge and thank the Galaxy Zoo volunteers who
contributed to this dataset. Thanks is also given to Mike Walmsley for making
the Zoobot Python library publicly available and for grating access to the
Galaxy Zoo DECaLS dataset. The authors acknowledge the Telkom Center of
Excelence at the University of the Western Cape for providing financial
support, as well as the ilifu cloud computing facility for providing
computational resources.

## References

  * [1] M. Walmsley, C. Lintott, T. Géron, S. Kruk, C. Krawczyk, K. W. Willett, S. Bamford, L. S. Kelvin, L. Fortson, Y. Gal _et al._ , “Galaxy Zoo DECaLS: Detailed visual morphology measurements from volunteers and deep learning for 314 000 galaxies,” _Monthly Notices of the Royal Astronomical Society_ , vol. 509, no. 3, pp. 3966–3988, 09 2021.
  * [2] C. J. Lintott, K. Schawinski, A. Slosar, K. Land, S. Bamford, D. Thomas, M. J. Raddick, R. C. Nichol, A. Szalay, D. Andreescu _et al._ , “Galaxy zoo: morphologies derived from visual inspection of galaxies from the sloan digital sky survey,” _Monthly Notices of the Royal Astronomical Society_ , vol. 389, no. 3, pp. 1179–1189, 2008.
  * [3] K. L. Masters and G. Z. Team, “Twelve years of galaxy zoo,” _Proceedings of the International Astronomical Union_ , vol. 14, no. S353, pp. 205–212, 2019\.
  * [4] T. J. Galvin, M. T. Huynh, R. P. Norris, X. Wang, E. Hopkins, K. Polsterer, N. O. Ralph, A. N. O’Brien, and G. H. Heald, “Cataloguing the radio-sky with unsupervised machine learning: a new approach for the ska era,” _Monthly Notices of the Royal Astronomical Society_ , vol. 497, no. 3, pp. 2730–2758, 2020.
  * [5] P. E. Dewdney, P. J. Hall, R. T. Schilizzi, and T. J. L. Lazio, “The square kilometre array,” _Proceedings of the IEEE_ , vol. 97, no. 8, pp. 1482–1496, 2009.
  * [6] C. J. Fluke and C. Jacobs, “Surveying the reach and maturity of machine learning and artificial intelligence in astronomy,” _Wiley Interdisciplinary Reviews: Data Mining and Knowledge Discovery_ , vol. 10, no. 2, p. e1349, 2020.
  * [7] J. K. Banfield, O. Wong, K. W. Willett, R. P. Norris, L. Rudnick, S. S. Shabala, B. D. Simmons, C. Snyder, A. Garon, N. Seymour _et al._ , “Radio galaxy zoo: host galaxies and radio morphologies derived from visual inspection,” _Monthly Notices of the Royal Astronomical Society_ , vol. 453, no. 3, pp. 2326–2340, 2015.
  * [8] S. Dieleman, K. W. Willett, and J. Dambre, “Rotation-invariant convolutional neural networks for galaxy morphology prediction,” _Monthly notices of the royal astronomical society_ , vol. 450, no. 2, pp. 1441–1459, 2015.
  * [9] W. Alhassan, A. Taylor, and M. Vaccari, “The first classifier: compact and extended radio galaxy classification using deep convolutional neural networks,” _Monthly Notices of the Royal Astronomical Society_ , vol. 480, no. 2, pp. 2085–2093, 2018.
  * [10] H. Domínguez Sánchez, M. Huertas-Company, M. Bernardi, D. Tuccillo, and J. Fischer, “Improving galaxy morphologies for sdss with deep learning,” _Monthly Notices of the Royal Astronomical Society_ , vol. 476, no. 3, pp. 3661–3676, 2018.
  * [11] C. J. Burke, P. D. Aleo, Y.-C. Chen, X. Liu, J. R. Peterson, G. H. Sembroski, and J. Y.-Y. Lin, “Deblending and classifying astronomical sources with mask r-cnn deep learning,” _Monthly Notices of the Royal Astronomical Society_ , vol. 490, no. 3, pp. 3952–3965, 2019.
  * [12] V. Lukic, M. Brüggen, J. K. Banfield, O. Wong, L. Rudnick, R. P. Norris, and B. Simmons, “Radio galaxy zoo: compact and extended radio source classification with deep learning,” _Monthly Notices of the Royal Astronomical Society_ , vol. 476, no. 1, pp. 246–260, 2018.
  * [13] Z. Ma, H. Xu, J. Zhu, D. Hu, W. Li, C. Shan, Z. Zhu, L. Gu, J. Li, C. Liu _et al._ , “A machine learning based morphological classification of 14,245 radio agns selected from the best–heckman sample,” _The Astrophysical Journal Supplement Series_ , vol. 240, no. 2, p. 34, 2019.
  * [14] B. Becker, M. Vaccari, M. Prescott, and T. Grobler, “Cnn architecture comparison for radio galaxy classification,” _Monthly Notices of the Royal Astronomical Society_ , vol. 503, no. 2, pp. 1828–1846, 2021.
  * [15] E. Fielding, C. N. Nyirenda, and M. Vaccari, “A comparison of deep learning architectures for optical galaxy morphology classification,” in _2021 International Conference on Electrical, Computer and Energy Technologies (ICECET)_ , 2021, pp. 1–5.
  * [16] H. Tang, A. M. Scaife, and J. Leahy, “Transfer learning for radio galaxy classification,” _Monthly Notices of the Royal Astronomical Society_ , vol. 488, no. 3, pp. 3358–3375, 2019.
  * [17] T. J. Galvin, M. Huynh, R. P. Norris, X. R. Wang, E. Hopkins, O. Wong, S. Shabala, L. Rudnick, M. J. Alger, and K. L. Polsterer, “Radio galaxy zoo: Knowledge transfer using rotationally invariant self-organizing maps,” _Publications of the Astronomical Society of the Pacific_ , vol. 131, no. 1004, p. 108009, 2019.
  * [18] Z. Ghahramani, “Unsupervised learning,” in _Summer School on Machine Learning_. Springer, 2003, pp. 72–112.
  * [19] N. O. Ralph, R. P. Norris, G. Fang, L. A. Park, T. J. Galvin, M. J. Alger, H. Andernach, C. Lintott, L. Rudnick, S. Shabala _et al._ , “Radio galaxy zoo: Unsupervised clustering of convolutionally auto-encoded radio-astronomical images,” _Publications of the Astronomical Society of the Pacific_ , vol. 131, no. 1004, p. 108011, 2019.
  * [20] K. L. Polsterer, F. Gieseke, and B. Doser, “Pink: Parallelized rotation and flipping invariant kohonen maps,” _Astrophysics Source Code Library_ , pp. ascl–1910, 2019.
  * [21] M. Jiménez, M. Torres Torres, R. John, and I. Triguero, “Galaxy image classification based on citizen science data: A comparative study,” _IEEE Access_ , vol. 8, pp. 47 232–47 246, 2020.
  * [22] J. A. Hartigan and M. A. Wong, “Algorithm as 136: A k-means clustering algorithm,” _Journal of the Royal Statistical Society. Series C (Applied Statistics)_ , vol. 28, no. 1, pp. 100–108, 1979.
  * [23] T. J. Ross, _Fuzzy logic with engineering applications_. John Wiley & Sons, 2005.
  * [24] F. Nielsen, “Hierarchical clustering,” in _Introduction to HPC with MPI for Data Science_. Springer, 2016, pp. 195–211.
  * [25] H. Zha, X. He, C. Ding, M. Gu, and H. D. Simon, “Spectral relaxation for k-means clustering,” in _Advances in neural information processing systems_ , 2001, pp. 1057–1064.
  * [26] D. Charte, F. Charte, S. García, M. J. del Jesus, and F. Herrera, “A practical tutorial on autoencoders for nonlinear feature fusion: Taxonomy, models, software and guidelines,” _Information Fusion_ , vol. 44, pp. 78–96, 2018.
  * [27] M. Abadi, A. Agarwal, P. Barham, E. Brevdo, Z. Chen, C. Citro, G. S. Corrado, A. Davis, J. Dean, M. Devin _et al._ , “TensorFlow: Large-scale machine learning on heterogeneous systems,” 2015, software available from tensorflow.org. [Online]. Available: https://www.tensorflow.org/
  * [28] F. Pedregosa _et al._ , “Scikit-learn: Machine learning in Python,” _Journal of Machine Learning Research_ , vol. 12, pp. 2825–2830, 2011.
  * [29] J. Warner _et al._ , “Jdwarner/scikit-fuzzy: Scikit-fuzzy version 0.4.2,” Nov. 2019. [Online]. Available: https://doi.org/10.5281/zenodo.3541386
  * [30] Z. Cebeci and F. Yildiz, “Comparison of k-means and fuzzy c-means algorithms on different cluster structures,” _Agrárinformatika/journal of agricultural informatics_ , vol. 6, no. 3, pp. 13–23, 2015.