Observational Cosmology with Artificial Neural Networks

Abstract

In cosmology, the analysis of observational evidence is very important when testing theoretical models of the Universe. Artificial neural networks are powerful and versatile computational tools for data modelling and have recently been considered in the analysis of cosmological data. The main goal of this paper is to provide an introduction to artificial neural networks and to describe some of their applications to cosmology. We present an overview on the fundamentals of neural networks and their technical details. Through three examples, we show their capabilities in the modelling of cosmological data, numerical tasks (saving computational time), and the classification of stellar objects. Artificial neural networks offer interesting qualities that make them viable alternatives for data analysis in cosmological research.

1. Introduction

Observational cosmology has three relevant scientific pillars: cosmological theory, astronomical observations and statistical methods for data analysis. These areas allow us to compare theoretical cosmology with the observational evidence and thus validate or discard cosmological models. As the amount of observational data increases, the choice of data analysis methods becomes more crucial. Therefore, computational methods, including machine learning, have been incorporated into the cosmological field in recent years [1,2,3].

Machine learning is a branch of artificial intelligence focused on the mathematical modelling of the data. In recent times, the most growing field of machine learning is deep learning, which focuses on computational models called artificial neural networks (ANNs). In several respects, neural networks have been proven to have more flexibility and computational power than other machine learning methods, so they have been successfully applied in a large number of fields, ranging from industry and medicine to education and science, to name a few.

There are several types of artificial neural network: some of them fall under the category of supervised learning and others under unsupervised learning. Hence, the problems that deep learning is able to solve include: regression, classification, pattern recognition, generative processes, and time series, among many others. The ability of the ANNs to deal with complex and large datasets has allowed them to be good alternatives in several observational cosmological works [4,5], where theoretical models can be highly nonlinear, numerical methods be computationally expensive, and there may be very complex datasets. Artificial neural networks have been used in several cosmological applications, such as N-body simulations [6,7], image analysis [8,9], and statistical methods [10,11,12], and they have also been used to perform non-parametric reconstructions of cosmological functions [13,14,15,16]. In addition, ANNs have decreased the computational time taken for cosmological calculations [17,18,19,20,21]. Furthermore, neural networks have made it possible to analyse CMB signals [22,23], and to classify observational measurements from extensive surveys—for example, quasars in the Sloan Digital Sky Survey (SDSS) [24]. Finally, the use of deep learning in cosmology has increased considerably in recent years, and several works have already incorporated this type of research, i.e., [25,26,27,28].

The main goal of this paper is to present an introduction to deep learning followed by some examples of neural network applications to cosmology. In Section 2 we present an overview of neural networks with the basic concepts. Section 3 contains the cosmological background necessary for the subsequent examples. In Section 4, Section 5 and Section 6 we show three applications of the ANNs in cosmology. First, in Section 4 we present a reconstruction of the Hubble parameter. Second, an ANN is trained from the solutions of the dynamical system of the Universe and its content (Section 5). Third, an example of stellar object classification is shown in Section 6. Finally, in Section 7 we provide some final comments and conclusions.

2. A Deep Learning Overview

The initial steps of artificial neural networks started in 1943 when the first computational logic model for learning neurons was introduced [29]. However, this model was only capable of solving a few linearly separable logic gates and required plenty of information about the problem. Some years later, in 1957, Frank Rosenblatt [30] proposed the closest precursor to modern neural networks, the computational model known as the perceptron.

The perceptron proposed changes in the learning process, and unlike its predecessor, the neuron was now able to learn by itself from the input signals. However, in 1969 Marvin Minsky and Seymour Papert, famous artificial intelligence researchers, highlighted the inability of the perceptron to solve some non-linear problems, such as the well-known classification problem called exclusive OR (XOR) [31]. Due to this, the scientific and technological community lost interest in neural networks, and it took many years to change this situation. This stagnation stage is known as the artificial intelligence winter. The curiosity in neural networks was regained in the 1980s, driven by Geoffrey Hinton and colleagues, who presented the backpropagation algorithm that solved some of the computational limitations of neural networks [32]. Nevertheless, it was not until the 21st century, due to computing advancements, that neural networks regained great relevance, and a new scientific discipline was born: deep learning, focused exclusively on the study of artificial neural networks.

Nowadays there are several types of neural networks—for example, the recurrent networks that are widely used for time series, the convolutional neural nets that are very successful in image processing, the autoencoders used in image denoising, and the modern generative adversarial networks. In this work, we focus on the most basic deep neural network, which is known as the multilayer perceptron (MLP).

