LAPORAN PRAKTIKUM

ANALISIS DATA GEOFISIKA TG2207

MODUL 7
ESTIMASI DATA GEOFISIKA MENGGUNAKAN MACHINE LEARNING
Oleh:
Mutiara islamia 118120080

Asisten :
Lestari Sukma Apriliana 12117009
Mustika 12117025
Santo Tri Prabowo 12117041
Agastya Pramadya 12117094
Michael Febrian Mardongan 12117128
Didian Noveni Waruwu 12117131
Muhammad Ichsan 12117143
Fira Pratiwi Darsono 12117151

PROGRAM STUDI TEKNIK GEOFISIKA

JURUSAN TEKNOLOGI PRODUKSI DAN INDUSTRI
INSTITUT TEKNOLOGI SUMATERA
2021
I. Tujuan pratikum
1. Memahami konsep Machine Learning pada bidang geofisika.
2. Mampu menyajikan data geofisika agar dapat diolah menggunakan
Machine Learning.
3. Memahami cara kerja regresi data geofisika menggunakan Machine
Learning.
4. Menghasilkan suatu prediksi/estimasi data geofisika menggunakan
Machine Learning.
II. Dasar teori
 Pengertian
Machine Learning adalah salah satu disiplin ilmu dari Computer Science
yang mempelajari bagaimana membuat komputer/mesin itu mempunyai
suatu kecerdasan. Agar mempunyai suatu kecerdasan, komputer/mesin harus
dapat belajar. Machine Learning adalah suatu bidang keilmuan yang berisi
tentang pembelajaran komputer/mesin untuk menjadi cerdas.Pembelajaran
mesin atau machine learning memungkinkan komputer mempelajari
sejumlah data (learn from data) sehingga dapat menghasilkan suatu model
untuk melakukan proses input-output tanpa menggunakan kode program
yang dibuat secara eksplisit. Proses belajar tersebut menggunakan algoritma
khusus yang disebut machine learning algorithms. Terdapat banyak
algoritma machine learning dengan efisiensi dan spesifikasi kasus yang
berbeda-beda.
 Konsep Dasar dan Cara kerja Machine Learning
Secara fundamental cara kerja machine learning adalah belajar seperti
manusia dengan menggunakan contoh-contoh dan setelah itu barulah dapat
menjawab suatu pertanyaan terkait. Proses belajar ini menggunakan data
yang disebut train dataset. Berbeda dengan program statis, machine learning
diciptakan untuk membentuk program yang dapat belajar sendiri.
Dari data tersebut, komputer akan melakukan proses belajar (training) untuk
menghasilkan suatu model. Proses belajar ini menggunakan algoritma
machine learning sebagai penerapan teknik statistika. Model inilah yang
menghasilkan informasi, kemudian dapat dijadikan pengetahuan untuk
memecahkan suatu permasalahan sebagai proses input-output. Model yang
dihasilkan dapat melakukan klasifikasi ataupun prediksi ke depan.
Untuk memastikan efisiensi model yang terbentuk, data akan dibagi menjadi
data pembelajaran (train dataset) dan data pengujian (test dataset).
Pembagian data yang digunakan bervariasi bergantung algoritma yang
digunakan. Pada umumnya train dataset lebih banyak dari test dataset,
misalnya dengan rasio 3:1. Test dataset digunakan untuk menghitung
seberapa efisien model yang dihasilkan untuk melakukan klasifikasi atau
prediksi kedepan yang disebut test score. Semakin banyak data yang
 digunakan, test score yang dihasilkan semakin baik. Nilai test score berada
dalam rentang 0-1.
 Metode Algoritma Machine Learning

- Supervised machine learning algorithms

Supervised machine learning adalah algoritma machine learning yang
dapat menerapkan informasi yang telah ada pada data dengan
memberikan label tertentu, misalnya data klasifikasi sebelumnya
(terarah). Algoritma ini mampu memberikan target terhadap output yang
dilakukan dengan membandingkan pengalaman belajar di masa lalu.
- Unsupervised machine learning algorithms
Unsupervised machine learning adalah algoritma machine learning yang
digunakan pada data yang tidak mempunyai informasi yang dapat
diterapkan secara langsung (tidak terarah). Algoritma ini diharapkan
mampu menemukan struktur tersembunyi pada data yang tidak berlabel.
- Reinforcement machine learning algorithms
Reinforcement machine learning adalah algoritma yang mempunyai
kemampuan untuk berinteraksi dengan proses belajar yang dilakukan,
algoritma ini akan memberikan poin (reward) saat model yang diberikan
semakin baik atau mengurangi poin (error) saat model yang dihasilkan
semakin buruk. Salah satu penerapan yang sering dijumpai yaitu pada
mesin pencari.
 Model regresi
