A connectivity fracture network structure intelligent generation method based on a GA-GAN model

Abstract

The present application relates to the technical field of fracture network prediction, and discloses a connectivity fracture network structure intelligent generation method based on a GA-GAN model, comprising the following steps: step 1, establishing a fracture network database; step 2, establishing a GA-GAN model: step 2.1, information import and parameter setting; step 2.2, constructing a discriminator; step 2.3, establishing a generator based on a genetic algorithm; step 2.4, discriminator training; step 2.5, iterative training; step 3, automatically generating a corresponding connectivity fracture network structure by using the GA-GAN model. The fracture network structure intelligent generation method proposed in the present application successfully solves the problems of low efficiency, high cost and insufficient authenticity in traditional fracture network generation, and the fracture network generated by the model not only retains the complex geometric characteristics of the real network, but also can adapt to different geological scenes, thereby providing more valuable research data for practical applications such as groundwater flow simulation and oil and gas exploitation.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of fracture network prediction, and in particular to a connectivity fracture network structure intelligent generation method based on a GA-GAN model. BACKGROUND

[0002] In the fields of hydrogeology and petroleum engineering, the study of fracture networks is crucial for predicting fluid flow, contaminant transport, and optimizing oil and gas extraction strategies. The geometry, connectivity, and distribution characteristics of fracture networks have a significant impact on the behavior of fluids in groundwater flow, geothermal systems, and oil and gas reservoirs. In oil reservoirs, fractures are often the primary pathways for fluids, while the matrix has lower permeability, limiting fluid transport. Therefore, accurately characterizing fracture networks not only improves extraction efficiency but also prevents potential environmental risks such as contaminant leakage.

[0003] Defects and deficiencies of the prior art:

[0004] Nonlinear characteristics of fracture networks are difficult to capture: Fracture networks often exhibit highly nonlinear and complex parameter spaces, making it difficult for traditional simulation methods to effectively cover and explore the entire parameter space. As a result, fracture network models lack diversity and are difficult to fully reflect real geological characteristics, especially in the prediction of complex reservoir fracture distribution. The geometric characteristics of oil reservoir fractures have a significant impact on oil and gas migration, extraction efficiency, and safety. However, traditional models struggle to accurately capture the fracture fluid dynamics under high pressure and high temperature conditions, leading to a decline in the effectiveness of simulation results.

[0005] In traditional generative adversarial network (GAN) methods, the generation ability of the generator is often limited, making it difficult to generate complex geometric characteristics that conform to real fracture networks. The generator often performs poorly in the confrontation with the discriminator, especially in data-rich and complex detail application scenarios, resulting in poor quality of generated samples that cannot accurately represent the structure and connectivity of real fracture networks. Moreover, traditional numerical simulation methods are inefficient and costly when generating large-scale and realistic fracture networks. To address these issues, GAN is introduced to generate realistic fracture network images, thereby accelerating research progress and reducing computational costs. SUMMARY

[0006] To solve the technical problems presented in the background art, the present application provides a connectivity fracture network structure intelligent generation method based on a GA-GAN model.

[0007] The present application adopts the following technical solution: A connectivity fracture network structure intelligent generation method based on a GA-GAN model, comprising the following steps:

[0008] Step 1, establish a fracture network database;

[0009] Step 2, establish a GA-GAN model, as follows:

[0010] Step 2.1: information import and parameter setting;

[0011] Step 2.2: build discriminator;

[0012] Step 2.3: establish a generator based on genetic algorithm;

[0013] Step 2.4: discriminator training;

[0014] Step 2.5: iterative training;

[0015] Step 3, use the GA-GAN model to automatically generate the corresponding connectivity fracture network structure.

[0016] Further, the specific operation of step 1 is as follows:

[0017] Step 1.1: parameter setting and initialization;

[0018] Step 1.2: generate fracture network;

[0019] Step 1.3, read the fracture network data generated in step 1.2, store the data in a three-dimensional matrix DataDFN_CNN, and save it as DataDFN_CNN.mat format data.

[0020] Further, the operation of step 1.2 is as follows:

[0021] Step a, fracture length generation;

[0022] Step b, fracture angle generation;

[0023] Step c, random generation of fracture position;

[0024] Step d, shadow area detection and removal;

[0025] Step e, fracture intersection requirement;

[0026] Step f, fracture network connectivity judgment;

[0027] Step g, save the finally generated fracture network data as a matrix of size Nfrac*4, where: Nfrac represents the number of generated fractures, each row represents a fracture; 4 represents four key attributes of each fracture.

