[PYTHON] Ich habe versucht, die Hauptkomponenten mit Titanic-Daten zu analysieren!

Überblick

Verwenden der Titanic-Daten, die häufig zu Beginn von kaggle verwendet werden, Ich habe versucht, die Hauptkomponenten zu analysieren. Diesmal wurde dies jedoch nicht zum Zweck der Vorhersage durchgeführt. Der Zweck bestand einfach darin, die Eigenschaften der Daten unter Verwendung einer statistischen Analysemethode zu beobachten. Deshalb habe ich mich entschlossen, die Hauptkomponenten der Zug- / Testdaten gemeinsam zu analysieren.

Annahme

――Was ist die Hauptkomponentenanalyse? Für Daten, die durch mehrere Achsen (Variablen) dargestellt werden Eine Methode, um "Achse mit hoher Datenvariation" zu finden. Wegen der Dimensionskomprimierung bei der Vorhersage Bei der Analyse vorhandener Daten erfolgt dies häufig zur Zusammenfassung. In der Abbildung unten (Bild) Es gibt die rote Achse mit der höchsten Variation, gefolgt von der blauen Achse mit der höchsten Variation (senkrecht zur roten Achse). Die Hauptkomponentenanalyse besteht darin, solche roten und blauen Achsen zu finden. image_pca.png

Analyseübersicht

--Analytische Daten Titanic-Daten (Zug + Test). Sie können es von folgenden herunterladen (kaggle). (Sie müssen sich jedoch anmelden, um zu kaggen.) https://www.kaggle.com/c/titanic/data

Analyse_Details

  1. Bibliotheksimport
import os
import pandas as pd
import matplotlib.pyplot as plt
from IPython.display import display
from sklearn.decomposition import PCA
  1. Definition der Variablen (CSV-Speicherziel für Titandaten usw.)
#Aktueller Ordner
forlder_cur = os.getcwd()
print(" forlder_cur : {}".format(forlder_cur))
print(" isdir:{}".format(os.path.isdir(forlder_cur)))

#Datenspeicherort
folder_data = os.path.join(forlder_cur , "data")
print(" folder_data : {}".format(folder_data))
print(" isdir:{}".format(os.path.isdir(folder_data)))

#Datendatei

## train.csv
fpath_train = os.path.join(folder_data , "train.csv")
print(" fpath_train : {}".format(fpath_train))
print(" isdir:{}".format(os.path.isfile(fpath_train)))

## test.csv
fpath_test = os.path.join(folder_data , "test.csv")
print(" fpath_test : {}".format(fpath_test))
print(" isdir:{}".format(os.path.isfile(fpath_test)))

# id
id_col = "PassengerId"

#Objektive Variable
target_col = "Survived"
  1. Importieren Sie Titanic-Daten Die mit dem folgenden Code erstellten Daten "all_data" (train + test) werden später verwendet.
# train.csv
train_data = pd.read_csv(fpath_train)
print("train_data :")
print("n = {}".format(len(train_data)))
display(train_data.head())

# test.csv
test_data = pd.read_csv(fpath_test)
print("test_data :")
print("n = {}".format(len(test_data)))
display(test_data.head())

# train_and_test
col_list = list(train_data.columns)
tmp_test = test_data.assign(Survived=None)
tmp_test = tmp_test[col_list].copy()
print("tmp_test :")
print("n = {}".format(len(tmp_test)))
display(tmp_test.head())

all_data = pd.concat([train_data , tmp_test] , axis=0)
print("all_data :")
print("n = {}".format(len(all_data)))
display(all_data.head())

all_data.jpg

  1. Vorbehandlung Die Konvertierung von Dummy-Variablen, die fehlende Vervollständigung und das Löschen von Variablen werden für jede Variable durchgeführt, und die erstellten Daten "proc_all_data" werden später verwendet.
#Kopieren
proc_all_data = all_data.copy()

# Sex -------------------------------------------------------------------------
col = "Sex"

def app_sex(x):
    if x == "male":
        return 1
    elif x == 'female':
        return 0
    #Vermisst
    else:
        return 0.5
proc_all_data[col] = proc_all_data[col].apply(app_sex)