Light GBM
Light GBM adalah framework peningkatan gradien yang cepat,
terdistribusi, dan berperforma tinggi berdasarkan algoritme pohon
keputusan, yang digunakan untuk memberi peringkat, klasifikasi, dan
banyak tugas pembelajaran mesin lainnya.
Keunggulan Light GBM
1. Kecepatan pelatihan yang lebih cepat dan efisiensi yang lebih tinggi
GBM Ringan menggunakan algoritme berbasis histogram, yaitu
mengelompokkan nilai fitur berkelanjutan ke dalam kotak terpisah
yang mempercepat prosedur pelatihan.
2. Penggunaan memori yang lebih rendah: Mengganti nilai
berkelanjutan ke nampan terpisah yang menghasilkan penggunaan
memori yang lebih rendah.
3. Akurasi yang lebih baik daripada algoritme pendorong lainnya:
Algoritme ini menghasilkan pohon yang jauh lebih kompleks
dengan mengikuti pendekatan pemisahan daun daripada pendekatan
tingkat bijak yang merupakan faktor utama dalam mencapai akurasi
yang lebih tinggi. Namun, terkadang dapat menyebabkan overfitting
yang dapat dihindari dengan menyetel parameter max_depth.
4. Kompatibilitas dengan Kumpulan Data Besar: Ia mampu berkinerja
sama baiknya dengan kumpulan data besar dengan pengurangan
waktu pelatihan yang signifikan dibandingkan dengan XGBOOST.
5. Pembelajaran paralel didukung.

Linear regression

Linear regression adalah pendekatan linier yang menunjukan hubungan

sebab akibat antara dua atau lebih variabel. Linear regression menunjukan
bagaimana sebuah variable mempengaruhi variable lainnya dan sifatnya
adalah satu arah. Linear regression adalah cara yang paling umum untuk
menarik kesimpulan dan prediksi.

Proses Linear Regression

1. Mengumpulkan sample data.

2. Design model yang menjelaskan sample data.
3. Gunakan model untuk melakukan prediksi untuk population data.

Linear regression banyak sekali modelnya, model yang paling mudah adalah
Simple Linear Regression. Persamaannya adalah seperti berikut

y : dependent variable, nilai yang akan diprediksi.

x : independent variable, nilai yang digunakan untuk melakukan prediksi.

Linear regression umumnya dipresentasikan dalam graph line dengan titik-

titik disekitar garis tersebut. Objektif dari linear regression adalah membuat
garis prediksi sedekat mungkin dengan titik-titik tersebut.

Random Forest

Random Forest adalah model ansambel di mana ia membangun model

besar dengan beberapa model decision tree . Model kesalahan decision tree
diumpankan ke pohon lain untuk meminimalkan kesalahan klasifikasi
model. Ini memperkuat model dalam hal prediksi nilai data dengan
kemungkinan kesalahan yang lebih kecil.

Random Forest membantu meningkatkan efisiensi model karena

mengurangi kemungkinan kesalahan pelatihan dengan teknik ansambel yang
diterapkan padanya dengan proses bagging.
 Langkah-langkah untuk membangun Model Random Forest

1. Pilih beberapa titik data acak 'x' dari data pelatihan.

2. Bangun decision tree pada titik-titik data tersebut.
3. Pilih jumlah pohon yang akan dibangun dan ulangi langkah 1 dan 2.
4. Lebih lanjut, secara internal, kesalahan klasifikasi yang salah dari
setiap pohon keputusan dimasukkan ke pohon berikutnya dan ini
berlanjut hingga data habis.

Xgboost

XGBoost atau eXtreme Gradient Boosting adalah algoritma berbasis

pohon (Chen dan Guestrin, 2016 [2]). XGBoost adalah bagian dari keluarga
pohon (Decision tree, Random Forest, bagging, boosting, gradient boosting).

Boosting adalah metode ensembel dengan tujuan utama mengurangi

bias dan varians. Tujuannya adalah untuk membuat pohon yang lemah
secara berurutan sehingga setiap pohon baru (atau pelajar) berfokus pada
kelemahan (data yang salah diklasifikasikan) dari yang sebelumnya. Setelah
pelajar yang lemah ditambahkan, bobot data disesuaikan kembali, yang
dikenal sebagai "pembobotan ulang". Keseluruhan membentuk model yang
kuat setelah konvergensi karena koreksi otomatis setelah setiap pelajar baru
ditambahkan.

Kekuatan XGBoost adalah paralelisme dan pengoptimalan perangkat

keras. Data disimpan dalam memori, disebut blok, dan disimpan dalam
format kolom terkompresi [CSC]. Algoritma tersebut dapat melakukan
pemangkasan pohon untuk menghilangkan cabang yang probabilitasnya
rendah. Fungsi kerugian model memiliki istilah untuk menghukum
kompleksitas model dengan regularisasi untuk memperlancar proses
pembelajaran (mengurangi kemungkinan overfitting).

Model tersebut bekerja dengan baik bahkan dengan nilai yang hilang
atau banyak nilai nol dengan kesadaran ketersebaran. XGBoost
menggunakan algoritme yang disebut “algoritme sketsa kuantil berbobot”,
hal ini memungkinkan algoritme untuk fokus pada data yang salah
klasifikasi. Jumlah iterasi untuk proses boosting secara otomatis ditentukan
oleh algoritma dengan metode validasi silang terintegrasi.

Gradient Boosting

Gradient Boosting sebenarnya membuat prediksi pada residu pendahulu.

