Überblick

Verwenden der Titanic-Daten, die häufig zu Beginn von kaggle verwendet werden, Ich habe versucht, Faktoren 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. Also entschied ich mich für eine Faktorenanalyse der Zug- / Testdaten.

Ich schreibe einen Artikel über die Analyse von Hauptkomponenten mit denselben Daten wie dieser Artikel. Ich habe diesen Artikel als Fortsetzung geschrieben. Die Programme (1.-4.) Bis zur Vorverarbeitung in den folgenden [Analysis_Details] sind "fast" gleich. (Bitte überprüfen Sie unten [Analysis_Summary].) https://qiita.com/cleeeear/items/67210d977a901ebf9b4f

Annahme

――Was ist Faktoranalyse? Erwägen Sie, die erklärenden Variablen als "lineare Kombination aus gemeinsamem Faktor und eindeutigem Faktor" auszudrücken.

X=FA+UB

$ X: Daten (Anzahl der Daten (N) x Anzahl der erklärenden Variablen (n)) $ $ F: Gemeinsame Faktormatrix (N x Anzahl der Faktoren (m)) $

Besteht aus gemeinsamen Faktoren (Spaltenvektoren), an denen jede erklärende Variable gemeinsam beteiligt ist. $ A: Faktorladen (von gemeinsamen Faktoren) $ (m x n) $
Wenn Sie sich unten auf "Faktorladen" beziehen, bezieht sich dies darauf. $ U: Eigenfaktormatrix (N × n) $
Jede erklärende Variable besteht aus einem separaten Eigenfaktor (Spaltenvektor). $ B: Faktorbelastung des intrinsischen Faktors (N × n) $
Diagonale Matrix

(Jedes Element $ a_ {ij} $ des Faktorladens A ist Unter den folgenden Analysebedingungen (1) und (2), die auch die Analyse dieses Artikels sind, Dies ist der Korrelationswert zwischen dem gemeinsamen Faktor $ F_ {i} $ und der erklärenden Variablen $ X_ {i} $.

① Gemeinsamer Faktor: Orthogonaler Faktor (2) Erklärungsvariable: Standardisiert und verwendet (Mittelwert 0 Verteilung 1) )

Bei der Faktoranalyse wird diese Faktorbeladungsmenge A erhalten. Durch Erfassen der Eigenschaften gemeinsamer Faktoren aus der erhaltenen Faktorbelastung Gemeinsame Faktoren werden häufig als Zusammenfassung von Daten verwendet.

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

Einstellungen in dieser Analyse
Gemeinsame Faktoren: 2 & orthogonale Faktoren
Erklärende Variable: Standardisiert und verwendet (Mittelwert 0 Verteilung 1)
Bestätigungspunkt
Faktor laden --Variationen, die in der Analyse ausgeschlossen werden sollen Dieses Mal schließen wir zur einfachen Analyse die folgenden Variablen aus, die schwer vorverarbeiten können.
Cabin
Ticket
Name
Embarked_C
Embarked_Q
Embarked_S

Analyse_Details

Bibliotheksimport

import os
import pandas as pd
import matplotlib.pyplot as plt
from IPython.display import display
from sklearn.decomposition import PCA

Definition der Variablen (CSV-Speicherziel für Titandaten usw.)

Prämissencode, der Titanic-Daten csv (train.csv, test.csv) im Ordner "data" speichert.

#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"

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())

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())

# Embarked_C -------------------------------------------------------------------------
col = "Embarked_C"

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

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

# Embarked_Q -------------------------------------------------------------------------
col = "Embarked_Q"

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

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

# Embarked_S -------------------------------------------------------------------------
col = "Embarked_S"

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 :

Faktoranalyse 5-1. Standardisierung, fit Führen Sie nach der Standardisierung der erklärenden Variablen eine Faktoranalyse durch.

#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_tmp = proc_all_data[feature_cols]
print("features(Vor der Standardisierung):")
display(features_tmp.head())

#Standardisierung
ss = StandardScaler()
features = pd.DataFrame(
    ss.fit_transform(features_tmp)
    , columns=feature_cols
)
print("features(Nach der Standardisierung):")
display(features.head())

Funktionen (vor und nach der Standardisierung):

5-2. Faktorladematrix

#Faktorenanalyse
n_components = 2
fact_analysis = FactorAnalysis(n_components=n_components)
fact_analysis.fit(features)

#Faktorladematrix(X = FA +UB A.)
print("Faktorladematrix(X = FA +UB A.) :")
components_df = pd.DataFrame(
    fact_analysis.components_
    ,columns=feature_cols
)
display(components_df)

components_df:

5-3. [Referenz] ① Faktormatrix ② Korrelation zwischen Faktoren ③ "Korrelation zwischen Faktorladematrix (A) - Faktor (F) und erklärender Variable (X)" Dies wird als Referenz ausgegeben. Bestätigen Sie in Bezug auf (2), dass es sich um einen orthogonalen Faktor handelt. Über ③ Diesmal sind die erklärenden Variablen standardisierte und orthogonale Faktoren Bestätigen Sie, dass die Differenz 0 ist (obwohl ein Fehler vorliegt, da es sich um eine ungefähre Lösung handelt).

#Faktor
print("Faktormatrix(X = FA +UB F.) :")
fact_columns = ["factor_{}".format(i+1) for i in range(n_components)]
factor_df = pd.DataFrame(
    fact_analysis.transform(features)
    , columns=fact_columns
)
display(factor_df)

#Korrelation zwischen Faktoren
corr_fact_df = factor_df.corr()
print("Korrelation zwischen Faktoren:")
display(corr_fact_df)

