Proyek Deteksi Penipuan Kartu Kredit – Proyek Pembelajaran Mesin

Selamat datang di proyek deteksi penipuan kartu kredit kami. Hari ini, kita akan menggunakan Python dan pembelajaran mesin untuk mendeteksi penipuan dalam kumpulan data transaksi kartu kredit. Meskipun kami telah membagikan kode untuk setiap langkah, akan lebih baik untuk memahami cara kerja setiap langkah dan kemudian menerapkannya.

Mari kita mulai!

Proyek Deteksi Penipuan Kartu Kredit Dengan Langkah

Dalam proyek deteksi penipuan kartu kredit kami, kami akan menggunakan Python, salah satu bahasa pemrograman paling populer yang tersedia. Solusi kami akan mendeteksi jika seseorang melewati dinding keamanan sistem kami dan melakukan transaksi tidak sah.

Dataset memiliki transaksi kartu kredit, dan fitur-fiturnya adalah hasil analisis PCA. Ini memiliki fitur 'Jumlah', 'Waktu', dan 'Kelas' di mana 'Jumlah' menunjukkan nilai moneter dari setiap transaksi, 'Waktu' menunjukkan detik yang berlalu antara transaksi pertama dan masing-masing, dan 'Kelas' menunjukkan apakah suatu transaksi itu sah atau tidak.

Di 'Kelas', nilai 1 mewakili transaksi penipuan, dan nilai 0 mewakili transaksi yang valid.

Anda bisa mendapatkan dataset dan seluruh kode sumber di sini .

Langkah 1: Impor Paket

Kami akan memulai proyek deteksi penipuan kartu kredit kami dengan menginstal paket yang diperlukan. Buat file 'main.py' dan impor paket-paket ini:

impor numpy sebagai np

impor panda sebagai pd

impor sklearn

dari norma impor scipy.stats

dari scipy.stats impor multivariate_normal

dari sklearn.preprocessing impor MinMaxScaler

impor matplotlib.pyplot sebagai plt

impor seaborn sebagai sns

Langkah 2: Cari Kesalahan

Sebelum kita menggunakan dataset, kita harus mencari kesalahan dan nilai yang hilang di dalamnya. Adanya nilai yang hilang dapat menyebabkan model Anda memberikan hasil yang salah, menjadikannya tidak efisien dan tidak efektif. Oleh karena itu, kita akan membaca dataset dan mencari nilai yang hilang:

df = pd.read_csv('creditcardfraud/creditcard.csv')

# nilai yang hilang

print(“nilai yang hilang:”, df.isnull().values.any())

Kami tidak menemukan nilai yang hilang dalam kumpulan data ini, sehingga kami dapat melanjutkan ke langkah berikutnya.

Bergabunglah dengan Kursus Kecerdasan Buatan online dari Universitas top Dunia – Magister, Program Pascasarjana Eksekutif, dan Program Sertifikat Tingkat Lanjut di ML & AI untuk mempercepat karier Anda.

Langkah 3: Visualisasi

Dalam langkah proyek pendeteksian penipuan kartu kredit ini, kami akan memvisualisasikan data kami. Visualisasi membantu dalam memahami apa yang data kami tunjukkan dan mengungkapkan pola apa pun yang mungkin kami lewatkan. Mari kita buat plot dari dataset kita:

# plot normal dan penipuan

count_classes = pd.value_counts(df['Class'], sort=True)

count_classes.plot(kind='bar', rot=0)

plt.title("Transaksi Terdistribusi")

plt.xticks(range(2), ['Normal', 'Penipuan'])

plt.xlabel("Kelas")

plt.ylabel("Frekuensi")

plt.tampilkan()

Dalam plot kami, kami menemukan bahwa data sangat tidak seimbang. Ini berarti kami tidak dapat menggunakan algoritme pembelajaran yang diawasi karena akan mengakibatkan overfitting. Selain itu, kami belum menemukan metode apa yang terbaik untuk menyelesaikan masalah kami, jadi kami akan melakukan lebih banyak visualisasi. Gunakan yang berikut ini untuk memplot peta panas:

# peta panas

sns.heatmap(df.corr(), vmin=-1)

plt.tampilkan()