langkah-langkah modelnya:

1. Hal pertama yang dilakukan Gradient Boosting adalah dimulai

dengan Dummy Estimator. Pada dasarnya, ini menghitung nilai
rata-rata dari nilai target dan membuat prediksi awal. Menggunakan
prediksi, ini menghitung perbedaan antara nilai prediksi dan nilai
sebenarnya. Ini disebut residu.
2. Selanjutnya, alih-alih melatih estimator baru pada data untuk
memprediksi target, ia melatih estimator untuk memprediksi
residual dari prediktor pertama. Prediktor ini biasanya berupa Pohon
Keputusan dengan batasan tertentu, seperti jumlah maksimum
simpul daun yang diperbolehkan. Jika beberapa contoh residu
berada di simpul daun yang sama, itu mengambil rata-ratanya dan
menggunakannya sebagai nilai simpul daun.
3. Selanjutnya, untuk membuat prediksi, untuk setiap instance, ia
menambahkan nilai penduga dasar ke nilai sisa prediksi Decision
Tree dari instance tersebut untuk membuat prediksi baru. Kemudian
menghitung residual lagi antara nilai yang diprediksi dan nilai
sebenarnya.
4. Proses ini diulangi sampai ambang tertentu tercapai atau perbedaan
sisa sangat kecil.
5. Untuk membuat prediksi untuk contoh yang tidak terlihat, ini
memberikan contoh untuk setiap pohon keputusan yang dibuat,
 menjumlahkan prediksi mereka dan menambahkan nilai penduga
dasar.

Hyperparameter penting untuk diperhatikan di sini adalah kecepatan

pemelajaran . Ini sebenarnya menskalakan kontribusi setiap pohon, jadi pada
dasarnya meningkatkan bias dengan imbalan varian yang lebih rendah. Jadi
pada langkah 3 dan 4, nilai prediksi sebenarnya dikalikan dengan kecepatan
pembelajaran untuk mencapai generalisasi yang lebih baik pada data yang
tidak terlihat.

III. Langkah kerja dan diagram alir

 Langkah kerja
1. Siapkan data yang disediakan
2. Buka aplikasi google collab
3. Buat script yang telah ditentukan
- Input libraries yang diperlukan dalam kegiatan kali ini.
- Kemudian load and display the well-log datasets.
- Menampilkan informasi deskripsi statistik data sumur 1.
- Menampilkan informasi deskripsi statistic data sumur 2.
- Menampilkan plot data training dari well-data.
- Menampilkan plot data test dari well-data.
- Menampilkan jumlah data yang tidak memiliki nilai (-999.000).
- Mengganti data yang tidak memiliki nilai degan NaN.
- Menampilkan jumlah data yang tidak memiliki nilai.
- Kemudian tampilkan tabel analisis deskripsi statistic dari setiap sumur.
- Lakukan limitasi pada batas atas dan batas bawah.
- Filter data berdasarkan nilai depth dan diproses pada tahap EDA.
- Menampilkan crossplot dan histogram pada dua data sumur.
- Menampilkan data korelasi pada dua data sumur.
- Lakukan normalisasi pada rentang nilai dari setiap data log dengan
menggunakan metode yeo-jonhson.
 - Menampilkan kembali crossplot dan histogram pada dua data sumur
yang sudah di normalisasi.
- Lakukan pencilan terhadap trend data log (removing outliers) dengan
- menggunakan 5 metode, yaitu Standard Deviation, Isolation Forest,
Minimum Covarience Determinant, Local Outlier Factor, dan OneClass
SVM.
- Menampilkan kembali crossplot dan histogram pada dua data sumur
setelah dilakukan removing outliers.
- Untuk melalukan first prediction lakukan pendefinisian train data dan
test data terlebih dahulu.
- Masukkan Modul yang dibutuhkan.
- Create model Linear Regression.
- Create model Gradient Boosting Regressor.
- Create model Random Forest Regressor.
- Create model XBoost XGB Regressor.
- Create model LGBM Regressor.
- Prediksi nilai RMS Error.
- Kemudian buat transformer fit to the target dan Lakukan denormalisasi
pada y data test dan y data prediksi.
- Menampilkan plot kedua DT pada data well 1.
- Defenisikan data test dan kedalaman well Prediction.
- Lakukan normalisasi terhadap data test x dan prediksi data sumur pada y
prediksi kemudian denormalisasi kembali.
- Memplot predicted DT Well.
- Menampilkan data deskripsi statistic Well Predicted.
- Menampilkan data log kedua sumur pada final prediksi.
- Save data dengan format .csv.
4. Running setiap script yang dibuat.
5. Ss setiap hasil yang dikeluarkan.
6. Analisis setiap hasil
7. Selesai.
 Diagram alir

mulai

Buka aplikasi
collab

Input script

Running

selesai
IV. Hasil dan pembahasan

1. Deskriptif data sebelum penghapusan data yang tidak diketahui

- Script

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
!pip install lasio
import lasio
import glob
import os

#get all path and alphabetically ordered

paths=sorted(glob.glob(os.path.join("/content/", "*.LAS")))
well_df=[0]*2

