Connectivity fracture network structure intelligent generation method based on GA-GAN model

Abstract

The invention 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, and the method comprises the following steps: 1, building a fracture network database; step 2, establishing a GA-GAN model; step 2.1, importing information and setting parameters; step 2.2, constructing a discriminator; step 2.3, establishing a generator based on a genetic algorithm; 2.4, training the discriminator; step 2.5, carrying out iterative training; and step 3, automatically generating a corresponding connectivity fracture network structure by using the GA-GAN model. The fracture network structure intelligent generation method successfully solves the problems of low efficiency, high cost, insufficient authenticity and the like in the traditional fracture network generation, and the fracture network generated by the model not only retains the complex geometric characteristics of a real network, but also can adapt to different geological scenes, and has good application prospects. And research data with higher reference value is provided for practical applications such as underground water flow simulation and oil and gas exploitation.

Description

Technical Field

[0001] The present invention relates to the technical field of crack network prediction, and in particular to a method for intelligently generating a connected crack network structure based on a GA-GAN model. Background Art

[0002] In the fields of hydrogeology and petroleum engineering, the study of fracture networks is crucial in predicting fluid flow, contaminant migration, and optimizing oil and gas production strategies. The geometry, connectivity, and distribution characteristics of fracture networks have a significant impact on groundwater flow, geothermal systems, and the behavior of fluids in oil and gas reservoirs. In oil reservoirs, fractures are usually the main channels for fluids, while the matrix has low permeability, which limits fluid migration. Therefore, accurate characterization of fracture networks can not only improve production efficiency, but also prevent potential environmental risks, such as pollutant leakage.

[0003] Defects and shortcomings of the existing technology:

[0004] The nonlinear characteristics of fracture networks are difficult to capture: Fracture networks usually exhibit highly nonlinear and complex parameter spaces, and traditional simulation methods have difficulty effectively covering and exploring the entire parameter space. The resulting fracture network models lack diversity and are difficult to fully reflect the true geological characteristics, especially in predicting the distribution of fractures in complex reservoirs. The geometric characteristics of oil reservoir fractures have an important impact on oil and gas migration, production efficiency and safety. However, traditional models have difficulty accurately capturing the dynamic characteristics of fracture fluids under high pressure and high temperature conditions, resulting in a decrease in the effectiveness of simulation results.

[0005] In traditional generative adversarial network (GAN) methods, the generator's generation ability is often limited, and it is difficult to generate complex geometric features that conform to real fracture networks. The generator often performs poorly in confrontation with the discriminator, especially in application scenarios with rich data sets and complex details, resulting in poor quality of generated samples and failure to accurately present the structure and connectivity of real fracture networks. In addition, traditional numerical simulation methods are inefficient and costly in generating large-scale and realistic fracture networks. In order to solve these problems, GAN is introduced to generate realistic fracture network images, thereby accelerating research progress and reducing computational costs. Summary of the invention

[0006] In order to solve the technical problems raised in the background technology, the present invention provides a method for intelligently generating a connected crack network structure based on a GA-GAN model.

[0007] The present invention is implemented by the following technical solution: a method for intelligently generating a connected crack network structure based on a GA-GAN model, comprising the following steps:

[0008] Step 1: Establish a fracture network database;

[0009] Step 2: Establish the GA-GAN model as follows:

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

[0011] Step 2.2: Build the 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 crack network structure.

[0016] Furthermore, the specific operations of step 1 are as follows:

[0017] Step 1.1: Parameter setting and initialization;

[0018] Step 1.2: Generate a fracture network;

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

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

[0021] Step a, generating crack length;

[0022] Step b, generating crack angle;

[0023] Step c: random generation of crack positions;

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

[0025] Step e, crack intersection requirements;

[0026] Step f, judging the connectivity of the fracture network;

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

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

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

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

[0031] Input layer: used to receive an 80-dimensional vector, i.e., the coordinate data of 20 crack entities; this data is directly input into 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, and 1 respectively; the fully connected network structure gradually processes the input data to extract the characteristic information of the crack coordinates, where:

[0033] The first fully connected layer: inputs 80-dimensional data and outputs 512 neurons; this layer can capture preliminary coordinate feature information;

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

[0035] The third fully connected layer: The output of neurons is reduced from 1024 to 512, and the feature dimension is reduced to focus on higher dimensional features.

[0036] The fourth fully connected layer: outputs from 512 neurons to 256 neurons, further extracts features and performs dimensionality reduction;

