Cable-stayed bridge fire-induced broken cable stress data generation method based on time convolution-gan

Abstract

The application discloses a cable-stayed bridge fire-induced broken cable stress data generation method based on a time sequence convolution-GAN, and specifically relates to the following steps: simulating the tension change of a cable and the stress-strain redistribution of a stiffening beam caused by the breaking of different numbers of cables at different positions possibly caused by a sudden fire accident of a large-span cable-stayed bridge, collecting the tension of each cable and the stress-strain data of the stiffening beam of each cable under each cable breaking condition along the bridge length direction, preprocessing the data, and constructing a data set required for training a GAN network; building a GAN network model fused with a time sequence convolution; inputting a random vector and training set data to train the GAN network model fused with the time sequence convolution, obtaining a generation network; generating cable tension or stiffening beam stress data after the breaking of different numbers of cables at different positions by using the GAN network model fused with the time sequence convolution, measuring the data generation quality, and evaluating the distribution difference between real data and generated data.

Description

TECHNICAL FIELD

[0001] The present application relates to the cross field of bridge engineering and artificial intelligence, in particular to a cable-stayed bridge fire-induced broken cable stress data generation method based on a temporal convolution-GAN. BACKGROUND

[0002] As an important model in deep learning, the temporal convolutional network (TCN) combines the advantages of convolutional neural networks (CNN) and long short-term memory networks (LSTM), and can effectively process two-dimensional image data and one-dimensional sequence data, automatically extract and learn features, and achieve accurate prediction and analysis of complex time series data. However, there are still many challenges in the rapid generation of cable-stayed bridge cable stress-strain data. On the one hand, the cable-stayed bridge cable stress-strain data has the characteristics of time series, nonlinearity, high dimensionality, etc., and the traditional data analysis method is difficult to accurately capture its internal law; on the other hand, due to environmental factors such as sudden fire accidents and other factors, the cable-stayed bridge cable stress-strain data has great uncertainty and volatility, further increasing the difficulty of data generation. SUMMARY

[0003] In view of the above technical deficiencies, the purpose of the present application is to provide a cable-stayed bridge fire-induced broken cable stress data generation method based on temporal convolution-GAN, which can overcome the limitations of existing cable-stayed bridge cable tension and stiffening beam stress-strain data acquisition methods and force performance evaluation problems under sudden accident fires, provide efficient and accurate data support for bridge multi-disaster prevention and early warning, and promote the deep integration and development of bridge engineering and artificial intelligence technology.

[0004] To solve the above technical problems, the present application adopts the following technical solutions:

[0005] The present application provides a cable-stayed bridge fire-induced broken cable stress data generation method based on temporal convolution-GAN, comprising the following steps:

[0006] Step 1: Use software to simulate the cable tension changes and stiffening beam stress-strain redistribution caused by the rupture of different numbers of cables at different positions due to sudden fire accidents on long-span cable-stayed bridges, collect the tension of each cable and the stress-strain data of the stiffening beam along the bridge length direction under each cable rupture condition, and preprocess the data to construct the data set required for training the GAN network;

[0007] Step 2: Build a GAN network model fused with temporal convolution, including a data generator and a discriminator;

[0008] Step 3: Input a random vector and training set data to train the GAN network network fused with temporal convolution, and obtain a generation network;

[0009] Step 4: Generate cable tension or stiffened beam stress data after cable rupture at different positions and different numbers of cables using a GAN network model with fused temporal convolution, and use root mean square error, mean absolute error and R 2 To measure the quality of data generation, principal component analysis and t-SNE data dimensionality reduction visualization techniques are used to evaluate the distribution difference between real data and generated data.

[0010] Preferably, in step 1, the data set required for training the GAN network is constructed, specifically including:

[0011] Step 1.1: Use finite element analysis software to establish a 1:1 refined numerical model of the cable-stayed bridge. The cables are simulated by line elements, and the remaining main tower, steel box girder and main girder structure are constructed by three-dimensional shell elements. The cables are selected by truss elements, and the remaining solid parts are selected by linear four-edge elements, with a total of 46710 elements. The cables are connected to the main tower and stiffened beam using MPC hinges. The prestress of the cables is applied using stress in the load predefinition field. The analysis and calculation are performed using the static general analysis step.

[0012] Step 1.2: Use ODB file output to export key grid stress-strain data and save it as a.csv format;

[0013] Step 1.3: Use the read_csv function in the Numpy database to read the data and convert it to a dictionary type, and perform normalization processing to ensure that the data value is between 0 and 1.

[0014] Step 1.4: Use the torch.tensor function to convert the dictionary data to a 32-bit floating-point operation tensor form, which is convenient for network training and reading.

[0015] Preferably, step 2 specifically includes the following steps:

[0016] Step 2.1: The GAN network with fused temporal convolution includes 4 temporal convolution neural network modules with different parameters, which contain 2-3 one-dimensional convolutional neural networks, 1 LeakyReLU nonlinear activation function, 3 layers of fully connected layers with different numbers of neurons, 1 ReLU and 1 Tanh nonlinear activation function.

[0017] Step 2.1.1: Use the nn.Conv1d module in the Pytorch library to build the temporal convolution neural network module.

[0018] Step 2.1.2: Two fully connected layers and two nonlinear activation layers are sequentially built using nn.Linear module, nn.ReLU and nn.Tanh nonlinear activation units in Pytorch library; the input and output channel numbers of the first fully connected layer are 256 and 512 respectively, ensuring the consistency of the output channel number with the fourth temporal convolutional neural network module and connecting the ReLU nonlinear activation function; the input and output channel numbers of the second fully connected layer are 512 and N respectively, connecting the Tanh nonlinear activation function and outputting the generated data;

