def objective_function():
X, y = production_rate_dataset(producers[0], *injectors)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.5,
shuffle=False)
crmp = CRMP().fit(X_train, y_train)
for i in range(number_of_producers):
X, y = production_rate_dataset(producers[i], *injectors)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.5,
shuffle=False)
for p0 in param_grid['p0']:
crmp.tau_ = p0[0]
crmp.gains_ = p0[1:]
y_hat = crmp.predict(X_test)
r2, mse = fit_statistics(y_hat, y_test)
objective_function_data['Producer'].append(i + 1)
objective_function_data['tau'].append(p0[0])
objective_function_data['f1'].append(p0[1])
objective_function_data['f2'].append(p0[2])
objective_function_data['r2'].append(r2)
objective_function_data['MSE'].append(mse)
objective_function_df = pd.DataFrame(objective_function_data)
objective_function_df.to_csv(objective_function_file)
def plot_production_history_with_fit_and_predict():
df = pd.read_csv(predict_file)
starting_index = producer_starting_indicies[1]
producer = producers[1][starting_index:]
injectors_tmp = [injector[starting_index:] for injector in injectors]
X, y = production_rate_dataset(producer, *injectors_tmp)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.5,
shuffle=False)
crmp = CRMP().fit(X_train, y_train)
for i in range(len(producer_names)):
producer_df = producer_rows_from_df(df, i + 1)
starting_index = producer_starting_indicies[i]
producer = producers[i][starting_index:]
injectors_tmp = [injector[starting_index:] for injector in injectors]
X, y = production_rate_dataset(producer, *injectors_tmp)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.5,
shuffle=False)
producer_length = len(producer)
t = np.linspace(1, producer_length, producer_length)
train_length = len(y_train)
train_time = t[:train_length]
test_time = t[train_length:][1:]
empty = []
plt.plot(empty, empty, c='r', label='Fit')
plt.plot(empty, empty, c='g', label='Predict')
plt.plot(t, producer, c='k')
for index, row in producer_df.iterrows():
tau = row['tau_final']
f1 = row['f1_final']
f2 = row['f2_final']
f3 = row['f3_final']
f4 = row['f4_final']
crmp.tau_ = tau
crmp.gains_ = [f1, f2, f3, f4]
# Fitting
y_hat = crmp.predict(X_train)
plt.plot(train_time, y_hat, '--', alpha=0.02, c='r', linewidth=2)
# Prediction
y_hat = crmp.predict(X_test)
plt.plot(test_time, y_hat, ':', alpha=0.02, c='g', linewidth=2)
plt.vlines(test_time[0],
0,
1.1 * max(producer),
linewidth=2,
alpha=0.8)
plot_helper(FIG_DIR,
title=producer_names[i],
xlabel='Time [days]',
ylabel='Production Rate [bbls/day]',
legend=True,
save=True)
def test_predict_three_injectors(self):
X, y = production_rate_dataset(q, inj1, inj2, inj3)
crmp = CRMP().fit(X, y)
# There is no helper to construct the prediction matrix
# since the prediction matrix is constructed by the cross validator
X = np.array([q[1:], inj1[1:], inj2[1:], inj3[1:]]).T
y_hat = crmp.predict(X)
assert (y_hat is not None)
assert (len(y_hat) == 4)
def convergence_sensitivity_analysis():
for i in range(len(producer_names)):
starting_index = producer_starting_indicies[i]
producer = producers[i][starting_index:]
injectors_tmp = [injector[starting_index:] for injector in injectors]
X, y = production_rate_dataset(producer, *injectors_tmp)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.5,
shuffle=False)
for p0 in p0s:
crmp = CRMP(p0=deepcopy(p0))
crmp = crmp.fit(X_train, y_train)
# Fitting
y_hat = crmp.predict(X_train)
r2, mse = fit_statistics(y_hat, y_train)
fit_data['Producer'].append(i + 1)
fit_data['Model'].append(model_namer(crmp))
fit_data['tau_initial'].append(p0[0])
fit_data['tau_final'].append(crmp.tau_)
fit_data['f1_initial'].append(p0[1])
fit_data['f1_final'].append(crmp.gains_[0])
fit_data['f2_initial'].append(p0[2])
fit_data['f2_final'].append(crmp.gains_[1])
fit_data['f3_initial'].append(p0[3])
fit_data['f3_final'].append(crmp.gains_[2])
fit_data['f4_initial'].append(p0[4])
fit_data['f4_final'].append(crmp.gains_[3])
fit_data['r2'].append(r2)
fit_data['MSE'].append(mse)
# Prediction
y_hat = crmp.predict(X_test)
r2, mse = fit_statistics(y_hat, y_test)
predict_data['Producer'].append(i + 1)
predict_data['Model'].append(model_namer(crmp))
predict_data['tau_initial'].append(p0[0])
predict_data['tau_final'].append(crmp.tau_)
predict_data['f1_initial'].append(p0[1])
predict_data['f1_final'].append(crmp.gains_[0])
predict_data['f2_initial'].append(p0[2])
predict_data['f2_final'].append(crmp.gains_[1])
predict_data['f3_initial'].append(p0[3])
predict_data['f3_final'].append(crmp.gains_[2])
predict_data['f4_initial'].append(p0[4])
predict_data['f4_final'].append(crmp.gains_[3])
predict_data['r2'].append(r2)
predict_data['MSE'].append(mse)
# Fitting
fit_df = pd.DataFrame(fit_data)
fit_df.to_csv(fit_ouput_file)
# Prediction
predict_df = pd.DataFrame(predict_data)
predict_df.to_csv(predict_output_file)
def test_fit_two_injectors(self):
X, y = production_rate_dataset(q, inj1, inj2)
crmp = CRMP().fit(X, y)
assert (crmp.tau_ is not None)
assert (crmp.tau_ > 1 and crmp.tau_ < 100)
assert (crmp.gains_ is not None)
assert (len(crmp.gains_) == 2)
f1 = crmp.gains_[0]
f2 = crmp.gains_[1]
assert (0 <= f1 <= 1)
assert (0 <= f2 <= 1)
sum_of_gains = f1 + f2
assert (abs(1 - sum_of_gains) <= 1.e-2)
def fit_all_producers():
for i in range(number_of_producers):
producer = producers[i]
X, y = production_rate_dataset(producer, *injectors)
X_train, X_test, y_train, y_test = train_test_split(
X, y, train_size=0.5, shuffle=False
)
crmp = CRMP(q0=producer[0])
crmp = crmp.fit(X_train, y_train)
print('Producer {}'.format(i + 1))
print('Tau: {}'.format(crmp.tau_))
print('Gains: {}'.format(crmp.gains_))
print()
def fit_individual_initial_guesses():
producer = producers[2]
X, y = production_rate_dataset(producer, *injectors)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
train_size=0.5,
shuffle=False)
crmp = CRMP(p0=[1e-03, 0.4, 0.6])
crmp = crmp.fit(X_train, y_train)
y_hat = crmp.predict(X_train)
r2, mse = fit_statistics(y_hat, y_train)
print(crmp.tau_)
print(crmp.gains_)
print(mse)
def minimum_train_size():
data_sizes = np.linspace(1, 148, 148).astype(int)
for data_size in data_sizes:
X, y = production_rate_dataset(producers[3], *injectors)
X_train, X_test, y_train, y_test = train_test_split(
X, y, train_size=data_size, shuffle=False)
crmp = CRMP(p0=[5, 0.5, 0.5])
crmp = crmp.fit(X_train, y_train)
y_hat = crmp.predict(X_test)
r2, mse = fit_statistics(y_hat, y_test)
if np.log(mse) < 11.0581424463:
print(data_size)
print(mse)
return
def test_fit_four_injectors(self):
X, y = production_rate_dataset(q, inj1, inj2, inj3, inj4)
crmp = CRMP().fit(X, y)
assert (crmp.tau_ is not None)
assert (crmp.tau_ > 1 and crmp.tau_ < 100)
assert (crmp.gains_ is not None)
assert (len(crmp.gains_) == 4)
f1 = crmp.gains_[0]
f2 = crmp.gains_[1]
f3 = crmp.gains_[2]
f4 = crmp.gains_[3]
assert (0 <= f1 <= 1)
assert (0 <= f2 <= 1)
assert (0 <= f3 <= 1)
assert (0 <= f4 <= 1)
sum_of_gains = f1 + f2 + f3 + f4
assert (abs(1 - sum_of_gains) <= 1.e-2)
def fit_all_producers():
for i in range(number_of_producers):
producer = producers[i]
X, y = production_rate_dataset(producer, *injectors)
q = X[:, 0].reshape(150, 1)
delta_p = np.zeros((len(X), 1))
inj1 = X[:, 1].reshape(150, 1)
inj2 = X[:, 2].reshape(150, 1)
X = np.hstack((q, delta_p, inj1, inj2))
X_train, X_test, y_train, y_test = train_test_split(X,
y,
train_size=0.5,
shuffle=False)
crmp = CrmpBHP(q0=producer[0])
crmp = crmp.fit(X_train, y_train)
print('Producer {}'.format(i + 1))
print('Tau: {}'.format(crmp.tau_))
print('Gains: {}'.format(crmp.gains_))
print()
i = 3
producer = producers[i]
producer += np.random.normal(loc=0.0, scale=25, size=len(producer))
name = producer_names[i]
print(name)
activations = ['sigmoid', 'relu', 'elu', 'tanh']
optimizers = ['adam', 'adagrad', 'sgd']
epochs = [5, 10, 20]
batches = [32, 64, 128]
input_layers = [128, 256]
layer_1s = [64, 128]
layer_2s = [64, 128]
X, y = production_rate_dataset(producer, *injectors)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
train_size=0.5,
shuffle=False)
X_train = np.array(X_train)
X_train_scaled = deepcopy(X_train)
y_train_scaled = deepcopy(y_train)
X_test_scaled = deepcopy(X_test)
y_test_scaled = deepcopy(y_test)
scaler = MinMaxScaler()
X_train_scaled = scaler.fit_transform(X_train)
y_train_scaled = scaler.fit_transform(y_train.reshape(-1, 1))
X_test_scaled = scaler.fit_transform(X_test)
def test_predict_unfitted_crmp_raises_error(self):
X, y = production_rate_dataset(q, inj1, inj2, inj3)
crmp = CRMP()
with pytest.raises(NotFittedError):
crmp.predict(X)
def test_fit_X_y_different_shape(self):
X, y = production_rate_dataset(q, inj1, inj2, inj3)
X = X[:-2]
with pytest.raises(ValueError):
crmp = CRMP().fit(X, y)
train_size=0.8,
random_state=1,
shuffle=False)
koval = Koval().fit(X=X_train, y=y_train)
y_hat = koval.predict(X_train)
time = np.linspace(1, len(y_hat), num=len(y_hat))
for k in range(len(y_hat)):
koval_fitting_data['Model'].append(model_namer(koval))
koval_fitting_data['t_i'].append(k + 1)
koval_fitting_data['Fit'].append(y_hat[k])
pickled_model = serialized_model_path('koval', koval)
with open(pickled_model, 'wb') as f:
pickle.dump(koval, f)
X, y = production_rate_dataset(f_w, W_t)
train_split, test_split, train_test_seperation_idx = forward_walk_splitter(
X, y, 2)
X_train = X[:train_test_seperation_idx]
y_train = y[:train_test_seperation_idx]
models = [BayesianRidge(), ElasticNetCV, LassoCV, LinearRegression()]
for model in models:
if is_CV_model(model):
model = train_model_with_cv(X, y, model, train_split)
model = model.fit(X_train, y_train)
y_hat = model.predict(X_train)
time = np.linspace(1, len(y_hat), num=len(y_hat))
for k in range(len(y_hat)):
koval_fitting_data['Model'].append(model_namer(model))
koval_fitting_data['t_i'].append(k + 1)
koval_fitting_data['Fit'].append(y_hat[k])
def convergence_sensitivity_analysis():
t = time[1:]
iterations = 0
for i in range(number_of_producers):
X, y = production_rate_dataset(producers[i], *injectors)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
train_size=0.5,
shuffle=False)
train_length = len(y_train)
test_length = len(y_test)
train_time = t[:train_length]
test_time = t[train_length:]
# plt.plot(train_time, y_train, c='r', label='Fit')
# plt.plot(test_time, y_test, c='g', label='Predict')
# plt.plot(t, y, c='k', label='Actual')
for p0 in param_grid['p0']:
crmp = CRMP(p0=deepcopy(p0))
crmp = crmp.fit(X_train, y_train)
# Fitting
y_hat = crmp.predict(X_train)
# plt.plot(train_time, y_hat, alpha=0.01, c='r', linewidth=2)
r2, mse = fit_statistics(y_hat, y_train)
fit_data['Producer'].append(i + 1)
fit_data['Model'].append(model_namer(crmp))
fit_data['tau_initial'].append(p0[0])
fit_data['tau_final'].append(crmp.tau_)
fit_data['f1_initial'].append(p0[1])
fit_data['f1_final'].append(crmp.gains_[0])
fit_data['f2_initial'].append(p0[2])
fit_data['f2_final'].append(crmp.gains_[1])
fit_data['r2'].append(r2)
fit_data['MSE'].append(mse)
# Prediction
y_hat = crmp.predict(X_test)
# plt.plot(test_time, y_hat, alpha=0.01, c='g', linewidth=2)
r2, mse = fit_statistics(y_hat, y_test)
predict_data['Producer'].append(i + 1)
predict_data['Model'].append(model_namer(crmp))
predict_data['tau_initial'].append(p0[0])
predict_data['tau_final'].append(crmp.tau_)
predict_data['f1_initial'].append(p0[1])
predict_data['f1_final'].append(crmp.gains_[0])
predict_data['f2_initial'].append(p0[2])
predict_data['f2_final'].append(crmp.gains_[1])
predict_data['r2'].append(r2)
predict_data['MSE'].append(mse)
iterations += 1
print(iterations)
# plt.vlines(76, 0, 1000, linewidth=1, alpha=0.8)
# plt.title(producer_names[i])
# plt.xlabel('Time')
# plt.ylabel('Production Rate')
# plt.legend()
# plt.show()
# Fitting
fit_df = pd.DataFrame(fit_data)
fit_df.to_csv(fit_ouput_file)
# Prediction
predict_df = pd.DataFrame(predict_data)
predict_df.to_csv(predict_output_file)