#Korrelation zwischen Faktoren(Bruchnotation)
def show_float(x):
    return "{:.5f}".format(x)
print("* Bruchnotation:")
display(corr_fact_df.applymap(show_float))

# [Faktorladematrix(A)] - [Faktor(F)Und erklärende Variablen(X)Korrelation von]
##Faktor(F)Und erklärende Variablen(X)Korrelation von
fact_exp_corr_df = pd.DataFrame()
for exp_col in feature_cols:
    data = list()
    for fact_col in fact_columns:
        x = features[exp_col]
        f = factor_df[fact_col]
        data.append(x.corr(f))
    fact_exp_corr_df[exp_col] = data
print("Faktor(F)Und erklärende Variablen(X)Korrelation von:")
display(fact_exp_corr_df)

print("[Faktorladematrix(A)] - [Faktor(F)Und erklärende Variablen(X)Korrelation von]:")
display(components_df - fact_exp_corr_df)

5-4. Diagrammerstellung _1 / 2 (Faktorbelastung für jeden Faktor prüfen)

#Grafik(Balkendiagramm / gestrichelte Linie_Faktorbelastung jedes Faktors)
for i in range(len(fact_columns)):
    #Belastung des Zielfaktors
    fact_col = fact_columns[i]
    component = components_df.iloc[i]
    #Ladebetrag und sein absoluter Wert, absoluter Wert Rang
    df = pd.DataFrame({
        "component":component
        , "abs_component":component.abs()
    })
    df["rank_component"] = df["abs_component"].rank(ascending=False)
    df.sort_values(by="rank_component" , inplace=True)
    print("[{}]".format(fact_col) , "-" * 80)
    display(df)
    
    #Grafik(Balkendiagramm: Faktor laden, Bruchlinie: Absolutwert)
    x_ticks = df.index.tolist()
    x_ticks_num = [i for i in range(len(x_ticks))]
    fig = plt.figure(figsize=(12 , 5))
    plt.bar(x_ticks_num , df["component"] , label="factor loadings" , color="c")
    plt.plot(x_ticks_num , df["abs_component"] , label="[abs] factor loadings" , color="r" , marker="o")
    plt.legend()
    plt.xticks(x_ticks_num , labels=x_ticks)
    plt.xlabel("features")
    plt.ylabel("factor loadings")
    plt.show()
    
    fig.savefig("bar_{}.png ".format(fact_col))

5-5. Graphing_2 / 2 (Plotfaktorladungen auf zwei Achsen, bestehend aus beiden Faktoren)

#Grafik(Faktorbelastung von zwei Faktoren)

#Grafikanzeigefunktion
def plotting_fact_load_of_2_fact(x_fact , y_fact):
    #Datenrahmen für Grafik
    df = pd.DataFrame({
        x_fact : components_df.iloc[0].tolist()
        , y_fact : components_df.iloc[1].tolist()    
        }
        ,index = components_df.columns
    )

    fig = plt.figure(figsize=(10 , 10))
    for exp_col in df.index.tolist():
        data = df.loc[exp_col]
        x_label = df.columns.tolist()[0]
        y_label = df.columns.tolist()[1]
        x = data[x_label]
        y = data[y_label]
        plt.plot(x
                 , y
                 , label=exp_col
                 , marker="o"
                 , color="r")
        plt.annotate(exp_col , xy=(x , y))
    plt.xlabel(x_label)
    plt.ylabel(y_label)
    plt.grid()
    
    print("x = [{x_fact}] , y = [{y_fact}]".format(
        x_fact=x_fact
        , y_fact=y_fact
    ) , "-" * 80)
    display(df)
    plt.show()
    fig.savefig("plot_{x_fact}_{y_fact}.png ".format(
        x_fact=x_fact
        , y_fact=y_fact
    ))

#Grafikanzeige
plotting_fact_load_of_2_fact("factor_1" , "factor_2")

Als Voraussetzung ist der Wertebereich von Pclass (Passagierklasse) 1 bis 3, und es scheint, dass der kleinere höher ist.

Über den ersten Faktor Die Faktorbelastung des Tarifs (Boarding-Gebühr) ist groß und die Pclass (Passagierklasse) ist klein. (Das heißt, je höher die Klasse, desto größer die Faktorlast) Der erste Faktor ist also "Indikator zur Bewertung des Wohlstands" Es scheint, dass Sie daran denken können.

Es ist der gleiche Index wie die erste Hauptkomponente in der oben beschriebenen Hauptkomponentenanalyse.

Über den zweiten Faktor Als absolute Werte sind Parch (Anzahl der Eltern und Kinder) und SibSp (Anzahl der Brüder und Ehepartner) sowohl groß als auch positiv. Der zweite Faktor ist also "Indikator für die Anzahl der Familien" Es scheint, dass Sie daran denken können.

Zusammenfassung

Als Ergebnis der Faktorenanalyse mit zwei Faktoren Als erster Faktor "ein Index zur Bewertung des Wohlstands" Und als zweiter Faktor "ein Index, der die Anzahl der Familien anzeigt" wurde bekommen.

Der erste Faktor ist "Erste Hauptkomponente, als die vorherige Hauptkomponentenanalyse durchgeführt wurde" Es wurde ein ähnlicher Index wie. In einem multivariaten Analysebuch Es wurde festgestellt, dass das Wesen der Hauptkomponentenanalyse und der Faktoranalyse dasselbe ist, Es ist ein Gefühl, dass das Ergebnis dies deutlich zeigt.

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

Überblick

Annahme

Analyseübersicht

Analyse_Details

Zusammenfassung