[0019] Step 2.2: The discriminator includes three temporal convolutional neural network modules, two fully connected layers and one ReLU nonlinear activation function.

[0020] Preferably, step 2.1.1: a temporal convolutional neural network module is built using nn.Conv1d module unit in Pytorch library; specifically:

[0021] The input channel, output channel, convolution kernel size and dilation rate of the first temporal convolutional neural network module are N, 512, 3 and 1 respectively, and N is consistent with the dimension of the input data; the temporal convolutional neural network module contains three one-dimensional convolutional neural networks and a LeakyReLU nonlinear activation function; the input channel, output channel, convolution kernel size, dilation rate and padding value of the first one-dimensional convolutional neural network are N, 512, 3, 1 and 1 respectively; the second one-dimensional convolutional neural network is sequentially connected with the first one-dimensional convolutional neural network, and the input channel, output channel, convolution kernel size, dilation rate and padding value are 512, 512, 3, 1 and 1 respectively; then it is connected with the LeakyReLU nonlinear activation function; it should be pointed out that if the data dimension N≠512, there will be an additional branch of residual connection in the one-dimensional convolutional neural network, which connects the input data with the output parameters of the LeakyReLU nonlinear activation function, and contains one one-dimensional convolutional neural network with input and output channels and a convolution kernel size of N, 512 and 1 respectively;

[0022] The input channel, output channel, convolution kernel size and dilation rate of the second temporal convolutional neural network module are 512, 512, 3 and 2 respectively; it contains two one-dimensional convolutional neural networks and one LeakyReLU nonlinear activation function layer, and the input channel, output channel, convolution kernel size, dilation rate and padding value of the two one-dimensional convolutional neural networks are 512, 512, 3, 2 and 2 respectively;

[0023] The input channel, output channel, convolution kernel size and dilated rate of the third time sequence convolutional neural network module are 512, 256, 3 and 4 respectively; it contains three one-dimensional convolutional neural networks and a LeakyRuLU nonlinear activation function layer, the first two one-dimensional convolutional neural networks are connected in sequence with the LeakyRuLU nonlinear activation function, and the third one-dimensional convolutional neural network contains a residual connection; the input channel, output channel, convolution kernel size, dilated rate and padding value of the first one-dimensional convolutional neural network are 512, 256, 3, 4 and 4 respectively; the input channel, output channel, convolution kernel size, dilated rate and padding value of the second one-dimensional convolutional neural network are 256, 256, 3, 4 and 4 respectively; the input channel, output channel and convolution kernel size of the third one-dimensional convolutional neural network are 512, 256 and 3 respectively;

[0024] The input channel, output channel, convolution kernel size and dilated rate of the fourth time sequence convolutional neural network module are 256, 256, 3 and 8 respectively; it contains two one-dimensional convolutional neural networks and a LeakyReLU nonlinear activation function, and the input channel, output channel, convolution kernel size, dilated rate and padding value of the two one-dimensional convolutional neural networks are 256, 256, 3, 8 and 8 respectively;

[0025] Preferably, step 2.2.1 is specifically:

[0026] The input channel, output channel, convolution kernel size and dilated rate of the first time sequence convolutional neural network module are N, 512, 3 and 1 respectively; it contains three one-dimensional convolutional neural networks and a LeakyReLU nonlinear activation function; the input channel, output channel, convolution kernel size, dilated rate and padding value of the first one-dimensional convolutional neural network are N, 512, 3, 1 and 1 respectively; the second one-dimensional convolutional neural network is connected in sequence with the first one, and the input channel, output channel, convolution kernel size, dilated rate and padding value are 512, 512, 3, 1 and 1 respectively; then it is connected with a LeakyReLU nonlinear activation function; if the data dimension N≠512, the third one-dimensional convolutional neural network contains a residual connection, and the input, output channel and convolution kernel size are N, 512 and 1 respectively;

[0027] The input channel, output channel, convolution kernel size and dilated rate of the second time sequence convolutional neural network module are 512, 512, 3 and 2 respectively; it contains two one-dimensional convolutional neural networks and a LeakyReLU nonlinear activation function, and the input channel, output channel, convolution kernel size, dilated rate and padding value of the two one-dimensional convolutional neural networks are 512, 512, 3, 2 and 2 respectively;

[0028] The input channel, output channel, convolution kernel size and inflation rate of the third time sequence convolutional neural network module are 512, 256, 3 and 4 respectively; it includes three one-dimensional convolutional neural networks and a LeakyRuLU nonlinear activation function, the first two one-dimensional convolutional neural networks are connected in sequence with the LeakyRuLU nonlinear activation function, and the third one-dimensional convolutional neural network is a residual connection; the input channel, output channel, convolution kernel size, inflation rate and padding value of the first one-dimensional convolutional neural network are 512, 256, 3, 4 and 4 respectively; the input channel, output channel, convolution kernel size, inflation rate and padding value of the second one-dimensional convolutional neural network are 256, 256, 3, 4 and 4 respectively; the input channel, output channel and convolution kernel size of the third one-dimensional convolutional neural network are 512, 256 and 3 respectively.

[0029] Two fully connected layers and one nonlinear activation function are sequentially built using the nn.Linear module and the nn.ReLU nonlinear activation function in the Pytorch library; the input and output channel numbers of the first fully connected layer are 256 and 512 respectively, ensuring that the output channel number of the third time sequence convolutional neural network module in the discriminator network is consistent, and connecting the ReLU nonlinear activation function; the input and output channel numbers of the second fully connected layer are 512 and 1 respectively, and the output is the discrimination score.

