, deep learning with Deep Neural Networks (DNN) has been helping machines to gain intelligence to outperform humans in many aspects: from text processing (Collobert and Weston 2008), speech recognition (Dahl et al. 2012;Hinton et al. 2012) and driverless cars (Nguyen et al. 2015) to disease diagnosis (Fakoor et al. 2013;Li et al. 2014) and stock market forecasting (Ding et al. 2015). In a recent triumph, Google's DNN program, AlphaGo, beat a top Go professional (Silver et al. 2016). These remarkable advances in AI are deemed as the 4th industrial revolution by many people (Kelnar 2016) and are reshaping many areas of modern society including scientific research (Ohlsson 2011). One of the biggest changes is the shift of focus from models to data (Kitchin 2014). Deep learning enables knowledge extraction from massive amounts of data, making the data outweigh the machine (or model). This shift happens in this era of big data, when data are explosively expanding due to the widespread application of low-cost sensors, electronic devices, and large-volume storage (Manyika et al. 2011). In geotechnical engineering, there have been incalculable and explosively increasing data from Geophysical Information Systems (GIS), weather stations, field monitoring, case studies and lab testing, the majority of which are collected/stored as images and live images (videos). But unfortunately, these data are mostly underutilized because they cannot be analyzed with the traditional model-driven methods in geotechnical engineering.
The precursor of deep learning is the Artificial Neural Networks (ANNs)-a topic that has been extensively studied in geotechnical engineering. ANNs are a form of AI attempting to mimic the behavior of the human brain and nervous system (Shahin et al. 2001). A surge of interest was sparked in the late 1980s and widely spread in 1990s in geotechnical engineering. ANNs were applied to almost all aspects of geotechnical engineering with some degree of success (Park et al. 2011), optimal design (Gowda et al. 2012), and seismic response (Ozturk 2014).
Despite the interest and success, the application of ANNs as well as other AI approaches in geotechnical engineering has been stagnating. This can be seen from the conclusive remarks of the two widely-cited review papers of Shahin and his co-workers, which summarized the practice before and after 2001 (Shahin et al. 2001(Shahin et al. , 2008)). The 2005 review paper was presented to ''attract more geotechnical engineers to pay better attention to this promising tool'' while the 2009 paper commented that the ''neural networks for the time being might be treated as a complement to conventional computing techniques rather than as an alternative''. The advantage of ANNs is its ability in handling pattern recognition and modeling of nonlinear relationships of multivariate dynamic systems (Sakellariou and Ferentinou 2005), especially those complex engineering problems that are beyond the computational capability of traditional research approaches (Shahin et al. 2008). The disadvantage is the concerns in robustness, transparency, extrapolation, and uncertainty. In summary, the AI tide represented by ANNs did not replace traditional geotechnical methods or even become widely-accepted alternatives. The reason is most likely that there were not many problems that ANNs can handle and traditional geotechnical methods cannot, while ANNs are less connected to physics and did not show a satisfactory level of intelligence back then.
Most of the studies summarized in the above subsection were built on Artificial Neural Network (ANN) techniques which had matured before the 1990s. This surge of interest quickly evaporated with the slump ANN research in the late 1990s. With the ascent of Support Vector Machines and the failure of backpropagation, ANN research enters a dark time in the early 2000s, a time when even the founders of deep learning, i.e., LeCun and Hinton, had their papers and grant proposals routinely rejected due to their subject being neural networks. As a result, as Hinton tells, they hatched a ''conspiracy'': ''rebrand'' the frowned-upon field of neural nets with ''Deep Learning''. However, the turning point was not the name, but a breakthrough published in Science in 2006 (Hinton and Salakhutdinov 2006), in which (Hinton et al. 2012). This innovation started from computer vision and speech recognition soon swept other areas such as driverless cars, natural language processing, drug discovery and toxicology, biomedical informatics, customer relationship management, and stock prediction. Despite its new birth, this innovation has been becoming a force changing the world, including many research areas. Taking computer linguistics for example, deep learning hit this area as a ''tsunami'' in the 2015 Natural Language Processing (NLP) conference (Manning 2016)-this major computer linguistics conference was predominated by deep learning within one year. Engineering disciplines have been significantly impacted by computer science innovations, which can be seen from NSF's promotion of new concepts such as ''big data'', ''cyber-physical system'', and ''smart city''. Based on these facts, one may be wondering ''when will deep learning especially the above imagedata-driven machine learning technique majorly impact engineering disciplines?'' and ''what a role will geotechnical engineering play in this process?''.
Data is another reason that deep learning is becoming a world-changing force (Chen and Lin 2014). Deep learning models or machines, especially those DNNs dealing with image data, enable learning from image and video data, which account for a major part of the ''big data'' (Kaisler et al. 2013;Wu et al. 2014).
Learning from these data significantly improves the machines' intelligence. The knowledge gained from the data has been surpassing that from the improvements of the machines. As a result, data have become a major resource. For instance, big data trends have been driving the future of businesses, leading to the wide acceptance of and transitions to data-driven marketing and data-driven companies. In industry giants such as Google, ''data drives 'everything''' (Metz 2009).
All the above changes have been occurring in the background of ''big data explosion'' (Lohr 2012). In geotechnical engineering, there exists a great amount of GIS data and more and more data created by remote sensing techniques. Additionally, the decreasing costs of cameras and storage devices help popularize the documentation of testing and construction in terms of images and videos. Despite the explosive occurrence of such data, our primary research tools, such as traditional physically-based analytical and numerical methods, only take a few inputs. Thus, most of the data mentioned above are underutilized or totally wasted. From another angle, these data, including the knowledge contained in the data, are barely extracted or utilized.
The goal of this study is to understand the image-datadriven deep learning in geosystems with an exploratory investigation into the stability analysis of retaining walls. To achieve the goal, the recent breakthrough in computer vision (Russakovsky et al. 2015), which was later used as one of the core techniques in the development of Google's AlphaGo (Moyer 2016), is studied for its capacity in assessing the stability of a typical geosystem, i.e., retaining walls. The core concept enabling the breakthrough, Convolutional Neural Networks (CNN), which helped machines surpass humans in visual classification capacity, is used to process the big data in geotechnical engineering, which primarily consist of images and live images (videos) and cannot be analyzed using traditional geotechnical methods. As shown in Fig. 1, the concept used in the famous Dogs vs. Cats Kaggle challenge, in which machine learning algorithms are used to classify whether an image contains a dog or a cat, is employed. A CNN is employed to analyze images for a retaining wall to tell whether the wall is a ''cat'' (safe) or a ''dog'' (failed). For quantitative analysis, 2D images for retaining walls are generated using a stochastic method and analyzed using a traditional mechanistic method for labeling. These labeled image data are used as input to train CNNs for supervised learning. The trained CNN is tested against another independent set of data generated in the same way as the training data. The study is proposed based on the hypothesis that telling a failed structure from a safe one is not essentially different from telling a dog from a cat in images in deep learning.
CNN, which are also frequently called ConvNets, are a special type of feed-forward network. CNNs are inspired by the connectivity pattern between neurons in the animal visual cortex. Each cortical neuron responds to stimuli only in a restricted region of the visual field, i.e., receptive field. The receptive fields of different neurons partially overlap to cover the entire visual field, i.e. the image. Such an organization empowers the CNN with an ability to extract features automatically: each neuron captures the local features in the image area that it can see, and such features can be extracted into a higher-level of features by another layer of neurons. As shown in Fig. 2, a CNN first identifies line features and then further extracts shapes. This overcomes one major drawback in traditional image classification algorithms, in which a lot of effort is required for manual pre-processing. In other words, the CNN learns the filters that are hand-engineered in traditional algorithms. This independence from prior knowledge and the save of human effort in the feature design are a major advantage. In addition, CNNs can contain special layers such as convolutional layers and pooling layers, allowing the networks to encode certain image properties. Due to the above characteristics, CNNs exhibit exceptional performance in visual recognition tasks.
As shown in Fig. 3, a CNN is usually composed of an input layer, multiple hidden layers, and an output layer. These hidden layers typically consist of convolutional layers, pooling layers, ReLU layers, fully 123 connected layers, and normalization layers. The convolutional, pooling, and ReLU layers act as learnable feature extractors, while the fully connected layers act as a machine learning classifier. Furthermore, the early layers (close to input) of the network encode generic patterns of the images, while later layers encode the detailed patterns of the images. It is noted that only the convolutional layers and fullyconnected layers have weights. Learning these weights is the primary goal of the training phase. A CNN with weights learned from labeled samples is a trained model, which can be used to classify/predict unlabeled samples (or called instances). This subsection for architecture explains the key components of the CNN used in this study.
Theoretically, fully connected feedforward neural networks (without convolutional and pooling layers) can also be used to learn features and classify image data. But, this use is still not realistic at this time because this architecture requires a number of neurons to learn from pixels. The required computation cost would be too high to afford due to the pixels numbers of normal image data. The convolutional layers help solve this problem by reducing the number of free parameters and consequently allowing the network to be deeper with fewer parameters (Aghdam and Heravi 2017). Attributed to this innovation, the CNN resolves the vanishing or exploding gradients problem in training deep neural networks with many layers.
As shown in Fig. 4, a convolutional layer consists of a set of learnable filters (or called neurons or kernels) that are slid over the image spatially. Mathematically, this corresponds to computing dot products between the entries of the filter, i.e., the matrix in The entries of the filter are the weights of the convolutional layer. Therefore, if the filter sliding over different image regions was viewed as different filters, the filters in the convolutional layer are essentially identical. These filters will be activated when they identify the same specific structures (features) in the images, e.g., lines, depending on the size of the image regions that the filers are applied to. It is worthwhile to mention that the filters should extend to the full depth of the input image. Thus, for a colored image, the filter should have a depth of 3 to cover all 3 color channels (red, green, blue) of the image. The mathematical convolution operation emulates the response of an individual neuron to visual stimuli (Glauner 2015).
CNNs may include local or global pooling layers, which combine the outputs of multiple neurons from one layer into a single neuron in the next layer (Ciresan et al. 2011;Krizhevsky et al. 2012). Two common types of pooling layers are the max pooling and average pooling. The max pooling uses the maximum value from a cluster of neurons as the output, as illustrated in Fig. 5, while the average pooling uses the average value. Mathematically, pooling is a non-linear down-sampling. The use of a pooling layer can progressively reduce the spatial size of the image data, and consequently, reduce the number of parameters and computation operations for the network. Also, pooling can also remove redundant specific features and consequently help control overfitting. This study adopts the max pooling, and detailed parameters for these pooling layers will be presented later.
Many existing CNNs can be applied to analyze the image data of geosystems with minor modifications. Since there have been no attempts at applying this relatively new computer vision technique to stability analysis of geosystems. There are still several issues that significantly differentiate the application of CNNs in geosystems from the normal use of CNNs in computer science and thus are critical to the success of such efforts. Described in this sub-section are three critical issues that were learned in this pioneering study. The detailed setup of learning algorithms will be introduced in the next section for deep learning and results.
As explained in the introduction section, data are a major driving force for deep learning. No study has been reported on the use of image data for stability analysis of geosystems. Therefore, it is unclear how to obtain and utilize such data. In this study, the major purpose is to prove the feasibility of applying imagedata-driven deep learning to geosystems, so the focus was placed on clean image data with 2D profiles of retaining walls generated by a computer. In this way, a large amount of high-quality data can be obtained without being distracted by less-relevant image preprocessing such as de-noising and thus can focus on the validation of the concept.
As shown in Figs. 2d and 6 images for cantilever retaining wall systems with different geometries were constructed using random numbers generated by 6, the retaining wall and the soil bodies on its two sides were generated in a 18 m 9 18 m rectangular region (canvas). The parameters in Table 1 were used to generate the image data to reach a compromise between the data variability and the classification balance (between failed and safe). As the first attempt at image-data-based deep learning for the stability analysis of geosystems, this study is focused on the geometry and thus adopts fixed material properties, which will be explored in the follow-up studies. The cohesion, internal friction angle, and density of the soil are 30 kPa (c), 308 (/), and 18.5 kN m 3 ( c), respectively; and the density of the retaining wall (assumed to be made of concrete) is 23.5 kN m 3 ( c c ). Labeled training datasets with 500, 1000, 2000, 5000, 10,000, 20,000, 400,000, 800,000, 120,000, and 200,000 images were generated with the above geometries for labeling, i.e., safe and failed. For each training dataset, 5/6 of the images were used for training and the rest 1/6 were used for validation (also called cross-validation in many deep learning publications). 5000 additional images were generated in the same way for testing. All the image data for training, validation, and testing were generated independently.
The retaining walls in the generated images were analyzed using Rankine's pressure theory for their stability against overturning (Das 2015). The images were labeled as safe or failed, depending on weather ratio between the stabilizing momentum, M s , and overturning momentum, M o , is greater than 1.
where
are active and passive Rankine's forces, respectively, in which K a ¼ tanðp=4 À /=2Þ 2 and K p ¼ tanðp=4 þ /=2Þ 2 are Rankine's active and passive pressure coefficients, respectively.
No safety factors were introduced in this pure mechanistic analysis. An assumption underneath the use of the above theory is that the theory has no model bias especially any potential bias/uncertainty in the calculation of Rankine's earth pressure coefficients.
Another critical technique to ensure the success of the image-data-driven deep learning in geosystems is transfer learning. It was found that, if the CNN is trained from scratch, that is, with initial weights generated from random numbers, the accuracy would remain at a very low level, e.g., less than 70%. The transfer learning technique was proven to be a very practical and powerful technique for building geosystem classifiers.
The idea behind transfer learning is analogous to cooking: for cuisine, it will be much more efficient to buy household food ingredients from groceries stores instead of growing the vegetables and hunting for the meats. Transfer learning starts the training from a trained model on a different dataset and adapts the trained model to the problem to be addressed. There are two strategies for transfer learning. The first strategy is to fine-tune the trained model, either the whole network or some layers, directly on the new replacing the fully-connected layers with new ones while fixing the other layers (as feature extractors) in training for new models. This study adopted the first strategy and an existing well-trained CNN, i.e., bvlc_reference_caffenet (Caffe's Model Zoo library), which was trained on the ImageNet dataset consisting of millions of images across 1000 categories.
Another factor critical to the success of the imagedata-driven deep learning in geosystems is the use of GPU, which is also a key to the recent advances in computer vision. CNNs require large datasets and a lot of computational time to train. Although training small CNNs for simple problems with normal CPUs could be possible, our computing experiments indicated that a GPU is essential. It takes days to train our CNN with an 8-core Intel i7-4790 3.6 GHz CPU using 4000 images. However, the time is shortened to less than one hour with an entry-level GPU, i.e., NVIDIA K620, and to several minutes with advanced GPU, i.e., NVIDIA K80. The deep learning framework used in this study, i.e., Caffe (Jia et al. 2014), provides options for GPU computation.
This section presents details for building, training, validating, and post-processing a CNN using an opensource deep learning framework, Caffe, and Python. The results will also be delivered and discussed.
Caffe is a deep learning framework developed by the Berkeley Vision and Learning Center, which comes with a C??, a Python, and a MATLAB interface. The Python interface was adopted and most of the deep learning work was conducted in a Linux environment (Red Hat distribution). The following are the five steps in deep learning with a CNN using Caffe.
1. Data preparation: The images as input are first cleaned and stored in a format that can be used by Caffe. A Python script was developed to handle both the pre-processing and storage of the images. Next, a Python module from the Python interface of Caffe, i.e., compute_image_mean, was utilized to obtain the mean image of the training data. Then, the mean image was subtracted from each input image to ensure that every feature pixel has zero mean. This is a common preprocessing step in supervised machine learning with image data to help improve the deep learning outcome. The pre-defined mean values of the R, G, B channels are 104, 117, and 123, respectively.
In this study, attempts were made to obtain a model using a CNN with an architecture shown in Fig. 7. As can be seen, this CNN, which is named GeoNet, contains a deep net consisting of multiple convolutional (Conv), ReLU, pooling (Pool), normalization, drop-out (Drop), and fully-connected (FC) layers. The arrows between layers show the direction of the data flow. The architecture was developed from a popular CNN model called AlexNet (Krizhevsky et al. 2012). This architecture was proven to be suitable for the binary classification tasks in this study, while more recent CNNs with deeper and wider architectures such as ResNet and Inception can be employed for more complex tasks.
The parameters of GeoNet was stored in a file with the extension of.prototxt. Table 2 lists the major parameters for different layers.
The solver in Caffe specifies the parameters for optimization. These parameters were defined in a.prototxt file. In detail, the solver adopted an adaptive learning rate method, AdaDelta (Zeiler 2012) for the optimization, and the initial learning rate was fixed at 0.001. The weight decay term for preventing overfitting is 0.0005 (weight_decay). The maximum training iteration number was set to 40,000 (max_iter). If this value is too small, convergence cannot be guaranteed; if it is too large, oscillations may be produced, leading to a waste of training time. Other parameters such as display frequency (display) and result recording frequency (snapshot) do not impact the training and validation results, and thus, can be chosen based on the needs and available resources. The solver mode is GPU (solver_mode).
With the model and solver defined in the above subsections, the training (including validation) process was started with the ''train'' tool provided by Caffe via command line in Bash as follows: ''path_to_train train -solver path_to_solver/solver_name.prototxt 2 [ &1 | tee path_to_log/log_name.log''. The model parameters were defined in a file named ''solver_name.prototxt''. This files also contains the paths for both the model definition file and the result file. Depending on the result recording frequency, the trained model, i.e., weights for neurons in the network, were saved as a file in the path and name that was specified in the solver file, appended with the iteration number. For example, if the snapshot_prefix was defined as path_to_result/model_name, then the trained model after 2000 iterations would be stored in the file ''model_-name_2000'' in the folder of ''path_to_result''.
As mentioned in the previous section, if deep learning is conducted using the above data, model, and solver, it is very difficult to obtain good training results. A much more efficient way is to start training from a trained model, which was not necessarily trained with our data or even image data containing the same type of object. This is because most images share similar low-level features such as lines. Here a very useful fine-tuning technique, transfer learning, was utilized. The transfer learning in this study was conducted with bvlc_reference_caffenet from Caffe's repository, Model Zoon, which has been widely used by researchers and machine learning practitioners to share their trained models. The model bvlc_refer-ence_caffenet was trained with the ImageNet dataset which contains millions of images across 1000 categories. The command was very similar to that for training from scratch and can also be used to restart a training process from any previously-stored model. The model configuration file used in the transfer learning was identical to that in the original training process.
The training alternates between training and validation iterations. The loss in the training and the loss and accuracy in the validation were saved to the log file at the frequency specified in the solver configuration file (via model parameters ''display' ' and ''test_interval''). The variations of the loss and the accuracy can be plotted in real time during the training (including validation) process using Python scripts or plotted manually after the training is finished. A script file was developed based on open-source code CaffePlot.py. Typical variations of the accuracy and loss (in the validation) are shown in Fig. 8. With NVIDIA K620 GPU, it took 14 h for GeoNet to achieve an accuracy of 97.94%, which scores the output as the accuracy of output with respect to the target. The loss in Figure ,L, was calculated as
where f w X i ð Þ is the loss at X i and r w ð Þ is a regularization term avoiding overfitting. Thus, it has been shown that an accuracy exceeding the traditional geotechnical ANNs' can be achieved with an entrylevel CNN and a small amount of computational effort while dealing with data whose size (e.g., Gigabytes), however, exceeds the size of the data processed by traditional ANNs (e.g., bytes) by orders (e.g., 9 orders).
After training, the trained model can be applied to predict/analyze image data that are independent of the training data. Ideally, it is hoped the trained model can be used to predict data that are out of the range of the training data-achieving a good generalization ability. This generalization ability has been tested to some extent in the testing process. In fact, when the validation dataset is independent of the training dataset, validation serves a role similar to testing. However, the validation may not be totally independent of the training, because the training and validation data, though exclusive of each other, can still be related depending on the sampling technique adopted. In this study, the training and validation datasets were generated by randomly splitting the training (and validation) datasets before training and remained unchanged during training. However, to provide a totally independent evaluation of the trained CNN, the trained model was used to analyze the 20,000 independent retaining wall images generated in the same way as the training and validation data. Such data were also labeled using the result from the mechanistic analysis. As a result, the labeled data can be used to validate the predictions, which provides us with a second validation of GeoNet.
The predictions were carried out with packages from the Python interface of Caffe. The images were first pre-processed in the same way as that used for the training and validation data. The same trained model, GeoNet, was used for predictions; therefore, the net architecture remains the same except for changing the final output layers from loss and accuracy layers to a Softmax layer for classifications, which is needed for predictions.
In binary classification problems, it is common to use a confusion matrix consisting of True Positive (TP), False Positive (FP), True Negative (TN), and False Negative (FN) to measure the outcome of the. The prediction results for 20,000 images are listed in Table 3. The accuracy is defined as
The accuracy of the classification using the trained GeoNet is 97.90%. As can be seen, the precision is very close to the accuracy obtained in the testing process, e.g., 97.94%. These results confirmed the high accuracy of the trained CNN in analyzing the stability of the geosystems via image data. 123
Sometimes, a trained model can exhibit significantly different performance in different aspects of predictions, i.e., in the selections of safe instances and failed instances. To further evaluate the performance of the trained CNN, the precision and recall were calculated. Precision P, also called positive predictive value, is the fraction of relevant instances (accurately predicted as safe) among the retrieved instances (predicted as safe); while recall R, also known as sensitivity, is the fraction of relevant instances (accurately predicted as safe) that have been retrieved over the total amount of relevant instances (safe):
The precision and recall are 97.82% and 97.97% respectively. Despite the slight difference, both of these two values are very close to the accuracy. Therefore, the trained has a good performance in different aspects of the predictions. It is worthwhile to mention that an accuracy value of 97.90% does not mean that the deep learning method is inferior to the classic mechanistic methods, which can obtain a 100% accuracy here. In this study, the classic mechanistic stability analysis method was just used as a reference. As we know, no mechanistic stability method is accurate due to the high uncertainty in geotechnical system analysis with typical safety factors ranging from 1.5 to 3. The goal of this study is to show the possibility of analyzing the stability of geosystems with image data directly, which has never been attempted. The mechanistic method was just utilized as a benchmark. This study could be a groundbreaking one in that it provides a big-data solution for geotechnical engineering and other civil engineering areas, especially for traditional stability analysis. Future studies with more categories, i.e., safety factors, instead of a binary classification of failed and safe, and more complicated and realistic images will advance the technique toward real-world applications.
The data size and computing power are two major concerns in the application of deep learning to the stability analysis of geosystems. Though big data is an inevitable trend in the long run, great numbers of highquality labeled data are still not easy to obtain. Therefore, it is desired that deep learning can be satisfactorily implemented with a relatively small amount of data. This concern was studied in this study via benchmark training with different dataset sizes. For the purpose, datasets with different sizes, i.e., 500, 1000, 2000, 5000, 10,000, 20,000, 40,000, 80,000, 120,000, 160,000, and 200,000, were generated and split into training (and validation) datasets using the same ratio, i.e., 5 training to 1 validation. The data were preprocessed in the way as explained in the previous sections. Shown in Fig. 9 are the variations of accuracy and loss with 5000 and 200,000 images. It seems that, for the stability analysis problem targeted in this study, at least 5000 images are needed. The results of the training with 5000 images exhibits overfitting: accuracy from validation does not improve while loss keeps decreasing. Training with a small dataset such as 500 is implementable, however, the training result with an accuracy value of 80% may not be acceptable. Therefore, in the application of deep learning to stability analysis, the data size is still a major factor for ensuring good training results.
To assess the influence of computing power, training with the above-mentioned datasets was carried out with two different GPU resources: 1 NVIDIA K620 (1 physical core, 384 CUDA cores, 400 MHz, 2 GB memory, 29 GB/s bandwidth) and 2 NVIDIA K80 (2 X 13 physical cores, 2 X 2496 CUDA cores, 562 MHz, 2 X 12 GB memory, 2 X 240 GB/s bandwidth). For example, for 200,000 samples and a batch size of 40, training with K620 used over 630 min while that with 2 K80 used only 64 min. For results, the major differences were observed between training processes with different batch sizes. K620 only allows a small batch size such as 40, while K80 can easily handle a batch size of 400 due to their different memory sizes. In Fig. 9, the training results for 5000 images but different batch sizes, i.e., 40 (K620) and 400 (K80), are illustrated. As can be seen, training with a small batch size exhibits a much lower accuracy and much more oscillations in the accuracy and loss variations. Therefore, higher computing power with better GPUs is another critical factor in gaining better deep learning results in the stability analysis of geosystems.
This paper presents a study for exploring the concept of image-data analysis of the stability of geosystems with deep learning. A deep CNN, GeoNet, which consists of multiple convolutional, pooling, ReLU, drop-out, and full connection layers was employed. The deep net functions like a brain. This brain, which was like a newborn baby's, was trained with images that were labeled as ''cat (safe)'' or ''dog (failed)'' in datasets of sizes from 500 to 2,000,000 images. With datasets including 10,000 or more images, this training enabled the ''baby's brain'' to soon gain an ability to classify retaining walls far superseding that of any human's, that is, with a success rate of over 97%. Independent validations also show the values of accuracy, precision, and recall are close to the accuracy obtained in training and validation. Technical details for all steps of deep learning with CNNs were provided. Further investigations into the dataset sizes and computational power yielded quantitative insights into the influence of data and computing resources on the application of deep learning in the stability analysis of geosystems. This study is a ground-breaking one for applying the recent advances in computer vision, including convolutional neural network, to the stability analysis of geosystems and also likely to be among the first of such kind in the mechanical analysis.