Patent Application
20230111937
The present disclosure is generally related to using filter data based on deep image prior operations to reduce artifacts in images.
Conceptually, a “forward problem” attempts to make a prediction based on a model of causal factors associated with a system and initial conditions of the system. An “inverse problem” reverses the forward problem by attempting to model causal factors and initial conditions based on data (e.g., measurements or other observations of the system). Stated another way, an inverse problem starts with the effects (e.g., measurement or other data) and attempts to determine model parameters, whereas the forward problem starts with the causes (e.g., a model of the system) and attempts to determine the effects. Inverse problems are used for many remote sensing applications, such as radar, sonar, medical imaging, computer vision, seismic imaging, etc.
Optimization techniques are commonly used to generate solutions to inverse problems. For example, with particular assumptions about a system that generated a set of return data, a reverse time migration technique can be used to generate image data representing the system. However, images generated using such techniques generally include artifacts. Such artifacts can be reduced by increasing the quantity of data used to generate the solution; however, generating more data is costly and time consuming. Furthermore, the computing resources required to perform optimization increase dramatically as the amount of data increases.
According to a particular aspect, a method includes obtaining, by one or more processors, first image data that is based on waveform return data and is descriptive of an estimated solution to an inverse problem associated with the waveform return data. The method also includes performing, by the one or more processors, a plurality of deep image prior operations, using a reference image (also referred to herein as an “image prior”) based on the first image data, to generate filter data. The method further includes modifying, by the one or more processors, the first image data based on the filter data to generate second image data. The method also includes performing, by the one or more processors, an artifact reduction process based on the second image data to generate third image data.
According to a particular aspect, a system includes one or more processors configured to obtain first image data that is based on waveform return data and is descriptive of an estimated solution to an inverse problem associated with the waveform return data. The one or more processors are also configured to perform a plurality of deep image prior operations, using an image prior based on the first image data, to generate filter data. The one or more processors are further configured to modify the first image data based on the filter data to generate second image data. The one or more processors are also configured to perform an artifact reduction process based on the second image data to generate third image data. Artifacts are reduced in the third image data relative to the first image data.
According to a particular aspect, a computer-readable storage device stores instructions that, when executed by one or more processors, cause the one or more processors to obtain first image data that is based on waveform return data and is descriptive of an estimated solution to an inverse problem associated with the waveform return data. The instructions also cause the one or more processors to perform a plurality of deep image prior operations, using an image prior based on the first image data, to generate filter data. The instructions further cause the one or more processors to modify the first image data based on the filter data to generate second image data. The instructions also cause the one or more processors to perform an artifact reduction process based on the second image data to generate third image data. Artifacts are reduced in the third image data relative to the first image data.
According to a particular aspect, a method includes obtaining, by one or more processors, first image data that is based on waveform return data and is descriptive of an estimated solution to an inverse problem associated with the waveform return data. The method also includes performing, by the one or more processors, an artifact reduction process based on the first image data to generate second image data. The method further includes performing, by the one or more processors, a plurality of deep image prior operations, using an image prior based on the first image data or the second image data, to generate filter data. The method also includes modifying, by the one or more processors, the second image data based on the filter data to generate third image data.
According to a particular aspect, a system includes one or more processors configured to obtain first image data that is based on waveform return data and is descriptive of an estimated solution to an inverse problem associated with the waveform return data. The one or more processors are also configured to perform an artifact reduction process based on the first image data to generate second image data. The one or more processors are further configured to perform a plurality of deep image prior operations, using an image prior based on the first image data or the second image data, to generate filter data. The one or more processors are also configured to modify the second image data based on the filter data to generate third image data.
According to a particular aspect, a computer-readable storage device stores instructions that, when executed by one or more processors, cause the one or more processors to obtain first image data that is based on waveform return data and is descriptive of an estimated solution to an inverse problem associated with the waveform return data. The instructions also cause the one or more processors to perform an artifact reduction process based on the first image data to generate second image data. The instructions further cause the one or more processors to perform a plurality of deep image prior operations, using an image prior based on the first image data or the second image data, to generate filter data. The instructions also cause the one or more processors to modify the second image data based on the filter data to generate third image data.
The present disclosure describes systems and methods that use machine-learning to generate a solution to an inverse problem. In general, operations disclosed herein use machine-learning models, physics-based models, or both, to generate one or more estimated solutions to the inverse problem. A relatively small set of waveform return data is used to generate the estimated solution(s), and as a result, the estimated solution(s) are expected to include artifacts.
The waveform return data includes data based on records (referred to herein as “waveform return records”) for multiple sampling events associated with an observed area. The image data represents a solution to an inverse problem associated with the waveform return data. For example, the waveform return data may be generated by a seismic imaging system that includes one or more sources and one or more receivers. In this example, during a particular sampling event, the source(s) cause one or more waveforms to propagate in the observed area. Subsurface features within the observed area reflect the waveform(s), and the receiver(s) generate measurements (“waveform return measurements”) that indicate, for example, a magnitude of a received waveform return, a timing of receipt of the waveform return, etc. In this example, a waveform return record of the particular sampling event may include the waveform return measurements generated by the receiver(s) for the particular sampling event. Further, in this example, the waveform return data for the particular sampling event may be identical to the waveform return record, or the waveform return data may represent the waveform return record after particular data transformation operations are performed. To illustrate, the waveform return records generally include time-series data, and the waveform return data may include time-series data or may include depth domain data or images based on the time-series data.
Various additional operations are performed to reduce the intensity, distribution, and/or visual impact of the artifacts. In a particular aspect, deep image prior operations are used to generate filter data, which is used to reduce artifacts in the estimated solution(s). As described in more detail below, the deep image prior operations iteratively update a model to try to generate output data that matches a reference image (referred to herein as an “image prior”). In general, earlier iterations of the deep image prior operations tend to generate output data that recreate stronger features (e.g., low frequency and/or high intensity features) of the image prior. Later iterations tend to improve the overall similarity of the output data to the image prior, including recreating weaker features (e.g., higher frequency and/or lower intensity features) of the image prior.
When relatively small sets of waveform return data are subjected to reverse time migration (or other processes to transform the waveform return data to a depth domain), the resulting image data tend to have fairly strong migration swing artifacts (referred to herein simply as “artifacts”). When such an image (e.g., an image having relatively strong artifacts) is used as an image prior for deep image prior operations, the artifacts are recreated in the output data during early iterations. Accordingly, if the deep image prior operations are stopped after an appropriate number of iterations, an output image of the deep image prior operations can be used as filter data to facilitate removal of artifacts from another image. In some situations, preprocessing operations can be used to emphasize the artifacts in the image prior so that the artifacts are even more strongly represented in the filter data.
The filter data is used to modify a preliminary solution to the inverse problem to reduce artifacts in the preliminary solution. In some implementations, the preliminary solution includes image data generated using a physics-based technique, such as reverse time migration. In other implementations, machine-learning techniques are used to generate the preliminary solution to the inverse problem. In some such implementations, the machine-learning techniques may be able to generate high quality solutions (e.g., images with relatively few visible artifacts) using less waveform return data than would be used to generate solutions of similar quality using only physics-based techniques. In some implementations, physics-based techniques and machine-learning techniques are used cooperatively to generate the preliminary solution to the inverse problem.
Generating high quality solutions to inverse problems involves resource intensive calculations. For example, when using reverse time migration, waveform return data from hundreds or even thousands of sampling events (e.g., “shots” in the seismic imaging context) may be used in order to generate a detailed representation of an observed system and to reduce artifacts in the solution.
Machine-learning techniques can generate high-quality solutions using less waveform return data and fewer computing resources (e.g., memory and processor time) than would be used to generate solutions of similar quality using reverse-time migration alone. However, such machine-learning techniques generally use models that are trained or optimized using solutions (e.g., images) generated using reverse-time migration. As a result, the models learn to generate solutions (e.g., images) that include artifacts that are present in the solutions (e.g., images) generated using reverse-time migration.
By using filter data generated by the deep image prior operations to remove artifacts from an estimated solution, a higher quality solution (e.g., a more accurate representation of an observed area) can be generated using less waveform return data than would be used to generate a similar quality solution using traditional techniques. As a result, less waveform return data can be collected (which saves time and sensing resources) and fewer computing resources (e.g., memory used to store waveform return data as well as working memory used to generate the solution, and processor cycles) are used.
Particular aspects of the present disclosure are described below with reference to the drawings. In the description, common features are designated by common reference numbers throughout the drawings. As used herein, various terminology is used for the purpose of describing particular implementations only and is not intended to be limiting. For example, the singular forms “a,” “an,” and “the” are intended to include the plural forms as well, unless the context clearly indicates otherwise. Further the terms “comprise,” “comprises,” and “comprising” may be used interchangeably with “include,” “includes,” or “including.” Additionally, the term “wherein” may be used interchangeably with “where.” As used herein, “exemplary” may indicate an example, an implementation, and/or an aspect, and should not be construed as limiting or as indicating a preference or a preferred implementation.
As used herein, an ordinal term (e.g., “first,” “second,” “third,” “Nth,” etc.) used to modify an element, such as a structure, a component, an operation, etc., does not by itself indicate any priority or order of the element with respect to another element, but rather merely distinguishes the element from another element having a same name (but for use of the ordinal term). As used herein, the term “set” refers to a grouping of one or more elements, and the term “plurality” refers to multiple elements. Additionally, in some instances, an ordinal term herein may use a letter (e.g., “Nth”) to indicate an arbitrary or open-ended number of distinct elements (e.g., zero or more elements). Different letters (e.g., “N” and “M”) may be used for ordinal terms that describe two or more different elements when no particular relationship among the number of each of the two or more different elements is specified. For example, unless defined otherwise in the text, N may be equal to M, N may be greater than M, or N may be less than M.
In the present disclosure, terms such as “determining,” “calculating,” “estimating,” “shifting,” “adjusting,” etc. may be used to describe how one or more operations are performed. Such terms are not to be construed as limiting and other techniques may be utilized to perform similar operations. Additionally, as referred to herein, “generating,” “calculating,” “estimating,” “using,” “selecting,” “accessing,” and “determining” may be used interchangeably. For example, “generating,” “calculating,” “estimating,” or “determining” a parameter (or a signal) may refer to actively generating, estimating, calculating, or determining the parameter (or the signal) or may refer to using, selecting, or accessing the parameter (or signal) that is already generated, such as by another component or device.
As used herein, “coupled” may include “communicatively coupled,” “electrically coupled,” or “physically coupled,” and may also (or alternatively) include any combinations thereof. Two devices (or components) may be coupled (e.g., communicatively coupled, electrically coupled, or physically coupled) directly or indirectly via one or more other devices, components, wires, buses, networks (e.g., a wired network, a wireless network, or a combination thereof), etc. Two devices (or components) that are electrically coupled may be included in the same device or in different devices and may be connected via electronics, one or more connectors, or inductive coupling, as illustrative, non-limiting examples. In some implementations, two devices (or components) that are communicatively coupled, such as in electrical communication, may send and receive electrical signals (digital signals or analog signals) directly or indirectly, such as via one or more wires, buses, networks, etc. As used herein, “directly coupled” may include two devices that are coupled (e.g., communicatively coupled, electrically coupled, or physically coupled) without intervening components.
As used herein, the term “machine learning” should be understood to have any of its usual and customary meanings within the fields of computers science and data science, such meanings including, for example, processes or techniques by which one or more computers can learn to perform some operation or function without being explicitly programmed to do so. As a typical example, machine learning can be used to enable one or more computers to analyze data to identify patterns in data and generate a result based on the analysis. For certain types of machine learning, the results that are generated include data that indicates an underlying structure or pattern of the data itself. Such techniques, for example, include so called “clustering” techniques, which identify clusters (e.g., groupings of data elements of the data).
For certain types of machine learning, the results that are generated include a data model (also referred to as a “machine-learning model” or simply a “model”). Typically, a model is generated using a first data set to facilitate analysis of a second data set. For example, a first portion of a large body of data may be used to generate a model that can be used to analyze the remaining portion of the large body of data. As another example, a set of historical data can be used to generate a model that can be used to analyze future data.
Since a model can be used to evaluate a set of data that is distinct from the data used to generate the model, the model can be viewed as a type of software (e.g., instructions, parameters, or both) that is automatically generated by the computer(s) during the machine learning process. As such, the model can be portable (e.g., can be generated at a first computer, and subsequently moved to a second computer for further training, for use, or both). Additionally, a model can be used in combination with one or more other models to perform a desired analysis. To illustrate, first data can be provided as input to a first model to generate first model output data, which can be provided (alone, with the first data, or with other data) as input to a second model to generate second model output data indicating a result of a desired analysis. Depending on the analysis and data involved, different combinations of models may be used to generate such results. In some examples, multiple models may provide model output that is input to a single model. In some examples, a single model provides model output to multiple models as input.
Examples of machine-learning models include, without limitation, perceptrons, neural networks, support vector machines, regression models, decision trees, Bayesian models, Boltzmann machines, adaptive neuro-fuzzy inference systems, as well as combinations, ensembles and variants of these and other types of models. Variants of neural networks include, for example and without limitation, prototypical networks, autoencoders, transformers, self-attention networks, convolutional neural networks, deep neural networks, deep belief networks, etc. Variants of decision trees include, for example and without limitation, random forests, boosted decision trees, etc.
Since machine-learning models are generated by computer(s) based on input data, machine-learning models can be discussed in terms of at least two distinct time windows—a creation/training phase and a runtime phase. During the creation/training phase, a model is created, trained, adapted, validated, or otherwise configured by the computer based on the input data (which in the creation/training phase, is generally referred to as “training data”). Note that the trained model corresponds to software that has been generated and/or refined during the creation/training phase to perform particular operations, such as classification, prediction, encoding, or other data analysis or data synthesis operations. During the runtime phase (or “inference” phase), the model is used to analyze input data to generate model output. The content of the model output depends on the type of model. For example, a model can be trained to perform classification tasks or regression tasks, as non-limiting examples. In some implementations, a model may be continuously, periodically, or occasionally updated, in which case training time and runtime may be interleaved or one version of the model can be used for inference while a copy is updated, after which the updated copy may be deployed for inference.
In some implementations, a previously generated model is trained (or re-trained) using a machine-learning technique. In this context, “training” refers to adapting the model or parameters of the model to a particular data set. Unless otherwise clear from the specific context, the term “training” as used herein includes “re-training” or refining a model for a specific data set. For example, training may include so called “transfer learning.” As described further below, in transfer learning a base model may be trained using a generic or typical data set, and the base model may be subsequently refined (e.g., re-trained or further trained) using a more specific data set.
A data set used during training is referred to as a “training data set” or simply “training data”. The data set may be labeled or unlabeled. “Labeled data” refers to data that has been assigned a categorical label indicating a group or category with which the data is associated, and “unlabeled data” refers to data that is not labeled. Typically, “supervised machine-learning processes” use labeled data to train a machine-learning model, and “unsupervised machine-learning processes” use unlabeled data to train a machine-learning model; however, it should be understood that a label associated with data is itself merely another data element that can be used in any appropriate machine-learning process. To illustrate, many clustering operations can operate using unlabeled data; however, such a clustering operation can use labeled data by ignoring labels assigned to data or by treating the labels the same as other data elements.
Machine-learning models can be initialized from scratch (e.g., by a user, such as a data scientist) or using a guided process (e.g., using a template or previously built model). Initializing the model includes specifying parameters and hyperparameters of the model. “Hyperparameters” are characteristics of a model that are not modified during training, and “parameters” of the model are characteristics of the model that are modified during training. The term “hyperparameters” may also be used to refer to parameters of the training process itself, such as a learning rate of the training process. In some examples, the hyperparameters of the model are specified based on the task the model is being created for, such as the type of data the model is to use, the goal of the model (e.g., classification, regression, anomaly detection), etc. The hyperparameters may also be specified based on other design goals associated with the model, such as a memory footprint limit, where and when the model is to be used, etc.
Model type and model architecture of a model illustrate a distinction between model generation and model training. The model type of a model, the model architecture of the model, or both, can be specified by a user or can be automatically determined by a computing device. However, neither the model type nor the model architecture of a particular model is changed during training of the particular model. Thus, the model type and model architecture are hyperparameters of the model and specifying the model type and model architecture is an aspect of model generation (rather than an aspect of model training). In this context, a “model type” refers to the specific type or sub-type of the machine-learning model. As noted above, examples of machine-learning model types include, without limitation, perceptrons, neural networks, support vector machines, regression models, decision trees, Bayesian models, Boltzmann machines, adaptive neuro-fuzzy inference systems, as well as combinations, ensembles and variants of these and other types of models. In this context, “model architecture” (or simply “architecture”) refers to the number and arrangement of model components, such as nodes or layers, of a model, and which model components provide data to or receive data from other model components. As a non-limiting example, the architecture of a neural network may be specified in terms of nodes and links. To illustrate, a neural network architecture may specify the number of nodes in an input layer of the neural network, the number of hidden layers of the neural network, the number of nodes in each hidden layer, the number of nodes of an output layer, and which nodes are connected to other nodes (e.g., to provide input or receive output). As another non-limiting example, the architecture of a neural network may be specified in terms of layers. To illustrate, the neural network architecture may specify the number and arrangement of specific types of functional layers, such as long-short-term memory (LSTM) layers, fully connected (FC) layers, convolution layers, etc. While the architecture of a neural network implicitly or explicitly describes links between nodes or layers, the architecture does not specify link weights. Rather, link weights are parameters of a model (rather than hyperparameters of the model) and are modified during training of the model.
In many implementations, a data scientist selects the model type before training begins. However, in some implementations, a user may specify one or more goals (e.g., classification or regression), and automated tools may select one or more model types that are compatible with the specified goal(s). In such implementations, more than one model type may be selected, and one or more models of each selected model type can be generated and trained. A best performing model (based on specified criteria) can be selected from among the models representing the various model types. Note that in this process, no particular model type is specified in advance by the user, yet the models are trained according to their respective model types. Thus, the model type of any particular model does not change during training.
Similarly, in some implementations, the model architecture is specified in advance (e.g., by a data scientist); whereas in other implementations, a process that both generates and trains a model is used. Generating (or generating and training) the model using one or more machine-learning techniques is referred to herein as “automated model building”. In one example of automated model building, an initial set of candidate models is selected or generated, and then one or more of the candidate models are trained and evaluated. In some implementations, after one or more rounds of changing hyperparameters and/or parameters of the candidate model(s), one or more of the candidate models may be selected for deployment (e.g., for use in a runtime phase).
Certain aspects of an automated model building process may be defined in advance (e.g., based on user settings, default values, or heuristic analysis of a training data set) and other aspects of the automated model building process may be determined using a randomized process. For example, the architectures of one or more models of the initial set of models can be determined randomly within predefined limits. As another example, a termination condition may be specified by the user or based on configurations settings. The termination condition indicates when the automated model building process should stop. To illustrate, a termination condition may indicate a maximum number of iterations of the automated model building process, in which case the automated model building process stops when an iteration counter reaches a specified value. As another illustrative example, a termination condition may indicate that the automated model building process should stop when a reliability metric associated with a particular model satisfies a threshold. As yet another illustrative example, a termination condition may indicate that the automated model building process should stop if a metric that indicates improvement of one or more models over time (e.g., between iterations) satisfies a threshold. In some implementations, multiple termination conditions, such as an iteration count condition, a time limit condition, and a rate of improvement condition can be specified, and the automated model building process can stop when one or more of these conditions is satisfied.
Another example of training a previously generated model is transfer learning. “Transfer learning” refers to initializing a model for a particular data set using a model that was trained using a different data set. For example, a “general purpose” model can be trained to detect anomalies in vibration data associated with a variety of types of rotary equipment, and the general-purpose model can be used as the starting point to train a model for one or more specific types of rotary equipment, such as a first model for generators and a second model for pumps. As another example, a general-purpose natural-language processing model can be trained using a large selection of natural-language text in one or more target languages. In this example, the general-purpose natural-language processing model can be used as a starting point to train one or more models for specific natural-language processing tasks, such as translation between two languages, question answering, or classifying the subject matter of documents. Often, transfer learning can converge to a useful model more quickly than building and training the model from scratch.
Training a model based on a training data set generally involves changing parameters of the model with a goal of causing the output of the model to have particular characteristics based on data input to the model. To distinguish from model generation operations, model training may be referred to herein as optimization or optimization training. In this context, “optimization” refers to improving a metric, and does not mean finding an ideal (e.g., global maximum or global minimum) value of the metric. Examples of optimization trainers include, without limitation, backpropagation trainers, derivative free optimizers (DFOs), and extreme learning machines (ELMs). As one example of training a model, during supervised training of a neural network, an input data sample is associated with a label. When the input data sample is provided to the model, the model generates output data, which is compared to the label associated with the input data sample to generate an error value. Parameters of the model are modified in an attempt to reduce (e.g., optimize) the error value. As another example of training a model, during unsupervised training of an autoencoder, a data sample is provided as input to the autoencoder, and the autoencoder reduces the dimensionality of the data sample (which is a lossy operation) and attempts to reconstruct the data sample as output data. In this example, the output data is compared to the input data sample to generate a reconstruction loss, and parameters of the autoencoder are modified in an attempt to reduce (e.g., optimize) the reconstruction loss.
As another example, to use supervised training to train a model to perform a classification task, each data element of a training data set may be labeled to indicate a category or categories to which the data element belongs. In this example, during the creation/training phase, data elements are input to the model being trained, and the model generates output indicating categories to which the model assigns the data elements. The category labels associated with the data elements are compared to the categories assigned by the model. The computer modifies the model until the model accurately and reliably (e.g., within some specified criteria) assigns the correct labels to the data elements. In this example, the model can subsequently be used (in a runtime phase) to receive unknown (e.g., unlabeled) data elements, and assign labels to the unknown data elements. In an unsupervised training scenario, the labels may be omitted. During the creation/training phase, model parameters may be tuned by the training algorithm in use such that during the runtime phase, the model is configured to determine which of multiple unlabeled “clusters” an input data sample is most likely to belong to.
As another example, to train a model to perform a regression task, during the creation/training phase, one or more data elements of the training data are input to the model being trained, and the model generates output indicating a predicted value of one or more other data elements of the training data. The predicted values of the training data are compared to corresponding actual values of the training data, and the computer modifies the model until the model accurately and reliably (e.g., within some specified criteria) predicts values of the training data. In this example, the model can subsequently be used (in a runtime phase) to receive data elements and predict values that have not been received. To illustrate, the model can analyze time series data, in which case, the model can predict one or more future values of the time series based on one or more prior values of the time series.
In some aspects, the output of a model can be subjected to further analysis operations to generate a desired result. To illustrate, in response to particular input data, a classification model (e.g., a model trained to perform classification tasks) may generate output including an array of classification scores, such as one score per classification category that the model is trained to assign. Each score is indicative of a likelihood (based on the model's analysis) that the particular input data should be assigned to the respective category. In this illustrative example, the output of the model may be subjected to a softmax operation to convert the output to a probability distribution indicating, for each category label, a probability that the input data should be assigned the corresponding label. In some implementations, the probability distribution may be further processed to generate a one-hot encoded array. In other examples, other operations that retain one or more category labels and a likelihood value associated with each of the one or more category labels can be used.
In particular implementations, the waveform return data 102 are gathered prior to processing by the system 100. For example, the waveform return data 102 may be gathered by a seismic testing system and may represent seismic testing data samples from a particular area observed by the seismic testing system (referred to herein as an “observed area”) In other examples, the waveform return data 102 represent data gathered by other types of sensing systems, such as sonar, lidar, radar, or other active sensing systems (e.g., sensing systems that emit a waveform and sense waveform returns).
The waveform return data 102 may also include other data, such as geometry data indicating positions of one or more source devices and one or more receiver devices when each waveform return was generated. For example, the waveform return data 102 may represent seismic sampling events (also referred to as “shots”), where each of the waveform returns corresponds to a particular arrangement of source and receiver devices relative to the observed area. In this example, the waveform return data 102 represent multiple observational geometries, where each observational geometry corresponds to one or more source locations and one or more receiver locations relative to the observed area. In this example, the image data corresponds to or represents a reflectivity image based on at least a subset of the waveform return data 102.
In the example illustrated in
The first image data 108 is descriptive of an estimated solution to an inverse problem associated with the waveform return data 102. For example, the preprocessor 106 may be configured to use reverse time migration to generate the first image data 108. The first image data 108 includes artifacts due, at least in part, to the quantity of waveform return data used to generate the first image data 108. To illustrate, the first image data 108 may include migration swing artifacts due to the use of a subset of the waveform return data 102 that represents few sampling events (e.g., a small number of shots) to generate the first image data 108. As one example, the first image data 108 may be based on 5 to 10 shots in the context of seismic imaging.
The DIP engine 110 is configured to perform a plurality of DIP operations using the first image data 108 as an image prior to generate the filter data 114. In this context, DIP operations refer to optimizing a model (e.g., DIP model 112) to decrease differences between an output image (e.g., the filter data 114) of the DIP model 112 and an image prior (e.g., the first image data 108 in
In a particular implementation, the DIP operations are performed iteratively until a termination condition is satisfied. For example, the termination condition may include a count of iterations. As another example, the termination condition may be satisfied when the output of the DIP model 112 satisfies an error metric. In other examples, other termination conditions or combinations of termination conditions may be used. The termination condition is selected such that the DIP operations terminate before the output of the DIP model 112 fully matches the image prior, which is referred to as early stopping. DIP operations tend to cause the DIP model 112 to reproduce particular features of the image prior before other features. In particular, weaker features (e.g., high frequency and/or low intensity features) are generally reproduced later than stronger features (e.g., low frequency and/or high intensity features). Data transform operations may be used to further emphasize this tendency. For example, the preprocessor 106 may subject the waveform return data 102 to a Radon Transform or other image transformation process while generating the first image data 108 in order to emphasize artifacts in the first image data.
During a particular iteration of the DIP operations, the DIP engine 110 provides input data to the DIP model 112. The DIP model 112 may include any generative machine-learning model architecture, such as a deep convolutional neural network, and the input data is an arbitrary input image, such as a Gaussian noise image. The DIP model 112 generates output data based on the input data and the parameters of the DIP model 112. The DIP engine 110 compares the output data to the image prior (e.g., the first image data 108 in
When the termination condition is satisfied, the DIP engine 110 generates output representing the filter data 114. In a particular implementation, the filter data 114 includes or corresponds to the output data generated by the DIP model 112 during the final iteration of the DIP operations. In other implementations, the termination condition may be set so that the final iteration of the DIP operations occurs later than a desired early stopping point. For example, the termination condition may be set based on a specific error value that is likely to be reached after the DIP model 112 has been optimized to reproduce some aspects of the image prior that are not associated with artifacts (e.g., high frequency and/or low intensity features, such as image features representing subsurface layer boundaries). In such implementations, the filter data 114 may include or correspond to output of the DIP model 112 from a prior iteration. For example, the model output from a fiftieth iteration may be used based on the termination condition being satisfied by the one hundredth iteration. In this example, the model output from fifty iterations prior to satisfaction of the termination condition is used merely as one possibility. In other examples, a different number of iterations may be used to select the model output used as the filter data 114 after the termination condition is satisfied. In still other examples, criteria other than a specified count of iterations may be used to select the model output used as the filter data 114 after the termination condition is satisfied. To illustrate, the model output from several iterations may be compared to one another to select model output that is most suitable for use as the filter data 114.
Due to early stopping of the DIP operations, the filter data 114 is expected to represent artifacts of the image prior (e.g., the first image data 108) and omit or represent with less intensity more detailed features of the image prior. For example, in the context of seismic imaging, the filter data 114 may include data representing migration swing artifacts and omit data representing subsurface layers and other geological features. In some implementations, the filter data 114 may include data representing subsurface layers and other geological features; however, the data representing the migration swing artifacts may be more strongly represented than the data representing subsurface layers and other geological features.
In the example illustrated in
In the example illustrated in
Since the artifacts present in the first image data 108 have been removed or attenuated to form the second image data 118A, using the second image data 118A to initialize the artifact reduction engine 120 enables the artifact reduction engine 120 to converge more quickly to the third image data 122, improves the quality of the third image data 122, enables the artifact reduction engine 120 to converge to the third image data 122 using less waveform return data, or all three.
In particular, in
In the example illustrated in
The DIP engine 110 performs DIP operations (as described above), using the second image data 118B as an image prior, to generate the filter data 114. The filter 116 modifies the second image data 118B based on the filter data 114 to remove or reduce artifacts in the second image data 118B. The filter 116 generates the third image data 122, which the image processor 104 outputs for subsequent use (e.g., for display to a user).
The image processors 104 of
An image 204 of
An image 206 of
Comparison of the image 206 and the image 208 shows that the image 206 has similar levels of residual artifacts; however, many fewer shots were used to generate the image 206. Reverse time migration is a very computationally demanding process and increases in computational demand as the number of shots used increases. Thus, significant computing resources (e.g., processor time, memory, etc.) are saved by generating the image 206 rather than the image 208.
The method 300 includes, at 302, obtaining (e.g., by one or more processors) first image data that is based on waveform return data and is descriptive of an estimated solution to an inverse problem associated with the waveform return data. For example, the preprocessor 106 of
As one specific example, the first image data may be determined using a physics-based model. To illustrate, the first image data may be obtained by performing reverse time migration based on at least a subset of the waveform return data 102. To illustrate, the waveform return data may include or correspond to waveform returns indicative of reflections, from a visually occluded structure, of one or more incident waves, and the image data represents an image of the structure.
The method 300 includes, at 304, performing (e.g., by the one or more processors) a plurality of deep image prior operations, using an image prior based on the first image data, to generate filter data. For example, the DIP engine 110 of
using early stopping) such that the output of the DIP model 112 (e.g., the filter data 114) includes at least some of the artifacts of the first image data 108 but omits high frequency details of the first image data 108. For example, the first image data may represent an image and the filter data may represent a partial reconstruction of the image generated by early stopping the deep image prior operations such that the plurality of deep image prior operations includes fewer deep image prior operations than would be used to fully reconstruct the image.
Performing the deep image prior operations includes performing a plurality of iterations of machine-learning optimization. A particular iteration of the machine-learning optimization includes, for example, providing input data to a model to determine first output data based on values of parameters of the model, determining an error value based on a comparison of the first output data and the image prior, and adjusting one or more of the values of the parameters of the model to reduce an error value associated with a subsequent iteration of the machine-learning optimization. In some implementations, the values of the parameters of the model are set independently of the first image data for an initial iteration of the machine-learning optimization. For example, the initial values of the parameters of the model may be set using a randomized process or using predetermined values. In the same or different implementations, the input data for the initial iteration of the machine-learning optimization is independent of the first image data. For example, the input data may include or correspond to randomized image data, such as a Gaussian noise image.
The method 300 includes, at 306, modifying (e.g., by the one or more processors) the first image data based on the filter data to generate second image data. For example, the filter 116 of
The method 300 includes, at 308, performing (e.g., by the one or more processors) an artifact reduction process based on the second image data to generate third image data. For example, the artifact reduction engine 120 may perform the artifact reduction process, such as the artifact reduction processes described with reference to
In some implementations, the artifact reduction process includes a plurality of iterations. In some such implementations, a particular iteration of the artifact reduction process includes, for example, using a machine-learning model (e.g., a score matching network) to determine a gradient associated with particular solution data and adjusting the particular solution data based on the gradient to generate updated solution data. In some implementations, the artifact reduction process may perform one or more further operations after the third image data is generated. For example, after the third image data is generated, the artifact reduction process may include providing the third image data as input to a physics-based model to generate fourth image data. To illustrate, the third image data may be used as a starting point for one or more iterations of reverse time migration. In some implementations, the method 300 may further include using the fourth image data to initiate a second plurality of iterations of the artifact reduction process to generate fifth image data. In such implementations, the artifacts are reduced in the fifth image data relative to the fourth image data.
The method 300 enables generation of similar quality images to those generated by traditional techniques (e.g., reverse-time migration) in a manner that is more efficient in terms of computer resources (e.g., processor time, power, and memory) required and in terms the quantity of waveform return data needed.
The method 400 includes, at 402, obtaining (e.g., by one or more processors) first image data that is based on waveform return data and is descriptive of an estimated solution to an inverse problem associated with the waveform return data. For example, the preprocessor 106 of
As one specific example, the first image data may be determined using a physics-based model. To illustrate, the first image data may be obtained by performing reverse time migration based on at least a subset of the waveform return data. To illustrate, the waveform return data may represent reflections, from a visually occluded structure, of one or more incident waves, and the image data represents an image of the structure.
The method 400 includes, at 404, performing (e.g., by the one or more processors) an artifact reduction process based on the first image data to generate second image data. For example, the artifact reduction engine 120 may perform the artifact reduction process, such as the artifact reduction processes described with reference to
In some implementations, the artifact reduction process includes a plurality of iterations. In some such implementations, a particular iteration of the artifact reduction process includes, for example, using a machine-learning model (e.g., a score matching network) to determine a gradient associated with particular solution data and adjusting the particular solution data based on the gradient to generate updated solution data.
The method 400 includes, at 406, performing (e.g., by the one or more processors) a plurality of deep image prior operations, using an image prior that is based on the second image data, to generate filter data. For example, the DIP engine 110 of
Performing the deep image prior operations includes performing a plurality of iterations of machine-learning optimization. A particular iteration of the machine-learning optimization includes, for example, providing input data to a model to determine first output data based on values of parameters of the model, determining an error value based on a comparison of the first output data and the image prior, and adjusting one or more of the values of the parameters of the model to reduce an error value associated with a subsequent iteration of the machine-learning optimization. In some implementations, the values of the parameters of the model are set independently of the second image data for an initial iteration of the machine-learning optimization. For example, the initial values of the parameters of the model may be set using a randomization process or using predetermined values. In the same or different implementations, the input data for the initial iteration of the machine-learning optimization is independent of the second image data. For example, the input data may include or correspond to randomized image data, such as a Gaussian noise image.
The method 400 includes, at 408, modifying (e.g., by the one or more processors) the second image data based on the filter data to generate third image data. For example, the filter 116 of
The method 400 enables generation of similar quality images to those generated by traditional techniques (e.g., reverse-time migration) in a manner that is more efficient in terms of computer resources (e.g., processor time, power, and memory) required and in terms the amount of waveform return data needed.
The computer system 500 includes one or more processors 502. Each processor of the one or more processors 502 can include a single processing core or multiple processing cores that operate sequentially, in parallel, or sequentially at times and in parallel at other times. Each processor of the one or more processors 502 includes circuitry defining a plurality of logic circuits 504, working memory 506 (e.g., registers and cache memory), communication circuits, etc., which together enable the processor(s) 502 to control the operations performed by the computer system 500 and enable the processor(s) 502 to generate a useful result based on analysis of particular data and execution of specific instructions.
The processor(s) 502 are configured to interact with other components or subsystems of the computer system 500 via a bus 570. The bus 570 is illustrative of any interconnection scheme serving to link the subsystems of the computer system 500, external subsystems or devices, or any combination thereof. The bus 570 includes a plurality of conductors to facilitate communication of electrical and/or electromagnetic signals between the components or subsystems of the computer system 500. Additionally, the bus 570 includes one or more bus controllers or other circuits (e.g., transmitters and receivers) that manage signaling via the plurality of conductors and that cause signals sent via the plurality of conductors to conform to particular communication protocols.
In
Examples of the output device(s) 530 include display devices, speakers, printers, televisions, projectors, or other devices to provide output of data (e.g., solution data representing a solution to an inverse problem) in a manner that is perceptible by a user. Examples of the input device(s) 510 include buttons, switches, knobs, a keyboard 512, a pointing device 514, a biometric device, a microphone, a motion sensor, or another device to detect user input actions. The pointing device 514 includes, for example, one or more of a mouse, a stylus, a track ball, a pen, a touch pad, a touch screen, a tablet, another device that is useful for interacting with a graphical user interface, or any combination thereof. A particular device may be an input device 510 and an output device 530. For example, the particular device may be a touch screen.
The interface device(s) 520 are configured to enable the computer system 500 to communicate with one or more other devices 524 directly or via one or more networks 522. For example, the interface device(s) 520 may encode data in electrical and/or electromagnetic signals that are transmitted to the other device(s) 524 as control signals or packet-based communication using pre-defined communication protocols. As another example, the interface device(s) 520 may receive and decode electrical and/or electromagnetic signals that are transmitted by the other device(s) 524. To illustrate, the other device(s) 524 may include sensor(s) that generate the waveform return data 102. The electrical and/or electromagnetic signals can be transmitted wirelessly (e.g., via propagation through free space), via one or more wires, cables, optical fibers, or via a combination of wired and wireless transmission. The waveform return data 102 can include or correspond to data descriptive of seismic returns, electromagnetic returns, or other waveform returns.
The computer system 500 also includes the one or more memory devices 540. The memory device(s) 540 include any suitable computer-readable storage device depending on, for example, whether data access needs to be bi-directional or unidirectional, speed of data access required, memory capacity required, other factors related to data access, or any combination thereof. Generally, the memory device(s) 540 includes some combinations of volatile memory devices and non-volatile memory devices, though in some implementations, only one or the other may be present. Examples of volatile memory devices and circuits include registers, caches, latches, many types of random-access memory (RAM), such as dynamic random-access memory (DRAM), etc. Examples of non-volatile memory devices and circuits include hard disks, optical disks, flash memory, and certain types of RAM, such as resistive random-access memory (ReRAM). Other examples of both volatile and non-volatile memory devices can be used as well, or in the alternative, so long as such memory devices store information in a physical, tangible medium. Thus, the memory device(s) 540 include circuits and structures and are not merely signals or other transitory phenomena (i.e., are non-transitory media).
In the example illustrated in
The GUI engine 552 is configured to render image data generated by the image processor 104 (e.g., the third image data 122 of
In some implementations, the artifact reduction engine 120, when executed by the processor(s) 502, causes the processor(s) 502 to initiate, perform, or control an iterative gradient descent artifact reduction process. The iterative gradient descent artifact reduction process uses the second image data 118A of
In a particular implementation, an iteration of the gradient descent artifact reduction process includes determining, using a machine-learning model, a gradient associated with particular solution data (e.g., the initial estimate or solution data generated by a prior iteration of the gradient descent artifact reduction process). The iteration also includes adjusting the particular solution data based on the gradient to generate updated solution data.
As one example, the artifact reduction engine 120 may perform operations as described by the following pseudocode. In the following pseudocode, a “shot” refers to a single sampling event, measurements from which may be used to generate a corresponding set of waveform return data. In other contexts (e.g., other than seismic imaging) shots may be replaced with other sampling events (e.g., pings in the context of sonar).
In the pseudocode above, RTM(k) represents an aggregation of k reverse time migration results (e.g., a combined image based on k images, each based on waveform return data for a respective shot), where k is an integer greater than one. For example. RTM(8) refers to solution data based on reverse time migration of 8 waveform return measurements of the waveform return data 102. The solution data generated by RTM(k) is used as an initial estimate (x0) of a solution to the inverse problem. Additionally, in the pseudocode above, n is a configurable counter having a value greater than or equal to one. Further, in the pseudocode above, m is a counter indicating a number of artifact levels over which operations are performed, where m is an integer greater than or equal to one and less than or equal to a count of the total number of shots represented in the waveform return data 102 or that are otherwise available. In this context, an “artifact level” refers to any metric that characterizes and distinguishes the number, distribution, and/or intensity of migration swing artifacts in a set of images. Generally, m is set within a range from a smallest number of shots (referred to as kmin) that can be used to generate acceptable solution data to a largest number of shots (referred to as kmax) that the image generator 118 is allowed to use. In a particular implementation, kmin is associated with a largest artifact level, λmax (e.g., strongest artifacts in the solution data) used to train or optimize the artifact reduction engine 120, and kmax is associated with a smallest artifact level, λmin (e.g., weakest artifacts in the solution data) used to train or optimize the artifact reduction engine 120.
Additionally, in the pseudocode above, αm is a step size parameter used by the Langevin operations in the inner loop and is annealed (e.g., iteratively decreased) based on a ratio of the current artifact level, λm, to the smallest artifact level, λmin, used to train or optimize the artifact reduction engine 120 adjusted by a configurable parameter ε.
Further, in the pseudocode above, an inner loop performs T iterations to modify the solution data x to decrease artifacts present in the solution data, where T is an integer greater than or equal to two. Generally, good results have been achieved with values of T on the order of 100 to 200. In each inner loop iteration, solution data xt is determined by adjusting prior solution data xt-1 based on a gradient αmS(xt-1,λm), and where S(xt-1, λm) is an output of the artifact reduction engine 120 based on the prior solution data xt-1 and the current artifact level, λm.
In some implementations, after T iterations of the inner loop to generate solution data xt, the solution data may be adapted to satisfy particular constraints. In some implementations, the solution data is adapted to conform the solution data to specified expectations, such as physical constraints of the observed system. Such adaptation of the solution data is optional. To illustrate, such adaptation can be omitted entirely in some implementations. In some implementations, adaptation of the solution data is selectively performed. To illustrate, particular solution data may be adapted to conform to specified constraints based on characteristics of the solution data or based on output of one or more the operations performed by the pseudocode.
In some implementations, the pseudocode above also includes one or more iterations of a physics-based model. For example, within the n iterations loop and after the T Langevin steps loop, the pseudocode may include performing one or more least mean square reverse time migration (LSRTM) iterations of p shots, where p is an integer greater than one. In some implementations, p is set equal to k. In some implementations, physics-based modelling after the T Langevin steps loop is optional.
To illustrate, physics-based modelling can be omitted from the gradient descent artifact reduction process in some implementations. In some implementations, physics-based modelling after the T Langevin steps loop is selectively performed. To illustrate, physics-based modelling may be performed based on characteristics of the solution data generated by the T Langevin steps loop or based on output of another operation performed by the pseudocode.
One benefit of using a gradient descent artifact reduction process based on the pseudocode above is that high-quality solutions (e.g., solutions with weaker or fewer artifacts) can be generated using fewer computing resources than would be used to generate similar high-quality solutions using reverse time migration alone. When filtered image data (e.g., the second image data 118A of
Comparison of
Returning to
The score matching network is trained using the multiple sets of training data. For example, the score matching network may be trained by adjusting parameters of the score matching network to decrease a value of an objective function. In this example, the value of the objective function represents a weighted sum of values of objective functions for multiple different artifact levels. To illustrate, the objective function for a particular artifact level λ, may be represented by:
In this example, the objective function used to train or optimize the score matching network may be represented by:
In the objective function for a particular artifact level λ, pdata(x) refers to a probability density function of a data set x and p
RTM(k) represents an expectation over the set of images that are produced (e.g., an expectation over each allowed k value and over each set of specific images from the set of available image that are used to generate the k shots). Sθ({tilde over (x)},λ) represents solution data generated by the artifact reduction engine 120 for a particular artifact level λ. Further, xRTM(K) represents solution data generated by a physics-based model (e.g., RTM) based on K shots, where K is a count of shots of the largest set of shots used for any solution in the training data, and XRTM(k) represents solution data generated by the physics-based model (e.g., RTM) based on k shots, where k is an integer greater than one and less than K.
represents a value of an error metric that is based on a difference between solution data associated with the particular artifact level (corresponding to using k shots) and solution data associated with a lowest artifact level (corresponding to using K shots) of the multiple sets of solution data used to generate the training data.
In the objective function used to train or optimize the score matching network, L is the total count of artifact levels used, and γ is a function of a fitting parameter that is based on an error metric associated with the particular artifact level. In some implementations, γ is equal to λ2.
In a particular implementation, values of λ for a particular count of shots can be determined by determining multiple RTM(k) solutions for the same value of k. For example, from among a large set of waveform return data 102, multiple subsets of k shots can be selected. To illustrate, in the example of seismic sampling, different source and/or receiver positions can be selected for different subsets of k shots. The RTM(k) values for a particular value of k can be compared to RTM(K) to determine a mean square error for the artifact level associated with k. The value of λ for the particular count of shots k can be determined by fitting a parameterized function to the mean square error values with respect to a normalized count of shots (e.g., kmin/k).
In an alternative embodiment, dedicated hardware implementations, such as application specific integrated circuits, programmable logic arrays and other hardware devices, can be constructed to implement one or more of the operations described herein. Accordingly, the present disclosure encompasses software, firmware, and hardware implementations.
The method 600 includes, at 602, determining, based on waveform return data, a first estimated solution to an inverse problem associated with the waveform return data. The first estimated solution includes artifacts due, at least in part, to the quantity of waveform return data used to determine the first solution data.
As a particular example, the waveform return data may include waveform return measurements associated with one or more seismic imaging shots. In this particular example, the first estimated solution may be determined by performing one or more iterations of reverse time migration based on the waveform return measurements associated with the one or more seismic imaging shots, and the artifacts correspond to migration swing artifacts. To illustrate, in this example, the first estimated solution may correspond to the first image data 108 of
In some implementations, the first solution data is determined by generating filter data using DIP operations and subtracting the filter data from prior estimated solution data. To illustrate, in such implementations, the first estimated solution corresponds to the second image data 118A of
The method 600 also includes, at 604, performing a plurality of iterations of a gradient descent artifact reduction process to generate second solution data. The artifacts are reduced in the second solution data relative to the first solution data. A particular iteration of the gradient descent artifact reduction process includes, at 606, determining, using a machine-learning model (e.g., a score-matching network of the artifact reduction engine 120), a gradient associated with particular solution data, and at 608, adjusting the particular solution data based on the gradient to generate updated solution data.
In some implementations, the method 600 also includes, after determining the second solution data, providing the second solution data as input to the physics-based model to generate third solution data. For example, a result generated by the Langevin steps of the pseudocode above may be subjected to one or more LSRTM iterations to further refine the solution. In some such implementations, the method 600 may further include, performing a second plurality of iterations of the gradient descent artifact reduction process to generate fourth solution data, where the artifacts are reduced in the fourth solution data relative to the third solution data.
In some implementations, during the particular iteration of the gradient descent artifact reduction process, the particular solution data is adjusted further based on a step size parameter (e.g., αm). Further, the step size parameter may be adjusted after one or more iterations. For example, the gradient descent artifact reduction process may include, after performing the plurality of iterations, adjusting the step size parameter and performing a second plurality of iterations using the adjusted step size parameter. In a particular aspect, the step size parameter is based on a ratio of an error metric associated with a count of waveform measurement events (e.g., shots) and an error metric associated with a specified minimum count of waveform measurement events.
In some implementations, the particular solution data generated via one or more iterations is adjusted further based on one or more specified constraints. For example, particular solution data may be modified to enforce expected features of the solution data (e.g., an image) based on prior knowledge or assumptions about the observed system. As another example, particular solution data may be modified to enforce physics-based or experience-based expectations, such as an arrangement of features in the solution data.
One benefit of the method 600 is that it facilitates generation of high-quality solutions (e.g., solutions with weaker or fewer artifacts) using fewer computing resources than would be used to generate similar high-quality solutions using RTM alone. Further, the method 600 uses less waveform return data (e.g., fewer seismic imaging shots) than would be used to generate similar high-quality solutions using RTM alone. As a result, time and resources expended to gather the waveform return data can be reduced.
The method 700 includes, at 702, obtaining a first batch of solution data. Each set of solution data of the first batch corresponds to a physics-based solution to an inverse problem and is associated with a respective artifact level. For example, the sets of solution data may be determined using reverse time migration (RTM). As one specific example, RTM is performed for each set of waveform return data (e.g., each shot in a seismic imaging context) of a plurality of sets of waveform return data that are available to be processed to generate RTM data.
In this example, a first set of solution data may include RTM data based on k1 sets of waveform return data, where k1 is an integer that is greater than one and indicates a quantity of waveform return data included in the set. For example, the k1 sets of waveform return data may include waveform return data associated with k1 sampling events (e.g., k1 shots in a seismic imaging context), and the k1 sets of waveform return data do not include all of the waveform return data that are available for processing. Further, in this example, a second set of solution data may include RTM data based on k2 sets of waveform return data, where k2 is an integer that is greater than k1 and indicates a quantity of waveform return data included in the second set. The k2 sets of waveform return data also do not include all of the waveform return data that are available for processing. Similarly, other sets of solution data may include RTM data for sets of waveform return data. In some implementations, a randomized process is used to select the specific sets of waveform return data (from all of the waveform return data that are available for processing) used to determine a particular set of solution data. In the same or different implementations, a randomized process is used to select a k value used to determine a quantity of waveform return data used for each set of solution data.
The method 700 includes, at 704, generating training data based on the first batch. The training data associated with a particular artifact level is determined based on differences between a set of solution data associated with a lowest artifact level and a set of solution data associated with the particular artifact level.
The method 700 includes, at 706, training a score matching network using the training data. For example, training the score matching network may include adjusting parameters of the score matching network to decrease a value of an objective function, where the value of the objective function represents a weighted sum of values of objective functions for multiple different artifact levels. In this example, a value of an objective function for a particular artifact level of the multiple different artifact levels is weighted based on a fitting parameter, and the fitting parameter is based on an error metric associated with the particular artifact level. To illustrate, a value of the error metric may be determined based on a difference between solution data associated with the particular artifact level and solution data associated with a lowest artifact level of the multiple sets of solution data.
In some implementations, the score matching network may be further trained based on one or more additional batches of training data. For example, the method 700 may include obtaining one or more second batches of solution data corresponding to physics-based solutions to the inverse problem, generating additional training data based on the one or more second batches, and training the score matching network using the additional training data.
Particular aspects of the disclosure are highlighted in the following Examples:
Example 1 includes a method including: obtaining, by one or more processors, first image data that is based on waveform return data and is descriptive of an estimated solution to an inverse problem associated with the waveform return data; performing, by the one or more processors, a plurality of deep image prior operations, using an image prior based on the first image data, to generate filter data; modifying, by the one or more processors, the first image data based on the filter data to generate second image data; and performing, by the one or more processors, an artifact reduction process based on the second image data to generate third image data.
Example 2 includes the method of Example 1, wherein the waveform return data represent reflections, from a visually occluded structure, of one or more incident waves, and wherein the third image data represents an enhanced image of the structure as compared to the first image data.
Example 3 includes the method of Example 1 or the method of Example 2, wherein obtaining the first image data includes determining the first image data using a physics-based model.
Example 4 includes the method of any of Examples 1 to 3, wherein obtaining the first image data includes performing reverse time migration based on at least a subset of the waveform return data.
Example 5 includes the method of any of Examples 1 to 4, wherein the estimated solution to the inverse problem includes a reflectivity image.
Example 6 includes the method of any of Examples 1 to 5, wherein the first image data represents an image and the filter data represents a partial reconstruction of the image generated by early stopping the deep image prior operations such that the plurality of deep image prior operations includes fewer deep image prior operations than would be used to fully reconstruct the image.
Example 7 includes the method of any of Examples 1 to 6, wherein determining the filter data based on the first image data includes performing a plurality of iterations of machine-learning optimization, wherein a particular iteration of the machine-learning optimization includes: providing input data to a model to determine first output data based on values of parameters of the model; determining an error value based on a comparison of the first output data and the image prior; and adjusting one or more of the values of the parameters of the model to reduce an error value associated with a subsequent iteration of the machine-learning optimization.
Example 8 includes the method of Example 7, wherein an initial iteration of the machine-learning optimization includes setting the values of the parameters of the model independently of the first image data.
Example 9 includes the method of Example 7 or the method of Example 10, wherein the input data for an initial iteration of the machine-learning optimization is independent of the first image data.
Example 10 includes the method of any of Examples 1 to 9, further including, before modifying the first image data based on the filter data, performing one or more data transform operations to emphasize artifacts in the filter data.
Example 11 includes the method of any of Examples 1 to 10, wherein modifying the first image data based on the filter data includes subtracting the filter data from the first image data.
Example 12 includes the method of any of Examples 1 to 11, further including, after determining the third image data, providing the third image data as input to a physics-based model to generate fourth image data.
Example 13 includes the method of Example 12, further including performing a second plurality of iterations of the artifact reduction process to generate fifth image data, wherein artifacts are reduced in the fifth image data relative to the fourth image data.
Example 14 includes the method of any of Examples 1 to 13, wherein the artifact reduction process includes a plurality of iterations and a particular iteration of the artifact reduction process includes: determining, using a machine-learning model, a gradient associated with particular solution data; and adjusting the particular solution data based on the gradient to generate updated solution data.
Example 15 includes the method of Example 14, wherein, during the particular iteration of the artifact reduction process, the particular solution data is adjusted further based on a step size parameter.
Example 16 includes the method of Example 15, further including, after performing the plurality of iterations of the artifact reduction process: adjusting the step size parameter; and performing a second plurality of iterations of the artifact reduction process.
Example 17 includes the method of any of Examples 14 to 16, wherein, during the particular iteration of the artifact reduction process, the particular solution data is adjusted to satisfy a specified constraint.
Example 18 includes the method of any of Examples 14 to 17, wherein the machine-learning model corresponds to a score-matching network.
Example 19 includes a system including: one or more processors configured to: obtain first image data that is based on waveform return data and is descriptive of an estimated solution to an inverse problem associated with the waveform return data; perform a plurality of deep image prior operations, using an image prior based on the first image data, to generate filter data; modify the first image data based on the filter data to generate second image data; and perform an artifact reduction process based on the second image data to generate third image data, wherein artifacts are reduced in the third image data relative to the first image data.
Example 20 includes the system of Example 19, wherein the waveform return data represent reflections, from a visually occluded structure, of one or more incident waves, and wherein the third image data represents an enhanced image of the structure as compared to the first image data.
Example 21 includes the system of Example 19 or the system of Example 20, wherein obtaining the first image data includes determining the first image data using a physics-based model.
Example 22 includes the system of any of Examples 19 to 21, wherein obtaining the first image data includes performing reverse time migration based on at least a subset of the waveform return data.
Example 23 includes the system of any of Examples 19 to 22, wherein the estimated solution to the inverse problem includes a reflectivity image.
Example 24 includes the system of any of Examples 19 to 23, wherein the first image data represents an image and the filter data represents a partial reconstruction of the image.
Example 25 includes the system of any of Examples 19 to 24, wherein determining the filter data based on the first image data includes performing a plurality of iterations of machine-learning optimization, wherein a particular iteration of the machine-learning optimization includes: providing input data to a model to determine first output data based on values of parameters of the model; determining an error value based on a comparison of the first output data and the image prior; and adjusting one or more of the values of the parameters of the model to reduce an error value associated with a subsequent iteration of the machine-learning optimization.
Example 26 includes the system of Example 25, wherein an initial iteration of the machine-learning optimization includes setting the values of the parameters of the model independently of the first image data.
Example 27 includes the system of Example 25 or the system of Example 30, wherein the input data for an initial iteration of the machine-learning optimization is independent of the first image data.
Example 28 includes the system of any of Examples 25 to 27, wherein the one or more processors are further configured to, before modifying the first image data based on the filter data, perform one or more data transform operations to emphasize artifacts in the filter data.
Example 29 includes the system of any of Examples 19 to 28, wherein modifying the first image data based on the filter data includes subtracting the filter data from the first image data.
Example 30 includes the system of any of Examples 19 to 29, wherein the one or more processors are further configured to, after determining the third image data, provide the third image data as input to a physics-based model to generate fourth image data.
Example 31 includes the system of Example 30, wherein the one or more processors are further configured to perform a second plurality of iterations of the artifact reduction process to generate fifth image data, wherein artifacts are reduced in the fifth image data relative to the fourth image data.
Example 32 includes the system of any of Examples 19 to 31, wherein the artifact reduction process includes a plurality of iterations and a particular iteration of the artifact reduction process includes: determining, using a machine-learning model, a gradient associated with particular solution data; and adjusting the particular solution data based on the gradient to generate updated solution data.
Example 33 includes the system of Example 32, wherein, during the particular iteration of the artifact reduction process, the particular solution data is adjusted further based on a step size parameter.
Example 34 includes the system of Example 33, wherein the one or more processors are further configured to, after performing the plurality of iterations of the artifact reduction process: adjust the step size parameter; and perform a second plurality of iterations of the artifact reduction process.
Example 35 includes the system of any of Examples 32 to 34 wherein, during the particular iteration of the artifact reduction process, the particular solution data is adjusted to satisfy a specified constraint.
Example 36 includes the system of any of Examples 32 to 35, wherein the machine-learning model corresponds to a score-matching network.
Example 37 includes a computer-readable storage device storing instructions that, when executed by one or more processors, cause the one or more processors to: obtain first image data that is based on waveform return data and is descriptive of an estimated solution to an inverse problem associated with the waveform return data; perform a plurality of deep image prior operations, using an image prior based on the first image data, to generate filter data; modify the first image data based on the filter data to generate second image data; and perform an artifact reduction process based on the second image data to generate third image data, wherein artifacts are reduced in the third image data relative to the first image data.
Example 38 includes the computer-readable storage device of Example 37, wherein the waveform return data represent reflections, from a visually occluded structure, of one or more incident waves, and wherein the third image data represents an enhanced image of the structure as compared to the first image data.
Example 39 includes the computer-readable storage device of Example 37 or the computer-readable storage device of Example 38, wherein obtaining the first image data includes determining the first image data using a physics-based model.
Example 40 includes the computer-readable storage device of any of Examples 37 to 39, wherein obtaining the first image data includes performing reverse time migration based on at least a subset of the waveform return data.
Example 41 includes the computer-readable storage device of any of Examples 37 to 40, wherein the estimated solution to the inverse problem includes a reflectivity image.
Example 42 includes the computer-readable storage device of any of Examples 37 to 41, wherein the first image data represents an image and the filter data represents a partial reconstruction of the image.
Example 43 includes the computer-readable storage device of any of Examples 37 to 42, wherein determining the filter data based on the first image data includes performing a plurality of iterations of machine-learning optimization, wherein a particular iteration of the machine-learning optimization includes: providing input data to a model to determine first output data based on values of parameters of the model; determining an error value based on a comparison of the first output data and the image prior; and adjusting one or more of the values of the parameters of the model to reduce an error value associated with a subsequent iteration of the machine-learning optimization.
Example 44 includes the computer-readable storage device of Example 43, wherein an initial iteration of the machine-learning optimization includes setting the values of the parameters of the model independently of the first image data.
Example 45 includes the computer-readable storage device of Example 43 or the computer-readable storage device of Example 44, wherein the input data for an initial iteration of the machine-learning optimization is independent of the first image data.
Example 46 includes the computer-readable storage device of any of Examples 43 to 45, wherein the instructions further cause the one or more processors to, before modifying the first image data based on the filter data, perform one or more data transform operations to emphasize artifacts in the filter data.
Example 47 includes the computer-readable storage device of any of Examples 37 to 46, wherein modifying the first image data based on the filter data includes subtracting the filter data from the first image data.
Example 48 includes the computer-readable storage device of any of Examples 37 to 47, wherein the instructions further cause the one or more processors to, after determining the third image data, provide the third image data as input to a physics-based model to generate fourth image data.
Example 49 includes the computer-readable storage device of Example 48, wherein the instructions further cause the one or more processors to perform a second plurality of iterations of the artifact reduction process to generate fifth image data, wherein artifacts are reduced in the fifth image data relative to the fourth image data.
Example 50 includes the computer-readable storage device of any of Examples 37 to 49, wherein the artifact reduction process includes a plurality of iterations and a particular iteration of the artifact reduction process includes: determining, using a machine-learning model, a gradient associated with particular solution data; and adjusting the particular solution data based on the gradient to generate updated solution data.
Example 51 includes the computer-readable storage device of Example 50, wherein, during the particular iteration of the artifact reduction process, the particular solution data is adjusted further based on a step size parameter.
Example 52 includes the computer-readable storage device of Example 51, wherein the instructions further cause the one or more processors to, after performing the plurality of iterations of the artifact reduction process: adjust the step size parameter; and perform a second plurality of iterations of the artifact reduction process.
Example 53 includes the computer-readable storage device of any of Examples 50 to 52, wherein, during the particular iteration of the artifact reduction process, the particular solution data is adjusted to satisfy a specified constraint.
Example 54 includes the computer-readable storage device of any of Examples 50 to 53, wherein the machine-learning model corresponds to a score-matching network.
Example 55 includes a method including: obtaining, by one or more processors, first image data that is based on waveform return data and is descriptive of an estimated solution to an inverse problem associated with the waveform return data; performing, by the one or more processors, an artifact reduction process based on the first image data to generate second image data; performing, by the one or more processors, a plurality of deep image prior operations, using an image prior based on the first image data or the second image data, to generate filter data; and modifying, by the one or more processors, the second image data based on the filter data to generate third image data.
Example 56 includes the method of Example 55, wherein the waveform return data represent reflections, from a visually occluded structure, of one or more incident waves, and wherein the third image data represents an enhanced image of the structure as compared to the first image data.
Example 57 includes the method of Example 55 or the method of Example 56, wherein obtaining the first image data includes determining the first image data using a physics-based model.
Example 58 includes the method of any of Examples 55 to 57, wherein obtaining the first image data includes performing reverse time migration based on at least a subset of the waveform return data.
Example 59 includes the method of any of Examples 55 to 58, wherein the estimated solution to the inverse problem includes a reflectivity image.
Example 60 includes the method of any of Examples 55 to 59, wherein the first image data represents an image and the filter data represents a partial reconstruction of the image generated by early stopping the deep image prior operations such that the plurality of deep image prior operations includes fewer deep image prior operations than would be used to fully reconstruct the image.
Example 61 includes the method of any of Examples 55 to 60, wherein determining the filter data based on the first image data includes performing a plurality of iterations of machine-learning optimization, wherein a particular iteration of the machine-learning optimization includes: providing input data to a model to determine first output data based on values of parameters of the model; determining an error value based on a comparison of the first output data and the image prior; and adjusting one or more of the values of the parameters of the model to reduce an error value associated with a subsequent iteration of the machine-learning optimization.
Example 62 includes the method of Example 61, wherein an initial iteration of the machine-learning optimization includes setting the values of the parameters of the model independently of the first image data.
Example 63 includes the method of Example 61 or the method of Example 62, wherein the input data for an initial iteration of the machine-learning optimization is independent of the first image data.
Example 64 includes the method of any of Examples 55 to 63, further including, before modifying the first image data based on the filter data, performing one or more data transform operations to emphasize artifacts in the filter data.
Example 65 includes the method of any of Examples 55 to 64, wherein modifying the first image data based on the filter data includes subtracting the filter data from the first image data.
Example 66 includes the method of any of Examples 55 to 65, further including, after determining the third image data, providing the third image data as input to a physics-based model to generate fourth image data.
Example 67 includes the method of Example 66, further including performing a second plurality of iterations of the artifact reduction process to generate fifth image data, wherein artifacts are reduced in the fifth image data relative to the fourth image data.
Example 68 includes the method of any of Examples 55 to 67, wherein the artifact reduction process includes a plurality of iterations and a particular iteration of the artifact reduction process includes: determining, using a machine-learning model, a gradient associated with particular solution data; and adjusting the particular solution data based on the gradient to generate updated solution data.
Example 69 includes the method of Example 68, wherein, during the particular iteration of the artifact reduction process, the particular solution data is adjusted further based on a step size parameter.
Example 70 includes the method of Example 69, further including, after performing the plurality of iterations of the artifact reduction process: adjusting the step size parameter; and performing a second plurality of iterations of the artifact reduction process.
Example 71 includes the method of any of Examples 68 to 70, wherein, during the particular iteration of the artifact reduction process, the particular solution data is adjusted to satisfy a specified constraint.
Example 72 includes the method of any of Examples 68 to 71, wherein the machine-learning model corresponds to a score-matching network.
Example 73 includes a system including: one or more processors configured to: obtain first image data that is based on waveform return data and is descriptive of an estimated solution to an inverse problem associated with the waveform return data; perform an artifact reduction process based on the first image data to generate second image data; perform a plurality of deep image prior operations, using an image prior based on the first image data or the second image data, to generate filter data; and modify the second image data based on the filter data to generate third image data.
Example 74 includes the system of Example 73, wherein the waveform return data represent reflections, from a visually occluded structure, of one or more incident waves, and wherein the third image data represents an enhanced image of the structure as compared to the first image data.
Example 75 includes the system of Example 73 or the system of Example 74, wherein obtaining the first image data includes determining the first image data using a physics-based model.
Example 76 includes the system of any of Examples 73 to 75, wherein obtaining the first image data includes performing reverse time migration based on at least a subset of the waveform return data.
Example 77 includes the system of any of Examples 73 to 76, wherein the estimated solution to the inverse problem includes a reflectivity image.
Example 78 includes the system of any of Examples 73 to 77, wherein the first image data represents an image and the filter data represents a partial reconstruction of the image.
Example 79 includes the system of any of Examples 73 to 78, wherein determining the filter data based on the first image data includes performing a plurality of iterations of machine-learning optimization, wherein a particular iteration of the machine-learning optimization includes: providing input data to a model to determine first output data based on values of parameters of the model; determining an error value based on a comparison of the first output data and the image prior; and adjusting one or more of the values of the parameters of the model to reduce an error value associated with a subsequent iteration of the machine-learning optimization.
Example 80 includes the system of Example 79, wherein an initial iteration of the machine-learning optimization includes setting the values of the parameters of the model independently of the first image data.
Example 81 includes the system of Example 79 or the system of Example 80, wherein the input data for an initial iteration of the machine-learning optimization is independent of the first image data.
Example 82 includes the system of any of Examples 79 to 81, wherein the one or more processors are further configured to, before modifying the first image data based on the filter data, perform one or more data transform operations to emphasize artifacts in the filter data.
Example 83 includes the system of any of Examples 73 to 82, wherein modifying the first image data based on the filter data includes subtracting the filter data from the first image data.
Example 84 includes the system of any of Examples 73 to 83, wherein the one or more processors are further configured to, after determining the third image data, provide the third image data as input to a physics-based model to generate fourth image data.
Example 85 includes the system of Example 84, wherein the one or more processors are further configured to perform a second plurality of iterations of the artifact reduction process to generate fifth image data, wherein artifacts are reduced in the fifth image data relative to the fourth image data.
Example 86 includes the system of any of Examples 73 to 85, wherein the artifact reduction process includes a plurality of iterations and a particular iteration of the artifact reduction process includes: determining, using a machine-learning model, a gradient associated with particular solution data; and adjusting the particular solution data based on the gradient to generate updated solution data.
Example 87 includes the system of Example 86, wherein, during the particular iteration of the artifact reduction process, the particular solution data is adjusted further based on a step size parameter.
Example 88 includes the system of Example 87, wherein the one or more processors are further configured to, after performing the plurality of iterations of the artifact reduction process: adjust the step size parameter; and perform a second plurality of iterations of the artifact reduction process.
Example 89 includes the system of any of Examples 86 to 88, wherein, during the particular iteration of the artifact reduction process, the particular solution data is adjusted to satisfy a specified constraint.
Example 90 includes the system of any of Examples 86 to 89, wherein the machine-learning model corresponds to a score-matching network.
Example 91 includes a computer-readable storage device storing instructions that, when executed by one or more processors, cause the one or more processors to: obtain first image data that is based on waveform return data and is descriptive of an estimated solution to an inverse problem associated with the waveform return data; perform an artifact reduction process based on the first image data to generate second image data; perform a plurality of deep image prior operations, using an image prior based on the first image data or the second image data, to generate filter data; and modify the second image data based on the filter data to generate third image data.
Example 92 includes the computer-readable storage device of Example 91, wherein the waveform return data represent reflections, from a visually occluded structure, of one or more incident waves, and wherein the third image data represents an enhanced image of the structure as compared to the first image data.
Example 93 includes the computer-readable storage device of Example 91 or the computer-readable storage device of Example 92, wherein obtaining the first image data includes determining the first image data using a physics-based model.
Example 94 includes the computer-readable storage device of any of Examples 91 to 93, wherein obtaining the first image data includes performing reverse time migration based on at least a subset of the waveform return data.
Example 95 includes the computer-readable storage device of any of Examples 91 to 94, wherein the estimated solution to the inverse problem includes a reflectivity image.
Example 96 includes the computer-readable storage device of any of Examples 91 to 95, wherein the first image data represents an image and the filter data represents a partial reconstruction of the image.
Example 97 includes the computer-readable storage device of any of Examples 91 to 96, wherein determining the filter data based on the first image data includes performing a plurality of iterations of machine-learning optimization, wherein a particular iteration of the machine-learning optimization includes: providing input data to a model to determine first output data based on values of parameters of the model; determining an error value based on a comparison of the first output data and the image prior; and adjusting one or more of the values of the parameters of the model to reduce an error value associated with a subsequent iteration of the machine-learning optimization.
Example 98 includes the computer-readable storage device of Example 97, wherein an initial iteration of the machine-learning optimization includes setting the values of the parameters of the model independently of the first image data.
Example 99 includes the computer-readable storage device of Example 97 or the computer-readable storage device of Example 98, wherein the input data for an initial iteration of the machine-learning optimization is independent of the first image data.
Example 100 includes the computer-readable storage device of any of Examples 97 to 99, wherein the instructions further cause the one or more processors to, before modifying the first image data based on the filter data, perform one or more data transform operations to emphasize artifacts in the filter data.
Example 101 includes the computer-readable storage device of any of Examples 91 to 100, wherein modifying the first image data based on the filter data includes subtracting the filter data from the first image data.
Example 102 includes the computer-readable storage device of any of Examples 91 to 101, wherein the instructions further cause the one or more processors to, after determining the third image data, provide the third image data as input to a physics-based model to generate fourth image data.
Example 103 includes the computer-readable storage device of Example 102, wherein the instructions further cause the one or more processors to perform a second plurality of iterations of the artifact reduction process to generate fifth image data, wherein artifacts are reduced in the fifth image data relative to the fourth image data.
Example 104 includes the computer-readable storage device of any of Examples 91 to 103, wherein the artifact reduction process includes a plurality of iterations and a particular iteration of the artifact reduction process includes: determining, using a machine-learning model, a gradient associated with particular solution data; and adjusting the particular solution data based on the gradient to generate updated solution data.
Example 105 includes the computer-readable storage device of Example 104, wherein, during the particular iteration of the artifact reduction process, the particular solution data is adjusted further based on a step size parameter.
Example 106 includes the computer-readable storage device of Example 105, wherein the instructions further cause the one or more processors to, after performing the plurality of iterations of the artifact reduction process: adjust the step size parameter; and perform a second plurality of iterations of the artifact reduction process.
Example 107 includes the computer-readable storage device of any of Examples 104 to 106, wherein, during the particular iteration of the artifact reduction process, the particular solution data is adjusted to satisfy a specified constraint.
Example 108 includes the computer-readable storage device of any of Examples 104 to 107, wherein the machine-learning model corresponds to a score-matching network.
The systems and methods illustrated herein may be described in terms of functional block components, screen shots, optional selections, and various processing steps. It should be appreciated that such functional blocks may be realized by any number of hardware and/or software components configured to perform the specified functions. For example, the system may employ various integrated circuit components, e.g., memory elements, processing elements, logic elements, look-up tables, and the like, which may carry out a variety of functions under the control of one or more microprocessors or other control devices. Similarly, the software elements of the system may be implemented with any programming or scripting language such as C, C++, C#, Java, JavaScript, VBScript, Macromedia Cold Fusion, COBOL, Microsoft Active Server Pages, assembly, PERL, PHP, AWK, Python, Visual Basic, SQL Stored Procedures, PL/SQL, any UNIX shell script, and extensible markup language (XML) with the various algorithms being implemented with any combination of data structures, objects, processes, routines or other programming elements. Further, it should be noted that the system may employ any number of techniques for data transmission, signaling, data processing, network control, and the like.
The systems and methods of the present disclosure may be embodied as a customization of an existing system, an add-on product, a processing apparatus executing upgraded software, a standalone system, a distributed system, a method, a data processing system, a device for data processing, and/or a computer program product. Accordingly, any portion of the system or a module or a decision model may take the form of a processing apparatus executing code, an internet based (e.g., cloud computing) embodiment, an entirely hardware embodiment, or an embodiment combining aspects of the internet, software, and hardware. Furthermore, the system may take the form of a computer program product on a computer-readable storage medium or device having computer-readable program code (e.g., instructions) embodied or stored in the storage medium or device. Any suitable computer-readable storage medium or device may be utilized, including hard disks, CD-ROM, optical storage devices, magnetic storage devices, and/or other storage media. As used herein, a “computer-readable storage medium” or “computer-readable storage device” is not a signal.
Systems and methods may be described herein with reference to screen shots, block diagrams and flowchart illustrations of methods, apparatuses (e.g., systems), and computer media according to various aspects. It will be understood that each functional block of a block diagram and flowchart illustration, and combinations of functional blocks in block diagrams and flowchart illustrations, respectively, can be implemented by computer program instructions.
Computer program instructions may be loaded onto a computer or other programmable data processing apparatus to produce a machine, such that the instructions that execute on the computer or other programmable data processing apparatus create means for implementing the functions specified in the flowchart block or blocks. These computer program instructions may also be stored in a computer-readable memory or device that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart block or blocks. The computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer-implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart block or blocks.
Accordingly, functional blocks of the block diagrams and flowchart illustrations support combinations of means for performing the specified functions, combinations of steps for performing the specified functions, and program instruction means for performing the specified functions. It will also be understood that each functional block of the block diagrams and flowchart illustrations, and combinations of functional blocks in the block diagrams and flowchart illustrations, can be implemented by either special purpose hardware-based computer systems which perform the specified functions or steps, or suitable combinations of special purpose hardware and computer instructions.
Although the disclosure may include one or more methods, it is contemplated that it may be embodied as computer program instructions on a tangible computer-readable medium, such as a magnetic or optical memory or a magnetic or optical disk/disc. All structural, chemical, and functional equivalents to the elements of the above-described exemplary embodiments that are known to those of ordinary skill in the art are expressly incorporated herein by reference and are intended to be encompassed by the present claims. Moreover, it is not necessary for a device or method to address each and every problem sought to be solved by the present disclosure, for it to be encompassed by the present claims. Furthermore, no element, component, or method step in the present disclosure is intended to be dedicated to the public regardless of whether the element, component, or method step is explicitly recited in the claims. As used herein, the terms “comprises,” “comprising,” or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus.
Changes and modifications may be made to the disclosed embodiments without departing from the scope of the present disclosure. These and other changes or modifications are intended to be included within the scope of the present disclosure, as expressed in the following claims.
The present application claims priority from U.S. Provisional Patent Application No. 63,255,322, entitled “ARTIFACT REDUCTION FOR SOLUTIONS TO INVERSE PROBLEMS”, filed Oct. 13, 2021, and claims priority from U.S. Provisional Patent Application No. 63,263,532, entitled “ARTIFACT REDUCTION FOR SOLUTIONS TO INVERSE PROBLEMS”, filed Nov. 4, 2021, and claims priority from U.S. Provisional Patent Application No. 63,362,787, entitled “DATA SELECTION FOR IMAGE GENERATION”, filed Apr. 11, 2022, and claims priority from U.S. Provisional Patent Application No. 63,362,789, entitled “IMAGE ARTIFACT REDUCTION USING FILTER DATA BASED ON DEEP IMAGE PRIOR OPERATIONS”, filed Apr. 11, 2022, and claims priority from U.S. Provisional Patent Application No. 63,362,792, entitled “RELIABILITY FOR MACHINE-LEARNING BASED IMAGE GENERATION”, filed Apr. 11, 2022, the contents of each of which are incorporated herein by reference in their entirety.
| Number | Date | Country | |
|---|---|---|---|
| 63362792 | Apr 2022 | US | |
| 63362789 | Apr 2022 | US | |
| 63362787 | Apr 2022 | US | |
| 63263532 | Nov 2021 | US | |
| 63255322 | Oct 2021 | US |