for i in range(len(paths)):
#read with lasio
well=lasio.read(paths[i])
#convert to dataframe
df=well.df()
 #in this dataframe, depth is positioned as index, not as c
olumn
#so better to change depth index to column
well_df[i]=df.reset_index()

well1, well2=well_df

well1.describe()

Well2.describe()

- Hasil

 Data well 1

 Data well 2

Analisis:
Pada pratikum modul ini dilakukan estimasi data geofisika menggunakan machine
learning.pada tahap awal ini dilakukan proses untuk menampilkan data log
Lapangan Volve yang terletak 200 kilometer barat Stavanger di ujung Selatan sektor
Norwegia di Laut Utara. Adapun data sumur yang digunakan yaitu 15_9-F-
 11A.LAS sebagai data train dan 15_9-F-11B.LAS sebagai data test. Pada kedua data
tersebut dapat dilihat terlalu banyak data dan kemungkinan pada data tersebut
banyak data outlier. Untuk pengolahan tidak boleh data yang ditampilkan banyak
oulier maka data outlier harus direduksi agar data dapat ditampilkan dengan baik.
Maka dari itu pada pratikum ini dilakukan percobaan pengolahan data untuk
menghasilkan data yang baik.
2. Plot yang sebelum dinormalisasi

- Script

import glob
import os

#get all path and alphabetically ordered

paths=sorted(glob.glob(os.path.join("/content/", "*.LAS")))
well_df=[0]*2

for i in range(len(paths)):
#read with lasio
well=lasio.read(paths[i])
#convert to dataframe
df=well.df()
#in this dataframe, depth is positioned as index, not as c
olumn
#so better to change depth index to column
well_df[i]=df.reset_index()

well1, well2=well_df
- Hasil
 Train well data

- Script

# Display the test data

#well = well2 # test wells: well2, well5

# define what logs are we going to us

logs = ['NPHI', 'RHOB', 'GR', 'RT', 'PEF', 'CALI']
# create the subplots; ncols equals the number of logs
fig, ax = plt.subplots (nrows=1, ncols=len(logs), figsize=(1
3,10))
# looping each log to display in the subplots
colors = ['black', 'red', 'blue', 'green', 'purple', 'black'
]
for i in range (len(logs)):
if i == 3:
# for resistivity, semilog plot
ax[i].semilogx(well2[logs[i]], well2['DEPTH'], color=col
ors[i])
else:
# for non-resistivity, normal plot
ax[i].plot (well2[logs[i]], well2[ 'DEPTH'], color=color
s[i])
ax[i].set_title(logs[i])
ax[i].grid(True)
 ax[2].set_xlim(0, 200)
plt.tight_layout(1)
plt.show()

- Hasil
 Test well data

Analisis
Pada gambar 2 merupakan tampilan data well pertama dan kedua. Pada data pertama
didefiniskan data training. Data tersebut hanya dimasukkan 'NPHI', 'RHOB', 'GR',
'RT', 'PEF', 'CALI', 'DT Karena data itu yang hanya dibutuhkan. Untuk data
resistivitas datanya memakai logaritmik. Sehingga kita memakai semilog. Selain
resistivitas itu kita tidak memakai logaritmik. Untuk data gamma ray diinput nilai
sebesar 300 dikarenakan data aslinya mencapai ribuan dan itu kebanyak outlier
maka dari itu kita harus membatasinya atau diberi limit pada data agar tampilannya
beraturan. Sedangkan untuk data 2 didefinisikan data test. Pada tampilan data 2
sama dengan data 1 akan tetapi dapat kita lihat tidak ada data DT Karena pada data
nya memang tidak ada. Data ini diberikan nilai limit sebesar 200 agar data tersebut
lebih jelas.
3. Pengecekan data yang tidak ketahui pada data 1 dan data 2

- Script
print(well1.isna().sum())
 print('\n')
print(well2.isna().sum())
- Hasil

Data 1 Data 2
Analisis :

Pada tahap 3 ini dilakukan pengecekan data yang tidak diperlukan terlihat pada data
1 dibeberapa log banyak data yang tidak diketahui begitupun dengan data 2
ditemukan banyak data yang tidak diperlukan. Pengecekan data ini menggunakan
kondsep ISNA.
4. Memotong data yang tidak digunakan

- Script

well1=well1.replace(-999.000, np.nan).dropna()
well2=well2.replace(-999.000, np.nan).dropna()
print(well1.isna().sum())
print(well1.shape)
print('\n')
print(well2.isna().sum())
print(well2.shape)

- Hasil

data 1 data 2
 Analisis :
pada tahap ini dilakukan pemotongan data pertama dan kedua atau menghilangkan
data yang tidak diperlukan dengan konsep NaN (not a number). Konsep ini
mengahsilkan nilai 0 hal ini berarti data yang tidak diperlukan sudah hilang.

5. Deskriptif data yang telah dilakukan penghapusan data yang tidak diketahui

- Script

well1.describe()

- Hasil
 Data well 1

- Script

well1.describe()

- Hasil
 Data well 2