[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 ​​will be completely suppressed to zero, which may cause neurons to "die" in some cases, that is, the weights of these neurons will no longer be updated, resulting in a decrease in the model's learning ability. Leaky ReLU allows negative values ​​to have a very small output (determined by the negative slope), so that there is also a small amount of gradient in the negative area, which will not completely "turn off" the neurons, so that each neuron always maintains a certain learning ability during training.

[0039] Improved gradient flow:

[0040] When there is a small slope in the negative region, the gradient can be passed more smoothly during back propagation, and will not completely disappear in the negative region like the standard ReLU. The setting of negative slope of 0.01 ensures that the gradient in the negative region is small but not zero, thus avoiding the problem of gradient vanishing.

[0041] Output layer: It is a fully connected layer that outputs a single value and converts it into a probability value between 0 and 1 through the Sigmoid activation function; this probability value represents the discriminator's judgment on 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 fake data generated by the generator.

[0042] Further, the step 2.3 is performed as follows:

[0043] Step 2.3.1: Population initialization:

[0044] A population of 5000 crack vectors is randomly generated, where each vector represents a potential crack network.

[0045] Step 2.3.2: Population selection;

[0046] After the population is generated, the discriminator evaluates each crack vector and assigns an appropriate fitness score. The selection process is based on these fitness scores. Crack vectors with high scores have a greater chance of being selected into the next generation. Specifically, the selection uses a multinomial sampling method. The probability of selecting each crack vector (P i ) is proportional to its fitness score:

[0047]

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

[0049] Step 2.3.3: Population reproduction;

[0050] Offspring generated by crossover often receive lower scores, so the genetic algorithm uses a form of asexual reproduction, where each crack vector reproduces by self-mutation;

[0051] Step 2.3.4: Iterative generation;

[0052] The selection and reproduction process will be repeated in multiple generations. In each generation, 5,000 new crack vectors are generated, evaluated and optimized by the discriminator. Due to the selection process and random perturbations, the population continues to evolve, and it is possible to generate a crack network with a higher score than the previous generation. Therefore, the target threshold of the discriminator score is set to 0.965, which represents a more realistic crack network structure. Any vector with a score of 0.965 or more will be recorded in the "high fitness individual pool", and individuals with a score lower than 0.965 will be eliminated; this 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] 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 that, the entire population will be randomly initialized again, i.e., step 2.3.1, and the process of generating high-scoring individuals will be 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] Furthermore, 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] Furthermore, in step 2.5, in the GA-GAN framework, the training of the GA-generator and the discriminator is performed in alternating steps to ensure that the generator and the discriminator can be gradually improved together;

[0057] The alternating steps are performed as follows:

[0058] Training loop and discriminator performance evaluation: After each training loop, the real validation samples are fed into the discriminator to evaluate its performance and assign scores to these real samples; if the scores assigned to these real validation samples begin to decrease, it indicates that the GA generator has begun to generate samples that are highly similar to the real samples in the validation set; as training progresses, the discriminator may assign lower scores to these highly similar generated samples;

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

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

[0061] The GA-GAN model proposed in this paper successfully solves the problems of low efficiency, high cost, and lack of authenticity in traditional fracture network generation by combining the self-improvement mechanism of the generative adversarial network and the evolutionary optimization strategy of the genetic algorithm. The fracture network generated by this model not only retains the complex geometric characteristics of the real network, but also can adapt to different geological scenarios, providing more valuable research data for practical applications such as groundwater flow simulation and oil and gas extraction. BRIEF DESCRIPTION OF THE DRAWINGS

[0062] Figure 1 Schematic diagram of the GA-GAN model proposed in the present invention to generate a crack network;

[0063] Figure 2 This is a sample file diagram of a crack network;

[0064] Figure 3 Schematic diagram of the working principle of the genetic algorithm-improved GAN (GA-GAN) proposed in the present invention. DETAILED DESCRIPTION

[0065] The present invention is further described below in conjunction with the accompanying drawings and specific implementation methods. It should be noted that, under the premise of no conflict, the various embodiments or technical features described below can be arbitrarily combined to form a new embodiment.

[0066] Embodiment 1:

[0067] Reference Figure 1-Figure 3 ,This scheme proposes a method for intelligent generation of connectivity crack network structure, which includes the following steps: This scheme performs the following operations in matlab.

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

[0069] Step 1.1: Parameter setting and initialization; the specific operations are as follows:

