Soft computing techniques for compressive strength prediction of concrete cylinders strengthened by CFRP composites

6.2.1 Brief overview of NNs

Artificial neural networks (NNs) are computer models that mimic the biological nervous system. An NN can be defined as a massively parallel distributed processor that has a natural propensity for storing experiential knowledge and making it available for use [37]. The basic element of an NN is the artificial neuron as shown in Figure 2, which consists of three main components, namely as weights, bias, and an activation function.

Figure 2

Basic elements of an artificial neuron.

Each neuron receives inputs x1; x2;...; xn, attached with a weight w_i, which shows the connection strength for that input for each connection. Each input is then multiplied by the corresponding weight of the neuron connection. A bias b_i can be defined as a type of connection weight with a constant nonzero value added to the summation of inputs and corresponding weights u_i, given by

The summation u_i is transformed using a scalar-to-scalar function called an “activation or transfer function”, F(u_i), yielding a value called the unit’s “activation”, given by

Activation functions serve to introduce nonlinearity into NNs. which makes NNs so powerful. NNs are commonly classified by their network topology (i.e., feedback, feed forward) and learning or training algorithms (i.e., supervised, unsupervised). For example, a multilayer feed forward NN with back propagation indicates the architecture and learning algorithm of the NN.

6.2.2 Optimal NN model selection

The performance of an NN model mainly depends on the network architecture and parameter settings. One of the most difficult tasks in NN studies is to find this optimal network architecture, which is based on determination of numbers of optimal layers and neurons in the hidden layers by trial and error approach. The assignment of initial weights and other related parameters may also influence the performance of the NN in a great extent. However, there is no well-defined rule or procedure to have optimal network architecture and parameter settings where trial and error method still remains valid. This process is very time consuming. In this study, Matlab NN toolbox is used for NN applications. Matlab NN toolbox randomly assigns the initial weights for each run each time, which considerably changes the performance of the trained NN even if all parameters and NN architecture are kept constant. This leads to extra difficulties in the selection of optimal network architecture and parameter settings. To overcome this difficulty, a program has been developed in Matlab, which handles the trial and error process automatically. The program tries various numbers of layers and neurons in the hidden layers both for first and second hidden layers for a constant epoch for several times and selects the best NN architecture with the minimum MAPE or RMSE of the testing set, and maximum R value. For instance, an NN architecture with one hidden layer with five nodes is tested 10 times, and the average error of 10 trials is stored where in the second cycle the number of hidden nodes is increased to six, and the process is repeated. All of the errors for different networks are stored and compared to select the best network. This process is repeated N times where N denotes the number of hidden nodes for the first hidden layer. This whole process is repeated for a changing number of nodes in the second hidden layer. Moreover, this selection process can be performed for different back propagation training algorithms such as trainlm, trainscg, and trainbfg, wherein the best one here selected is trainlm, which is a Levenberg-Marquardt algorithm. The Levenberg-Marquardt (LM) algorithm randomly divides input vectors and target vectors into three sets including training, validation, and testing. Changing the relative percentages of these three sets could slightly improve the generalization process. In this study, as a preliminary step, some data sets with different relative percentages were examined in which the training data varies from 50% to 90%, and the values of 60%, 20%, and 20% were selected for training, validation, and testing, respectively, in order to obtain the most efficient distribution of data sets. So, 60% of the whole data was specified as the training data in which the network would be adjusted according to its error. Similarly, 20% of the database was considered as the validating data, which was used to measure network generalization and to halt training when generalization stops improving. Finally, the remaining 20% of the whole data was specified as the testing data, which has no effect on training and so provides an independent measure of network performance during and after training. The network architecture used in this study was called NN 6-n-1, where the first digit is the number of input nodes, n is the number of nodes in the hidden layer, and the last digit is the number of output nodes as shown in Figure 3.

Figure 3

Schematic diagram of ANN model.

In this program, up to 20 neurons in the hidden layer were tested, and the optimal network was selected based on the minimum error and maximum correlation. The flowchart of the whole process is shown in Figure 4, in which the minimum error has occurred with six neurons in the hidden layer. So, the optimal NN architecture was obtained as 6-6-1. The results for training, validation, and testing of the NN 6-6-1 are summarized in Figures 5–7.

Figure 4

Flowchart of optimal NN selection.

Figure 5

Performance of NN 6-6-1.

Figure 6

Training state of NN 6-6-1.

Figure 7

Regressions of training, validation, testing, and all data simulated by NN 6-6-1.

6.3.1 Brief overview of GEP