print("columns:{}".format(col) , "-" * 40)
display(all_data[col].value_counts())
display(proc_all_data[col].value_counts())
print("n of missing :" , len(proc_all_data.query("{0} != {0}".format(col))))

# Age -------------------------------------------------------------------------
col = "Age"

medi = proc_all_data[col].median()
proc_all_data[col] = proc_all_data[col].fillna(medi)

print("columns:{}".format(col) , "-" * 40)
display(all_data[col].value_counts())
display(proc_all_data[col].value_counts())
print("n of missing :" , len(proc_all_data.query("{0} != {0}".format(col))))
print("median :" , medi)

# Fare -------------------------------------------------------------------------
col = "Fare"

medi = proc_all_data[col].median()
proc_all_data[col] = proc_all_data[col].fillna(medi)

print("columns:{}".format(col) , "-" * 40)
display(all_data[col].value_counts())
display(proc_all_data[col].value_counts())
print("n of missing :" , len(proc_all_data.query("{0} != {0}".format(col))))
print("median :" , medi)

# Embarked -------------------------------------------------------------------------
col = "Embarked"

proc_all_data = pd.get_dummies(proc_all_data , columns=[col])

print("columns:{}".format(col) , "-" * 40)
display(all_data.head())
display(proc_all_data.head())

# Cabin -------------------------------------------------------------------------
col = "Cabin"

proc_all_data = proc_all_data.drop(columns=[col])

print("columns:{}".format(col) , "-" * 40)
display(all_data.head())
display(proc_all_data.head())

# Ticket -------------------------------------------------------------------------
col = "Ticket"

proc_all_data = proc_all_data.drop(columns=[col])

print("columns:{}".format(col) , "-" * 40)
display(all_data.head())
display(proc_all_data.head())

# Name -------------------------------------------------------------------------
col = "Name"

proc_all_data = proc_all_data.drop(columns=[col])

print("columns:{}".format(col) , "-" * 40)
display(all_data.head())
display(proc_all_data.head())

proc_all_data : proc_all_data.jpg

  1. Hauptkomponentenanalyse (Berechnung des Beitragssatzes)
#Erklärende Variable
feature_cols = list(set(proc_all_data.columns) - set([target_col]) - set([id_col]))
print("feature_cols :" , feature_cols)
print("len of feature_cols :" , len(feature_cols))

features = proc_all_data[feature_cols]

pca = PCA()
pca.fit(features)

print("Anzahl der Hauptkomponenten: " , pca.n_components_)
print("Beitragssatz: " , ["{:.2f}".format(ratio) for ratio in pca.explained_variance_ratio_])

Wie in den folgenden Ergebnissen gezeigt, ist die erste Hauptkomponente überwiegend sehr variabel. Im Folgenden werden der Eigenvektor der ersten Hauptkomponente und die Faktorbelastung bestätigt. 寄与率.jpg

  1. Eindeutiger Vektor der ersten Hauptkomponente

6-1. Datentransformation

#Einzigartiger Vektor(Erste Hauptkomponente)

components_df = pd.DataFrame({
    "feature":feature_cols
    , "component":pca.components_[0]
})
components_df["abs_component"] = components_df["component"].abs()
components_df["rank_component"] = components_df["abs_component"].rank(ascending=False)

#Absteigende Sortierung nach Absolutwert des Vektorwerts
components_df.sort_values(by="abs_component" , ascending=False , inplace=True)
display(components_df)

components_df : 固有ベクトル.jpg

6-2. Grafik

#Diagrammerstellung
max_abs_component = max(components_df["abs_component"])
min_component = min(components_df["component"])
x_ticks_num = list(i for i in range(len(components_df)))

fig = plt.figure(figsize=(15,8))

plt.grid()
plt.title("Components of First Principal Component")
plt.xlabel("feature")
plt.ylabel("component")
plt.xticks(ticks=x_ticks_num , labels=components_df["feature"])

plt.bar(x_ticks_num , components_df["component"] , color="c" , label="components")
plt.plot(x_ticks_num , components_df["abs_component"] , color="r" , marker="o" , label="[abs] components")

plt.legend()

plt.show()

