Projekt wykrywania oszustw związanych z kartami kredytowymi – projekt uczenia maszynowego

Witamy w naszym projekcie wykrywania oszustw związanych z kartami kredytowymi. Dzisiaj użyjemy Pythona i uczenia maszynowego do wykrywania oszustw w zbiorze danych dotyczących transakcji kartami kredytowymi. Chociaż udostępniliśmy kod dla każdego kroku, najlepiej byłoby zrozumieć, jak działa każdy krok, a następnie go zaimplementować.

Zaczynajmy!

Projekt wykrywania oszustw kart kredytowych z krokami

W naszym projekcie wykrywania oszustw związanych z kartami kredytowymi użyjemy Pythona, jednego z najpopularniejszych dostępnych języków programowania. Nasze rozwiązanie wykryłoby, czy ktoś ominie zabezpieczenia naszego systemu i dokona nielegalnej transakcji.

Zbiór danych zawiera transakcje kartami kredytowymi, a jego cechy są wynikiem analizy PCA. Ma funkcje „Kwota”, „Czas” i „Klasa”, gdzie „Kwota” pokazuje wartość pieniężną każdej transakcji, „Czas” pokazuje sekundy, które upłynęły między pierwszą a odpowiednią transakcją, a „Klasa” pokazuje, czy transakcja jest legalne czy nie.

W „Klasie” wartość 1 oznacza transakcję oszustwa, a wartość 0 – prawidłową transakcję.

Zestaw danych i cały kod źródłowy można pobrać tutaj .

Krok 1: Importuj pakiety

Nasz projekt wykrywania oszustw związanych z kartami kredytowymi rozpoczniemy od zainstalowania wymaganych pakietów. Utwórz plik „main.py” i zaimportuj te pakiety:

importuj numer jako np

importuj pandy jako PD

importuj sklearn

z normy importu scipy.stats

ze scipy.stats importuj multivariate_normal

ze sklearn.preprocessing import MinMaxScaler

importuj matplotlib.pyplot jako plt

importuj seaborn jako sns

Krok 2: Poszukaj błędów

Zanim użyjemy zbioru danych, powinniśmy poszukać w nim ewentualnych błędów i brakujących wartości. Brak wartości może spowodować, że Twój model będzie dawać błędne wyniki, czyniąc go nieefektywnym i nieefektywnym. Dlatego odczytamy zbiór danych i poszukamy brakujących wartości:

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

# brakujące wartości

print("brakujące wartości:", df.isnull().values.any())

Nie znaleźliśmy brakujących wartości w tym zbiorze danych, więc możemy przejść do następnego kroku.

Dołącz do kursu Sztucznej Inteligencji online z najlepszych światowych uniwersytetów — studiów magisterskich, programów podyplomowych dla kadry kierowniczej oraz zaawansowanego programu certyfikacji w zakresie uczenia maszynowego i sztucznej inteligencji, aby przyspieszyć swoją karierę.

Krok 3: Wizualizacja

Na tym etapie naszego projektu wykrywania oszustw związanych z kartami kredytowymi będziemy wizualizować nasze dane. Wizualizacja pomaga zrozumieć, co pokazują nasze dane i ujawnia wszelkie wzorce, które mogliśmy przeoczyć. Stwórzmy wykres naszego zbioru danych:

# fabuła normalna i oszustwa

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

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

plt.title("Transakcje rozproszone")

plt.xticks(zakres(2), ['Normalny', 'Oszustwo'])

plt.xlabel("Klasa")

plt.ylabel(„Częstotliwość”)

plt.pokaż()

Na naszym wykresie stwierdziliśmy, że dane są bardzo niezrównoważone. Oznacza to, że nie możemy używać nadzorowanych algorytmów uczenia się, ponieważ spowoduje to nadmierne dopasowanie. Co więcej, nie wymyśliliśmy, jaka byłaby najlepsza metoda rozwiązania naszego problemu, więc przeprowadzimy więcej wizualizacji. Użyj poniższych wskazówek, aby wykreślić mapę termiczną:

# Mapa ciepła

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

plt.pokaż()

Teraz utworzymy wykresy dystrybucji danych, które pomogą nam zrozumieć, skąd pochodzą nasze dane:

fig, axs = plt.subplots(6, 5, ściśnięcie=False)

dla i, ax w enumerate(axs.flatten()):

ax.set_facecolor('xkcd:węgiel')

ax.set_title(df.kolumny[i])

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

kolor=”#DC143C”, fit_kws={„kolor”: „#4e8ef5”})

topór.set_xlabel()

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

plt.pokaż()

Dzięki wykresom rozkładu danych odkryliśmy, że prawie każda cecha pochodzi z rozkładu Gaussa, z wyjątkiem „Czasu”.

Więc użyjemy wielowymiarowego rozkładu Gaussa do wykrywania oszustw. Ponieważ tylko funkcja „Czas” pochodzi z rozkładu bimodalnego (i zwróć uwagę na rozkład Gaussa), odrzucimy ją. Co więcej, nasza wizualizacja ujawniła, że ​​funkcja „Czas” nie ma żadnych ekstremalnych wartości, jak inne, co jest kolejnym powodem, dla którego ją odrzucimy.

Dodaj następujący kod, aby usunąć omówione przez nas funkcje i skalować inne:

klasy = df['Klasa']

df.drop(['Czas', 'Klasa', 'Kwota'], oś=1, inplace=True)

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

MMscaller = MinMaxScaler()

df = MMscaller.fit_transform(df)

df = pd.DataFrame(dane=df, kolumny=kolumny)

df = pd.concat([df, klasy], oś=1)

Krok 4: Dzielenie zbioru danych