Sekarang, kita akan membuat grafik distribusi data untuk membantu kita memahami dari mana data kita berasal:

ara, axs = plt.subplots(6, 5, squeeze=False)

untuk saya, kapak di enumerate(axs.flatten()):

ax.set_facecolor('xkcd:arang')

ax.set_title(df.columns[i])

sns.distplot(df.iloc[:, i], ax=ax, fit=norm,

color="#DC143C", fit_kws={"warna": "#4e8ef5"})

ax.set_xlabel()

fig.tight_layout(h_pad=-1.5, w_pad=-1.5)

plt.tampilkan()

Dengan grafik distribusi data, kami menemukan bahwa hampir setiap fitur berasal dari distribusi Gaussian kecuali 'Waktu'.

Jadi kami akan menggunakan distribusi Gaussian multivariat untuk mendeteksi penipuan. Karena hanya fitur 'Waktu' yang berasal dari distribusi bimodal (dan perhatikan distribusi gaussian), kami akan membuangnya. Selain itu, visualisasi kami mengungkapkan bahwa fitur 'Waktu' tidak memiliki nilai ekstrem seperti yang lain, yang merupakan alasan lain mengapa kami akan membuangnya.

Tambahkan kode berikut untuk menghapus fitur yang kita diskusikan dan skala lainnya:

kelas = df['Kelas']

df.drop(['Waktu', 'Kelas', 'Jumlah'], axis=1, inplace=True)

cols = df.columns.difference(['Kelas'])

MMscaller = MinMaxScaler()

df = MMscaller.fit_transform(df)

df = pd.DataFrame(data=df, kolom=kolom)

df = pd.concat([df, kelas], sumbu=1)

Langkah 4: Memisahkan Dataset

Buat file 'functions.py'. Di sini, kami akan menambahkan fungsi untuk mengimplementasikan berbagai tahapan algoritme kami. Namun, sebelum kita menambahkan fungsi-fungsi tersebut, mari kita pisahkan dataset kita menjadi dua set, set validasi dan set pengujian.

impor panda sebagai pd

impor numpy sebagai np

def train_validation_splits(df):

# Transaksi Penipuan

penipuan = df[df['Kelas'] == 1]

# Transaksi Normal

normal = df[df['Kelas'] == 0]

print('normal:', normal.shape[0])

print('penipuan:', penipuan.bentuk[0])

normal_test_start = int(normal.shape[0] * .2)

penipuan_test_start = int(fraud.shape[0] * .5)

normal_train_start = normal_test_start * 2

val_normal = normal[:normal_test_start]

val_fraud = penipuan[:fraud_test_start]

validasi_set = pd.concat([val_normal, val_fraud], axis=0)

test_normal = normal[normal_test_start:normal_train_start]

test_fraud = penipuan[fraud_test_start:fraud.shape[0]]

test_set = pd.concat([test_normal, test_fraud], axis=0)

Xval = validasi_set.iloc[:, :-1]

Yval = validasi_set.iloc[:, -1]

Xtest = test_set.iloc[:, :-1]

Ytest = test_set.iloc[:, -1]

train_set = normal[normal_train_start:normal.shape[0]]

Xtrain = train_set.iloc[:, :-1]

kembalikan Xtrain.to_numpy(), Xtest.to_numpy(), Xval.to_numpy(), Ytest.to_numpy(), Yval.to_numpy()

Langkah 5: Hitung Mean dan Matriks Kovarians

Fungsi berikut akan membantu kita menghitung mean dan matriks kovarians:

def estimasi_gaussian_params(X):

"""

Menghitung mean dan kovarians untuk setiap fitur.

Argumen:

X: kumpulan data

"""

mu = np.mean(X, sumbu=0)

sigma = np.cov(XT)

kembali mu, sigma

Langkah 6: Tambahkan Sentuhan Terakhir

Dalam file 'main.py' kami, kami akan mengimpor dan memanggil fungsi yang kami terapkan pada langkah sebelumnya untuk setiap set:

(Xtrain, Xtest, Xval, Ytest, Yval) = train_validation_splits(df)

(mu, sigma) = estimasi_gaussian_params(Xtrain)

# menghitung gaussian pdf