Der Tarif (Boarding-Gebühr) ist überwältigend hoch, gefolgt von Alter (Alter). Es gibt nur wenige andere. Betrachtet man nur die Eigenvektoren, so scheint dies die Hauptkomponente zu sein, die von Fare zusammengefasst wird. Da sich der Wert des Eigenvektors jedoch in Abhängigkeit von der Größe der Dispersion der Zielvariablen ändert, Schauen wir uns die Faktorbelastung an, die später berechnet wird. graph_components.png

  1. Faktorbelastung der ersten Hauptkomponente

7-1. Datentransformation

#Hauptkomponentenbewertung(Erste Hauptkomponente)
score = pca.transform(features)[: , 0]

#Faktor laden
dict_fact_load = dict()
for col in feature_cols:
    data = features[col]
    factor_loading = data.corr(pd.Series(score))
    dict_fact_load[col] = factor_loading

fact_load_df = pd.DataFrame({
    "feature":feature_cols
    , "factor_loading":[dict_fact_load[col] for col in feature_cols]
})
fact_load_df["abs_factor_loading"] = fact_load_df["factor_loading"].abs()
fact_load_df["rank_factor_loading"] = fact_load_df["abs_factor_loading"].rank(ascending=False)

#Absteigende Sortierung nach Absolutwert des Vektorwerts
fact_load_df.sort_values(by="abs_factor_loading" , ascending=False , inplace=True)
display(fact_load_df)

因子負荷量.jpg

7-2. Grafik

#Diagrammerstellung
max_abs_factor_loading = max(fact_load_df["abs_factor_loading"])
min_factor_loading = min(fact_load_df["factor_loading"])
x_ticks_num = list(i for i in range(len(fact_load_df)))

plt.figure(figsize=(15,8))

plt.grid()
plt.title("Factor Lodings of First Principal Component")
plt.xlabel("feature")
plt.ylabel("factor loading")
plt.xticks(ticks=x_ticks_num , labels=fact_load_df["feature"])

plt.bar(x_ticks_num , fact_load_df["factor_loading"] , color="c" , label="factor loadings")
plt.plot(x_ticks_num , fact_load_df["abs_factor_loading"] , color="r" , marker="o" , label="[abs] factor loadings")

plt.legend()

plt.show()

Betrachtet man den Faktor Laden, Als absoluter Wert (Bruchlinie) ist der Tarif (Boarding-Gebühr) am höchsten, gefolgt von Pclass (Passagierklasse). Mit einem Unterschied in Pclass sind die anderen ungefähr so klein. Die erste Hauptkomponente ist "Indikator zur Bewertung des Wohlstands" Es scheint, dass Sie daran denken können.

Im Vergleich zu dem oben bestätigten Eigenvektor In Bezug auf den Tarif war der Eigenvektor überwiegend der größte, aber die Faktorbelastung machte keinen solchen Unterschied. In Bezug auf das Alter war es das zweitgrößte im Eigenvektor, aber das niedrigste in der Faktorbelastung. Tarif und Alter scheinen stark verteilt zu sein.

Wenn Sie versuchen, die Korrelation zwischen der Hauptkomponentenbewertung und jeder Variablen anhand des Eigenvektors zu beurteilen, Ich wollte gerade einen Fehler machen. Die Faktorbelastung sollte berechnet und bestätigt werden. graph_factor_loadings.png

Zusammenfassung

Als Ergebnis der Hauptkomponentenanalyse Der Index "Vermögen bewerten" wird erhalten. Der Index war derjenige, den die meisten Kunden (alle Daten) teilen (variieren) konnten.

Wir haben auch festgestellt, dass sich die Trends zwischen dem Eigenvektor und der Faktorbelastung unterscheiden. das ist, "(Um den Inhalt der Hauptkomponente zu überprüfen) Wenn Sie die Korrelation zwischen den Hauptkomponenten und jeder Variablen betrachten, betrachten Sie die Faktorbelastung. Nur nach dem Eigenvektor zu urteilen (Weil es von der Größe der Dispersion beeinflusst wird) Kann irreführend sein " Es gibt eine Einschränkung.

Recommended Posts