[0070] Number of fractures: The number of fractures in each fracture network is randomly generated. The range of the number of fractures can be set according to the requirements, for example, between [14,20].

[0071] Crack angle: Set the crack direction parameters angle1 = -10 and angle2 = 65, representing the two main crack directions. std = 2 is the standard deviation of the crack angle.

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

[0073] Step 1.2: Generate a fracture network, which includes the following steps;

[0074] Step a, generating crack length;

[0075] The crack length is generated based on the statistical model of fractal geometry, and the specific steps are as follows:

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

[0077] Distribution generation: The fractional dimension D and the power a are used to control the distribution of the crack length. The probability distribution of the 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 crack length distribution, and c is a normalization constant. The length generated in this way obeys a power law distribution and can simulate the distribution of cracks of different lengths in nature;

[0080] Random length generation: Generate the length of each crack through the cumulative distribution function (CDF). The crack length is obtained by random number sampling to ensure the diversity of the crack network.

[0081] Step b, generating crack angle;

[0082] The angles of the cracks were generated based on a normal distribution with random deviations from the two main directions;

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

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

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

[0086] Step c: random generation of crack positions;

[0087] Random center point generation: The center point of each crack is randomly generated in the set domain [0,xL]×[0,yL]. The position follows a uniform distribution;

[0088] Specific region generation: For the first few cracks, a specific y-direction distribution can be set so that their centers are located in a specific region (e.g., near the center of the domain) to simulate a more orderly crack distribution;

[0089] Step d: shadow area detection and removal;

[0090] After the cracks are generated, it is necessary to detect whether the newly generated cracks invade the shadow area of ​​the existing cracks;

[0091] Shadow zone generation: A shadow zone is generated for each crack, usually a certain width (w, 2 unit length) around the crack, which represents the impact range of the crack;

[0092] Shadow area detection: Use the geometric intersection algorithm to detect whether the newly generated cracks overlap with the existing crack shadow areas. If overlap occurs, it means that the new crack generation position is not appropriate and the center position or angle needs to be regenerated;

[0093] Step e, crack intersection requirements;

[0094] Connectivity of the fracture network is achieved by enforcing that new fractures intersect with existing fractures;

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

[0096] Geometric intersection detection: Use the geometric intersection algorithm to detect whether two cracks intersect. If the intersection requirement is not met, the algorithm will regenerate the center or angle of the crack until the intersection condition is met;

[0097] Step f, judging the connectivity of the fracture network;

[0098] The resulting fracture network must be 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 will check whether there is a connected path from the left side of the domain x=0x=0x=0 to the right side x=xLx=xLx=xL. Only when the fracture network meets this connectivity will it be considered a qualified fracture network;

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

[0101] Step g: The generated fracture network data will be saved as a matrix of size Nfrac*4, where: Nfrac: represents the number of fractures generated, and each row represents a fracture. 4: represents the four key attributes of each fracture, specifically: x1: the x-coordinate of the fracture's starting point. y1: the y-coordinate of the fracture's starting point. x2: the x-coordinate of the fracture's ending point. y2: the y-coordinate of the fracture's ending point. A total of 9,000 fracture network samples were generated as training data, as shown in the following table. The sample file of the fracture network can be found in Figure 1.

[0102]

[0103]

[0104] Step 1.3, read the fracture network data:

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

[0106] Step 2: Establish GA-GAN model:

[0107] Step 2.1: Information import and parameter setting, the operation is as follows:

[0108] The program first imports necessary libraries, such as torch, numpy, matplotlib, scipy.io, etc. The hyperparameters of the GAN model, such as learning rate, batch size, potential dimension, etc., are set 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 the part of the GAN model responsible for generating images from random noise. It includes fully connected layers and transposed convolutional layers, through which the input random noise is gradually expanded into a 200x200 crack network image.

[0113] Step 2.2: Build the Discriminator

[0114] In the Generative Adversarial Network (GAN) model, the discriminator is designed to distinguish between real crack coordinate data and synthetic data generated by the generator. The discriminator accepts an 80-dimensional input vector that contains the coordinate information of 20 crack 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, which contains the coordinate data of 20 crack entities. This data is directly input into the first fully connected layer.

[0117] Fully connected network structure: The discriminator contains five fully connected layers, and the number of neurons is set to 80-512-1024-512-256-1. This network structure processes the input data step by step to extract the feature information of the crack coordinates.

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

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

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

