ML Solutions for Oil & Gas Production: Forecasting, Optimization, Monitoring

Suboptimal ESP modes can eat up to 15% of potential production — and that's just the tip of the iceberg. We develop ML systems for oil and gas that solve concrete problems: flow rate prediction with ±5% accuracy, RL-based ESP optimization yielding a 3–8% gain, and anomaly detection 1–2 hours before failure. Our models are in production on 15+ projects, delivering a 20% reduction in downtime and up to 8% production increase. The annual savings on a single field can reach millions of rubles.

We use PyTorch, Hugging Face Transformers, and LangChain for NLP tasks, and LSTM and Transformer architectures for time series. Physics-Informed Neural Networks (PINN) enable physically consistent predictions even with limited data: Darcy's filtration equation is embedded in the loss function, ensuring physical plausibility. This is especially valuable when data is scarce — the model avoids overfitting and provides accurate estimates even for wells with short observation histories. In our projects, PINN reduced error by 40% compared to a pure ML approach.

How does ML improve well flow rate prediction?

DCA+ML: Classic Decline Curve Analysis (Arps) suffers from ±15% error due to neglecting reservoir physics. ML corrections trained on historical pressure, water cut, and ESP frequency data reduce the error to ±5% — three times more accurate than the traditional approach.

import numpy as np
from scipy.optimize import curve_fit
from sklearn.ensemble import GradientBoostingRegressor
import pandas as pd

class WellProductionPredictor:
    """Combined flow rate prediction model: DCA + ML corrections"""

    def arps_decline(self, t, qi, di, b):
        """Hyperbolic decline curve (Arps): q(t) = qi / (1 + b*di*t)^(1/b)"""
        return qi / (1 + b * di * t) ** (1 / b)

    def fit_dca(self, time_days, production_bbl_day):
        """Fit DCA parameters for a well"""
        try:
            popt, _ = curve_fit(
                self.arps_decline,
                time_days, production_bbl_day,
                p0=[production_bbl_day[0], 0.01, 0.5],
                bounds=([0, 1e-6, 0], [1e6, 2.0, 2.0]),
                maxfev=5000
            )
            return {'qi': popt[0], 'di': popt[1], 'b': popt[2]}
        except:
            return None

    def ml_correction_features(self, well_data):
        """Features for ML correction of DCA"""
        return {
            'reservoir_pressure': well_data['bhp_current_psi'],
            'water_cut': well_data['water_cut_pct'],
            'choke_size': well_data['choke_size_64th'],
            'esp_frequency': well_data.get('esp_hz', 50),
            'glr': well_data.get('gas_liquid_ratio', 0),
            'cumulative_oil': well_data['cumulative_oil_bbl'],
            'days_producing': well_data['days_on_production'],
            'dca_residual': well_data['actual'] - well_data['dca_predicted']
        }

Why is operating mode optimization important?

RL-based ESP optimization: The electric submersible pump is the primary method of artificial lift. Our goal is to find the operating frequency that maximizes oil production while minimizing power consumption. We use SAC (Soft Actor-Critic) for continuous control. Typical gains: 3–8% flow rate increase plus 10–15% energy reduction.

from stable_baselines3 import SAC
import gymnasium as gym

class ESPOptimizationEnv(gym.Env):
    """Environment for RL-based ESP optimization"""

    def __init__(self, well_simulator):
        self.simulator = well_simulator
        self.action_space = gym.spaces.Box(low=40, high=60, shape=(1,))  # ESP frequency (Hz)
        self.observation_space = gym.spaces.Box(
            low=0, high=np.inf,
            shape=(6,)  # intake pressure, flow rate, water cut, current, temperature, cumulative
        )

    def step(self, action):
        freq = float(action[0])
        new_state, production_bbl_day, power_kw = self.simulator.step(freq)

        # Reward: oil production minus electricity cost
        oil_rate = production_bbl_day * (1 - new_state[2]/100)  # account for water cut
        reward = oil_rate * 0.5 - power_kw * 0.01  # in arbitrary units

        return new_state, reward, False, False, {}

Comparison with a classic PID controller:

RL responds to changes in reservoir pressure five times faster than manual PID tuning.

Anomaly detection using LSTM-Autoencoder

The LSTM-Autoencoder is trained on multivariate time series (pressure, flow rate, currents) to reconstruct the signal. A high reconstruction error indicates an anomaly: water breakthrough, ESP clogging, or seal failure. Detection occurs 1–2 hours before failure — twice as fast as statistical threshold methods. We also use CNN on acoustic sensor spectrograms for early sand production detection.

Geophysics and drilling

MWD/LWD interpretation: An ML classifier trained on well logs (GR, SP, resistivity) predicts lithology in real time. Geo-steering: We direct the wellbore to optimally intersect the reservoir. Prediction of rate of penetration (ROP) optimizes drilling parameters.

Seismic: ML-accelerated FWI reconstructs the velocity model; U-Net automatically identifies faults on seismic sections.

How to deploy an ML system: 5 steps

1. Data and infrastructure audit: Analysis of SCADA, sensors, and historical data for 2+ years. Identify available fields and signal quality.
2. Prototype development: Train baseline models (DCA+ML, LSTM) on selected wells. Validate on a holdout set.
3. Simulator integration: Test models in tNavigator to evaluate impact on actual operating conditions.
4. Production deployment: Deploy on edge devices or in the cloud via Triton Inference Server. Data pipeline via MQTT or OPC UA.
5. Monitoring and retraining: Regularly update models as new data arrives; track drift metrics.

What's included in the work

• Data and infrastructure audit (SCADA, sensors, historical data)
• Model development and training (DCA+ML, RL, LSTM, CNN)
• Integration with existing systems (API, MQTT, OPC UA)
• Documentation: model card, technical description, operation manual
• Customer team training (2–3 business days)
• 6-month warranty support with fixed response times

Development timeline: 6 to 10 months for an ML well analysis platform with flow rate prediction, ESP optimization, and integrity monitoring. The exact cost and schedule are assessed based on your case. Request a data audit and receive a detailed implementation plan. Contact us for a consultation.