Cable-stayed bridge fire-induced cable breaking stress data generation method based on time sequence convolution-GAN

Abstract

The invention discloses a cable-stayed bridge fire-induced cable breaking stress data generation method based on time sequence convolution-GAN, and the method specifically comprises the steps: simulating inhaul cable tension changes and stiffening beam stress-strain redistribution caused by the fracture of different numbers of inhaul cables at different positions possibly caused by a sudden fire accident of a large-span cable-stayed bridge; the method comprises the following steps: acquiring tension of each inhaul cable and stress-strain data of a stiffening beam along the length direction of a bridge under each inhaul cable fracture working condition, preprocessing the data, and constructing a data set required for training a GAN network; building a GAN network model fused with time sequence convolution; inputting a random vector and training set data to train the GAN network fused with the time sequence convolution, and obtaining a generative network; and the GAN model fused with the time sequence convolution is utilized to generate data of cable tension or stiffening beam stress after different numbers of cables at different positions are broken, the data generation quality is measured, and the distribution difference between the real data and the generated data is evaluated.

Description

Technical Field

[0001] The present invention relates to the intersection of bridge engineering and artificial intelligence, and in particular to a method for generating stress data of fire-induced broken cables of a cable-stayed bridge based on time series convolution-GAN. Background Art

[0002] As an important model in deep learning, Temporal Convolutional Network (TCN) combines the advantages of Convolutional Neural Network (CNN) and Long Short-Term Memory Network (LSTM). It 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 stress-strain data of suspension bridge cables. On the one hand, the stress-strain data of suspension bridge cables has the characteristics of temporal, nonlinear, and high-dimensionality, and traditional data analysis methods are difficult to accurately capture its internal laws; on the other hand, due to the influence of environmental factors such as sudden fire accidents and other factors, the stress-strain data of suspension bridge cables has great uncertainty and volatility, which further increases the difficulty of data generation. Summary of the invention

[0003] In view of the above-mentioned technical deficiencies, the purpose of the present invention is to provide a method for generating stress data of fire-induced broken cables of cable-stayed bridges based on time-series convolution-GAN, which can overcome the limitations of the existing stress-strain data acquisition methods of key components such as cable tension and stiffening beams of cable-stayed bridges under sudden fire accidents and the difficulty in evaluating the force performance, provide efficient and accurate data support for bridge multi-disaster prevention and control early warning, and promote the deep integration and development of bridge engineering and artificial intelligence technology.

[0004] In order to solve the above technical problems, the present invention adopts the following technical solutions:

[0005] The present invention provides a method for generating stress data of cable-stayed bridge fire-induced cable breakage based on time series convolution-GAN, comprising the following steps:

[0006] Step 1: Use software to simulate the cable tension changes and stress-strain redistribution of stiffening beams caused by cable breakage at different locations and in different numbers due to sudden fire accidents in large-span cable-stayed bridges. Collect the tension data of each cable and the stress-strain data of the stiffening beam along the length of the bridge under each cable break condition, pre-process the data, and construct the data set required for training the GAN network.

[0007] Step 2: Build a GAN network model that integrates 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 fused with temporal convolution to obtain a generated network;

[0009] Step 4: Generate cable tension or stiffening beam stress data after cable breakage at different locations and with different numbers of cables using the GAN network model fused with time series convolution. 2 To measure the quality of data generation, principal component analysis and t-SNE data dimensionality reduction visualization techniques were used to evaluate the distribution differences between real data and generated data.

[0010] Preferably, in step 1, constructing a data set required for training the GAN network specifically includes:

[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 with line elements, and the other main towers, steel box girders, and main beam structures are constructed with three-dimensional shell elements. Truss elements are used for the cables, and linear quadrilateral elements are used for the other solid parts. The total number of elements is 46710. The cables are connected to the main towers and stiffening beams using MPC hinges. In the load predefined field, stress is used to apply cable prestress. The static general analysis step is used for analysis and calculation.

[0012] Step 1.2: Export the key mesh stress-strain data using ODB file output and save it in .csv format;

[0013] Step 1.3: Use the read_csv function in the Numpy database to read the data, convert it into a dictionary type, and normalize it 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 into a 32-bit floating-point tensor for easy reading during network training.

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

[0016] Step 2.1: The GAN network fused with temporal convolution includes 4 temporal convolutional neural network modules with different parameters, and the temporal convolutional neural network module includes 2 to 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;

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

[0018] Step 2.1.2: Use the nn.Linear module, nn.ReLU and nn.Tanh nonlinear activation units in the Pytorch library to build two fully connected layers and two nonlinear activation layers in sequence; the number of input and output channels of the first fully connected layer is 256 and 512 respectively, ensuring that it is consistent with the number of output channels of the fourth temporal convolutional neural network module, and connecting the ReLU nonlinear activation function; the number of input and output channels of the second fully connected layer is 512 and N, connecting the Tanh nonlinear activation function, and outputting the generated data;

[0019] Step 2.2: The discriminator includes 3 temporal convolutional neural network modules, 2 fully connected layers and 1 ReLU nonlinear activation function;

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

[0021] The input channel, output channel, convolution kernel size and expansion rate of the first temporal convolutional neural network module are N, 512, 3, and 1 respectively, where N is consistent with the dimension of the input data. The temporal convolutional neural network module contains a total of three one-dimensional convolutional neural networks and a LeakyReLU nonlinear activation function. The input channel, output channel, convolution kernel size, expansion 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. The input channel, output channel, convolution kernel size, expansion rate, and padding value 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 residual connection branch in the one-dimensional convolutional neural network, which connects the input data with the output parameters of the LeakyReLU nonlinear activation function, including 1 one-dimensional convolutional neural network, whose input, output channel, and convolution kernel size are 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. 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 dilation rate of the third temporal convolutional neural network module are 512, 256, 3, and 4 respectively; it contains 3 one-dimensional convolutional neural networks and a LeakyRuLU nonlinear activation function layer. The first two one-dimensional convolutional neural networks are connected with the LeakyRuLU nonlinear activation function in sequence, and the third one-dimensional convolutional neural network contains 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;

[0024] The input channel, output channel, convolution kernel size, and dilation rate of the fourth temporal convolutional neural network module are 256, 256, 3, and 8, respectively. It contains two one-dimensional convolutional neural networks and one LeakyReLU nonlinear activation function. The input channel, output channel, convolution kernel size, dilation 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 dilation rate of the first temporal convolutional neural network module are N, 512, 3, and 1 respectively; the module contains a total of 3 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 to the first one, and its input channel, output channel, convolution kernel size, dilation rate, and padding value are 512, 512, 3, 1, and 1 respectively; then the LeakyReLU nonlinear activation function is connected; if the data dimension N≠512, the third one-dimensional convolutional neural network contains residual connection, and its input, output channel, and convolution kernel size are N, 512, and 1 respectively;

[0027] 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. 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.

[0028] The input channel, output channel, convolution kernel size and dilation rate of the third temporal convolutional neural network module are 512, 256, 3, and 4 respectively; it contains 3 one-dimensional convolutional neural networks and a LeakyRuLU nonlinear activation function. The first two one-dimensional convolutional neural networks are connected with the LeakyRuLU nonlinear activation function in sequence, and the third one-dimensional convolutional neural network is 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;

[0029] Using the nn.Linear module and nn.ReLU nonlinear activation function in the Pytorch library, two fully connected layers and one nonlinear activation function are built in sequence; the number of input and output channels of the first fully connected layer is 256 and 512 respectively, ensuring that the number of output channels is consistent with the third temporal convolutional neural network module in the discriminant network, and connecting the ReLU nonlinear activation function; the number of input and output channels of the second fully connected layer is 512 and 1, and the discriminant score is output.

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

[0031] 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 generator and discriminator network parameters, and initialize the Adam optimizer parameters by instance;

[0032] Step 3.2: Train 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 whose dimensions are consistent with the real data;

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

[0035] Step 3.2.3: Input the generated cable tension data and the real data into the discriminator network and output the discriminant score. For the real data, the discriminant output score will be close to 1, and the discriminant score of the generated data will be close to 0. Finally, the discriminant score output by the discriminator will be close to 0.5, that is, the discriminator cannot distinguish whether the input is generated data or real data;

[0036] Step 3.2.4: Calculate the discriminator loss through Wasserstein distance and add the gradient penalty term to ensure the stability of the training process and avoid the discriminator's gradient disappearance or explosion. The loss calculation formula is as follows:

[0037]

[0038] In the formula, x is the real data, z is the random noise, P r is the true sample distribution, P z is a random noise distribution, D(x) is the discrimination score of the discriminator output for the real data, G(z) is the generated data output by the generator, D(G(z)) is the discrimination score of the discriminator output for the generated data, the third term is the gradient penalty term, which is 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, 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 back propagation;

[0040] Step 3.2.6: Use the RMSprop optimizer to update the discriminator parameters so that it can better distinguish between real data and generated data;

[0041] Step 3.3: Use the discriminator network loss to update the training generator network;

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

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

[0044]

[0045] The meaning of each symbol in the formula is consistent with the discriminator loss calculation formula in step 3.2.4;

[0046] Step 3.3.3: Calculate the total loss and pass 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 the parameters β1 and β2 in the optimizer are 0.9 and 0.999 respectively;

[0048] Step 3.3.5: Iterate 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 is completed.

[0049] Step 3.4: Train for 10,000 rounds in total, using the torch.save.state_dict function in the Pytorch library to save the generator network weights every 1,000 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 torch.load.load_state_dict 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 to the generator, output the generated cable tension data, and denormalize and store the data;

[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 the form of .txt;

[0053] Step 4.3: Use the mean_absolute_error function provided by 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 by the Numpy library to calculate the R2 score between the generated data and the real data. 2 , save the error results in .txt format;

[0055] Step 4.5: Use the PCA function provided by the sklearn library to calculate the two-dimensional distribution law 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 by the sklearn library to calculate the two-dimensional distribution law 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 beneficial effect of the present invention is that the method introduces a temporal convolutional neural network module into the generative adversarial network, increases the receptive field of the model, expands the data capture range of the model, improves the quality of data generation, and introduces the Wasserstein distance loss function to improve the stability of the model training process and accelerate the convergence of the model. This technology is proposed to overcome the limitations of the existing stress-strain data acquisition methods of key components such as cable tension and stiffening beams of cable-stayed bridges under sudden fire accidents and the difficulty of force performance evaluation, provide efficient and accurate data support for bridge multi-disaster prevention and control early warning, and promote the deep integration and development of bridge engineering and artificial intelligence technology. BRIEF DESCRIPTION OF THE DRAWINGS

[0058] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings required for use in the embodiments or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative work.

[0059] Figure 1 A diagram of the architecture of a generative adversarial network based on temporal convolution provided by an embodiment of the present invention;

[0060] Figure 2 Generate a graph for the stress-strain data of a stiffening beam with cable breakage under a certain condition;

[0061] Figure 3 This is the dimensionality reduction analysis diagram of the real and generated data of stress-strain of a stiffening beam with cable fracture under certain working conditions. DETAILED DESCRIPTION

[0062] The following will be combined with the drawings in the embodiments of the present invention to clearly and completely describe the technical solutions in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0063] like Figures 1 to 3 As shown in FIG. 1 , a method for generating stress data of cable-stayed bridge fire-induced cable breakage based on time series convolution-GAN includes the following steps:

[0064] Step 1: Use software to simulate the cable tension changes and stress-strain redistribution of stiffening beams caused by cable breakage at different locations and in different numbers due to sudden fire accidents in large-span cable-stayed bridges. Collect the tension data of each cable and the stress-strain data of the stiffening beam along the length of the bridge under each cable break condition, pre-process the data, and construct the data set required for training the GAN network.

[0065] Construct the data set required for training the GAN network, including:

[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 with line elements, and the other main towers, steel box girders, and main beam structures are constructed with three-dimensional shell elements. Truss elements are used for the cables, and linear quadrilateral elements are used for the other solid parts. The total number of elements is 46710. The cables are connected to the main towers and stiffening beams using MPC hinges. In the load predefined field, stress is used to apply cable prestress. The static general analysis step is used for analysis and calculation.

[0067] Step 1.2: Export the key mesh stress-strain data using ODB file output and save it in .csv format;

[0068] Step 1.3: Use the read_csv function in the Numpy database to read the data, convert it into a dictionary type, and normalize it 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 into a 32-bit floating-point tensor for easy reading during network training.

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

[0071] The specific steps include:

[0072] Step 2.1: The GAN network fused with temporal convolution includes 4 temporal convolutional neural network modules (Temporal Convolutional Network Block, TCNBlock) with different parameters, and the temporal convolutional neural network module includes 2 to 3 one-dimensional convolutional neural networks, 1 LeakyReLU non-linear activation function, 3 fully connected layers with different numbers of neurons, 1 ReLU and 1 Tanh non-linear activation function;

[0073] Step 2.1.1: Use the nn.Conv1d module unit in the Pytorch library to build a temporal convolutional neural network module;

[0074] Use the nn.Conv1d module unit in the Pytorch library to build a temporal convolutional neural network module; specifically:

[0075] 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 a total of 3 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 connected to the first one-dimensional convolutional neural network in sequence, and its input channel (in_c), output channel (out_c), convolution kernel size (kernel size), dilation rate (dilation), and padding value (padding) are 512, 512, 3, 1, and 1, respectively; and 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 residual connection (Residual Connection) in the one-dimensional convolutional neural network. Connection), which connects the input data with the output parameters of the LeakyReLU nonlinear activation function, and contains a one-dimensional convolutional neural network, whose input, 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 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. 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 temporal convolutional neural network module are 512, 256, 3, and 4 respectively; it contains 3 one-dimensional convolutional neural networks and a LeakyRuLU nonlinear activation function layer. The first two one-dimensional convolutional neural networks are connected with the LeakyRuLU nonlinear activation function in sequence, and the third one-dimensional convolutional neural network contains 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 dilation rate of the fourth temporal convolutional neural network module are 256, 256, 3, and 8, respectively. It contains two one-dimensional convolutional neural networks and one LeakyReLU nonlinear activation function. The input channel, output channel, convolution kernel size, dilation 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: Use the nn.Linear module, nn.ReLU and nn.Tanh nonlinear activation units in the Pytorch library to build two fully connected layers and two nonlinear activation layers in sequence; the number of input and output channels of the first fully connected layer is 256 and 512 respectively, ensuring that it is consistent with the number of output channels of the fourth temporal convolutional neural network module, and connecting the ReLU nonlinear activation function; the number of input and output channels of the second fully connected layer is 512 and N, connecting the Tanh nonlinear activation function, and outputting the generated data;

[0080] Step 2.2: The discriminator includes 3 temporal convolutional neural network modules, 2 fully connected layers and 1 ReLU nonlinear activation function;

[0081] Step 2.2.1 is as follows:

[0082] 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; the module contains a total of 3 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 to the first one, and its input channel, output channel, convolution kernel size, dilation rate, and padding value are 512, 512, 3, 1, and 1 respectively; then the LeakyReLU nonlinear activation function is connected; if the data dimension N≠512, the third one-dimensional convolutional neural network contains residual connection, and its input, output channel, and convolution kernel size are N, 512, and 1 respectively;

[0083] 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. 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.

[0084] The input channel, output channel, convolution kernel size and dilation rate of the third temporal convolutional neural network module are 512, 256, 3, and 4 respectively; it contains 3 one-dimensional convolutional neural networks and a LeakyRuLU nonlinear activation function. The first two one-dimensional convolutional neural networks are connected with the LeakyRuLU nonlinear activation function in sequence, and the third one-dimensional convolutional neural network is 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;

[0085] Using the nn.Linear module and nn.ReLU nonlinear activation function in the Pytorch library, two fully connected layers and one nonlinear activation function are built in sequence; the number of input and output channels of the first fully connected layer is 256 and 512 respectively, ensuring that the number of output channels is consistent with the third temporal convolutional neural network module in the discriminant network, and connecting the ReLU nonlinear activation function; the number of input and output channels of the second fully connected layer is 512 and 1, and the discriminant score is output.

[0086] Step 3: Input random vectors and training set data to train the GAN network fused with temporal convolution to obtain a generated network; specifically, the following steps are included:

[0087] 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 generator and discriminator network parameters, and initialize the Adam optimizer parameters by instance;

[0088] Step 3.2: Train 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 whose dimensions are consistent with the real data;

[0090] Step 3.2.2: Input the random variables into the generator network and output the generated cable tension data;

[0091] Step 3.2.3: Input the generated cable tension data and the real data into the discriminator network and output the discriminant score. For the real data, the discriminant output score will be close to 1, and the discriminant score of the generated data will be close to 0. Finally, the discriminant score output by the discriminator will be close to 0.5, that is, the discriminator cannot distinguish whether the input is generated data or real data;

[0092] Step 3.2.4: Calculate the discriminator loss through Wasserstein distance and add the gradient penalty term to ensure the stability of the training process and avoid the discriminator's gradient disappearance or explosion. 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 true sample distribution, P z is a random noise distribution, D(x) is the discrimination score of the discriminator output for the real data, G(z) is the generated data output by the generator, D(G(z)) is the discrimination score of the discriminator output for the generated data, the third term is the gradient penalty term, which is 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, P x` is the interpolation distribution;

[0095] Step 3.2.5: Calculate the discriminator loss value and propagate the loss gradient to the discriminator parameters through back propagation;

[0096] Step 3.2.6: Use the RMSprop optimizer to update the discriminator parameters so that it can better distinguish between real data and generated data;

[0097] Step 3.3: Use the discriminator network loss to update the training generator network;

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

[0099] Step 3.3.2: The loss function of the generator will maximize the discriminant score, making the data generated by the generator as close to the real data as possible, thereby deceiving the discriminator. The loss calculation formula is as follows:

[0100]

[0101] The meaning of each symbol in the formula is consistent with the discriminator loss calculation formula in step 3.2.4;

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

[0103] 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 the 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 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 is completed.

[0105] Step 3.4: Train for 10,000 rounds in total, using the torch.save.state_dict function in the Pytorch library to save the generator network weights every 1,000 rounds.

[0106] Step 4: Generate cable tension or stiffening beam stress data after cable breakage at different locations and with different numbers of cables using the GAN network model fused with time series convolution. 2 To measure the quality of data generation, principal component analysis (PCA) and t-SNE (t-Distributed Stochastic Neighbor Embedding) data dimension reduction visualization techniques are used to evaluate the distribution difference between real data and generated data. Figure 3 a (PCA dimensionality reduction) and Figure 3 b (t-SNE dimensionality reduction).

[0107] Data generation quality evaluation indicators and data visualization dimensionality reduction analysis include the following steps:

[0108] Step 4.1: Use torch.load.load_state_dict 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 to the generator, output the generated cable tension data, and denormalize and store the data;

[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 the form of .txt;

[0110] Step 4.3: Use the mean_absolute_error function provided by 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 by the Numpy library to calculate the R2 score between the generated data and the real data. 2 , save the error results in .txt format;

[0112] Step 4.5: Use the PCA function provided by the sklearn library to calculate the two-dimensional distribution law 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;

[0113] Step 4.6: Use the TSNE function provided by the sklearn library to calculate the two-dimensional distribution law 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.

[0114] The present invention creatively embeds a time-series convolutional neural network module in the generative adversarial network and incorporates the Wasserstein distance loss function to achieve efficient generation of stress-strain data of key components of the entire bridge after the cables are damaged and broken at different positions and numbers. Specifically, the optimized generative adversarial network significantly enhances the model's receptive field for time-series data by integrating the time-series convolutional neural network module, broadens the breadth and depth of data capture; at the same time, the use of the Wasserstein loss function greatly improves the stability of the network training process, alleviates the mode collapse problem, and accelerates the network convergence speed. Compared with the traditional method of relying on complex numerical simulation methods to evaluate the stress-strain changes of key components of the entire bridge under different cable-breaking conditions in the bridge field, this method can accurately and quickly generate a stress state data set of key structures of cable-stayed bridges under different cable-breaking conditions, eliminating complex numerical simulation work, improving calculation efficiency, and achieving efficient and accurate expansion of the stress state database of key components after cable-breaking caused by fire accidents in large-span cable-stayed bridges, and improving the fire response capability of bridge structures and the safety level of operation.

[0115] Obviously, those skilled in the art can make various changes and modifications to the present invention without departing from the spirit and scope of the present invention. Thus, if these modifications and variations of the present invention fall within the scope of the claims of the present invention and their equivalents, the present invention is also intended to include these modifications and variations.

Claims

1. A method for generating stress data of cable-stayed bridge fire-induced cable breakage based on a temporal convolution-GAN network, characterized in that: The following steps are involved: Step 1: Use software to simulate the cable tension changes and stress-strain redistribution of stiffening beams caused by cable breakage at different locations and in different numbers due to sudden fire accidents in large-span cable-stayed bridges. Collect the tension data of each cable and the stress-strain data of the stiffening beam along the length of the bridge under each cable break condition, pre-process the data, and construct the data set required for training the GAN network. Step 2: Build a GAN network model that integrates temporal convolution, including a data generator and a discriminator; Step 3: Input a random vector and training set data to train the GAN network fused with temporal convolution to obtain a generated network; Step 4: Generate cable tension or stiffening beam stress data after cable breakage at different locations and with different numbers of cables using the GAN network model fused with time series convolution. 2 To measure the quality of data generation, principal component analysis and t-SNE data dimensionality reduction visualization techniques were used to evaluate the distribution differences between real data and generated data.

2. The method according to claim 1, characterized in that In step 1, the data set required for training the GAN network is constructed, including: 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 with line elements, and the other main towers, steel box girders, and main beam structures are constructed with three-dimensional shell elements. Truss elements are used for the cables, and linear quadrilateral elements are used for the other solid parts. The total number of elements is 46710. The cables are connected to the main towers and stiffening beams using MPC hinges. In the load predefined field, stress is used to apply cable prestress. The static general analysis step is used for analysis and calculation. Step 1.2: Export the key mesh stress-strain data using ODB file output and save it in .csv format; Step 1.3: Use the read_csv function in the Numpy database to read the data, convert it into a dictionary type, and normalize it to ensure that the data value is between 0 and 1; Step 1.4: Use the torch.tensor function to convert the dictionary data into a 32-bit floating-point tensor for easy reading during network training.

3. The method according to claim 1, characterized in that Step 2 specifically includes the following steps: Step 2.1: The GAN network fused with temporal convolution includes 4 temporal convolutional neural network modules with different parameters, and the temporal convolutional neural network module includes 2 to 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: Use the nn.Conv1d module unit in the Pytorch library to build a temporal convolutional neural network module; Step 2.1.2: Use the nn.Linear module, nn.ReLU and nn.Tanh nonlinear activation units in the Pytorch library to build two fully connected layers and two nonlinear activation layers in sequence; the number of input and output channels of the first fully connected layer is 256 and 512 respectively, ensuring that it is consistent with the number of output channels of the fourth temporal convolutional neural network module, and connecting the ReLU nonlinear activation function; the number of input and output channels of the second fully connected layer is 512 and N, connecting the Tanh nonlinear activation function, and outputting the generated data; Step 2.2: The discriminator includes 3 temporal convolutional neural network modules, 2 fully connected layers and 1 ReLU nonlinear activation function.

4. The method according to claim 1, characterized in that Step 2.1.1: Use the nn.Conv1d module unit in the Pytorch library to build a temporal convolutional neural network module; specifically: The input channel, output channel, convolution kernel size and expansion rate of the first temporal convolutional neural network module are N, 512, 3, and 1 respectively, where N is consistent with the dimension of the input data. The temporal convolutional neural network module contains a total of three one-dimensional convolutional neural networks and a LeakyReLU nonlinear activation function. The input channel, output channel, convolution kernel size, expansion 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. The input channel, output channel, convolution kernel size, expansion rate, and padding value 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 residual connection branch in the one-dimensional convolutional neural network, which connects the input data with the output parameters of the LeakyReLU nonlinear activation function, including 1 one-dimensional convolutional neural network, whose input, output channel, and convolution kernel size are N, 512, and 1 respectively; 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. 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. The input channel, output channel, convolution kernel size and dilation rate of the third temporal convolutional neural network module are 512, 256, 3, and 4 respectively; it contains 3 one-dimensional convolutional neural networks and a LeakyRuLU nonlinear activation function layer. The first two one-dimensional convolutional neural networks are connected with the LeakyRuLU nonlinear activation function in sequence, and the third one-dimensional convolutional neural network contains 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; The input channel, output channel, convolution kernel size and expansion rate of the fourth temporal convolutional neural network module are 256, 256, 3, and 8, respectively; it contains 2 one-dimensional convolutional neural networks and 1 LeakyReLU nonlinear activation function. The input channel, output channel, convolution kernel size, expansion rate, and padding value of the two one-dimensional convolutional neural networks are 256, 256, 3, 8, and 8, respectively.

5. The method according to claim 1, characterized in that Step 2.2.1 is as follows: 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; the module contains a total of 3 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 to the first one, and its input channel, output channel, convolution kernel size, dilation rate, and padding value are 512, 512, 3, 1, and 1 respectively; then the LeakyReLU nonlinear activation function is connected; if the data dimension N≠512, the third one-dimensional convolutional neural network contains residual connection, and its input, output channel, and convolution kernel size are N, 512, and 1 respectively; 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. 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. The input channel, output channel, convolution kernel size and dilation rate of the third temporal convolutional neural network module are 512, 256, 3, and 4 respectively; it contains 3 one-dimensional convolutional neural networks and a LeakyRuLU nonlinear activation function. The first two one-dimensional convolutional neural networks are connected with the LeakyRuLU nonlinear activation function in sequence, and the third one-dimensional convolutional neural network is 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; Using the nn.Linear module and nn.ReLU nonlinear activation function in the Pytorch library, two fully connected layers and one nonlinear activation function are built in sequence; the number of input and output channels of the first fully connected layer is 256 and 512 respectively, ensuring that the number of output channels is consistent with the third temporal convolutional neural network module in the discriminant network, and connecting the ReLU nonlinear activation function; the number of input and output channels of the second fully connected layer is 512 and 1, and the discriminant score is output.

6. The method according to 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 generator and discriminator network parameters, and initialize the Adam optimizer parameters 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 whose dimensions are 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 the discriminant score. For the real data, the discriminant output score will be close to 1, and the discriminant score of the generated data will be close to 0. Finally, the discriminant score output by the discriminator will be close to 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 through Wasserstein distance and add the gradient penalty term to ensure the stability of the training process and avoid the discriminator's gradient disappearance or explosion. The loss calculation formula is as follows: In the formula, x is the real data, z is the random noise, P r is the true sample distribution, P z is a random noise distribution, D(x) is the discrimination score of the discriminator output for the real data, G(z) is the generated data output by the generator, D(G(z)) is the discrimination score of the discriminator output for the generated data, the third term is the gradient penalty term, which is 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, P x` is the interpolated distribution; Step 3.2.5: Calculate the discriminator loss value and propagate the loss gradient to the discriminator parameters through back propagation; Step 3.2.6: Use the RMSprop optimizer to update the discriminator parameters so that it can better distinguish between real data and generated data; Step 3.3: Use the discriminator network loss to update the training generator network; Step 3.3.1: Initialize a set of random variables and input them into the generator network, output the generated data, and then send them to the discriminator for scoring, and output the discriminant score; Step 3.3.2: The loss function of the generator will maximize the discriminant score, making the data generated by the generator as close to the real data as possible, thereby deceiving the discriminator. The loss calculation formula is as follows: The meaning of each symbol in the formula is consistent with the discriminator loss calculation formula in step 3.2.4; Step 3.3.3: Calculate the total loss and pass the loss to the generator through the gradient backpropagation method; 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 the parameters β1 and β2 in the optimizer are 0.9 and 0.999 respectively; Step 3.3.5: Iterate 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 is completed. Step 3.4: Train for 10,000 rounds in total, using the torch.save.state_dict function in the Pytorch library to save the generator network weights every 1,000 rounds.

7. The method for generating stress data of cable-stayed bridge fire-induced cable breakage based on time series convolution-GAN as claimed in claim 1, characterized in that: In step 4, data generation quality evaluation indicators and data visualization dimensionality reduction analysis are performed, which specifically includes the following steps: Step 4.1: Use torch.load.load_state_dict 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 to the generator, output the generated cable tension data, and denormalize and store 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 the form of .txt; Step 4.3: Use the mean_absolute_error function provided by 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 by the Numpy library to calculate the R2 score between the generated data and the real data. 2 , save the error results in .txt format; Step 4.5: Use the PCA function provided by the sklearn library to calculate the two-dimensional distribution law 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; Step 4.6: Use the TSNE function provided by the sklearn library to calculate the two-dimensional distribution law 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.

Images