[0028] Further, the operation of step 2.1 is as follows:

[0029] The program first imports the necessary libraries, such as torch, numpy, matplotlib, scipy.io; sets the hyperparameters of the GAN model, such as learning rate, batch size, latent dimension, to ensure that the program can run efficiently in model training.

[0030] Further, the discriminator structure in step 2.2 is as follows:

[0031] Input layer: used to receive an 80-dimensional vector, i.e. containing 20 coordinates of fissure entities; the data is directly input to the first fully connected layer;

[0032] Fully connected network structure: it contains five fully connected layers, and the number of neurons in the five fully connected layers is set to 80, 512, 1024, 512, 256, 1; the fully connected network structure gradually processes the input data, thereby extracting the feature information of the fissure coordinates, wherein:

[0033] The first fully connected layer: input 80-dimensional data, output 512 neurons; this layer can capture the initial coordinate feature information;

[0034] The second fully connected layer: from 512 neurons to 1024 neurons; this layer further deepens the network depth and expands the feature space;

[0035] The third fully connected layer: from 1024 neurons to 512 neurons, starting to reduce the feature dimension and focusing on higher-dimensional features;

[0036] The fourth fully connected layer: from 512 neurons to 256 neurons, further extracting features and performing dimension reduction processing;

[0037] Activation function: Leaky ReLU activation function is used in each hidden layer, and the negative slope is set to 0.01; the purpose of setting the negative slope to 0.01 is to solve the "neuron death" problem:

[0038] In the traditional ReLU (Rectified Linear Unit) activation function, negative values are completely suppressed to zero, which may cause "neuron death" in some cases, i.e. the weights of these neurons will not be updated again, leading to a decrease in the learning ability of the model. Leaky ReLU allows a small output for negative values (determined by the negative slope), so there is a small amount of gradient in the negative value region, and the neurons are not completely "turned off", so each neuron always maintains a certain learning ability during training.

[0039] Improve gradient flow:

[0040] When the negative region has a small slope, the gradient can be passed more smoothly during back propagation, and will not be completely lost in the negative region as in the standard ReLU. The setting of a negative slope of 0.01 ensures that the gradient in the negative region is small but not zero, thereby avoiding the problem of gradient disappearance.

[0041] Output layer: It is a fully connected layer, which outputs a single value and is converted into a probability value between 0 and 1 through a Sigmoid activation function; the probability value represents the discriminator's judgment of the authenticity of the input data, and a value close to 1 indicates that the discriminator judges the input data to be real data, while a value close to 0 indicates that the input is pseudo-data generated by the generator.

[0042] Further, the step 2.3 operates as follows:

[0043] Step 2.3.1: Population initialization:

[0044] Randomly generate a population containing 5000 crack vectors, where each vector represents a potential crack network;

[0045] Step 2.3.2: Population selection;

[0046] After the population is generated, the discriminator will evaluate each crack vector and assign an appropriate fitness score, and the selection process is based on these fitness scores, with high-scoring crack vectors having a greater chance of being selected for the next generation. Specifically, the selection uses a multinomial sampling method, and the probability (P i ) of selecting each crack vector is directly proportional to its fitness score:

[0047]

[0048] Where f i is the fitness score of vector i; this probability calculation method ensures that high-fitness individuals are more likely to be selected, but low-fitness individuals also have a chance; the population size is fixed at 5000, and 5000 individuals are formed in each generation through probability selection, where high-scoring individuals may appear multiple times in the newly selected population, thereby increasing their proportion in the next generation;

[0049] Step 2.3.3: Population breeding;

[0050] Offspring generated by crossing often obtain lower scores, so the genetic algorithm uses a form of asexual reproduction, and each crack vector is reproduced through self-mutation;

[0051] Step 2.3.4: Iterative generation;

[0052] The selection and breeding process is repeated in multiple generations, in each generation, 5000 new crack vector are generated, evaluated and optimized by the discriminator, due to the selection process and random disturbance, the population is constantly evolving, and it is possible to generate a higher score than the previous generation of crack network, therefore, the target threshold of the discriminator score is set to 0.965, which represents a more realistic crack network structure, any vector that reaches or exceeds the score of 0.965 will be recorded in the "high fitness individual pool", and the individual with a score lower than 0.965 will be eliminated; the process continues until 50 high fitness crack vectors are collected in the "high fitness individual pool";

[0053] Step 2.3.5: Multi-stage GA generation;