[0121] Layer 4: Output from 512 neurons to 256 neurons, further extract features and perform dimensionality 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 can not only effectively handle nonlinear features, but also avoid the "neuron death" problem, ensuring that the network remains active during deep learning.

[0123] Output layer: The last layer is a fully connected layer that outputs a single value and is converted into a probability value between 0 and 1 through the Sigmoid activation function. This probability value represents the discriminator's judgment on the authenticity of the input data - close to 1 means that the discriminator judges the input data to be real data, while close to 0 means that the input is fake 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. During the training process of GAN, the discriminator will conduct adversarial training with the generator to continuously improve its ability to distinguish generated data, thereby driving the generator to generate more realistic data.

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

[0126] In the GA-GAN model, the generator combines the genetic algorithm (GA) to generate and optimize the fracture network to ensure that the generated fracture structure is more realistic and consistent with geological characteristics. The GA generator is mainly divided into the following steps:

[0127] Step 2.3.1: Population initialization:

[0128] First, a population of 5000 crack vectors is randomly generated, where each vector represents a potential crack network. The discriminator scores each crack network in the population to evaluate its authenticity. If the highest score is zero (that is, all generated crack networks are completely unrealistic), the population is discarded and regenerated. After multiple tests, it is shown that as long as there is a non-zero score, the genetic algorithm (GA) can effectively improve the quality of crack vectors in subsequent iterations;

[0129] Step 2.3.2: Select

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

[0131]

[0132] Where fi is the fitness score of vector i. This probability calculation method ensures that individuals with high fitness are more likely to be selected, but individuals with low fitness also have a certain chance. The population size is fixed at 5000, and 5000 individuals are formed by probability selection in each generation. Individuals with high scores may appear in the newly selected population multiple times, thereby 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 crack vector reproduces by self-mutation. After selection, each selected crack vector will undergo a small range of random perturbations, and the 80 coordinates of each vector will be randomly adjusted within the range of [-2.4, 2.4][-2.4, 2.4][-2.4, 2.4]. This perturbation range is relatively small compared to a 200m x 200m domain, but it is sufficient to introduce effective mutations.

[0135] Step 2.3.4: Iterative Generation

[0136] The selection and reproduction process is repeated over multiple generations. In each generation, 5000 new crack vectors are generated, and the discriminator is evaluated and optimized. Due to the selection process and random perturbations, the population continues to evolve, and it is possible to generate crack networks with higher scores than the previous generation. 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 a score of 0.965 will be recorded in the "high fitness individual pool (high_fitness_populations)", and individuals with a score below 0.965 will be eliminated. This process continues until 50 high fitness crack vectors are collected in the "high fitness individual pool".

[0137] Step 2.3.5: Multi-stage GA generation

[0138] 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 that, the entire population will be randomly initialized again, i.e., step 2.3.1, and the process of generating high-scoring individuals will be repeated, including steps 2.3.2, 2.3.3, and 2.3.4. This multi-stage method ensures that the final population has both high quality and high population diversity.

[0139] Step 2.4: Discriminator training

[0140] In order to effectively train the discriminator (D), this method uses five sets of data to construct a more continuous scoring gradient, which is different from the traditional method of only using "real samples" and "generated samples" with scores of 1 and 0 respectively: gradually transitioning from samples of poor quality to "partially similar", "highly similar" and finally "real samples", with scores continuously distributed between 0 and 1. This scoring gradient is crucial for the feedback of the GA-Generator, because it provides the generator with a clearer direction for improvement, enabling it to gradually optimize the generated fracture network.

[0141] Importance of Continuous Rating Gradients:

[0142] Support for initial population generation: "slightly similar" training samples need to be introduced and given 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 (that is, all generated crack networks are completely unrealistic), the entire population will be abandoned and regenerated. Adding such samples allows the initial population to have more samples for subsequent evolutionary optimization.

[0143] Avoid stagnation in the evolution process of the GA generator: If there is no "highly similar" sample data as a reference, the optimization process of the GA generator may stagnate at a certain stage. For example, after the generator reaches a score of about 0.1, if there is a lack of clear feedback from samples with higher scores, the difficulty of improvement will increase significantly. By adding "highly similar" samples to the training samples, the generator can be further guided to approach the real samples.

[0144]

[0145]

[0146] This design enables the discriminator (D) to learn a 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 used: 2,500 samples are randomly selected from group 3 (previous generator output) and group 4 (current generator output) to form a new group of 5,000 samples. This updated group is used as group 3 in the next round of training, ensuring that the generator maintains the diversity of generated outputs while improving.