[0030] Preferably, step 3 specifically includes the following steps:

[0031] Step 3.1: Adversarial training of the generator and the discriminator; the network parameters of the generator and the discriminator are randomly initialized using the torch.randn function provided in the Pytorch library, and the parameters of the Adam optimizer are initialized by instance;

[0032] Step 3.2: Training the discriminator network using generated data and real data;

[0033] Step 3.2.1: Sample a batch of data from the training set, and initialize a set of random variables with the same dimension as the real data;

[0034] Step 3.2.2: Input the random variable into the generator network to output the generated cable tension data;

[0035] Step 3.2.3: Input the generated cable tension data and real data into the discriminator network to output the discrimination score; for real data, the output score of the discriminator will tend to 1, and the discrimination score of the generated data will tend to 0; finally, the discrimination score output by the discriminator will tend to 0.5, i.e. the discriminator cannot distinguish between generated data and real data;

[0036] Step 3.2.4: Calculate the discriminator loss by Wasserstein distance, and add a gradient penalty term to ensure the stability of the training process and avoid the phenomenon of gradient vanishing or explosion of the discriminator. The loss calculation formula is as follows:

[0037]

[0038] where x is the real data, z is the random noise, P r is the real sample distribution, P z is the random noise distribution, D(x) is the discriminator output score for real data, G(z) is the generated data output by the generator, D(G(z)) is the discriminator output score for generated data, the third term is the gradient penalty term to force the discriminator to satisfy the Lipschitz continuity condition, λ is the penalty coefficient, x' is the interpolation between real samples and generated samples, P x` is the interpolation distribution;

[0039] Step 3.2.5: Calculate the discriminator loss value, and propagate the loss gradient to the discriminator parameters through backpropagation;

[0040] Step 3.2.6: Update the discriminator parameters using the RMSprop optimizer to better distinguish real data and generated data;

[0041] Step 3.3: Update the generator network using the discriminator network loss;

[0042] Step 3.3.1: Initialize a set of random variables input to the generator network, output the generated data, and then input it to the discriminator for scoring, output the discrimination score;

[0043] Step 3.3.2: The loss function of the generator will maximize the discrimination score, so that the data generated by the generator is as close to the real data as possible, thereby cheating the discriminator. The loss calculation formula is as follows:

[0044]

[0045] where the meanings of the symbols are consistent with the discriminator loss calculation formula in step 3.2.4;

[0046] Step 3.3.3: Calculate the total loss and propagate the loss to the generator through the gradient backpropagation method;

[0047] Step 3.3.4: Use the Adam optimizer to update the generator network parameters according to the loss value, so that it can generate more realistic data. The values of parameters β1 and β2 in the optimizer are 0.9 and 0.999, respectively;

[0048] Step 3.3.5: Iterating the above training process, when the discriminant score output by the discriminator tends to 0.5, it indicates that the generator and discriminator have reached a relatively balanced state, and the training is completed;

[0049] Step 3.4: Co-training for 10000 rounds, using the torch.save.state_dict function in the Pytorch library to save the generator network weight every 1000 rounds.

[0050] Preferably, in step 4, the data generation quality evaluation index and data visualization dimensionality reduction analysis specifically include the following steps:

[0051] Step 4.1: Use the torch.load.load_state_dict call to complete the trained generator model, use the torch.rand function to generate random variables, and use the torch.tensor function to convert them to vector form, input to the generator, output the generated cable tension data, and store the data after inverse normalization;

[0052] Step 4.2: Use the sqrt and mean_squared_error functions provided in the Numpy library to calculate the root mean square error between the generated data and the real data, and save the error results in.txt format;

[0053] Step 4.3: Use the mean_absolute_error function provided in the Numpy library to calculate the mean absolute error between the generated data and the real data, and save the error results in.txt format;

[0054] Step 4.4: Use the r2_score function provided in the Numpy library to calculate the R 2 , save the error results in.txt format;

[0055] Step 4.5: Use the PCA function provided in the sklearn library to calculate the two-dimensional distribution rule between the generated data and the real data, and use the plt function in the matplotlib library to save the analysis results in the form of pictures;

[0056] Step 4.6: Use the TSNE function provided in the sklearn library to calculate the two-dimensional distribution rule between the generated data and the real data, and use the plt function in the matplotlib library to save the analysis results in the form of pictures.

[0057] The method of the present application introduces a time sequence convolutional neural network module in the generative adversarial network, increases the receptive field of the model, expands the data capture range of the model, improves the data generation quality, and introduces a Wasserstein distance loss function to improve the stability of the model training process and accelerate the model convergence. BRIEF DESCRIPTION OF DRAWINGS

[0058] In order to more clearly illustrate the technical solutions in the embodiments of the present application or the prior art, the drawings needed to be used in the embodiments or the prior art description will be briefly introduced. Obviously, the drawings in the following description are only some embodiments of the present application, and other drawings can be obtained by those skilled in the art without creative labor.

[0059] Fig. 1 The generative adversarial network architecture based on time sequence convolution provided for the embodiments of the present application is shown in the figure.

[0060] Fig. 2 The stress-strain data generation figure of the stiffened beam under the condition of cable rupture is shown in the figure.

[0061] Fig. 3 The stress-strain real and generated data dimensionality reduction analysis figure of the stiffened beam under the condition of cable rupture is shown in the figure. DETAILED DESCRIPTION