[0054] In order to prevent the population from becoming too homogeneous during the optimization process, only 50 high fitness individuals are allowed to be generated in each generation, i.e. steps 2.3.1 to 2.3.4, after which the entire population is randomly initialized again, i.e. step 2.3.1, and the process of generating high-score individuals is repeated, including steps 2.3.2, 2.3.3, and 2.3.4, to ensure that the final population has both high quality and high population diversity.

[0055] Further, the discriminator training in step 2.4 is used to learn the continuous gradient from low-quality samples to real samples, thereby providing clear feedback for the improvement of the generator, to ensure that the discriminator is continuously exposed to new data, thereby enhancing its robustness and generalization ability.

[0056] Further, in step 2.5, in the GA-GAN framework, the training of the GA-generator and the discriminator is carried out in an alternating manner to ensure that the generator and the discriminator can gradually improve together;

[0057] The execution of the alternating steps is as follows:

[0058] Training cycle and discriminator performance evaluation: after each training cycle, the real verification samples are input into the discriminator to evaluate its performance and assign scores to these real samples; if the scores assigned to these real verification samples start to decline, it indicates that the GA generator has begun to generate samples that are highly similar to the real samples in the verification set; as the training progresses, the discriminator may assign lower scores to these highly similar generated samples;

[0059] Score threshold setting: by evaluating the visual similarity of the samples, we set a score threshold; when the average score assigned by the discriminator to 1000 real verification samples falls below this threshold, the training process stops.

[0060] Compared with the prior art, the present application has the following beneficial effects:

[0061] The GA-GAN model provided by the application successfully solves the problems of low efficiency, high cost and insufficient authenticity in traditional fracture network generation by combining the self-improvement mechanism of the generative adversarial network and the evolution optimization strategy of the genetic algorithm, and the fracture network generated by the model not only retains the complex geometric characteristics of the real network, but also adapts to different geological scenes, thereby providing more valuable research data for practical applications such as groundwater flow simulation and oil and gas exploitation. BRIEF DESCRIPTION OF DRAWINGS

[0062] Figure 1 The schematic diagram of the fracture network generated by the GA-GAN model provided by the application;

[0063] Figure 2 The schematic diagram of the sample file of the fracture network;

[0064] Figure 3 The working principle schematic diagram of the genetic algorithm improved generative adversarial neural network (GA-GAN) provided by the application. DETAILED DESCRIPTION

[0065] In the following, the application will be further described in combination with the drawings and the specific embodiments, and it should be noted that, under the premise of no conflict, the following described embodiments or technical features can be combined to form new embodiments.

[0066] Embodiment 1:

[0067] Reference Figures 1-3 The present scheme provides an intelligent generation method for connectivity fracture network structure, which comprises the following steps: the present scheme performs the following operations in matlab.

[0068] Step 1: Establish a fracture network database:

[0069] Step 1.1: Parameter setting and initialization; the specific operation is as follows:

[0070] Fracture number: the number of fractures in each fracture network is randomly generated, and the number of fractures is set according to the demand, such as between [14, 20].

[0071] Fracture angle: set the direction parameters angle1 = -10 and angle2 = 65 of the fracture, which represent two main fracture directions. std = 2 is the standard deviation of the fracture angle.

[0072] Space size: define the space size of the fracture network, xL = 200, yL = 200, and set the minimum value lmin = 50 and the maximum value lbig = 140 of the fracture length;

[0073] Step 1.2: Generate the fracture network, which comprises the following steps:

[0074] Step a, crack length generation;

[0075] Crack length is generated according to a statistical model of fractal geometry, with the following steps:

[0076] Parameter setting: Set the range between the minimum value lmin and the maximum value lbig of crack length. The length of each crack is randomly generated within this range;

[0077] Distribution generation: Use the fractional dimension D and the power a to control the distribution of crack length. The probability distribution of crack length is calculated by the following formula:

[0078] N fra (L)=c·L -a

[0079] where L is the length of the crack, a is the power that controls the distribution of crack length, and c is the normalization constant. The length generated in this way follows a power-law distribution, which can simulate the distribution of cracks of different lengths in nature;

[0080] Random length generation: The length of each crack is generated by the cumulative distribution function (CDF). The crack length is sampled by a random number, ensuring the diversity of the crack network.

[0081] Step b, crack angle generation;

[0082] The angle of the crack is generated based on a normal distribution, with random deviation from two main directions;

[0083] Main angle: Set two main directions, θ1=-10° and θ2=65°