[0148] To improve the training effect of the discriminator, we replaced the binary cross entropy (BCE) loss function with the mean squared error (MSE) to enable the model to capture the subtle differences between random samples and real samples by assigning continuous scores from 0 to 1. The five data groups were combined into one dataset and randomly mixed to ensure that each batch contained mixed samples from all groups. Each batch contained 500 samples, and the Adam optimizer was used in training. The learning rate was set to 0.00025, and each round of training ran for 40 epochs.

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

[0150] Step 2.5: Iterative training

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

[0152] The alternating steps are performed as follows:

[0153] Training cycle and discriminator performance evaluation: After each training cycle, the real validation samples (number of 1000) are fed 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 decrease, it indicates that the GA generator has started to generate samples that are highly similar to the real samples in the validation set. As training progresses, the discriminator may assign lower scores to these highly similar generated samples.

[0154] Rating threshold setting: By visually evaluating the similarity of samples, we set a rating threshold of 0.765. When the average rating assigned by the discriminator to 1,000 real validation samples falls below this threshold, the training process stops. This setting ensures that the output of the generator reaches the best similarity level while avoiding overfitting or collapse of the model.

[0155] Results display.

[0156] Results of GA-GAN generating crack networks.

[0157] In the process of deep learning and generative adversarial network (GAN) training, an epoch is a complete training cycle, which means that the model passes the entire training data set through forward and backward propagation once. In each epoch, the model gradually updates its parameters to better fit the data in each round of training. The end of each epoch marks that the model has completed learning all training samples once, and it usually takes multiple epochs for the model to achieve the expected accuracy or generation effect.

[0158] During the training process of GA-GAN, as the number of epochs increases, the generated fracture networks gradually show higher authenticity and connectivity. In the initial epochs, the generated fracture networks are relatively simple and irregular, lacking the complex geometry 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 network gradually conform to the real geological conditions.

[0159] like Figure 2 As shown in the figure, with the increase of training epochs, the generated crack network shows more and more features, including clearer intersections, consistency of direction, and more connectivity, gradually approaching the distribution and morphology of real cracks. Each subsequent epoch shows the improvement of GA-GAN in generating crack networks, indicating that the model performs well in generating realistic and complex crack structures.

[0160] The generated fracture network is shown in Figure 2 As shown in the figure, multiple samples of crack networks are shown, which 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 shows two distinct directions, reflecting the dominant structural characteristics of the fractures. Such directionality is an important manifestation of the model when learning complex geological features, which meets our requirements for directional distribution in fracture modeling. The generation of such bidirectional fractures shows that the model has been able to capture the key geometric characteristics in the training data well.

[0162] Left-right connectivity: Multiple fractures are interconnected in both the horizontal and vertical directions, simulating the interconnectedness of a real fracture network. 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 that are consistent with actual geological conditions.

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

[0164] Large amount of data: The model can generate large-scale fracture network data, which is sufficient to meet the needs of subsequent simulation and research. 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 the fractures, indicating the wide application potential of the model in geological structure simulation.

[0166] The above-mentioned embodiments are only preferred embodiments of the present invention and cannot be used to limit the scope of protection of the present invention. Any non-substantial changes and substitutions made by technicians in this field on the basis of the present invention shall fall within the scope of protection required by the present invention.

Claims

1. A method for intelligently generating a connected fracture network structure based on a GA-GAN model, characterized in that: The steps include: Step 1: Establish a fracture network database; Step 2: Establish the GA-GAN model as follows: Step 2.1: Information import and parameter setting; Step 2.2: Build the discriminator; Step 2.3: Establish a generator based on genetic algorithm; Step 2.4: Discriminator training; Step 2.5: Iterative training; Step 3: Use the GA-GAN model to automatically generate the corresponding connectivity crack network structure.

2. The method for intelligently generating a connected fracture network structure based on a GA-GAN model according to claim 1, characterized in that: The specific operations of step 1 are as follows: Step 1.1: Parameter setting and initialization; Step 1.2: Generate a fracture network; Step 1.3, read the fracture network data generated in step 1.2, store the data into the three-dimensional matrix DataDFN_CNN, and save it in the format of DataDFN_CNN.mat.