[0062] The technical solutions in the embodiments of the present application will be described clearly and completely in combination with the drawings in the embodiments of the present application. Obviously, the described embodiments are only some embodiments of the present application, not all embodiments. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without creative labor are within the scope of protection of the present application.

[0063] As shown in the figure, the cable stress data generation method for cable rupture caused by fire of a cable-stayed bridge based on time sequence convolution-GAN includes the following steps: Figs. 1 to 3 Step 1: Use software to simulate the cable tension changes and stiffened beam stress-strain redistribution caused by cable rupture at different positions and different numbers of cables caused by sudden fire accidents of long-span cable-stayed bridges, collect the tension of each cable and the stress-strain data of the stiffened beam under each cable rupture condition along the bridge length direction, preprocess the data, and construct the data set required for training the GAN network.

[0064]

[0065] ​The data set required for constructing the training GAN network specifically includes:

[0066] Step 1.1: Use finite element analysis software to establish a 1:1 refined numerical model of the cable-stayed bridge. The cables are simulated by line elements, and the remaining main tower, steel box girder, and main girder structure are constructed by three-dimensional shell elements. The cables are selected by truss elements, and the remaining solid parts are selected by linear four-edge elements. The total number of elements is 46710. The cables and the main tower and stiffened beam are connected using MPC hinges. The cable prestress is applied using stress in the load predefinition field. The static general analysis step is used for analysis and calculation.

[0067] Step 1.2: Use the ODB file output to export key grid stress-strain data and save it as a.csv format.

[0068] Step 1.3: Use the read_csv function in the Numpy database to read the data and convert it to a dictionary type, and perform normalization processing to ensure that the data value is between 0 and 1.

[0069] Step 1.4: Use the torch.tensor function to convert the dictionary data to a 32-bit floating-point operation tensor form, which is convenient for network training reading.

[0070] Step 2: Build a GAN network model that integrates time series convolution, including data generator and discriminator.

[0071] Specifically, the following steps are included:

[0072] Step 2.1: The GAN network that integrates time series convolution includes 4 Temporal Convolutional Network Blocks (TCN Blocks) with different parameters. Each TCN Block contains 2-3 one-dimensional convolutional neural networks, 1 LeakyReLU nonlinear activation function, 3 layers of fully connected layers with different numbers of neurons, 1 ReLU and 1 Tanh nonlinear activation function.

[0073] Step 2.1.1: Use the nn.Conv1d module unit in the Pytorch library to build the Temporal Convolutional Network Block.

[0074] Use the nn.Conv1d module unit in the Pytorch library to build the Temporal Convolutional Network Block. Specifically:

[0075] The input channel, output channel, convolution kernel size and dilation rate of the first time sequence convolutional neural network module are N, 512, 3 and 1 respectively, and N is consistent with the dimension of the input data; the first time sequence convolutional neural network module comprises three one-dimensional convolutional neural networks and a LeakyReLU nonlinear activation function; the input channel, output channel, convolution kernel size, dilation rate and padding value of the first one-dimensional convolutional neural network are N, 512, 3, 1 and 1 respectively; the second one-dimensional convolutional neural network is sequentially connected with the first one-dimensional convolutional neural network, and the input channel (in_c), output channel (out_c), convolution kernel size, dilation rate (dilation) and padding value (padding) are 512, 512, 3, 1 and 1 respectively; then the LeakyReLU nonlinear activation function is connected; it should be pointed out that if the data dimension N ≠ 512, there will be an additional branch of residual connection (Residual Connection) in the one-dimensional convolutional neural network, which connects the input data and the output parameters of the LeakyReLU nonlinear activation function, and comprises one one-dimensional convolutional neural network, and the input channel, output channel and convolution kernel size are N, 512 and 1 respectively;

[0076] The input channel, output channel, convolution kernel size and dilation rate of the second time sequence convolutional neural network module are 512, 512, 3 and 2 respectively; which comprises two one-dimensional convolutional neural networks and one LeakyReLU nonlinear activation function layer, and the input channel, output channel, convolution kernel size, dilation rate and padding value of the two one-dimensional convolutional neural networks are 512, 512, 3, 2 and 2 respectively;

[0077] The input channel, output channel, convolution kernel size and dilation rate of the third time sequence convolutional neural network module are 512, 256, 3 and 4 respectively; which comprises three one-dimensional convolutional neural networks and one LeakyRuLU nonlinear activation function layer, the first two one-dimensional convolutional neural networks are sequentially connected with the LeakyRuLU nonlinear activation function, and the third one-dimensional convolutional neural network comprises a residual connection; the input channel, output channel, convolution kernel size, dilation rate and padding value of the first one-dimensional convolutional neural network are 512, 256, 3, 4 and 4 respectively; the input channel, output channel, convolution kernel size, dilation rate and padding value of the second one-dimensional convolutional neural network are 256, 256, 3, 4 and 4 respectively; the input channel, output channel and convolution kernel size of the third one-dimensional convolutional neural network are 512, 256 and 3 respectively;

[0078] The input channel, output channel, convolution kernel size and dilated rate of the fourth time sequence convolutional neural network module are 256, 256, 3 and 8 respectively; wherein, two one-dimensional convolutional neural networks and one LeakyReLU nonlinear activation function are included, and the input channel, output channel, convolution kernel size, dilated rate and padding value of the two one-dimensional convolutional neural networks are 256, 256, 3, 8 and 8 respectively;