[0084] Random deviation: Use a normal distribution with a standard deviation σ=2° to generate the actual angle of each crack. Some cracks will randomly deviate from the main direction to simulate the change in direction in the crack network;

[0085] Angle normalization: Ensure that the generated angle is between 0° and 180°, avoiding too large or too small angles.

[0086] Step c, random generation of crack position;

[0087] Random center point generation: Randomly generate the center point position of each crack within the set domain [0, xL] x [0, yL]. The position follows a uniform distribution;

[0088] Specific area generation: For the first few cracks, you can set a specific y-direction distribution so that their centers are located in a specific area (such as near the center of the domain), to simulate a more ordered crack distribution;

[0089] Step d, shadow zone detection and removal;

[0090] After a fracture is generated, it is necessary to check whether the newly generated fracture invades the shadow zone of the existing fracture;

[0091] Shadow zone generation: For each fracture, a shadow zone is generated, usually a certain width (w, 2 units of length) around the fracture, which represents the influence range of the fracture;

[0092] Shadow zone detection: By geometric intersection algorithm, it is detected whether the newly generated fracture overlaps with the shadow zone of the existing fracture. If there is overlap, it means that the generation position of the new fracture is not suitable, and the center position or angle needs to be regenerated;

[0093] Step e, fracture intersection requirement;

[0094] The connectivity of the fracture network is achieved by forcing the new fracture to intersect with the existing fracture;

[0095] Forced intersection: For each newly generated fracture, it is required to intersect with at least one existing fracture. This process is achieved by detecting the geometric intersection point of the two fractures;

[0096] Geometric intersection detection: By using geometric intersection algorithm, it is detected whether the two fractures intersect. If the intersection requirement is not met, the algorithm will regenerate the center or angle of the fracture until the intersection condition is met;

[0097] Step f, fracture network connectivity judgment;

[0098] The final generated fracture network needs to ensure that it is connected from the left side of the domain to the right side:

[0099] Left-right connectivity detection: After the fracture network is generated, the algorithm checks whether there is a connected path from the left side of the domain x=0 to the right side x=xL. Only the fracture network that meets this connectivity requirement is considered to be a qualified fracture network;

[0100] Connectivity determination: If the fracture network does not meet the connectivity requirement, the generation process will start over until a connected fracture network is generated;

[0101] Step g, the generated fracture network data will finally be saved as a matrix format with a size of Nfrac*4, where: Nfrac: represents the number of fractures generated, each row represents a fracture. 4: represents four key attributes of each fracture, specifically: x1: the starting x coordinate of the fracture. y1: the starting y coordinate of the fracture. x2: the ending x coordinate of the fracture. y2: the ending y coordinate of the fracture. A total of 9000 such fracture network samples are generated as training data, as shown in the following table, and the fracture network sample file is Figure 1.

[0102]

[0103]

[0104] Step 1.3, reading fracture network data:

[0105] The binary image (i.e. Figure 1 ) file is iteratively loaded and the data is stored in a three-dimensional matrix DataDFN_CNN. The binary image data of 9,000 discrete fracture networks is loaded and integrated, saved as DataDFN_CNN.mat.

[0106] Step 2, establish GA-GAN model:

[0107] Step 2.1: information import and parameter setting, operation as follows:

[0108] The program first imports the necessary libraries, such as torch, numpy, matplotlib, scipy.io, etc. The hyperparameters of the GAN model are set, such as learning rate, batch size, latent dimension, etc., to ensure that the program can run efficiently in model training.

[0109] lrr = 0.0001

[0110] latent_dim = 200

[0111] bs = 64.

[0112] The generator is part of the GAN model, responsible for generating images from random noise. It includes fully connected layers and transposed convolutional layers, which gradually expand the input random noise into a 200x200 fracture network image.

[0113] Step 2.2: build discriminator

[0114] In the generative adversarial network (GAN) model, the purpose of the discriminator is to distinguish between real fracture coordinate data and synthetic data generated by the generator. The discriminator accepts an 80-dimensional input vector, which contains the coordinate information of 20 fracture entities. The discriminator processes the input through a fully connected neural network (FCNN) to determine the authenticity of the input data.

[0115] The discriminator structure is as follows:

[0116] Input layer: receives an 80-dimensional vector, i.e. contains the coordinate data of 20 fracture entities. This data is directly input to the first fully connected layer.

[0117] Fully Connected Network Structure: The discriminator contains five fully connected layers with 80-512-1024-512-256-1 neurons. This network structure gradually processes input data to extract the feature information of fracture coordinates.

