import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score
#sns.set_style('darkgrid')
plt.style.use('ggplot')
import warnings
warnings.filterwarnings('ignore')
# Auto completer
%config Completer.use_jedi = False
np.random.seed(0)
syn_data = [{"Qo": np.random.uniform(5, 1501, 250), "TVD": np.random.uniform(100, 16001, 250),
"API": np.random.uniform(8, 15, 250), "Temperature": np.random.uniform(100, 351, 250),
"Azimuthal_Angle": np.random.uniform(0, 21, 250), "AL_Method": "Rod Pump"},
{"Qo": np.random.uniform(100, 10001, 200), "TVD": np.random.uniform(5000, 15001, 200),
"API": np.random.uniform(15, 30, 200), "Temperature": np.random.uniform(100, 401, 200),
"Azimuthal_Angle": np.random.uniform(0, 71, 200), "AL_Method": "Gas Lift"},
{"Qo": np.random.uniform(50, 4001, 165), "TVD": np.random.uniform(5000, 15001, 165),
"API": np.random.uniform(8, 30, 165), "Temperature": np.random.uniform(100, 501, 165),
"Azimuthal_Angle": np.random.uniform(0, 91, 165), "AL_Method": "Hydraulic Pump"},
{"Qo": np.random.uniform(100, 30001, 325), "TVD": np.random.uniform(5000, 15001, 325),
"API": np.random.uniform(10, 35, 325), "Temperature": np.random.uniform(100, 401, 325),
"Azimuthal_Angle": np.random.uniform(0, 81, 325), "AL_Method": "ESP"},
{"Qo": np.random.uniform(5, 2201, 200), "TVD": np.random.uniform(2000, 10001, 200),
"API": np.random.uniform(10, 35, 200), "Temperature": np.random.uniform(75, 251, 200),
"Azimuthal_Angle": np.random.uniform(0, 91, 200), "AL_Method": "PCP"}]
data = pd.DataFrame()
for values in syn_data:
df = pd.DataFrame(values)
data = pd.concat([data, df], ignore_index=True)
data
data.AL_Method.value_counts()
columns = ['Qo', 'TVD', 'API', 'Temperature', 'Azimuthal_Angle']
for column in columns:
data[column] = data[column].round(decimals=3)
data
# Rename columns
data.rename(columns={'Qo':'Qo (bpd)', 'TVD':'TVD (ft)', 'Temperature':'Temperatura (F)',
'Azimuthal_Angle':'Ángulo de incl', 'AL_Method':'Método de LA'}, inplace=True)
data
data.info()
data.describe()
data["Qo (bpd)"] = data["Qo (bpd)"].astype('float64')
data["TVD (ft)"] = data["TVD (ft)"].astype('float64')
data["API"] = data["API"].astype('float64')
data["Temperatura (F)"] = data["Temperatura (F)"].astype('float64')
data["Ángulo de incl"] = data["Ángulo de incl"].astype('float64')
data.info()
data
fig, ax = plt.subplots(figsize=(14,8))
sns.heatmap(data.isnull(), cmap='gist_heat')
ax.set_xticklabels(ax.get_xticklabels(), rotation=45, fontsize=12)
plt.show()
# Pair plot
pair_plot = sns.pairplot(data=data, hue="Método de LA", height=1.5)
plt.savefig('tenca.png')
def box_plots(data, h_column, v_column):
fig, ax = plt.subplots(figsize=(10, 8))
sns.boxplot(data=data, x=h_column, y=v_column, ax=ax)
ax.set_xlabel("")
ax.set_ylabel(v_column, fontsize=12)
ax.set_xticklabels(ax.get_xticklabels(), fontsize=12)
ax.set_title('Boxplot: {} VS Métodos de LA'.format(v_column), fontname="Times New Roman", size=16, fontweight='bold')
plt.show()
props = ["Qo (bpd)", "TVD (ft)", "API", "Temperatura (F)", "Ángulo de incl"]
fig, ax = plt.subplots(len(props),1, figsize=(10,25))
for axes, prop in zip(ax, props):
sns.boxplot(data=data, x="Método de LA", y=prop, ax=axes)
axes.set_xlabel("")
axes.set_ylabel(prop, fontsize=12)
axes.set_xticklabels(axes.get_xticklabels(), fontsize=12)
axes.set_title('Boxplot: {} VS Métodos de LA'.format(prop), fontname="Times New Roman", size=16, fontweight='bold')
plt.tight_layout()
sns.displot(data=data, x="Qo (bpd)", hue="Método de LA")
plt.show()
#fig, ax = plt.subplots(5,1, figsize=(8,20))
props = ["Qo (bpd)", "TVD (ft)", "API", "Temperatura (F)", "Ángulo de incl"]
fig, ax = plt.subplots(len(props),1, figsize=(10,25))
for axes, prop in zip(ax, props):
sns.kdeplot(data=data, x=prop, shade=True, ax=axes)
axes.set_xlabel(prop, fontsize=12)
axes.set_title(f'Función de densidad de probabilidades: {prop}', fontname="Times New Roman", size=16, fontweight='bold')
plt.tight_layout()
# Pearson correlation
corr = data.corr()
# Heatmap of pearson's correlations
fig, ax = plt.subplots(figsize=(14,8))
sns.heatmap(data=corr, cmap='RdYlGn', annot=True, linewidths=0.01, linecolor='black', square=True, ax=ax)
ax.set_xticklabels(ax.get_xticklabels(), rotation=30, fontsize=12)
ax.set_yticklabels(ax.get_yticklabels(), rotation=30, fontsize=12)
plt.show()
fig.savefig('correlation matrix.png')
# Feature Selection (Feature importance)
X = data.iloc[:,:4].values #Feature Variables
y = data.iloc[:,-1] # Target Variable
# Split the data in training and testing dataset
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=42)
# Call the Machine Learning Algorithms for Classfication
knn = KNeighborsClassifier()
decision_tree = DecisionTreeClassifier()
svc = SVC()
rf = RandomForestClassifier()
# Define the hyperparameters to tune for each algorithm
knn_params = {'n_neighbors': np.arange(1, 30)}
dt_params = {'max_depth': np.arange(2,20,1)}
svc_params= {'C': [0.001, 0.01, 0.1, 1, 10, 100]}
rf_params = {'max_depth': np.arange(0.1, 1.1, 0.1)}
# Function to train each algorithm
def training_model(model, param_grid):
model = GridSearchCV(model, param_grid=param_grid, scoring='accuracy')
model.fit(X_train, y_train)
return model
# KNN Algorithm
knn_model = training_model(knn, knn_params)
knn_model.best_params_
knn_model_final = knn_model.best_estimator_.fit(X_train, y_train)
# Prediction on test set
y_pred_knn = knn_model_final.predict(X_test)
# Accuracy of model
print(knn_model_final.score(X_train, y_train))
print(knn_model_final.score(X_test, y_test))
# Accuracy
accuracy_knn = accuracy_score(y_test, y_pred_knn)
print(accuracy_knn)
# Plot of Accuracy vs K values using the training and testing data
# Function to plot Accuracy vs main hyperparameter of each algorithm
def evaluation_plot_knn(init, stop, step, algorithm):
fig, ax = plt.subplots(figsize=(15,8))
param = np.arange(init, stop, step)
train_accuracy = np.empty(len(param))
test_accuracy = np.empty(len(param))
for i, k in enumerate(param):
model = algorithm(n_neighbors=k)
model.fit(X_train, y_train)
train_accuracy[i] = model.score(X_train, y_train)
test_accuracy[i] = model.score(X_test, y_test)
ax.plot(param, test_accuracy, label = 'Prueba')
ax.plot(param, train_accuracy, label = 'Entrenamiento')
plt.legend(fontsize=12)
ax.set_xlabel('K neighbors', size=12)
ax.set_ylabel('Accuracy')
ax.set_title('Accuracy Vs K neighbors', fontname="Times New Roman", size=16, fontweight='bold')
plt.show()
evaluation_plot_knn(1, 30, 1, KNeighborsClassifier)
# Decision tree algorithm
dt_model = training_model(decision_tree, dt_params)
dt_model.best_params_
dt_model_final = dt_model.best_estimator_.fit(X_train, y_train)
# Prediction on test set
y_pred_dt = dt_model_final.predict(X_test)
# Accuracy of model
print(dt_model_final.score(X_train, y_train))
print(dt_model_final.score(X_test, y_test))
# Accuracy
accuracy_dt = accuracy_score(y_test, y_pred_dt)
print(accuracy_dt)
def evaluation_plot_tree(init, stop, step, algorithm):
fig, ax = plt.subplots(figsize=(15,8))
max_depth = np.arange(init, stop, step)
train_accuracy = np.empty(len(max_depth))
test_accuracy = np.empty(len(max_depth))
for i, k in enumerate(max_depth):
Dt = DecisionTreeClassifier(max_depth=k)
Dt.fit(X_train, y_train)
train_accuracy[i] = Dt.score(X_train, y_train)
test_accuracy[i] = Dt.score(X_test, y_test)
ax.plot(max_depth, test_accuracy, label = 'Prueba')
ax.plot(max_depth, train_accuracy, label = 'Entrenamiento')
plt.legend(fontsize=12)
ax.set_xlabel('Max depth', size=12)
ax.set_ylabel('Accuracy')
ax.set_title('Accuracy Vs Max depth', fontname="Times New Roman", size=16, fontweight='bold')
plt.show()
evaluation_plot_tree(2, 20, 1, DecisionTreeClassifier)
# Support vector classifier algorithm
svc_model = training_model(svc, svc_params)
svc_model.best_params_
svc_model_final = svc_model.best_estimator_.fit(X_train, y_train)
# Prediction on test set
y_pred_svc = svc_model_final.predict(X_test)
# Accuracy of model
print(svc_model_final.score(X_train, y_train))
print(svc_model_final.score(X_test, y_test))
# Accuracy
accuracy_svc = accuracy_score(y_test, y_pred_svc)
print(accuracy_svc)
fig, ax = plt.subplots(figsize=(15,8))
C_values = [0.001, 0.01, 0.1, 1, 10, 100]
train_accuracy = np.empty(len(C_values))
test_accuracy = np.empty(len(C_values))
for i, k in enumerate(C_values):
svc = SVC(C=k)
svc.fit(X_train, y_train)
train_accuracy[i] = svc.score(X_train, y_train)
test_accuracy[i] = svc.score(X_test, y_test)
ax.plot(C_values, test_accuracy, label = 'Prueba')
ax.plot(C_values, train_accuracy, label = 'Entrenamiento')
plt.legend(fontsize=12)
ax.set_xlabel('C', fontsize=12)
ax.set_ylabel('Accuracy')
ax.set_xticklabels(C_values)
ax.set_title('Accuracy Vs C', fontname="Times New Roman", size=16, fontweight='bold')
plt.show()
fig.savefig('svc.png')
# Support vector classifier algorithm
rf_model = training_model(rf, rf_params)
rf_model.best_params_
rf_model_final = rf_model.best_estimator_.fit(X_train, y_train)
# Prediction on test set
y_pred_rf = rf_model_final.predict(X_test)
# Accuracy of model
print(rf_model_final.score(X_train, y_train))
print(rf_model_final.score(X_test, y_test))
# Accuracy
accuracy_rf = accuracy_score(y_test, y_pred_rf)
print(accuracy_rf)
def evaluation_plot_forest(init, stop, step, algorithm, max_depth):
fig, ax = plt.subplots(figsize=(15,8))
param = np.arange(init, stop, step)
train_accuracy = np.empty(len(param))
test_accuracy = np.empty(len(param))
for i, k in enumerate(param):
model = algorithm(max_depth=k)
model.fit(X_train, y_train)
train_accuracy[i] = model.score(X_train, y_train)
test_accuracy[i] = model.score(X_test, y_test)
ax.plot(param, test_accuracy, label = 'Prueba')
ax.plot(param, train_accuracy, label = 'Entrenamiento')
plt.legend(fontsize=12)
ax.set_xlabel('Max depth', fontsize=12)
ax.set_ylabel('Accuracy')
ax.set_title('Accuracy Vs Max depth', fontname="Times New Roman", size=16, fontweight='bold')
plt.show()
evaluation_plot_forest(0.1, 1.1, 0.1, RandomForestClassifier, max_depth)
accuracy = [accuracy_knn, accuracy_dt, accuracy_svc, accuracy_rf]
algorithms = ['KNN', 'Decision Tree', 'SVC', 'Random Forest']
model_select = pd.DataFrame({'Model': algorithms, 'Accuracy': accuracy})
model_select
def method_recommended(model, qo, tvd, api, temp):
predict = model.predict(np.array([qo, tvd, api, temp]).reshape(1, -1))
return print(f'The AL method recommended is: {predict[0]}')
predict_1 = method_recommended(dt_model_final, 720, 10355, 29.6, 214)
predict_1
predic_2 = method_recommended(dt_model_final, 166, 10085, 30, 232)
predic_2
predic_3 = method_recommended(dt_model_final, 1071, 9681, 24.1, 222)
predic_3
predict_4 = method_recommended(dt_model_final, 411.4, 9612, 30.8, 215)
predict_4
features = list(data.columns)
features.pop(-1)
# Columns of Dataframe
columns = features + ['Wells', 'AL Method Predicted']
columns