[0079] Step 2.1.2: using nn.Linear module, nn.ReLU and nn.Tanh nonlinear activation unit in Pytorch library, two fully connected layers and two nonlinear activation layers are built in sequence; the input and output channel numbers of the first fully connected layer are 256 and 512 respectively, to ensure that the output channel number is consistent with that of the fourth time sequence convolutional neural network module, and to connect the ReLU nonlinear activation function; the input and output channel numbers of the second fully connected layer are 512 and N, to connect the Tanh nonlinear activation function and output generated data;

[0080] Step 2.2: the discriminator includes three time sequence convolutional neural network modules, two fully connected layers and one ReLU nonlinear activation function;

[0081] Step 2.2.1 is specifically:

[0082] The input channel, output channel, convolution kernel size and dilated rate of the first time sequence convolutional neural network module are N, 512, 3 and 1 respectively; the module includes three one-dimensional convolutional neural networks and one LeakyReLU nonlinear activation function; the input channel, output channel, convolution kernel size, dilated rate and padding value of the first one-dimensional convolutional neural network are N, 512, 3, 1 and 1 respectively; the second one-dimensional convolutional neural network is connected in sequence with the first one-dimensional convolutional neural network, and the input channel, output channel, convolution kernel size, dilated rate and padding value are 512, 512, 3, 1 and 1 respectively; then a LeakyReLU nonlinear activation function is connected; if the data dimension N ≠ 512, the third one-dimensional convolutional neural network includes a residual connection, and the input, output channel and convolution kernel size are N, 512 and 1 respectively;

[0083] The input channel, output channel, convolution kernel size and dilated rate of the second time sequence convolutional neural network module are 512, 512, 3 and 2 respectively; wherein, two one-dimensional convolutional neural networks and one LeakyReLU nonlinear activation function are included, and the input channel, output channel, convolution kernel size, dilated rate and padding value of the two one-dimensional convolutional neural networks are 512, 512, 3, 2 and 2 respectively;

[0084] The input channel, output channel, convolution kernel size and inflation rate of the third time sequence convolutional neural network module are 512, 256, 3 and 4 respectively; it contains three one-dimensional convolutional neural networks and a LeakyRuLU nonlinear activation function, the first two one-dimensional convolutional neural networks are connected in sequence with the LeakyRuLU nonlinear activation function, and the third one-dimensional convolutional neural network is a residual connection; the input channel, output channel, convolution kernel size, inflation rate and padding value of the first one-dimensional convolutional neural network are 512, 256, 3, 4 and 4 respectively; the input channel, output channel, convolution kernel size, inflation rate and padding value of the second one-dimensional convolutional neural network are 256, 256, 3, 4 and 4 respectively; the input channel, output channel and convolution kernel size of the third one-dimensional convolutional neural network are 512, 256 and 3 respectively.

[0085] Two fully connected layers and one nonlinear activation function are sequentially built using the nn.Linear module and the nn.ReLU nonlinear activation function in the Pytorch library; the input and output channel numbers of the first fully connected layer are 256 and 512 respectively, ensuring that the output channel number of the third time sequence convolutional neural network module in the discriminator network is consistent, and connecting the ReLU nonlinear activation function; the input and output channel numbers of the second fully connected layer are 512 and 1, and the output is the discrimination score.

[0086] Step 3: input random vector and training set data to train the fusion time sequence convolutional GAN network, and obtain the generation network; specifically including the following steps:

[0087] Step 3.1: adversarial training of the generator and the discriminator; the generator and the discriminator network parameters are randomly initialized using the torch.randn function provided in the Pytorch library, and the Adam optimizer parameters are initialized;

[0088] Step 3.2: training the discriminator network using generated data and real data;

[0089] Step 3.2.1: sample a batch of data from the training set, and initialize a set of random variables with the same dimension as the real data;

[0090] Step 3.2.2: input the random variable to the generator network to output the generated cable tension data;

[0091] Step 3.2.3: input the generated cable tension data and real data to the discriminator network to output the discrimination score; for real data, the output score of the discriminator will tend to 1, and the discrimination score of the generated data will tend to 0; finally, the discrimination score output by the discriminator will tend to 0.5, i.e. the discriminator cannot distinguish whether the input is generated data or real data;

[0092] Step 3.2.4: Calculate the discriminator loss by Wasserstein distance, and add a gradient penalty term to ensure the stability of the training process and avoid the phenomenon of gradient vanishing or explosion of the discriminator. The loss calculation formula is as follows:

[0093]

[0094] In the formula, x is the real data, z is the random noise, P r is the real sample distribution, P z is the random noise distribution, D(x) is the discrimination score of the discriminator output for real data, G(z) is the generated data output by the generator, D(G(z)) is the discrimination score of the discriminator output for generated data, the third term is the gradient penalty term to force the discriminator to satisfy the Lipschitz continuity condition, λ is the penalty coefficient, x' is the interpolation between real samples and generated samples, P x` is the interpolation distribution;

[0095] Step 3.2.5: Calculate the loss value of the discriminator, and propagate the loss gradient to the discriminator parameters through backpropagation;

[0096] Step 3.2.6: Update the discriminator parameters using the RMSprop optimizer to better distinguish real data and generated data;

[0097] Step 3.3: Update the generator network using the discriminator network loss;

[0098] Step 3.3.1: Initialize a set of random variables and input them into the generator network to output generated data, which is then sent to the discriminator for scoring, outputting a discrimination score;

[0099] Step 3.3.2: The loss function of the generator maximizes the discrimination score, making the generated data as close to real data as possible to deceive the discriminator. The loss calculation formula is as follows:

[0100]

[0101] In the formula, the meanings of the symbols are consistent with the discriminator loss calculation formula in step 3.2.4;

[0102] Step 3.3.3: Calculate the total loss and propagate the loss to the generator through the gradient backpropagation method;

[0103] Step 3.3.4: Update the generator network parameters according to the loss value using the Adam optimizer to generate more realistic data. The values of parameters β1 and β2 in the optimizer are 0.9 and 0.999, respectively;

[0104] Step 3.3.5: Iterate the above training process, when the discriminant score output by the discriminator tends to 0.5, it indicates that the generator and discriminator have reached a relatively balanced state, and the training is completed;

[0105] Step 3.4: Co-training for 10000 rounds, using the torch.save.state_dict function in the Pytorch library to save the generator network weight every 1000 rounds.

[0106] Step 4: Use the GAN network model with fusion time convolution to generate cable tension or stiffened beam stress data after different positions and different numbers of cable fractures. The root mean square error (RMSE), mean absolute error (MAE) and R 2 The data generation quality is measured, and the Principal Component Analysis (PCA) and t-SNE (t-Distributed Stochastic Neighbor Embedding) data dimensionality reduction visualization techniques are used to evaluate the distribution difference between the real data and the generated data, see Fig. 3 a (PCA dimension reduction) and Fig. 3 b (t-SNE dimension reduction) in the article.

[0107] Data generation quality evaluation index and data visualization dimensionality reduction analysis, including the following steps:

[0108] Step 4.1: Use the torch.load.load_state_dict call to complete the trained generator model in the Pytorch library, use the torch.rand function to generate random variables, and use the torch.tensor function to convert them to vector form, input to the generator, output the generated cable tension data, and store the data after inverse normalization;

[0109] Step 4.2: Use the sqrt and mean_squared_error functions provided in the Numpy library to calculate the root mean square error between the generated data and the real data, and save the error results in.txt format;

[0110] Step 4.3: Use the mean_absolute_error function provided in the Numpy library to calculate the mean absolute error between the generated data and the real data, and save the error results in.txt format;

[0111] Step 4.4: Use the r2_score function provided in the Numpy library to calculate the R 2 between the generated data and the real data, and save the error results in.txt format;

[0112] Step 4.5: Calculate the two-dimensional distribution rule between the generated data and the real data by using the PCA function provided in the sklearn library, and save the analysis results in the form of pictures by using the plt function in the matplotlib library.

[0113] Step 4.6: Calculate the two-dimensional distribution rule between the generated data and the real data by using the TSNE function provided in the sklearn library, and save the analysis results in the form of pictures by using the plt function in the matplotlib library.

[0114] The bed in the application is creatively embedded in the generative adversarial network with a time sequence convolutional neural network module, and a Wasserstein distance loss function is introduced, so that the stress-strain data of key components of the whole bridge after the breaking of different positions and quantities of cables can be generated efficiently. Specifically, the optimized generative adversarial network significantly enhances the receptive field of the model to time sequence data by integrating the time sequence convolutional neural network module, and widens the breadth and depth of data capture; at the same time, the stability of the network training process is greatly improved by using the Wasserstein loss function, which relieves the mode collapse problem and accelerates the network convergence speed. Compared with the traditional method of evaluating the stress-strain change of key components of the whole bridge under different cable breaking conditions by relying on complex numerical simulation in the field of bridge, the method can accurately and quickly generate the stress state data set of key components of the cable-stayed bridge under different cable breaking conditions, save the complex numerical simulation work, improve the calculation efficiency, realize the efficient and accurate expansion of the stress state database of key components of the long-span cable-stayed bridge after the breaking of cables caused by fire accidents, and improve the fire response ability and operation period safety guarantee level of the bridge structure.

[0115] Obviously, those skilled in the art can make various modifications and variations to the present application without departing from the spirit and scope of the present application. Thus, if these modifications and variations of the present application fall within the scope of the claims of the present application and their equivalent technologies, the present application also intends to include these modifications and variations.

Claims