[0118] Layer 1: Input 80-dimensional data, output 512 neurons. This layer can capture preliminary coordinate feature information.

[0119] Layer 2: From 512 neurons to 1024 neurons. This layer further deepens the network depth and expands the feature space.

[0120] Layer 3: From 1024 neurons to 512 neurons, starting to reduce feature dimensions and focusing on higher-dimensional features.

[0121] Layer 4: From 512 neurons to 256 neurons, further extracting features and performing dimension reduction.

[0122] Activation Function: Leaky ReLU activation function is used in each hidden layer with a negative slope of 0.01. This nonlinear activation function not only effectively handles nonlinear features, but also avoids the "neuron death" problem, ensuring the network remains active during deep learning.

[0123] Output Layer: The last layer is a fully connected layer that outputs a single value, which is converted to a probability value between 0 and 1 through the Sigmoid activation function. This probability value represents the discriminator's judgment of the input data's authenticity - close to 1 indicates that the discriminator judges the input data as real data, while close to 0 indicates that the input is pseudo-data generated by the generator.

[0124] The discriminator continuously optimizes itself through this structure to improve its ability to distinguish between real and generated data. In the training process of GAN, the discriminator will be in adversarial training with the generator, constantly improving its ability to distinguish generated data, so as to push the generator to generate more realistic data.

[0125] Step 2.3: Establish a generator based on genetic algorithm:

[0126] In this GA-GAN model, the generator combines genetic algorithm (GA) to generate and optimize fracture networks, ensuring that the generated fracture structure is more realistic and consistent with geological features. The GA generator mainly consists of the following steps:

[0127] Step 2.3.1: Population Initialization:

[0128] First, a population of 5000 fracture vectors is randomly generated, each representing a potential fracture network. The discriminator scores each fracture network in the population for realism. If the highest score is zero (i.e. all generated fracture networks are completely unrealistic), the population is discarded and regenerated. Multiple tests have shown that as long as there is a non-zero score, the genetic algorithm (GA) can effectively improve the quality of fracture vectors in subsequent iterations;

[0129] Step 2.3.2: Selection

[0130] After the population is generated (either by random generation or mutation), the discriminator evaluates each fracture vector and assigns an appropriate fitness score. The selection process is based on these fitness scores, with higher-scoring fracture vectors having a greater chance of being selected for the next generation. Specifically, selection uses a multinomial sampling method, where the probability (Pi) of selecting each fracture vector is proportional to its fitness score:

[0131]

[0132] where fi is the fitness score of vector i. This probability calculation ensures that high-fitness individuals are more likely to be selected, but low-fitness individuals also have a chance. The population size is fixed at 5000, and 5000 individuals are formed in each generation through probabilistic selection. High-scoring individuals may appear multiple times in the newly selected population, increasing their proportion in the next generation.

[0133] Step 2.3.3: Reproduction

[0134] Experiments have shown that offspring generated by crossover often receive lower scores, so the algorithm uses a form of asexual reproduction, where each fracture vector is reproduced by self-mutation. After selection, each selected fracture vector undergoes a small random perturbation. Each vector's 80 coordinates are randomly adjusted within the range [-2.4, 2.4] [-2.4, 2.4] [-2.4, 2.4]. This perturbation range is relatively small compared to the 200m x 200m domain, but it is sufficient to introduce effective mutations.

[0135] Step 2.3.4: Iterative generation

[0136] The selection and breeding process is repeated over multiple generations. In each generation, new 5000 fissure vectors are generated, evaluated and optimized by the discriminator. Due to the selection process and the role of random perturbation, the population is constantly evolving, with the possibility of generating fissure networks with higher scores than the previous generation. A target threshold of 0.965 is set for the discriminator score, representing a relatively realistic fissure network structure. Any vector that reaches or exceeds a score of 0.965 is recorded in the "high fitness populations" pool, and individuals with scores below 0.965 are eliminated. This process continues until 50 high-fitness fissure vectors are collected in the "high fitness populations" pool.

[0137] Step 2.3.5: Multi-stage GA generation

[0138] To prevent the population from becoming too homogeneous during optimization, only 50 high-fitness individuals are allowed to be generated in each generation, i.e. steps 2.3.1 to 2.3.4. After that, the entire population is randomly initialized again, i.e. step 2.3.1, and the process of generating high-score individuals is repeated, including steps 2.3.2, 2.3.3, and 2.3.4. This multi-stage approach ensures that the final population has both high quality and high population diversity.