2.1. The Perceptron

The perceptron is considered the fundamental unit of neural networks, which consists of a mathematical model for a biological neuron. Neurons in the brain receive information from neighbouring cells, process it, and then, through synapses, transmit an electrical or chemical signal to other neurons. The perceptron performs a similar task. It takes as input n signals, i.e., $x_1,x_2,\cdots ,x_n$, each of them associated with a coefficient $w_j$, called a weight. Then, the perceptron computes a linear combination of weights and inputs, known as the weighted sumz:

$$z=\sum _{j=1}^n\left(x_j{w}_j\right)+b,$$

(1)

where b is called bias and indicates the output value when all of the $x_i$ are null. The weights determine the strength of influence of each input on the neural network model.

As in biological neurons, a modulation of the signal z is needed. In an ANN, that modulation is carried out through the activation functions, whose characteristics are described in Appendix A. The output of the perceptron is given by the activation function (denoted by $\sigma$) applied to the weighted sum:

$$a=\sigma \left(z\right).$$

(2)

For a schematic description, see Figure 1. This computational structure is commonly called a node or neuron, which acts as a brick for deep neural networks (multiple arrays of nodes).

Algorithm 1 shows the learning rule for updating the weights that the perceptron follows, given a dataset made of $x_i\in X$ independent variables and $y_i\in Y$ dependent variables. For the learning process, the output of the perceptron should be compared with the target value included in the original dataset. This can be done with an error function called a cost function, which in this case is the mean squared error between the target $y_i$ and the prediction $a_i$. The learning rate $\eta$ indicates how much the weights change (see Appendix B). The iteration steps in the updating process are known as epochs.

Algorithm 1 The perceptron rule.

2.2. Deep Neural Networks

The learning mechanism for a single neuron can be generalised to many of them with diverse arrangements. The simplest deep neural network is known as the multilayer perceptron (MLP) or feedforward neural network, which consists of several perceptrons or nodes interconnected with each other through different arrangements of neurons called layers. Every multilayer perceptron has an input layer; at least one intermediate layer, often called hidden layers; and one output layer (see Figure 2). The input layer of an ANN corresponds to the data to be processed through the subsequent layers, and the number of nodes in this input layer must match the number of independent variables (features or attributes) of the dataset. Similarly to the perceptron, the output layer has to be compared with the dependent variables (labels or classes) of the dataset, which are the predicted ones.

The connections between one node to another have an associated weight $w_{ij}^l$ and a bias $b_j^l$, where l represents the layer number. The weight connects the node i in the layer $l-1$, with the node j in the layer l. In consequence, the node j in the layer l will have an output $a_j^l$. The weighted sum of each node contains information on the weights, biases, and inputs of each layer, and is calculated as follows:

$$z_j^l=\sum _i{a}_i^{l-1}{w}_{ij}^l+b_j^l.$$

(3)

Then, the activation functions $\sigma$ are applied to the weighted sum, Equation (3), and are denoted by:

$$a_j^l=\sigma \left(z_j^l\right).$$

(4)

Using the matrix notation allows us to establish the structure of the MLP in a simpler way. Let L be last layer. Then the MLP output is the vector that takes each node $a_j^L$ as an entry:

$$\left(\begin{array}{c}{a}_1^L\\ a_2^L\\ ⋮\\ a_m^L\end{array}\right)=a^L.$$

(5)

Thus, we can call intermediate layers recursively as vectors $a^l$. For each layer, we can also build a weight matrix $W^l$ and denote the output $z^l$ of every layer as follows:

$$z^l=a^{l-1}{W}^l+b^l.$$

(6)

Notice that the inputs of the associated weight matrix, with layer number l, are defined as:

$${\left[W^l\right]}_{ij}=w_{ij}^l,$$

with $b^l$ being the vector that contains the biases of each node in the l layer. Afterwards, it is necessary to apply the activation function $\sigma$, as indicated in Equation (4):

$$a^l=\sigma \left(z^l\right).$$

(7)

The process by which the information is transmitted, from the input layer of the neural network to the generation of an output or prediction in the last layer, is known as forward propagation.

A multilayer perceptron can be considered as a function $f:a^0\in {\mathbb{R}}^n⟶a^L\in {\mathbb{R}}^k$. In this function, the hidden layers must also be considered even without being expressly mentioned. The forward propagation of a MLP is represented in the following diagram:

$$\begin{array}{c}\hfill a^0⟶W^1{a}^0+b^1\stackrel{\sigma }{⟶}{a}^1⟶\cdots \\ \hfill ⟶a^{l-1}⟶W^l{a}^{l-1}+b^l\stackrel{\sigma }{⟶}{a}^L.\end{array}$$

(8)

For example, let us assume the structure of a neural network consists of a single hidden layer with h nodes and a non-linear activation function $\sigma$. Using Equations (6) and (7), we can calculate the hidden layer weighted sum $z^1$ as follows:

$$z^1=a^0{W}^1+b^1.$$

The weight matrix $W^1$ is constructed by taking as a column j the vector of weights that enter the node j; thus, in this case $W^1\in {\mathrm{M}}_{n\times h}$ and $b^1\in {\mathbb{R}}^h$. Now, we choose the activation function and apply it to each input of $z^1$:

$$\sigma \left(z^1\right)=a^1\in {\mathbb{R}}^h.$$

Finally we apply this process to the hidden layers, if any. In this case, for the output layer:

$$z^2=a^1{W}^2+b^2,$$

with $W^2\in {\mathrm{M}}_{h\times k}$, $b^2\in {\mathbb{R}}^k$.

Forward propagation is the first step in training a neural network. The output of forward propagation must be evaluated with an error function known as the cost function. Next, other mechanisms are necessary to update the neural network parameters and get the predictions closer to the target values. This will be discussed in the next section.

2.3. Learning Process

Once the neural network has generated an output, it continues with the learning process. The learning mechanism for a single neuron can be generalised to many of them with diverse arrangements. Here, the network parameters are updated so the output is as close as possible to the label values. The measure for this comparison will be indicated by the cost function. A typical cost function for regression tasks is the mean squared error (Equation (A3)). Thus, the lower the value of the cost function, the better the neural network model. In deep learning, the most popular method for optimising cost functions is known as gradient descent (see Appendix B for details). When applying gradient descent to update the network parameters in both the output layer and the hidden layers, an algorithm known as backpropagation should be taken into account (Appendix C). This algorithm indicates how to modify the parameters of the neural network such that the value of the cost function becomes smaller in an efficient way. Algorithm 2 outlines the learning process of an MLP, which can be considered as a generalisation of Algorithm 1. The weights and bias updates are performed by applying the backpropagation Equations (A6)–(A9). A common way to initialise the random values for the weights and biases is generating random numbers normally distributed around zero.

Algorithm 2 Learning process.

2.4. Overfitting and Underfitting

During the training process the neural networks tune the values of the weights to minimise the loss function. However, there may be several combinations of weights that similarly minimise the loss function. Therefore, a neural network must generate a good model for the data, capable of generalising and predicting values for the data not included in the training set. These machine learning issues have been rigorously studied in the branch of mathematics known as statistical learning theory. In this work, we do not delve into these details, but for references, see [33,34,35] p. 142.

In ANN training, the dataset is usually split up into two parts: a training set and a validation set. The training set is used to train the neural network and therefore to fit the weights and biases. On the other hand, the validation set verifies whether that trained neural network can generalise beyond the dataset with which it was trained. The split in the dataset allows one to evaluate whether a neural network generates an acceptable model for the data. Then, we analyse the behaviour of the loss function and its change throughout the epochs by plotting the behaviour of the cost function on the training and validation sets. When a dataset is large enough, it is convenient to split it into three parts: a training set, a validation set, and a test set; the latter is used to perform a final test of the neural network’s performance.

If throughout the epochs the model does not reduce the training error, this is a sign that the model is too simple, so it is not learning the pattern that underlies the training set. This phenomenon is called underfitting (Figure 3a) and it could be solved with a more complex model. On the other hand, if the training error is remarkably lower than the validation error—that is, the validation error does not decrease through the epochs while the training error does—this may be a sign that the model is unable to generalise what it has learned. This is called overfitting (Figure 3b). Overfitting can be solved with processes called regularisation techniques; some examples are dropout [36] and regularisation norms [37,38].

2.5. Coding Tips

In this section we share some highlights about neural network coding. For technical details, we implemented an MLP from scratch, which is available in [39].