Analisis :
Tahap ini merupakan tampilan data 1 dan 2 setelah dilakukan pemotongan data yang
tidak diperlukan. Dapat dilihat antara kedua data jumlah data nya lebih sedikit dari
data sebelum dilakukan pemotongan.
6. Data dengan limitasi upper dan down

- Script

# lower limit
low = [2582.9, 3227.9]
# upper limit
up = [3723.1, 4744.7]
# train columns to use
train_cols = ['DEPTH', 'NPHI', 'RHOB', 'GR', 'RT', 'PEF',
'CALI', 'DT']
# test columns to use
test_cols = ['DEPTH', 'NPHI', 'RHOB', 'GR', 'RT', 'PEF', '
CALI']
well_df_restrict=[0]*2
for i in range(len(well_df)):
# restrict depth within the given lower and upper limit
df=well_df[i].loc[(well_df[i]['DEPTH'] >= low[i]) & (wel
l_df[i]['DEPTH'] <= up[i])]
if i == 0 or i == 2 or i == 3:
# the train data, drop unwanted columns
well_df_restrict[i] = df[train_cols]
else:
# the test data, drop unwanted columns
well_df_restrict[i] = df[test_cols]
well1, well2 = well_df_restrict # as we can see, both ends
already not have NaNs
well2
 - Hasil

Data 1

Data 2
Analisis :
Pada tahap ini ditampilkan data 1 dan data 2 yang telah diberikan limitasi atas dan
limitasi bawah berdasarkan depth .Lower limit = [data 1= 2582.9, data 2= 3227.9],
upper limit = [data 1= 3723.1, data 2= 4744.7]. maka dihasilkan tabel yang
berisikan beberapa data yang telah dilimimtasi.
7. Hasil training dan prediksi

- Script

well_train=well1
well_pred=well2
depth_train, depth_pred= well_train.pop('DEPTH'), well_pre
d.pop('DEPTH')
well_train['DEPTH'], well_pred['DEPTH']=depth_train, depth
_pred

well_pred
- Hasil

Analisis :
Pada proses ini dilakukan pemindahan posisi data depth dari ujung kiri kekanan
karna langkah selanjutnya kita hanya memerlukan data NPHI RHOB GR RT
PEF CALI. Pada tahap ini hanya dilakukan pendefinisian untuk data 2 maka dari itu
hasil yang ditampilkan tidak terdapat data DT. Data yang telah difilter berdasarkan
nilai depth maka akan diproses pada tahap eksplorasi data analisis.
8. Eksplorasi data analisis

- Script
train_features = ['NPHI', 'RHOB', 'GR', 'RT', 'PEF', 'CALI
', 'DT']
sns.pairplot(well_train, vars=train_features, diag_kind='k
de',
plot_kws = {'alpha': 0.6, 's': 30, 'edgecolor': 'k'})
- Hasil

Crossplot
 - Script

well_train_only_features=well_train[train_features]
# Generate a mask for the upper triangle
mask = np.zeros_like(well_train_only_features.corr(method
= 'spearman'), dtype=np.bool)
mask[np.triu_indices_from(mask)] = True
# Generate a custom diverging colormap
cmap = sns.cubehelix_palette(n_colors=12, start=-
2.25, rot=-1.3, as_cmap=True)
# Draw the heatmap with the mask and correct aspect ratio
plt.figure(figsize=(12,10))
sns.heatmap(well_train_only_features.corr (method = 'spear
man') ,annot=True, mask=mask, cmap=cmap, vmax=.3, square=T
rue)
plt.show()

- Hasil

hitmap
Analisis :
Pada eksplorasi data analisis ini dilakukan tampilan hasil crossplot antar 2 data ,
histogram pada masing-masing data log, dan korelasi antar dua atribut
menggunakan metode spearman. Tahap ini dimasukkan sebanyak tujuh data dimana
 pada masing – masing data menghasilkan crossplot yang berbeda-beda. Pada
beberapa data dapat terlihat banyaknya outlier yang tersebar dan pada histogram
nya. Selain itu terdapat juga histogram yang memberikan informasi distribusi
normal.pada tahap EDA ini juga ditampilkan hitmap yang menggambarkan korelasi
antara data satu dengan data yang lainnya. Pada hitmap dapat dilihat bahwa korealsi
yang paling baik ditunjukkan pada warna yang lebih gelap sedangkan korealsi yang
paling baik ditunjukkan pada warna yang lebih terang. Seperti yang kita ketahui
bahwa korealsi yang paling baik adalah yang mendekati satu sedangkan korealsi
yang paling buruk adalah yang mendekati 0.
9. Normalisasi data
- Script
colnames=well_train.columns

only_feature=['NPHI','RHOB','GR','RT','PEF','CALI']
only_target='DT'
feature_target=np.append(only_feature,only_target)
colnames
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import PowerTransformer
# transform the RT to logarithmic
well_train['RT'] = np.log10(well_train['RT'])
# normalize using power transform Yeo-Johnson method
scaler = PowerTransformer (method='yeo-johnson')
## ColumnTransformer
column_drop = ['DEPTH']
ct = ColumnTransformer([('transform', scaler, feature_target
)], remainder='passthrough')
## fit and transform
well_train_norm = ct.fit_transform(well_train)
## convert to dataframe
well_train_norm = pd.DataFrame (well_train_norm, columns=col
names)
well_train_norm
 - Hasil

Analisis :
Normalisasi dilakukan untuk membuat data log memiliki nilai yang sama. Data yang
diinput adalah data yang tujuh tadi. Target pada normalisasi ini adalah data DT.
Karena untuk testing yang kita cari adalah data DT. Pada normalisasi ini digunakan
metode yeo-jonhson. Dapat dilihat hasil dari normalisasi ini menghasilkan nilai pada
tabel hanya nilai kurang lebih 1 dan 0.
10. Crossplot normalisasi

- Script

# x = well_train_norm[feature_target].astype(float)
sns.pairplot(well_train_norm, vars=feature_target, diag_kind
= 'kde',
plot_kws = {'alpha': 0.6, 's': 30, 'edgecolor':
'k'})
- Hasil

Analisis :
Pada crossplot ini dapat dilihat bahwa dibeberapa korelasi antar 2 data sudah
menampilkan hasil yang baik dengan outlier yang minimum. Selain itu histogram
nya menunjukkan distribusi datanya bagus.
11. Penghapusan oulier

- Script

#make copy of well_train_norm, called well_train_dropped

well_train_drop = well_train_norm.copy()

#on the well_train_drop, drop WELL and DEPTH column

well_train_drop = well_train_norm.drop(['DEPTH'], axis = 1)
from sklearn.ensemble import IsolationForest
from sklearn.covariance import EllipticEnvelope
from sklearn.neighbors import LocalOutlierFactor
from sklearn.svm import OneClassSVM
# Method 1: Standard Deviation Method (traditional)
well_train_std = well_train_drop[np.abs(well_train_drop-
well_train_drop.mean()) <= (3*well_train_drop.std())]
## delete all rows that have NaNs
well_train_std = well_train_std.dropna()
# Method 2: Isolation Forest
iso = IsolationForest(contamination=0.5)
yhat = iso.fit_predict(well_train_drop)
mask = yhat != -1
well_train_iso = well_train_norm[mask]
# Method 3: Minimum Covariance Determinant
ee = EllipticEnvelope(contamination=0.1)
yhat = ee.fit_predict(well_train_drop)
mask = yhat != -1
well_train_ee = well_train_norm[mask]
# Method 4: Local Outlier Factor
lof = LocalOutlierFactor(contamination=0.3)
yhat = lof.fit_predict(well_train_drop)
mask = yhat != -1
well_train_lof = well_train_norm[mask]
# Method 5: One-class SVM
svm = OneClassSVM(nu=0.1)
yhat = svm.fit_predict(well_train_drop)
mask = yhat != -1
well_train_svm = well_train_norm[mask]
print('Number of points before a outliers removed :', len(we
ll_train_norm))
print('Number of points after outliers removed with Standard
Deviation:', len(well_train_std))
print('Number of points after outliers removed with Isolatio
n Forest :', len(well_train_iso))
print('Number of points after outliers removed with Min. Cov
ariance :', len(well_train_ee))
print('Number of points after outliers removed with Outlier
Factor :', len(well_train_lof))
print('Number of points after outliers removed with One-
class SVM :', len(well_train_svm))
plt.figure(figsize=(13,10))

plt.subplot(3,2,1)
well_train_norm[feature_target].boxplot()
plt.title('Before Outlier Removal', size=15)
plt.subplot(3,2,2)
well_train_std[feature_target].boxplot()
plt.title('After Outlier Removal with Standard Deviation Fil
ter', size=15)
plt.subplot(3,2,3)
well_train_iso[feature_target].boxplot()
plt.title('After Outlier Removal with Isolation Forest', siz
e=15)

plt.subplot(3,2,4)
well_train_ee[feature_target].boxplot()
plt.title('After Outlier Removal with Min. Covariance', size
=15)

plt.subplot(3,2,5)
well_train_lof[feature_target].boxplot()
plt.title('After Outlier Removal with Local Outlier Factor',
size=15)

plt.subplot(3,2,6)
well_train_svm[feature_target].boxplot()
plt.title('After Outlier Removal with One-
class SM', size=15)

plt.tight_layout(1.7)
plt.show()
 - Hasil

Analiisis
Pada tahap ini dilakukan penhapusan dan pemotongan pada data train nya. Gambar
diatas ditampilkan box plot sebelum dihapus outlier dan setelah dihapus oulier.
Digunakan penghapusan outlier menggunakan 5 metode yang mana masing –
masing metode dapat merepesentasikan hasilnya. Pada hasil bloxpot tersebut
metode yang dapat menghasilkan data dengan outlier yang minimum adalah metode
SM karena pada tampilannya metode SM yang mendapatkan nilai outlier kecil.
12. Crossplot penghapusan outlier

- Script

sns.pairplot(well_train_svm,vars=feature_target,
diag_kind='kde',
plot_kws={'alpha':0.6,'s':30,'edgecolor':'k'})
- Hasil

Analisis :
Pada hasil ini dapat dilihat bahwa crossplot ini sudah menampilkan data dengan
outlier yang minimum. Untuk data yang memiliki outlier kecil menurut saya yaitu
data DT dengan NPHI karena korelasi kedua data tersebut memunvulkan outlier
kecil dibandingkan data yang lainnya.
13. Prediction! First Attempt

- Script

#Define the train data

feature = ['NPHI', 'RHOB', 'GR', 'RT', 'PEF', 'CALI']
target = 'DT'

x_train = well_train_svm[only_feature].values
y_train = well_train_svm[only_target].values
x_test = well_train_norm[only_feature].values
y_test = well_train_norm[only_target].values
from sklearn.model_selection import train_test_split, GridSe
archCV
from sklearn.linear_model import LinearRegression, LogisticR
egression
from sklearn.ensemble import RandomForestRegressor, Gradient
BoostingRegressor
from sklearn.svm import SVR
from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import mean_squared_error
from sklearn.neighbors import KNeighborsRegressor

import xgboost
import lightgbm as lgb
#create the regressor
model = lgb.LGBMRegressor ()
#print(model)

##Hyperparameters
copy_X = [True]
#max_features = ['auto', 'sqrt']
fit_intercept = [True]
n_jobs = [-1,10]
normalize=[True]

param_grid = {'copy_X':copy_X,
'fit_intercept': fit_intercept,
'n_jobs' : n_jobs,
'normalize' : normalize }
##Randomized CV
model_random = GridSearchCV(model, param_grid, cv=3)
model_random.fit(x_train, y_train)
 ##print best model
model_random.best_params_
#predict on well 1
y_pred = model_random.predict(x_test)
print("R-
squared of Well 1: {}".format(model_random.score(x_test,y_
test)))
rmse = np.sqrt(mean_squared_error(y_test, y_pred))
print ("RMSE of Well 1: {}".format(rmse))

- Hasil

- RMS Error
 GradientBoostingRegressor

 Linearregressor

 RandomForestRegressor
  xgboost.XGBRegressor

 lgb.LGBMRegressor

- Plot DT predicted dan True Well 1

- Script
make the transformer fit to the target
y = well_train[target].values
scaler.fit(y.reshape(-1,1))
#denormalize y_test, y_pred
y_test, y_pred = scaler.inverse_transform(y_test.reshape(-
1,1)), scaler.inverse_transform(y_pred.reshape(-1,1))
x = [y_test, y_pred]
y = [well1['DEPTH'], well1['DEPTH']]
color = ['purple', 'green']
title = ['True DT Well 1', 'Predicted DT Well 1']
fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(7,12))
for i in range (len(x)):
ax[i].plot(x[i], y[i], color=color[i])
ax[i].set_xlim(50,150)
ax[i].set_ylim(np.max(y[i]), np.min(y[i]))
 ax[i].set_title(title[i])

plt.tight_layout(1)

plt.show

- Hasil

Analisis :
Pada tahap ini dilakukan pembuatan model regreresi. Disini menggunakan terrain
data atau well 1. Pada tahap ini digunakan variable x dan y untuk mendefiniskan
data. data X_train merupakan data dari hasil penhapusan outlir berupa ‘CALI’]
sedangkan y_train merupakan atribut hasil removing outlier yang berupa [‘DT’].
Selain itu terdapat variable X_test untuk pendefinisan data hasil normalisasi yang
berupa [‘NPHI’, ‘RHOB’, ‘GR’, ‘RT’, ‘PEF’, ‘CALI’] sedangkan y_test merupakan
atribut hasil normalisasi yang berupa [‘DT’]. Pada hasil ini juga ditampilkan hasil
RMS error dan R2 untuk ke 5 metode regresi yang ada. Dapat dilihat setiap nilai
RMS error dan R2 pada setiap metode berbeda – beda. Untuk nilai RMS Error yang
paling besar yaitu pada lgb.LGBMRegressor dan R2 yang paling besar adalah
gradientBoostingRegressor. Sedangkan untuk metode xboost.XGBRegressor ketika
di running terdapat beberapa peringatan yang dimungkinkan ada beberapa data yang
error atau tidak bisa dijalankan jika menggunakan metode ini. Dikarenakan nilai
log DT masih berupa data normalisasi maka dilakukan denormalisasi agar dapat
diketahui nilai log DT yang sebenarnya. Pada hasil diatas dapat juga dilihat hasil
plot antara data DT sebenarnya dan DT predicted. Hasil keduanya tidak terlau jauh
berbeda hal ini dimungkinkan data tersebut memiliki selisih nilai yang tidak jauh
berbeda. Pada tahap ini Setelah ditampilkan hasil pemodelan DT pada Well 1 yang
berwarna hijau kemudian dibandingkan dengan DT sebenarnya pada Well 1 yang
berwarna ungu terlihat bahwa sangat mirip diantara keduanya. Berarti metode dan
tahap yang kita kerjakan sudah benar. Walaupun ada beberapa bagian yang tidak
mirip tetapi grafiknya dominan terlihat sama. Untuk ke 5 metode regresi yang
digunakan hasil plot antara data DT sebenarnya dan DT predicted semuanya
mengeluarkan output yang sama. Hal ini dimungkinkan karena pada script ini hanya
menampilkan output depth karena nilai depth nya sama.
14. Final prediction

- Script

well_pred['DT'] = y_pred
well_pred

- Hasil
Tabel deskripsi statistic data well_pred
- Plot Data well bersih
- Script

#display the test data

#well = well_pred #test wells: well2, well5

#define what logs are we going to us

logs = ['NPHI', 'RHOB', 'GR', 'RT', 'PEF', 'CALI', 'DT']

#titles to show
title = ['NPHI', 'RHOB', 'GR', 'RT', 'PEF', 'CALI', 'Predict
ed DT']

#create the subplots; ncols equals the number of logs

fig, ax = plt.subplots(nrows=1, ncols=len(logs), figsize=(15
,10))
fig.suptitle('Well 15/9-F-118', size=20, y=1.05)

#looping each log to display in the subplots

colors = ['black', 'red', 'blue', 'green', 'purple', 'black'

, 'orange']

for i in range(len(logs)):
if i == 3:
# for resistivity, semilog plot
ax[i].semilogx(well_pred[logs[i]], well_pred['DEPTH'], c
olor=colors[i])
else:
#for non-resistivity, normal plot
ax[i].plot(well_pred[logs[i]], well_pred['DEPTH'], color
=colors[i])

ax[i].set_ylim(max(well_pred['DEPTH']), min(well_pred['DEP
TH']))
ax[i].set_title(title[i], pad=15)
ax[i].grid(True)

ax[2].set_xlim(0, 200)
plt.tight_layout(1)
plt.show()
- Hasil

 GradientBoostingRegressor
 Linearregressor
 RandomForestRegressor
 xgboost.XGBRegressor
  lgb.LGBMRegressor

Analisis :
Tahap ini adalah tahap final prediction dimana pada tahap ini diinput data test
berdasarkan data well 2 dan target yang diinput adalah DT untuk denoramlize data
hal ini dilakukan agar data DT dapat diprediksi pada data 2. Setelah dilakukan
prediksi DT pada Well 1, dilakukan juga prediksi DT pada Well 2 yang mana pada
data Well 2 memiliki keterbatasan data log DT (Delta T sonic). Tahap untuk
memprediksinya adalah pertama dilakukan normalisasi, kemudian tahap prediksi,
lalu tahap denormalisasi. Kemudian dibuat tampilan semua informasi log pada Well
2 termasuk DT yang sudah selesai dimodelkan yang ada pada gambar terakhir dari
hasil di atas. Hasil diatas juga dipengaruhi oleh inputan model regresi hal ini dapat
dilihat pada linearregressor yang relative lurus pada predictied DT well dan
predictied well nya.
V. Kesimpulan
Kesimpulan pada pratikum ini yaitu :
1. Machine Learning adalah salah satu disiplin ilmu dari Computer Science
yang mempelajari bagaimana membuat komputer/mesin itu mempunyai
suatu kecerdasan. Agar mempunyai suatu kecerdasan, komputer/mesin
harus dapat belajar. Machine Learning adalah suatu bidang keilmuan yang
berisi tentang pembelajaran komputer/mesin untuk menjadi cerdas.
2. Metode dalam mechine learning terdapat 3 yaitu Supervised machine
learning algorithms, Unsupervised machine learning algorithms,
Reinforcement machine learning algorithms.
3. Regresi merupakan suatu metode analisis statistic yang digunakan agar
dapat melihat pengaruh antara dua variabel atau lebih. Penerapan analisis
regresi ini pada machine learning adalah dengan mengaitkan data historis
dan label atau output yang saling berkaitan dan tidak berdiri sendiri.
4. Pada Machine learning dapat menghasilkan data prediksi/estimasi dengan
memastikan efisiensi model yang terbentuk dengan membagi data menjadi
dua, yakni data training dan data test.

Link

118120080_mutiaraislamia_modul7.ipynb - Colaboratory (google.com)

 DAFTAR PUSTAKA

Maiti, Tannistha. 2018. Machine Learning Applied to Geophysical Well Log Data.

Utami, Erna. 2017. Prediksi Zona Reservoir Berbasis Atribut Data Log Sumur Dengan
Metode Levenberg - Marquardt. Fakultas Teknologi Elektro. Institut Teknologi
Sepuluh November. Surabaya. Pp. 9-10.

Modul 7 praktikum ADG Institut Teknologi Sumatera

Apa itu Machine Learning? Beserta Pengertian dan Cara Kerjanya - Dicoding Blog

Random Forest in Python - JournalDev

Simple Linear Regression – Pendahuluan – SkillPlus

Apa itu XGBoost dan bagaimana cara mengoptimalkannya (ichi.pro)

Penjelasan langsung tentang Gradient Boosting Regression (ichi.pro)

LAMPIRAN
Maaf kak ini laporan yang benarnya kak. Laporan yang saya kirim sebelumnya
masih ada kekurangan dan sudah saya tambahkan kak.