[0139] Step 2.4: Discriminator training

[0140] To effectively train the discriminator (D), this method differs from the traditional method of using only "real samples" and "generated samples" with scores of 1 and 0, respectively. Instead, five groups of data are used to create a more continuous score gradient: from poor-quality samples to "partially similar", "highly similar", and finally "real samples", with scores continuously distributed between 0 and 1. This score gradient is crucial for feedback to the GA-Generator, as it provides a clearer direction for improvement, enabling the generator to gradually optimize the generated fissure network.

[0141] Importance of continuous score gradient:

[0142] Support for initial population generation: "slightly similar" training samples need to be introduced and assigned a score very close to 0 but greater than zero. In this way, the GA generator can complete the initialization process. Otherwise, if the highest score of the population is zero (i.e. all generated fissure networks are completely unrealistic), the entire population will be discarded and regenerated. The addition of such samples allows the initial population to have more samples for subsequent evolutionary optimization.

[0143] Avoiding stagnation in the GA generator evolution process: Without "highly similar" sample data as reference, the optimization process of the GA generator can stagnate at a certain stage. For example, after the generator reaches a score of around 0.1, it becomes significantly more difficult to improve if there is a lack of clear feedback from higher-scoring samples. By adding "highly similar" samples to the training set, the generator can be further guided towards the real samples.

[0144]

[0145]

[0146] This design enables the discriminator (D) to learn the continuous gradient from low-quality samples to real samples, providing clear feedback for the improvement of the generator. In each training iteration, new samples are dynamically generated for Group 1 (random samples) and Group 2 (slightly similar samples), ensuring that the discriminator is continuously exposed to new data, thereby enhancing its robustness and generalization ability.

[0147] For Groups 3 and 4, an iterative process is adopted: 2500 samples are randomly selected from Group 3 (previous generator output) and Group 4 (current generator output), combined into a new 5000-sample group. This updated group is used as Group 3 in the next round of training, ensuring that the generator improves while maintaining the diversity of generated outputs.

[0148] To improve the training effect of the discriminator, we replace the binary cross-entropy (BCE) loss function with the mean square error (MSE), which assigns a continuous score from 0 to 1, allowing the model to capture subtle differences between random samples and real samples. The five data groups are combined into a dataset and randomly mixed to ensure that each batch contains a mix of samples from all groups. Each batch contains 500 samples, and the Adam optimizer is used in training with a learning rate of 0.00025, running for 40 cycles per round of training.

[0149] During the training of the discriminator, through these five groups of samples of different quality, the discriminator can learn to make more detailed distinctions between samples of different quality. This continuous scoring mechanism helps the GA generator more effectively identify the direction of improvement, gradually approaching the target.

[0150] Step 2.5: Iterative training

[0151] In the GA-GAN framework, the training of the GA generator and the discriminator is carried out in alternating steps to ensure that the generator and the discriminator can gradually improve together. Unlike traditional GANs, only the discriminator (D) is explicitly trained in the GA-GAN framework, and the trained D is directly integrated into the evolution process of the generator, allowing the generator to evolve and improve based on the feedback from the discriminator.

[0152] The execution of the alternating steps is as follows:

[0153] Training cycle and discriminator performance evaluation: After each training cycle, real validation samples (number 1000) are inputted into the discriminator to evaluate its performance and assign scores for these real samples. If the scores assigned to these real validation samples start to decrease, it indicates that the GA generator has started to generate samples highly similar to the real samples in the validation set. As the training progresses, the discriminator can assign lower scores to these highly similar generated samples.

[0154] Score threshold setting: Through the visual similarity assessment of samples, we set a score threshold of 0.765. When the average score assigned by the discriminator to 1000 real validation samples falls below this threshold, the training process stops. This setting ensures that the output of the generator reaches an optimal level of similarity while avoiding overfitting or collapse of the model.

[0155] Results presentation.

[0156] Results presentation of GA-GAN generated fracture networks.

[0157] In the context of deep learning and Generative Adversarial Networks (GAN) training, an epoch is a complete training cycle that represents the model passing through the entire training dataset once, with one forward and one backward propagation. During each epoch, the model gradually updates its parameters to better fit the data in each training round. The end of each epoch marks the completion of one learning pass over all training samples, and multiple epochs are often required to achieve the desired accuracy or generation effect of the model.