The neural network’s architecture must be defined: the number of layers and the number of nodes. In addition, other intrinsic parameters (hyperparameters) of the neural network must also be established, such as the activation function, the number of epochs, and the learning rate, among others. The hyperparameters must be calibrated so the model generated by the neural network does not present problems such as underfitting or overfitting. It is important that the cost function be as small as required by the problem of interest. However, it is also necessary to take into account that the difference between the training and the validation errors should be small. By taking care of these aspects, the model generated by the neural network will be able to generalise to data not included in the original training dataset, and therefore make good predictions.

An interesting way to take advantage of a trained neural network model is to store it in a binary text file. In this way, the values of the weight matrices $W^l$ and the bias vectors $b^l$ obtained after proper training can be loaded to make more predictions; i.e., the neural network can be reusable.

Building a neural network from scratch is a very good way to understand the fundamental concepts of deep learning. However, in practice it is necessary to work with different network architectures, several cost functions and activation functions, and a large variety of hyperparameters; therefore, it is best to use specialised deep learning libraries. For instance, in Python one can use Pytorch, TensorFlow, or Keras, where the code is very efficient and contains a wide range of options. Other programming languages such as R and Julia also have deep learning libraries.

3. Cosmological Framework

One of the most important equations in cosmology is the Friedmann equation, which describes the evolution of the Universe and its expansion rate:

$$H{\left(t\right)}^2=\frac{{\kappa }_0}{3}\rho -\frac{k{c}^2}{a{\left(t\right)}^2},$$

(9)

where H is the Hubble parameter defined by $H\left(t\right)\equiv \dot{a}/a$ with $a\left(t\right)$ being the scale factor of the Universe; c is the speed of light; k is a constant that specifies the space geometry (curvature); and ${\kappa }_0$ is given in terms of the gravitational constant G, ${\kappa }_0=8\pi G$. $\rho$ represents the total energy density of the content of the cosmos, which is $\rho ={\sum }_i{\rho }_i$, where the index i shows the possible components: radiation (r), baryonic and dark matter (m), and dark energy ($\Lambda$).

Another important equation in cosmology is the continuity equation or fluid equation, which describes the behaviour and evolution of the content of the Universe:

$$\dot{{\rho }_i}+3\frac{\dot{a}}{a}\left({\rho }_i+\frac{p_i}{c^2}\right)=0,$$

(10)

where $p_i$ represents the pressure associated with every i component. A relationship between density and pressure can be established through an equation of state. The simplest way is to assume that the components behave as perfect fluids and they are described by a barotropic equation of state:

$$p_i=({\gamma }_i-1){\rho }_i{c}^2,$$

(11)

where ${\gamma }_i$ describes each fluid: radiation (${\gamma }_r=4/3$), baryonic and dark matter (${\gamma }_m=1$), and dark energy in the form of cosmological constant (${\gamma }_{\Lambda }=0$). By substituting the value of $p_i$ in Equation (10), for each component, a system of couple differential equations is obtained.

$${\dot{\rho }}_i+3{\gamma }_{i}H{\rho }_i=0.$$

(12)

Once we introduce the dimensionless density parameters, defined as

$${\Omega }_i=\frac{{\kappa }_0}{3H^2}{\rho }_i,$$

(13)

Equations (12) can be written as a dynamical system with the following form:

$${\Omega }_i^{\prime }=3(\Pi -{\gamma }_i){\Omega }_i,$$

(14)

with $\Pi ={\sum }_i{\gamma }_i{\Omega }_i$, and prime notation means derivative with respect to the e-fold parameter $N=ln\left(a\right)$. The Friedmann equation becomes a constraint for the density parameters at all time:

$$\sum _i{\Omega }_i=1.$$

(15)

This system can be solved traditionally, by setting some initial conditions for the parameters of radiation density, matter, dark energy, and the Hubble constant: ${\Omega }_{r,0}$, ${\Omega }_{m,0}$, ${\Omega }_{\Lambda ,0}$, $H_0$.

4. MLP Applied to the Hubble Parameter

In this example, we demonstrate the use of a neural network to generate a model from 20 simulated data points [14] corresponding to cosmic chronometers that consist of $H\left(z\right)$ measurements at redshift z and their respective statistical error bars. This is a simple application that, in a more rigorous way, has been used in other research works [13,14,15,16].

The neural network input corresponds to the redshift z and the output to both H and its error. Therefore, the neural network can be considered as a function from $z\in \mathbb{R}$→${\mathbb{R}}^2$. Top panel of Figure 4 shows the architecture of the neural network.