p = multivariat_normal.pdf(Xtrain, mu, sigma)

pval = multivariat_normal.pdf(Xval, mu, sigma)

ptest = multivariate_normal.pdf(Xtest, mu, sigma)

Sekarang kita harus mengacu pada epsilon (atau ambang batas). Biasanya, yang terbaik adalah menginisialisasi ambang dengan nilai minimum pdf dan meningkatkan setiap langkah hingga Anda mencapai pdf maksimum sambil menyimpan setiap nilai epsilon dalam sebuah vektor.

Setelah kami membuat vektor yang diperlukan, kami membuat loop 'untuk' dan mengulangi yang sama. Kami membandingkan ambang batas dengan nilai pdf yang menghasilkan prediksi kami di setiap iterasi.

Kami juga menghitung skor F1 sesuai dengan nilai kebenaran dasar dan prediksi kami. Jika skor F1 yang ditemukan lebih tinggi dari yang sebelumnya, kami mengganti variabel 'batas terbaik'.

Ingatlah bahwa kami tidak dapat menggunakan 'akurasi' sebagai metrik dalam proyek deteksi penipuan kartu kredit kami. Itu karena itu akan mencerminkan semua transaksi seperti biasa dengan akurasi 99%, membuat algoritme kami tidak berguna.

Kami akan menerapkan semua proses yang kami diskusikan di atas dalam file 'functions.py' kami:

metrik def (y, prediksi):

fp = np.sum(np.all([prediksi == 1, y == 0], sumbu=0))

tp = np.sum(np.all([prediksi == 1, y == 1], sumbu=0))

fn = np.sum(np.all([prediksi == 0, y == 1], sumbu=0))

presisi = (tp / (tp + fp)) jika (tp + fp) > 0 lain 0

ingat = (tp / (tp + fn)) jika (tp + fn) > 0 lain 0

F1 = (2 * presisi * ingat) / (presisi +

ingat) jika (presisi + ingat) > 0 lain 0

kembali presisi, ingat, F1

def pilihThreshold(yval, pval):

nilai_e = pval

terbaikF1 = 0

terbaikEpsilon = 0

untuk epsilon di e_values:

prediksi = pval < epsilon

(presisi, ingatan, F1) = metrik(yval, prediksi)

jika F1 > terbaikF1:

terbaikF1 = F1

terbaikEpsilon = epsilon

kembalikan Epsilon terbaik, F1 terbaik

Pada akhirnya, kami akan mengimpor fungsi dalam file 'main.py' dan memanggilnya untuk mengembalikan skor F1 dan ambang batas. Ini akan memungkinkan kami untuk mengevaluasi model kami pada set pengujian:

(epsilon, F1) = pilihThreshold(Yval, pval)

print("Epsilon terbaik ditemukan:", epsilon)

print("F1 terbaik pada set validasi silang:", F1)

(test_precision, test_recall, test_F1) = metrik(Ytest, ptest < epsilon)

print("Pencilan ditemukan:", np.sum(ptest < epsilon))

print("Tes set Precision:", test_precision)

print("Tes set Ingat:", test_recall)

print("Tes set nilai F1:", test_F1)

Berikut adalah hasil dari semua upaya ini:

Epsilon terbaik ditemukan: 5e-324

F1 terbaik pada set validasi silang: 0,7852998065764023

Pencilan ditemukan: 210

Set uji Presisi: 0.9095238095238095

Ingat set tes: 0,7764227642276422

Skor set tes F1: 0.837719298245614

Kesimpulan

Itu dia – proyek deteksi penipuan kartu kredit yang berfungsi penuh!

Jika Anda memiliki pertanyaan atau saran mengenai proyek ini, beri tahu kami dengan memberikan komentar di bawah. Kami akan senang mendengar dari Anda.

Dengan semua keterampilan yang dipelajari, Anda juga bisa aktif di platform kompetitif lainnya untuk menguji keterampilan Anda dan mendapatkan lebih banyak lagi praktik langsung. Jika Anda tertarik untuk mempelajari lebih lanjut tentang kursus ini, lihat halaman Program PG Eksekutif dalam Pembelajaran Mesin & AI dan bicarakan dengan konselor karir kami untuk informasi lebih lanjut.