[0158] During the training process of GA-GAN, as the number of epochs increases, the generated fracture networks gradually show higher realism and connectivity. In the initial epochs, the generated fracture networks are relatively simple and irregular, lacking the complex geometric structure and connectivity of natural fracture networks. However, as the training progresses, the GA-generator gradually optimizes the generated samples through the feedback of the discriminator, so that the arrangement and direction of the fracture networks gradually conform to the real geological conditions.

[0159] As shown in Figure 2 , as the number of training epochs increases, the generated fracture networks show more and more features, including clearer intersection points, consistency in direction, and more connectivity, gradually approaching the distribution and morphology of real fractures. Each subsequent epoch demonstrates the improvement of GA-GAN in generating fracture networks, indicating that the model performs well in generating realistic and complex fracture structures.

[0160] Generated fracture networks asFigure 2 As shown, the figure demonstrates a number of fracture network samples that meet a series of requirements for our training data. Specifically, the following aspects show the superiority of the DC-GAN model:

[0161] Two main directions of fractures: The fracture network clearly demonstrates two distinct directions, reflecting the dominant structural characteristics of the fractures. Such directionality is an important manifestation of the model in learning complex geological features, in line with our requirements for the distribution of directionality in fracture modeling. The generation of such bidirectional fractures indicates that the model has captured the key geometric characteristics in the training data.

[0162] Left-right connectivity: Multiple fractures exhibit connectivity in both the horizontal and vertical directions, simulating the interconnection characteristics of real fracture networks. This feature has a crucial impact on the behavior of fluids passing through the fracture network, indicating that our DC-GAN can generate fracture network structures consistent with actual geological conditions.

[0163] Diversity and complexity: As can be seen from the figure, although all samples conform to our fracture pattern, they exhibit rich diversity in specific geometric details. Each fracture network is unique, exhibiting different lengths, angles, and spatial distributions. This complex diversity indicates that the generated fracture networks can well simulate the spatial variability of actual fractures, enhancing the robustness and generalization ability of the generation model.

[0164] Large data volume: The model can generate large-scale fracture network data, sufficient to meet subsequent simulation and research needs. With the generation of a large number of samples, we can quickly obtain complex geological structure data that is difficult to obtain through traditional methods through deep learning models.

[0165] In summary, Figure 2 The fracture network samples shown in the figure perfectly demonstrate the training effect of the GA-GAN model, successfully capturing the main directionality, connectivity, and complexity of fractures, indicating the potential of the model for wide application in geological structure simulation.

[0166] The above embodiments are only preferred embodiments of the present application, and cannot be used to limit the scope of protection of the present application. Any non-essential changes and substitutions made by those skilled in the art based on the present application are within the scope of the present application.

Claims

1. A GA-GAN model-based intelligent generation method of connectivity fracture network structure, characterized in that, It comprises the following steps: Step 1, establishing a fracture network database; Step 2, establishing a GA-GAN model, specifically as follows: Step 2.1: information import and parameter setting; Step 2.2: constructing a discriminator; Step 2.3: establishing a generator based on a genetic algorithm; Step 2.4: discriminator training; Step 2.5: iterative training; Step 3, using the GA-GAN model to automatically generate the corresponding connectivity fracture network structure; The specific operation of the step 1 is as follows: Step 1.1: parameter setting and initialization; Step 1.2: generating a fracture network; Step 1.3, reading the fracture network data generated in step 1.2, storing the data into a three-dimensional matrix DataDFN_CNN, and saving it as DataDFN_CNN.mat format data; The operation of the step 1.2 is as follows: Step a, generating a fracture length; Step b, generating a fracture angle; Step c, random generation of fracture position; Step d, shadow area detection and removal; Step e, fracture intersection requirement; Step f, fracture network connectivity judgment; Step g, saving the finally generated fracture network data as a matrix with a size of Nfrac * 4, wherein: Nfrac represents the number of generated fractures, and each row represents a fracture; 4 represents four key attributes of each fracture; The discriminator structure in the step 2.2 is as follows: Input layer: used for receiving an 80-dimensional vector, i.e. containing 20 fracture entity coordinate data; the data is directly input into the first fully connected layer; Fully connected network structure: it contains five fully connected layers, and the number of neurons of the five fully connected layers is set to 80, 512, 1024, 512, 256, and 1 respectively; the fully connected network structure gradually processes the input data, thereby extracting the feature information of the fracture coordinates, wherein: The first fully connected layer: inputting 80-dimensional data, outputting 512 neurons; this layer can capture the preliminary coordinate feature information; The second fully connected layer: outputting from 512 neurons to 1024 neurons; this layer further deepens the network depth and expands the feature space; The third fully connected layer: outputting from 1024 neurons to 512 neurons, starting to reduce the feature dimension and focusing on higher-dimensional features; The fourth fully connected layer: outputting from 512 neurons to 256 neurons, further extracting features and performing dimension reduction processing; Activation function: Leaky ReLU activation function is adopted in each hidden layer, and the negative slope is set to 0.01; Output layer: it is a fully connected layer, outputting a single value and converting it to a probability value between 0 and 1 through a Sigmoid activation function; the probability value represents the discriminator's judgment on the authenticity of the input data, and close to 1 indicates that the discriminator judges the input data to be real data, while close to 0 indicates that the input is pseudo-data generated by the generator.