In this example, the trained neural network has one hidden layer with 100 nodes, and it was calibrated with a total of 300 trainable parameters (weights and bias). The dataset contains 20 observational data points; however, the computational model generated by the neural network had a good reconstruction of the Hubble parameter without assuming any theoretical model beforehand; its cost function was $1.7$. This value is a bit large due to the small size of the dataset; however, it could be improved using more advanced strategies to choose the hyperparameters and to train the neural network [14].

The cost function curves of the training and validation sets show that their errors decreased at each epoch, which suggests that the model was able to learn from the data points provided and generalise to any other missing z. Once the training process was completed, the network was able to predict $H\left(z\right)$ values and their errors to values of redshift (z) not included in the original dataset. See the lower panel of Figure 4 for details. In this figure, it can be noted that the neural network generated a model for the $H\left(z\right)$ measurements, and thus produced a reconstruction of the Hubble parameter based only on the dataset without making any cosmological assumptions beforehand. This result could be compared with the analytical $H\left(z\right)$ function coming from various cosmological models to assess how similar or different the curves are. That is, the MLP can be used to reconstruct various cosmological functions to obtain some physical conclusions [40,41].

5. Cosmological Differential Equations

Solving a system of differential equations can be computationally demanding, especially when this process has to be repeated multiple times. The use of neural networks in solving systems of differential equations has already been addressed by various authors [42,43,44]. In cosmology, it is common that some cosmological functions have to be evaluated multiple times, for example, in the case of simulations or in the Bayesian inference process [17,19,21]. In this example, with various combinations of initial conditions, we solve the dynamical system to generate our training set. Then, we build the optimal architecture of a MLP to generate a model for this dataset. Once the neural network is well trained, we can do the following with the predictions:

• Obtain the solutions of the system by evaluating the initial conditions at missing points in the training set.
• Reduce the computational time to obtain multiple solutions.

Throughout this example, we consider a flat Universe whose evolution goes back to the early times when radiation dominates. We also assume that its temperature is measured with great reliability, and this is reflected in a fix present radiation parameter with value ${\Omega }_{r,0}={10}^{-4}$. Once this value is established, and since the sum of all densities must be equal to one (Equation (15)), it is enough to vary the parameters ${\Omega }_{m,0}$ and $H_0$ to have the initial conditions for Equation (14). With these parameters, the solution of the differential equations can be treated as a function ${\Omega }_i(N,{\Omega }_{m,0},H_0)$.

To generate the set of solutions, the following was performed: First, the intervals where the initial conditions were selected, correspond to $N=ln\left(a\right)\in [-12,0]$, ${\Omega }_{m,0}\in [0.1,0.4]$, and $H_0\in [65,80]$. For the choice of these intervals, see [45]. Then, the dataset X was generated by computing the Cartesian product between all the intervals: $X=[-12,0]\times [0.1,0.4]\times [65,80]$, to get a set of about 30,000 elements. Last, we computed the solutions corresponding to these elements X to form the training dataset Y.

The network architecture used to process these data can be seen in Figure 5. Before starting the training process, a max-min transformation was performed on the Y dataset, because the size of the Hubble factor is large for the early stages of the Universe. The MLP architecture had four hidden layers with a sigmoid activation function, and considering both weights and biases, they had a total of 69,154 trainable parameters. It was trained for 500 epochs with a dataset of 30,000 elements and the final cost (error) function has a value of $2.9\times {10}^{-5}$.

Considering the flat Universe components mentioned above, the dynamical system (14) has analytical solutions; therefore, the Friedmann equation, in terms of the redshift, $z=1/a-1$, takes the following form:

$$\frac{H^2}{H_0^2}={\Omega }_{r,0}{(1+z)}^4+{\Omega }_{m,0}{(1+z)}^3+{\Omega }_{\Lambda ,0}.$$

(16)

Hence, in the top panel of Figure 6, the solutions and the predictions of the neural network for the density parameters are compared, whereas in the bottom are the results for the Hubble parameter H, and the error curves, which show a good performance. Notice the dynamical system in (14) can be extended too a more complex scenario that requires sophisticated numerical methods, i.e., [46,47].

Once the ANN was properly trained, we saved the generated model and used it to predict solutions of the system. However, this time, it was enough to evaluate the model under a combination of initial conditions to obtain the solutions (Figure 7). Finally, the model was evaluated in 10,000 different combinations of initial conditions, and we found that the ANN reduces the computing time by $53\%$ compared to the numerical solutions of the differential equations.

6. Classification of Astronomical Objects