1. A method for generating stress data of fire-induced cable breakage in cable-stayed bridges based on temporal convolutional GAN ​​networks, characterized in that, Includes the following steps: Step 1: Use software to simulate the changes in cable tension and stress-strain redistribution of stiffening beam caused by the breakage of different locations and numbers of cables in a sudden fire accident in a long-span cable-stayed bridge. Collect the tension of each cable and the stress-strain of the stiffening beam along the bridge length for each cable breakage condition. Preprocess the data to build the dataset required for training the GAN network. Step 2: Build a GAN network model that integrates temporal convolutions, including a data generator and a discriminator; Step 3: Train the GAN network with fused temporal convolutions by inputting random vectors and training set data to obtain the generator network; Step 4: Generate cable tension or stiffening girder stress data at different locations and with different numbers of cables after fracture using a GAN network model incorporating temporal convolutions. Calculate the data using root mean square error, mean absolute error, and R0. 2 To measure the quality of generated data, principal component analysis and t-SNE data dimensionality reduction and visualization techniques were used to evaluate the distribution differences between real data and generated data. Step 1 involves constructing the dataset required to train the GAN network, specifically including: Step 1.1: Using finite element analysis software, establish a 1:1 refined numerical model of the cable-stayed bridge. The cables are simulated using line elements, while the main tower, steel box girder, and main beam structure are constructed using three-dimensional shell elements. Truss elements are used for the cables, and linear quadrilateral elements are used for the remaining solid parts, with a total of 46,710 elements. The cables are connected to the main tower and stiffening girder using MPC hinged connections. The prestress of the cables is applied using stress in the predefined load field. The static general analysis step is used for analysis and calculation. Step 1.2: Export the key mesh stress-strain data using the ODB file output and save it as a .csv file; Step 1.3: Use the read_csv function in NumPy database to read the data, convert it to a dictionary type, and perform normalization to ensure that the data values ​​are between 0 and 1; Step 1.4: Use the torch.tensor function to convert the dictionary data into a 32-bit floating-point tensor form for easier reading during network training; Step 2 specifically includes the following steps: Step 2.1: The GAN network with fused temporal convolutions includes four temporal convolutional neural network modules with different parameters. Each temporal convolutional neural network module contains 2-3 one-dimensional convolutional neural networks, 1 LeakyReLU nonlinear activation function, 3 fully connected layers with different numbers of neurons, 1 ReLU and 1 Tanh nonlinear activation function. Step 2.1.1: Build a temporal convolutional neural network module using the nn.Conv1d module unit in the PyTorch library; Step 2.1.2: Using the nn.Linear module, nn.ReLU, and nn.Tanh non-linear activation units in the PyTorch library, construct two fully connected layers and two non-linear activation layers sequentially. The first fully connected layer has 256 input channels and 512 output channels, ensuring consistency with the number of output channels in the fourth temporal convolutional neural network module, and is connected to the ReLU non-linear activation function. The second fully connected layer has 512 input channels and N output channels, and is connected to the Tanh non-linear activation function to generate the output data. Step 2.2: The discriminator includes three temporal convolutional neural network modules, two fully connected layers, and one ReLU nonlinear activation function.

2. The method as described in claim 1, characterized in that, Step 2.1.1: Build a temporal convolutional neural network module using the nn.Conv1d module unit in the PyTorch library; specifically: The input channels, output channels, kernel size, and dilation rate of the first temporal convolutional neural network module are N, 512, 3, and 1, respectively, with N matching the dimension of the input data. This temporal convolutional neural network module contains three one-dimensional convolutional neural networks and one Leaky ReLU nonlinear activation function. The input channels, output channels, kernel size, dilation rate, and padding values ​​of the first one-dimensional convolutional neural network are N, 512, 3, 1, and 1, respectively. The second one-dimensional convolutional neural network follows the sequence of the first one-dimensional convolutional neural network. The first connection has input channels, output channels, kernel size, dilation rate, and padding value of 512, 512, 3, 1, and 1, respectively; then it is connected to the LeakyReLU non-linear activation function. It should be noted that if the data dimension N ≠ 512, the one-dimensional convolutional neural network will have an additional residual connection branch, which connects the input data with the output parameters of the LeakyReLU non-linear activation function, containing one one-dimensional convolutional neural network with input, output channels, and kernel size of N, 512, and 1, respectively. The second temporal convolutional neural network module has an input channel, an output channel, a kernel size, and a dilation rate of 512, 512, 3, and 2, respectively; it contains two one-dimensional convolutional neural networks and one LeakyReLU nonlinear activation function layer. The input channels, output channels, kernel size, dilation rate, and padding values ​​of the two one-dimensional convolutional neural networks are all 512, 512, 3, 2, and 2, respectively. The third temporal convolutional neural network module has input channels, output channels, kernel size, and dilation rate of 512, 256, 3, and 4, respectively; it contains three one-dimensional convolutional neural networks and one LeakyRuLU nonlinear activation function layer. The first two one-dimensional convolutional neural networks are sequentially connected to the LeakyRuLU nonlinear activation function, and the third one-dimensional convolutional neural network includes residual connections. The first one-dimensional convolutional neural network has input channels, output channels, kernel size, dilation rate, and padding value of 512, 256, 3, 4, and 4, respectively; the second one-dimensional convolutional neural network has input channels, output channels, kernel size, dilation rate, and padding value of 256, 256, 3, 4, and 4, respectively; and the third one-dimensional convolutional neural network has input channels, output channels, and kernel size of 512, 256, and 3, respectively. The fourth temporal convolutional neural network module has input channels, output channels, kernel size, and dilation rate of 256, 256, 3, and 8, respectively. It contains two one-dimensional convolutional neural networks and one LeakyReLU nonlinear activation function. The input channels, output channels, kernel size, dilation rate, and padding value of the two one-dimensional convolutional neural networks are all 256, 256, 3, 8, and 8, respectively.