Ich habe versucht, die Hauptkomponenten mit Titanic-Daten zu analysieren!
Ich habe versucht, Faktoren mit Titanic-Daten zu analysieren!
Fordern Sie die Hauptkomponentenanalyse von Textdaten mit Python heraus
Hauptkomponentenanalyse mit Spark ML
Dies und das der Hauptkomponentenanalyse
Datenanalyse Titanic 2
Datenanalyse Titanic 1
Datenanalyse Titanic 3
Ich habe eine multiple Regressionsanalyse mit Polypoly-Regression versucht
Hauptkomponentenanalyse mit Livedoor News Corpus --Practice--
Ich habe versucht, mit Kaggles Titanic (kaggle②) zu lernen.
Hauptkomponentenanalyse mit Livedoor News Corpus - Vorbereitung--
Dimensionskomprimierung durch Selbstcodierer- und Hauptkomponentenanalyse
Ich habe versucht, die Daten mit Zwietracht zu speichern
Ich habe versucht, CloudWatch-Daten mit Python abzurufen
Ich habe versucht, das Überleben der Titanic mit PyCaret vorherzusagen
Ich habe versucht, fMRI-Daten mit Python zu analysieren (Einführung in die Dekodierung von Gehirninformationen)
Hauptkomponentenanalyse (Hauptkomponentenanalyse: PCA)
Ich habe DBM mit Pylearn 2 unter Verwendung künstlicher Daten ausprobiert
Datenanalyse mit Python
Koordinierte Filterung mit Hauptkomponentenanalyse und K-Mittel-Clustering
Ich habe eine emotionale Analyse von Amazon Comprehend mit der AWS CLI durchgeführt.
Ich habe versucht, das Spiel in der J League vorherzusagen (Datenanalyse)
[OpenCV / Python] Ich habe versucht, Bilder mit OpenCV zu analysieren
Ich habe versucht, mit Scrapy Daten von einer Website zu sammeln
Hauptkomponentenanalyse mit Python von nim mit nimpy
Ich habe fp-Wachstum mit Python versucht
Ich habe versucht, mit Python zu kratzen
Ich habe versucht, mit Elasticsearch Ranking zu lernen!
Ich habe versucht, mit PyCaret zu clustern
Lernen ohne Lehrer 3 Hauptkomponentenanalyse
Ich habe gRPC mit Python ausprobiert
Ich habe versucht, mit Python zu kratzen
Ich habe versucht, mit Python faker verschiedene "Dummy-Daten" zu erstellen
Hauptkomponentenanalyse zum Anfassen mit PyCaret [Normalisierung + Visualisierung (grafisch)] Memo
Ich habe versucht, scRNA-seq-Daten mithilfe der topologischen Datenanalyse (TDA) zu analysieren.
Ich habe die gleiche Datenanalyse mit kaggle notebook (python) und PowerBI gleichzeitig versucht ②
Ich habe die gleiche Datenanalyse mit kaggle notebook (python) und PowerBI gleichzeitig versucht ①
Ich habe AdaNet gegen Tabellendaten ausprobiert
Ich habe versucht, Sätze mit summpy zusammenzufassen
Ich habe maschinelles Lernen mit liblinear versucht
Ich habe versucht, WebScraping mit Python.
Ich habe versucht, Essen mit SinGAN zu bewegen
Gesichtserkennung mit Hauptkomponentenanalyse
Ich habe versucht, DeepPose mit PyTorch zu implementieren
Ich habe versucht, das Gesicht mit MTCNN zu erkennen
Ich habe mit Mecab gespielt (morphologische Analyse)!
Datenanalyse beginnend mit Python (Datenvisualisierung 1)
Ich habe versucht, Prolog mit Python 3.8.2 auszuführen.
Ich habe die SMTP-Kommunikation mit Python versucht
Ich habe versucht, Sätze mit GPT-2 zu generieren
Datenanalyse beginnend mit Python (Datenvisualisierung 2)
Ich habe versucht, LightGBM mit Yellowbrick zu lernen
Ich habe versucht, das Gesicht mit OpenCV zu erkennen
[Pandas] Ich habe versucht, Verkaufsdaten mit Python zu analysieren. [Für Anfänger]