The classification of celestial objects is one of the main tasks that astronomers have carried out throughout history. The increase in the flow of data we receive from the cosmos is both an opportunity and a challenge. It allows us to classify objects based on many of their characteristics, but the amount of information is so large that it can become a daunting task. This example shows that deep learning is a fantastic option for performing classification problems, in this case the classification of stellar objects.

In classification problems, the independent variables X usually represent features or attributes, and the dependent variables Y indicate the classes (or labels) of each item in the dataset [3]. Unlike the previous examples, the categorical (or classification) labels must be transformed to numeric elements called one-hot vectors. It is convenient to apply the Softmax activation function in the last layer, since this activation function makes it possible to associate the ANN output with the probability that the element being processed belongs to each of the existing classes in the dataset. The softmax function, applied to a vector with k inputs $x_i$, is defined as:

$$\mathrm{softmax}\left(x_i\right)=\frac{e^{x_i}}{{\sum }_{j=1}^k{e}^{x_j}}.$$

(17)

For this case we have used the cross-entropy as a cost function, which is recommended for classification problems, and it is defined as follows:

$$C(Y,a^L)=-\sum _{j=1}^k{Y}_{j}ln\left(a_j^L\right);$$

(18)

therefore, this is the function to be minimised during neural network training.

The dataset used for this example comes from the Sloan Digital Sky Survey DR14 (https://www.sdss.org/dr14/ (accessed on 22 December 2021)), which consists of observations of different stellar objects: stars, quasars (QSO), and galaxies. These classes are represented in the Y label set. On the other hand, there are 17 features which include the redshift and the celestial coordinates, along with characteristics of the spectrograph used. These attributes make up the input features X.

In Figure 8, one can observe the ANN architecture used, with three hidden layers with sigmoid activation and the output layer with the softmax activation function. Taking into account the weights and bias, this neural network has 70,803 trainable parameters.

The ANN was trained for 80 epochs. To measure the performance in this classification task, we used the accuracy metric, defined as follows:

$$\mathrm{accuracy}=\frac{\#\mathrm{Correct}\mathrm{predictions}}{\#\mathrm{Total}\mathrm{predictions}}.$$

(19)

The ANN model, trained with the astronomical objects, reached 98.32% accuracy on its training set and 98.25% on the validation set, as shown in Figure 9.

Finally, for testing the model’s efficacy, the ANN was asked to classify a set of 2000 elements outside of the training process, thereby achieving classification with 97.65% accuracy. Results of this classification can be organised in a confusion matrix (see Figure 10), which is an arrangement where the numbers of errors and successes of the ANN can be seen graphically. In a confusion matrix, the horizontal axis represents the real values and the vertical axis those predicted by the model, such that the accuracy ratios are shown diagonally across the matrix, and the mistakes everywhere else. It can be noticed that, in this example, the errors are minimal compared to the correct data labelling done by the ANN.

7. Conclusions

This paper presented an introduction to the fundamental concepts of deep learning, with the intention of providing new tools for cosmological analysis. The applications were presented through three practical examples, and through them we showed that:

• Neural networks have the ability to emulate any function or pattern that pervades a given dataset. This can be very useful in various scientific areas, because such networks can generate a computational model for the data and are a good alternative when a satisfactory analytical model is not available.
• A properly trained neural network can be used to replace traditional computational calculations in a wide variety of problems and thus decrease the computational time necessary. In addition, in Section 5 we showed that the neural network also provides a model that can be evaluated and mathematically manipulated, something that traditional numerical methods may not always offer.
• With the last example, we showed the great efficiency of neural networks in tasks that can be complicated to perform—for example, object classification. In our case, we performed a classification with numerical features; however, the literature indicates that neural networks are also a great tool in image and video classification.

The examples that we presented in this article are just a small sample of the potential that deep learning has for cosmology. It is a branch of artificial intelligence that is booming and that, little by little, is being incorporated into various scientific disciplines.

Even though ANNs are considered as a great tool for several problems, in many cases they may present some disadvantages. For example: the training time can be considerably long for a very large database. It is commonly said that neural networks are “black boxes”, because the huge number of parameters are just a set of real numbers with no information about the phenomena they are modelling. The ANN must be used with caution to prevent overfitting or underfitting to ensure that the model can be generalised.

Continuing with this line of work, more deep learning tools could also be presented to facilitate data management in science, mainly in astronomy and observational cosmology. A next step could be numerical simulations of the Universe and its contents or using convolutional neural networks, which are widely used in image processing. However, that is a topic for another time.