Utwórz plik „functions.py”. Tutaj dodamy funkcje, które zaimplementują różne etapy naszego algorytmu. Zanim jednak dodamy te funkcje, podzielmy nasz zbiór danych na dwa zestawy, zestaw walidacyjny i zestaw testowy.

importuj pandy jako PD

importuj numer jako np

def train_validation_splits(df):

# Transakcje oszustwa

oszustwo = df[df['Klasa'] == 1]

# Normalne transakcje

normalny = df[df['Klasa'] == 0]

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

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

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

oszust_test_start = int(oszustwo.shape[0] * .5)

normal_train_start = normal_test_start * 2

val_normal = normalny[:normal_test_start]

val_fraud = oszustwo[:fraud_test_start]

validation_set = pd.concat([wartość_normalna, wartość_oszustwa], oś=0)

test_normal = normalny[normal_test_start:normal_train_start]

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

test_set = pd.concat([test_normalny, test_oszustwo], oś=0)

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

Yval = validation_set.iloc[:, -1]

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

Ytest = test_set.iloc[:, -1]

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

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

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

Krok 5: Oblicz średnią i macierz kowariancji

Poniższa funkcja pomoże nam obliczyć średnią i macierz kowariancji:

def oszacowanie_gaussian_params(X):

„””

Oblicza średnią i kowariancję dla każdej cechy.

Argumenty:

X: zbiór danych

„””

mu = np. średnia(X, oś=0)

sigma = np.cov(XT)

zwróć mu, sigma

Krok 6: Dodaj ostatnie poprawki

W naszym pliku „main.py” zaimportujemy i wywołamy funkcje, które zaimplementowaliśmy w poprzednim kroku dla każdego zestawu:

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

(mu, sigma) = szacunkowe_parametry_gaussian(Xtrain)

# oblicz pdf gaussowski

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

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

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

Teraz musimy odwołać się do epsilon (lub progu). Zwykle najlepiej jest zainicjować próg minimalną wartością pliku pdf i zwiększać z każdym krokiem, aż osiągniesz maksymalny plik pdf, jednocześnie zapisując każdą wartość epsilon w wektorze.

Po utworzeniu wymaganego wektora tworzymy pętlę „for” i iterujemy po tym samym. Porównujemy próg z wartościami pliku PDF, które generują nasze przewidywania w każdej iteracji.

Obliczamy również wynik F1 zgodnie z naszymi wartościami prawdy podstawowej i przewidywaniami. Jeśli znaleziony wynik F1 jest wyższy niż poprzedni, zastępujemy zmienną „najlepszego progu”.

Należy pamiętać, że nie możemy używać „dokładności” jako wskaźnika w naszym projekcie wykrywania oszustw związanych z kartami kredytowymi. Dzieje się tak, ponieważ wszystkie transakcje odzwierciedlałyby normalnie z 99% dokładnością, czyniąc nasz algorytm bezużytecznym.

Wszystkie procesy, które omówiliśmy powyżej, zaimplementujemy w naszym pliku „functions.py”:

def metryki(y, prognozy):

fp = np.sum(np.all([prognozy == 1, y == 0], oś=0))

tp = np.sum(np.all([prognozy == 1, y == 1], oś=0))

fn = np.sum(np.all([prognozy == 0, y == 1], oś=0))

precyzja = (tp / (tp + fp)) if (tp + fp) > 0 else 0

przywołaj = (tp / (tp + fn)) if (tp + fn) > 0 else 0

F1 = (2 * precyzja * przypomnienie) / (precyzja +

przypomnieć) jeśli (precyzja + przypomnieć) > 0 inaczej 0

precyzja powrotu, wycofanie, F1

def selectThreshold(yval, pval):

e_wartości = pval

najlepszyF1 = 0

najlepszyEpsilon = 0

dla epsilon w e_values:

przewidywania = pval < epsilon

(precyzja, przypomnienie, F1) = metryki (yval, prognozy)

jeśli F1 > bestF1:

najlepszyF1 = F1

bestEpsilon = epsilon

zwróć bestEpsilon, bestF1

Na koniec zaimportujemy funkcje z pliku „main.py” i wywołamy je w celu zwrócenia wyniku F1 i progu. Pozwoli nam to ocenić nasz model na zestawie testowym:

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

print("Najlepszy znaleziony epsilon:", epsilon)

print("Najlepszy F1 w zestawie walidacji krzyżowej:", F1)

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

print("Znaleziono wartości odstające:", np.sum(ptest < epsilon))

print("Test set Precision:", test_precision)

print("Test set Recall:", test_recall)

print("Test set F1 score:", test_F1)

Oto wyniki całego tego wysiłku:

Najlepszy znaleziony epsilon: 5e-324

Najlepszy F1 w zestawie do walidacji krzyżowej: 0,7852998065764023

Znalezione wartości odstające: 210

Zestaw testowy Precyzja: 0.9095238095238095

Zestaw testowy Przypomnijmy: 0.7764227642276422

Wynik F1 zestawu testowego: 0,837719298245614

Wniosek

Masz to – w pełni funkcjonalny projekt wykrywania oszustw związanych z kartami kredytowymi!

Jeśli masz jakieś pytania lub sugestie dotyczące tego projektu, daj nam znać, umieszczając komentarz poniżej. Chcielibyśmy usłyszeć od ciebie.

Dzięki wszystkim wyuczonym umiejętnościom możesz aktywować się na innych konkurencyjnych platformach, aby sprawdzić swoje umiejętności i zdobyć jeszcze więcej praktycznych umiejętności. Jeśli chcesz dowiedzieć się więcej o kursie, odwiedź stronę Execitive PG Program in Machine Learning & AI i porozmawiaj z naszym doradcą zawodowym, aby uzyskać więcej informacji.