Gene expression programming (GEP) software, which is used in this study is an extension to GP that evolves computer programs of different sizes and shapes encoded in linear chromosomes of fixed length. The chromosomes are composed of multiple genes, each gene encoding a smaller subprogram. Furthermore, the structural and functional organization of the linear chromosomes allows the unconstrained operation of important genetic operators such as mutation, transposition, and recombination. A significance of the GEP approach is that the creation of genetic diversity is extremely simplified as genetic operators work at the chromosome level. Another significance of GEP consists of its unique, multigenic nature which allows the evolution of more complex programs composed of several subprograms. As a result, GEP surpasses the old GP system in 100–10,000 times [43–45]. APS 3.0 (http://www.gepsoft.com/), GEP software developed by Candida Ferreira, is used in this study. The fundamental difference between GA, GP, and GEP is due to the nature of the individuals: in GAs, the individuals are linear strings of fixed length (chromosomes); in GP, the individuals are nonlinear entities of different sizes and shapes (parse trees); and in GEP, the individuals are encoded as linear strings of fixed length (the genome or chromosomes), which are afterwards expressed as nonlinear entities of different sizes and shapes (i.e., simple diagram representations or expression trees). Thus, the two main parameters of GEP are the chromosomes and expression trees (ETs). The process of information decoding (from the chromosomes to the ETs) is called translation, which is based on a set of rules. The genetic code is very simple where there exist one-to-one relationships between the symbols of the chromosome and the functions or terminals they represent. The rules, which are also very simple, determine the spatial organization of the functions and terminals in the ETs and the type of interaction between sub-ETs [43–45]. That is why two languages are utilized in GEP: the language of the genes and the language of ETs. A significant advantage of GEP is that it enables us to infer exactly the phenotype given the sequence of a gene, and vice versa, which is termed as Karva language. Consider, for example, the algebraic expression d4∗d3-d0+d1∗d4-d4, which can be represented by a diagram (Figure 8), which is the expression tree.

Figure 8

Expression tree (ET).

6.3.2 Solving a simple problem with GEP

For each problem, the type of linking function, as well as the number of genes and the length of each gene, are a priori chosen for each problem. While attempting to solve a problem, one can always start by using a single-gene chromosome and then proceed by increasing the length of the head. If it becomes very large, one can increase the number of genes and obviously choose a function to link the sub-ETs. One can start with addition for algebraic expressions or OR for Boolean expressions, but in some cases, another linking function might be more appropriate (like multiplication or IF, for instance). The idea, of course, is to find a good solution, and GEP provides the means of finding one very efficiently [44]. As an illustrative example, consider the following case where the objective is to show how GEP can be used to model complex realities with high accuracy. So, suppose one is given a sampling of the numerical values from the curve (remember, however, that in real-world problems, the function is obviously unknown):

There are over 10 randomly chosen points in the real interval [-10, +10] and the aim is to find a function fitting those values within a certain error. In this case, a sample of data in the form of 10 pairs (a_i, y_i) is given, where a_i is the value of the independent variable in the given interval, and y_i is the respective value of the dependent variable (a_i values: -4.2605, -2.0437, -9.8317, -8.6491, 0.7328, -3.6101, 2.7429, -1.8999, -4.8852, 7.3998; the corresponding y_i values can be easily evaluated). These 10 pairs are the fitness cases (the input) that will be used as the adaptation environment. The fitness of a particular program will depend on how well it performs in this environment [44]. There are five major steps in preparing to use GEP. The first is to choose the fitness function. For this problem, one could measure the fitness f_i of an individual program i by the following expression:

where M is the range of selection, C₍i_,j₎ the value returned by the individual chromosome i for fitness case j (out of Ct fitness cases), and T_j is the target value for fitness case j. If, for all j, ∣C₍i_,j₎–T_j∣ (the precision) is less than or equal to 0.01, then the precision is equal to zero, and f_i=f_max=C_t*M. For this problem, use an M=100, and therefore, f_max=1000. The advantage of this kind of fitness function is that the system can find the optimal solution for itself. However, there are other fitness functions available, which can be appropriate for different problem types [44]. The second step is choosing the set of terminals T and the set of functions F to create the chromosomes. In this problem, the terminal set consists obviously of the independent variable, i.e., T={a}. The choice of the appropriate function set is not so obvious, but a good guess can always be done in order to include all the necessary functions. In this case, to make things simple, use the four basic arithmetic operators. Thus, F={+, -, *, /}. It should be noted that there are many other functions that can be used. The third step is to choose the chromosomal architecture, i.e., the length of the head and the number of genes.

The fourth major step in preparing to use GEP is to choose the linking function. In this case, we will link the sub-ETs by addition. Other linking functions are also available such as subtraction, multiplication, and division. Finally, the fifth step is to choose the set of genetic operators that cause variation and their rates. In this case, one can use a combination of all genetic operators (mutation at pm=0.051; IS and RIS transposition at rates of 0.1 and three transpositions of lengths 1, 2, and 3; one-point and two-point recombination at rates of 0.3; gene transposition and gene recombination both at rates of 0.1). To solve this problem, let us choose an evolutionary time of 50 generations and a small population of 20 individuals in order to simplify the analysis of the evolutionary process and not fill this text with pages of encoded individuals. However, one of the advantages of GEP is that it is capable of solving relatively complex problems using small population sizes, and thanks to the compact Karva notation, it is possible to fully analyze the evolutionary history of a run. A perfect solution can be found in generation 3, which has the maximum value 1000 of fitness. The sub-ETs codified by each gene are given in Figure 9. Note that it corresponds exactly to the same test function given above in Eq. (10) [44]. Thus, expressions for each corresponding sub-ET can be given as follows:

Figure 9

ET for the problem of Eq. (10).

6.3.3 Numerical application of GP

The main focus of the GP in this paper is to model the compressive strength of CFRP-confined concrete cylinders based on experimental database gathered from the literature. Among these experimental data, 96 sets were used for GP training and 32 sets for GP testing. As mentioned earlier, the compressive strength of confined concrete is considered as a function of geometric and mechanical properties given as follows:

f′cc=f(f′c, d, h, t, εrup, EFRP)

Related parameters for the training of the GP model are given in Table 5. Detailed information on the values given in Table 3 can be found in Section 6.3.2.

6.4.1 Architecture of ANFIS

The architecture of an ANFIS model with two input variables is shown in Figure 10. Suppose that the rule base of ANFIS contains two fuzzy IF-THEN rules of Takagi and Sugeno type as follows:

Figure 10

The reasoning scheme of ANFIS [44].

Rule 1: IF x is A1 and y is B1, THEN f1=p1x+q1y+r1.

Rule 2: IF x is A2 and y is B2, THEN f2=p2x+q2y+r2.

where A1, A2 and B1, B2 are membership values of input variables x and y, respectively; p1, q1, r1 and p2, q2, r2 are the parameters of the output functions f1 and f2, respectively. A basic Takagi-Sugeno inference system, which produces an output function f from input variables x and y by applying triangular membership functions is illustrated schematically in Figure 10, and also, the corresponding equivalent ANFIS architecture is shown in Figure 11.

Figure 11

Schematic of ANFIS architecture [44].

The functions of each layer are described as follows [46–48]:

Layer 1 – Every node i in this layer is a square node with a node function:

where x is the input to node i, and A_i is the linguistic label (fuzzy sets: small, large,...) associated with this node function.

Layer 2 – Every node in this layer is a circle node labeled Π, which multiplies the incoming signals and sends the product out. For instance,

Each node output represents the firing weight of a rule.

Layer 3 – Every node in this layer is a circle node labeled N. The ith node calculates the ratio of the ith rule’s firing weight to the sum of all rule’s firing weights:

Layer 4 – Every node in this layer is a square node with a node function:

where w¯i is the output of layer 3, and {p_i, q_i, r_i} is the parameter set.

Layer 5 – The signal node in this layer is a circle node labeled Σ that computes the overall output as the summation of all incoming signals, i.e.,

The basic learning rule of ANFIS is the back-propagation gradient descent, which calculates error signals recursively from the output layer backward to the input nodes. This learning rule is exactly the same as the back-propagation learning rule used in the common feed-forward neural networks [47, 48]. Recently, ANFIS adopted a rapid learning method named as hybrid-learning method, which utilizes the gradient descent and the least-squares method to find a feasible set of antecedent and consequent parameters [47, 48]. Thus, in this paper, the latter method is used for constructing the proposed models.

The structure of the proposed ANFIS networks was consisted of six input variables (i.e., d,  h,  t,  E,  ε,  and  f′c) and one output variable (f′cc). In this paper, for comparison purposes, five types of membership functions (MFs) including the triangular, trapezoidal, bell-shape, Gaussian, and π-shaped were utilized to construct the suggested models. The ANFIS models were trained by 96 data sets and tested by 32 data sets. Moreover, to monitor the performance of the training process, 32 data sets were randomly selected as checking sets from both training and testing pairs. Parameter types and their values used in the ANFIS models can be seen in Table 6.