2. The GA-GAN model-based connectivity fracture network structure intelligent generation method according to claim 1, characterized in that, The operation of the step 2.1 is as follows: The program first imports the necessary libraries such as torch, numpy, matplotlib, scipy.io; sets the hyperparameters of the GAN model such as learning rate, batch size, latent dimension, to ensure the program can run efficiently in model training.

3. The GA-GAN model-based connectivity fracture network structure intelligent generation method of claim 1, wherein, The step 2.3 operation is as follows: Step 2.3.1: Population initialization: Randomly generate a population of 5000 crack vectors, each of which represents a potential crack network; Step 2.3.2: Population selection; After the population is generated, the discriminator evaluates each crack vector and assigns an appropriate fitness score, and the selection process is based on these fitness scores, with higher scoring crack vectors having a greater chance of being selected for the next generation. Specifically, selection uses a multinomial sampling method, with the probability (P i ) of selecting each crack vector being proportional to its fitness score: ； where f i is the fitness score of vector i; this probability calculation method ensures that high fitness individuals are more likely to be selected, but low fitness individuals also have a chance; the population size is fixed at 5000, and 5000 individuals are formed in each generation by probability selection, in which high-score individuals can appear multiple times in the newly selected population, thereby increasing their proportion in the next generation; Step 2.3.3: Population breeding; The offspring generated by crossing often get lower scores, so the genetic algorithm adopts a form of asexual reproduction, each crack vector is reproduced by self-mutation; Step 2.3.4: Iterative generation; The selection and breeding process will be repeated in multiple generations, in each generation, 5000 new crack vectors are generated, evaluated and optimized by the discriminator, due to the selection process and random disturbance, the population is constantly evolving, it is possible to generate a higher score than the previous generation of crack network, therefore, the target threshold of the discriminator score is set to 0.965, representing a relatively realistic crack network structure, any vector that reaches or exceeds 0.965 score will be recorded in the "high fitness individual pool", individuals with scores below 0.965 will be eliminated; the process continues until 50 high fitness crack vectors are collected in the "high fitness individual pool"; Step 2.3.5: Multi-stage GA generation; To prevent the population from becoming too homogeneous during optimization, only 50 high fitness individuals are allowed to be generated in each generation, i.e. steps 2.3.1 to 2.3.4, after which the entire population is randomly initialized again, i.e. step 2.3.1, and the process of generating high-score individuals is repeated, including steps 2.3.2, 2.3.3, 2.3.4, to ensure that the final population has both high quality and high population diversity.

4. The GA-GAN model-based connectivity fracture network structure intelligent generation method of claim 1, wherein, The discriminator training in step 2.4 is used to learn the continuous gradient from low-quality samples to real samples, providing clear feedback for the improvement of the generator, to ensure that the discriminator is constantly exposed to new data, thereby enhancing its robustness and generalization ability.

5. The GA-GAN model-based connectivity fracture network structure intelligent generation method of claim 1, wherein, In step 2.5, in the GA-GAN framework, the training of GA-generator and discriminator is carried out in an alternating step to ensure that the generator and discriminator can gradually improve together; The implementation of the alternating step is as follows: Training cycle and discriminator performance evaluation: after each training cycle, the real validation samples are input into the discriminator to evaluate its performance and assign scores to these real samples; If the scores assigned to these real validation samples start to decline, it indicates that the GA generator has begun to generate samples highly similar to the real samples in the validation set; As the training progresses, the discriminator may assign lower scores to these highly similar generated samples; Score threshold setting: through the visual similarity evaluation of the samples, we set a score threshold; when the average score assigned by the discriminator to 1000 real validation samples falls below this threshold, the training process stops.

Images