3. The method as described in claim 1, characterized in that, Step 2.2.1 specifically involves: The first temporal convolutional neural network module has input channels, output channels, kernel size, and dilation rate of N, 512, 3, and 1, respectively. This module contains three one-dimensional convolutional neural networks and one LeakyReLU non-linear activation function. The first one-dimensional convolutional neural network has input channels, output channels, kernel size, dilation rate, and padding value of N, 512, 3, 1, and 1, respectively. The second one-dimensional convolutional neural network is sequentially connected to the first one, with input channels, output channels, kernel size, dilation rate, and padding value of 512, 512, 3, 1, and 1, respectively. It is then connected to the LeakyReLU non-linear activation function. If the data dimension N ≠ 512, the third one-dimensional convolutional neural network contains residual connections, with input channels, output channels, and kernel size of N, 512, and 1, respectively. The second temporal convolutional neural network module has an input channel, an output channel, a kernel size, and a dilation rate of 512, 512, 3, and 2, respectively; it contains two one-dimensional convolutional neural networks and one LeakyReLU nonlinear activation function. The input channels, output channels, kernel size, dilation rate, and padding values ​​of the two one-dimensional convolutional neural networks are all 512, 512, 3, 2, and 2, respectively. The third temporal convolutional neural network module has input channels, output channels, kernel size, and dilation rate of 512, 256, 3, and 4, respectively. It contains three one-dimensional convolutional neural networks and one LeakyRuLU nonlinear activation function. The first two one-dimensional convolutional neural networks are sequentially connected to the LeakyRuLU nonlinear activation function, and the third one-dimensional convolutional neural network is a residual connection. The first one-dimensional convolutional neural network has input channels, output channels, kernel size, dilation rate, and padding value of 512, 256, 3, 4, and 4, respectively. The second one-dimensional convolutional neural network has input channels, output channels, kernel size, dilation rate, and padding value of 256, 256, 3, 4, and 4, respectively. The third one-dimensional convolutional neural network has input channels, output channels, and kernel size of 512, 256, and 3, respectively. Using the nn.Linear module and nn.ReLU non-linear activation function in the PyTorch library, two fully connected layers and one non-linear activation function are constructed sequentially. The first fully connected layer has 256 input channels and 512 output channels, ensuring consistency with the number of output channels of the third temporal convolutional neural network module in the discriminant network, and is connected to the ReLU non-linear activation function. The second fully connected layer has 512 input channels and 1 output channel, and outputs the discriminant score.

4. The method as described in claim 1, characterized in that, Step 3 specifically includes the following steps: Step 3.1: Perform adversarial training on the generator and discriminator; use the torch.randn function provided in the PyTorch library to randomly initialize the network parameters of the generator and discriminator, and initialize the parameters of the Adam optimizer by instance. Step 3.2: Train the discriminator network using generated data and real data; Step 3.2.1: Sample a batch of data from the training set and initialize a set of random variables with dimensions consistent with the real data; Step 3.2.2: Input the random variables into the generator network and output the generated cable tension data; Step 3.2.3: Input the generated cable tension data and the real data into the discriminator network and output a discrimination score. For the real data, the discriminator's output score will approach 1, while the discrimination score for the generated data will approach 0. Finally, the discrimination score output by the discriminator will approach 0.5, that is, the discriminator cannot distinguish whether the input is generated data or real data. Step 3.2.4: Calculate the discriminator loss using the Wasserstein distance and add a gradient penalty term to ensure the stability of the training process and avoid gradient vanishing or exploding phenomena in the discriminator. The loss calculation formula is as follows: （1） In the formula, x represents real data, z represents random noise, and P r For the true sample distribution, P z The noise distribution is random. D(x) is the discriminator's output score against the real data, G(z) is the generator's output generated data, D(G(z)) is the discriminator's output score against the generated data, the third term is the gradient penalty term, used to force the discriminator to satisfy the Lipschitz continuity condition, λ is the penalty coefficient, x` is the interpolation between the real sample and the generated sample, and P... x` It is an interpolation distribution; Step 3.2.5: Calculate the discriminator loss value and propagate the loss gradient to the discriminator parameters through backpropagation; Step 3.2.6: Update the discriminator parameters using the RMSprop optimizer to better distinguish between real data and generated data; Step 3.3: Update the trained generator network using the discriminator network loss; Step 3.3.1: Initialize another set of random variables and input them into the generator network to generate data. Then, send the generated data to the discriminator for scoring and output the discrimination score. Step 3.3.2: The generator's loss function maximizes the discrimination score, making the data generated by the generator as close as possible to the real data, thereby deceiving the discriminator. The loss calculation formula is as follows: （2） The meanings of the symbols in the formula are consistent with those in step 3.2.4, which calculates the discriminator loss. Step 3.3.3: Calculate the total loss and pass it to the generator using the gradient backpropagation method; Step 3.3.4: Use the Adam optimizer to update the generator network parameters based on the loss value, so that it can generate more realistic data. The values ​​of parameters β1 and β2 in the optimizer are 0.9 and 0.999, respectively. Step 3.3.5: Iterate through the above training process. When the discrimination score output by the discriminator approaches 0.5, it indicates that the generator and the discriminator have reached a relatively balanced state, and the training ends. Step 3.4: Train for a total of 10,000 rounds, and use the torch.save.state_dict function in the PyTorch library to save the generator network weights every 1,000 rounds.

5. The method as described in claim 1, characterized in that, Step 4 involves generating data quality evaluation indicators and performing data visualization and dimensionality reduction analysis, specifically including the following steps: Step 4.1: Use the torch.load.load_state_dict function in the Pytorch library to call the trained generator model, use the torch.rand function to generate random variables, and use the torch.tensor function to convert them into vector form, input them into the generator, output the generated cable tension data, and perform inverse normalization and storage on the data; Step 4.2: Use the sqrt and mean_squared_error functions provided in the NumPy library to calculate the root mean square error between the generated data and the real data, and save the error results in .txt format; Step 4.3: Use the mean_absolute_error function provided in the NumPy library to calculate the mean absolute error between the generated data and the real data, and save the error results in .txt format; Step 4.4: Use the r2_score function provided in the NumPy library to calculate the R-squared between the generated data and the real data. 2 The error results are saved in .txt format; Step 4.5: Use the PCA function provided in the sklearn library to calculate the two-dimensional distribution pattern between the generated data and the real data, and use the plt function in the matplotlib library to save the analysis results as an image; Step 4.6: Use the TSNE function provided in the sklearn library to calculate the two-dimensional distribution pattern between the generated data and the real data, and use the plt function in the matplotlib library to save the analysis results as an image.

Images