3. The method for intelligently generating a connected fracture network structure based on a GA-GAN model according to claim 1, characterized in that: The operation of step 1.2 is as follows: Step a, generating crack length; Step b, generating crack angle; Step c: random generation of crack positions; Step d: shadow area detection and removal; Step e, crack intersection requirements; Step f, judging the connectivity of the fracture network; Step g: Save the finally generated fracture network data in a matrix format of size Nfrac*4, where: Nfrac: represents the number of fractures generated, and each row represents a fracture; 4: represents the four key attributes of each fracture.

4. The method for intelligently generating a connected fracture network structure based on a GA-GAN model according to claim 1, characterized in that: The operation of step 2.1 is as follows: The program first imports necessary libraries, such as torch, numpy, matplotlib, and scipy.io; it sets the hyperparameters of the GAN model, such as learning rate, batch size, and latent dimension, to ensure that the program can run efficiently during model training.

5. The method for intelligently generating a connected fracture network structure based on a GA-GAN model according to claim 1, characterized in that: The discriminator structure in step 2.2 is as follows: Input layer: used to receive an 80-dimensional vector, i.e., the coordinate data of 20 crack entities; this 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 in 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 to extract the characteristic information of the crack coordinates, where: The first fully connected layer: inputs 80-dimensional data and outputs 512 neurons; this layer can capture preliminary coordinate feature information; The second fully connected layer: the output is increased from 512 neurons to 1024 neurons; this layer further deepens the network depth and expands the feature space; The third fully connected layer: The output of neurons is reduced from 1024 to 512, and the feature dimension is reduced to focus on higher dimensional features. The fourth fully connected layer: outputs from 512 neurons to 256 neurons, further extracts features and performs dimensionality reduction; Activation function: Leaky ReLU activation function is used in each hidden layer, and the negative slope is set to 0.01; Output layer: It is a fully connected layer that outputs a single value and converts it into a probability value between 0 and 1 through the Sigmoid activation function; this probability value represents the discriminator's judgment on 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 fake data generated by the generator.

6. The method for intelligently generating a connected fracture network structure based on a GA-GAN model according to claim 1, characterized in that: The step 2.3 is performed as follows: Step 2.3.1: Population initialization: A population of 5000 crack vectors is randomly generated, where each vector 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. The selection process is based on these fitness scores. Crack vectors with high scores have a greater chance of being selected into the next generation. Specifically, the selection uses a multinomial sampling method. The probability of selecting each crack vector (P i ) is proportional to its fitness score: where f i is the fitness score of vector i; this probability calculation method ensures that individuals with high fitness are more likely to be selected, but individuals with low fitness also have a certain chance; the population size is fixed at 5000, and 5000 individuals are formed by probability selection in each generation, among which individuals with high scores may appear in the newly selected population many times, thereby increasing their proportion in the next generation; Step 2.3.3: Population reproduction; Offspring generated by crossover often receive lower scores, so the genetic algorithm uses a form of asexual reproduction, where each crack vector reproduces by self-mutation; Step 2.3.4: Iterative generation; The selection and reproduction process will be repeated in multiple generations. In each generation, 5,000 new crack vectors are generated, evaluated and optimized by the discriminator. Due to the selection process and random perturbations, the population continues to evolve, and it is possible to generate a crack network with a higher score than the previous generation. Therefore, the target threshold of the discriminator score is set to 0.965, which represents a more realistic crack network structure. Any vector with a score of 0.965 or more will be recorded in the "high fitness individual pool", and individuals with a score lower than 0.965 will be eliminated; this 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 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 that, the entire population will be randomly initialized again, i.e., step 2.3.1, and the process of generating high-scoring individuals will be 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.

7. The method for intelligently generating a connected fracture network structure based on a GA-GAN model according to claim 1, characterized in that: The discriminator training in step 2.4 is used to learn a 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.

8. The method for intelligently generating a connected fracture network structure based on a GA-GAN model according to claim 1, characterized in that: In step 2.5, in the GA-GAN framework, the training of the GA-generator and the discriminator is performed in alternating steps to ensure that the generator and the discriminator can be gradually improved together; The alternating steps are performed as follows: Training cycle and discriminator performance evaluation: After each training cycle, real validation samples are fed into the discriminator to evaluate its performance and assign scores to these real samples; If the scores assigned to these true validation samples start to decrease, it indicates that the GA generator has started to generate samples that are highly similar to the true samples in the validation set; As training progresses, the discriminator may assign lower scores to these highly similar generated samples; Scoring threshold setting: By evaluating the visual similarity of samples, we set a scoring threshold; The training process stops when the average score assigned by the discriminator to the 1000 real validation samples falls below this threshold.

Images