Klasyfikacja binarna TensorFlow: przykład klasyfikatora liniowego
Evelyn Clarke
Dwa najczęstsze Nadzorowana nauka zadaniami są regresja liniowa i klasyfikator liniowy. Regresja liniowa przewiduje wartość, podczas gdy klasyfikator liniowy przewiduje klasę. Ten samouczek skupia się na klasyfikatorach liniowych.
Co to jest klasyfikator liniowy?
A Klasyfikator liniowy w uczeniu maszynowym to metoda znajdowania klasy obiektu na podstawie jego charakterystyki na potrzeby klasyfikacji statystycznej. Podejmuje decyzję o klasyfikacji na podstawie wartości kombinacji liniowej cech obiektu. Klasyfikator liniowy jest stosowany w problemach praktycznych, takich jak klasyfikacja dokumentów i problemy posiadające wiele zmiennych.
Problemy z klasyfikacją stanowią około 80 procent zadań uczenia maszynowego. Klasyfikacja ma na celu przewidzenie prawdopodobieństwa każdej klasy przy danym zestawie danych wejściowych. Etykieta (tj. zmienna zależna) jest wartością dyskretną, zwaną klasą.
- Jeśli etykieta ma tylko dwie klasy, algorytmem uczenia jest klasyfikator binarny.
- Klasyfikator wieloklasowy obsługuje etykiety zawierające więcej niż dwie klasy.
Na przykład typowym problemem klasyfikacji binarnej jest przewidzenie prawdopodobieństwa, że klient dokona drugiego zakupu. Przewidzenie rodzaju zwierzęcia wyświetlanego na obrazku jest problemem klasyfikacji wieloklasowej, ponieważ istnieją więcej niż dwie odmiany zwierząt.
Część teoretyczna tego samouczka skupia się przede wszystkim na klasie binarnej. Więcej o wieloklasowej funkcji wyjściowej dowiesz się w następnym samouczku.
Jak działa klasyfikator binarny?
Z poprzedniego samouczka dowiedziałeś się, że funkcja składa się z dwóch rodzajów zmiennych, zmiennej zależnej i zestawu cech (zmiennych niezależnych). W regresji liniowej zmienną zależną jest liczba rzeczywista bez zakresu. Podstawowym celem jest przewidzenie jego wartości poprzez minimalizację błędu średniokwadratowego.
W przypadku klasyfikatora binarnego TensorFlow etykieta może mieć dwie możliwe wartości całkowite. W większości przypadków jest to [0,1] lub [1,2]. Celem jest na przykład przewidzenie, czy klient kupi produkt, czy nie. Etykieta jest zdefiniowana w następujący sposób:
- Y = 1 (klient kupił produkt)
- Y = 0 (klient nie kupuje produktu)
Model wykorzystuje cechy X do zaklasyfikowania każdego klienta do najbardziej prawdopodobnej klasy, do której należy, czyli potencjalnego nabywcy lub nie.
Oblicza się prawdopodobieństwo sukcesu regresja logistyczna. Algorytm obliczy prawdopodobieństwo na podstawie cechy X i przewidzi sukces, gdy prawdopodobieństwo to przekroczy 50 procent. Bardziej formalnie, prawdopodobieństwo oblicza się w sposób pokazany w poniższym przykładzie klasyfikacji binarnej TensorFlow:
gdzie 0 to zbiór wag, cech, a b odchylenie.
Funkcję można rozłożyć na dwie części:
- Model liniowy
- Funkcja logistyczna
Model liniowy
Znasz już sposób obliczania wag. Wagi są obliczane za pomocą iloczynu skalarnego:
Y jest funkcją liniową wszystkich cech xi. Jeżeli model nie posiada cech, predykcja jest równa obciążeniu, b.
Wagi wskazują kierunek korelacji pomiędzy cechami xi i etykieta y. Dodatnia korelacja zwiększa prawdopodobieństwo klasy dodatniej, podczas gdy korelacja ujemna prowadzi prawdopodobieństwo bliżej 0 (tj. klasy ujemnej).
Model liniowy zwraca tylko liczbę rzeczywistą, co jest niezgodne z miarą prawdopodobieństwa zakresu [0,1]. Funkcja logistyczna jest wymagana do przekształcenia wyniku modelu liniowego na prawdopodobieństwo,
Funkcja logistyczna
Funkcja logistyczna, czyli funkcja sigmoidalna, ma kształt litery S, a wynik tej funkcji zawsze mieści się w przedziale od 0 do 1.
Wynik regresji liniowej łatwo jest zastąpić funkcją sigmoidalną. Wynikiem tego jest nowa liczba z prawdopodobieństwem od 0 do 1.
Klasyfikator może przekształcić prawdopodobieństwo w klasę
- Wartości od 0 do 0.49 stają się klasą 0
- Wartości od 0.5 do 1 stają się klasą 1
Jak zmierzyć wydajność klasyfikatora liniowego?
Dokładność
Ogólną wydajność klasyfikatora mierzy się za pomocą metryki dokładności. Dokładność zbiera wszystkie prawidłowe wartości podzielone przez całkowitą liczbę obserwacji. Na przykład wartość dokładności wynosząca 80 procent oznacza, że model jest poprawny w 80 procentach przypadków.
Można zauważyć niedociągnięcie tej metryki, szczególnie w przypadku klasy nierównowagi. Zbiór danych nierównowagi występuje, gdy liczba obserwacji na grupę nie jest równa. Powiedzmy, że próbujesz sklasyfikować rzadkie zdarzenie za pomocą funkcji logistycznej. Wyobraź sobie, że klasyfikator próbuje oszacować śmierć pacjenta po chorobie. W danych 5 procent pacjentów umiera. Możesz wytrenować klasyfikator, aby przewidywał liczbę zgonów i użyć metryki dokładności, aby ocenić wydajność. Jeśli klasyfikator przewiduje 0 zgonów dla całego zbioru danych, będzie poprawny w 95 procentach przypadków.
Macierz pomyłek
Lepszym sposobem oceny wydajności klasyfikatora jest spojrzenie na macierz zamieszania.
Kurs matryca zamieszania wizualizuje dokładność klasyfikatora poprzez porównanie rzeczywistych i przewidywanych klas, jak pokazano w powyższym przykładzie Klasyfikatora liniowego. Macierz pomyłek binarnych składa się z kwadratów:
- TP: True Positive: Przewidywane wartości prawidłowo przewidywane jako rzeczywiste dodatnie
- FP: Przewidywane wartości błędnie przewidywały rzeczywistą wartość dodatnią. tj. wartości ujemne przewidywane jako dodatnie
- FN: Fałszywie Negatywne: Wartości dodatnie przewidywane jako ujemne
- TN: True Negative: Przewidywane wartości prawidłowo przewidywane jako rzeczywiste ujemne
Korzystając z macierzy zamieszania, łatwo jest porównać klasę rzeczywistą i klasę przewidywaną.
Precyzja i czułość
Matryca zamieszania zapewnia dobry wgląd w informacje o wartościach prawdziwie dodatnich i fałszywie dodatnich. W niektórych przypadkach lepiej jest mieć bardziej zwięzłe dane.
Detaliczność
Metryka precyzji pokazuje dokładność klasy dodatniej. Mierzy prawdopodobieństwo, że przewidywanie klasy dodatniej jest prawidłowe.
Maksymalny wynik wynosi 1, gdy klasyfikator doskonale klasyfikuje wszystkie wartości dodatnie. Sama precyzja nie jest zbyt pomocna, ponieważ ignoruje klasę ujemną. Metryka jest zwykle łączona z metryką Recall. Przypomnienie jest również nazywane wrażliwością lub prawdziwie dodatnim współczynnikiem.
Wrażliwość
Czułość oblicza stosunek poprawnie wykrytych klas dodatnich. Metryka ta określa, jak dobrze model rozpoznaje klasę dodatnią.
Klasyfikator liniowy z TensorFlow
W tym samouczku użyjemy zbioru danych spisowych. Celem jest wykorzystanie zmiennych ze zbioru danych spisowych do przewidywania poziomu dochodów. Należy pamiętać, że dochód jest zmienną binarną
- z wartością 1, jeżeli dochód > 50 tys
- 0 jeżeli dochód < 50 tys.
Ta zmienna jest Twoją etykietą
Ten zbiór danych zawiera osiem zmiennych kategorycznych:
- miejsce pracy
- Edukacja
- małżeński
- zawód
- związek
- wyścig
- seks
- ojczyźnie
ponadto sześć zmiennych ciągłych:
- wiek
- fnlwgt
- edukacja_num
- zysk kapitałowy
- strata_kapitału
- godziny_tydzień
Dzięki temu przykładowi klasyfikacji TensorFlow zrozumiesz, jak szkolić liniowe klasyfikatory TensorFlow za pomocą estymatora TensorFlow i jak poprawić metrykę dokładności.
Postępujemy następująco:
- Krok 1) Zaimportuj dane
- Krok 2) Konwersja danych
- Krok 3) Wytrenuj klasyfikator
- Krok 4) Ulepsz model
- Krok 5) Hiperparametr: Lasso i Ridge
Krok 1) Zaimportuj dane
Najpierw importujesz biblioteki używane w samouczku.
import tensorflow as tf import pandas as pd
Następnie importujesz dane z archiwum UCI i definiujesz nazwy kolumn. Użyjesz COLUMNS, aby nazwać kolumny w ramce danych pandas.
Pamiętaj, że będziesz szkolić klasyfikator przy użyciu ramki danych Pandas.
## Define path data
COLUMNS = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital',
'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss',
'hours_week', 'native_country', 'label']
PATH = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"
PATH_test = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.test"
Dane przechowywane online są już podzielone pomiędzy skład pociągowy i zestaw testowy.
df_train = pd.read_csv(PATH, skipinitialspace=True, names = COLUMNS, index_col=False) df_test = pd.read_csv(PATH_test,skiprows = 1, skipinitialspace=True, names = COLUMNS, index_col=False)
Zestaw pociągowy zawiera 32,561 16,281 obserwacji, a zestaw testowy XNUMX XNUMX
print(df_train.shape, df_test.shape) print(df_train.dtypes) (32561, 15) (16281, 15) age int64 workclass object fnlwgt int64 education object education_num int64 marital object occupation object relationship object race object sex object capital_gain int64 capital_loss int64 hours_week int64 native_country object label object dtype: object
Tensorflow wymaga wartości logicznej do trenowania klasyfikatora. Musisz rzutować wartości z ciągu na liczbę całkowitą. Etykieta jest przechowywana jako obiekt, jednak musisz ją przekonwertować na wartość liczbową. Poniższy kod tworzy słownik z wartościami do przekonwertowania i pętlę po elemencie kolumny. Zwróć uwagę, że wykonujesz tę operację dwa razy, raz dla testu trenowania, raz dla zestawu testowego
label = {'<=50K': 0,'>50K': 1}
df_train.label = [label[item] for item in df_train.label]
label_t = {'<=50K.': 0,'>50K.': 1}
df_test.label = [label_t[item] for item in df_test.label]
W danych pociągu jest 24,720 50 dochodów niższych od 7841 tys. i XNUMX powyżej. Stosunek jest prawie taki sam dla zbioru testowego. Aby uzyskać więcej informacji, zapoznaj się z tym samouczkiem dotyczącym aspektów.
print(df_train["label"].value_counts()) ### The model will be correct in atleast 70% of the case print(df_test["label"].value_counts()) ## Unbalanced label print(df_train.dtypes) 0 24720 1 7841 Name: label, dtype: int64 0 12435 1 3846 Name: label, dtype: int64 age int64 workclass object fnlwgt int64 education object education_num int64 marital object occupation object relationship object race object sex object capital_gain int64 capital_loss int64 hours_week int64 native_country object label int64 dtype: object
Krok 2) Konwersja danych
Zanim wytrenujesz klasyfikator liniowy za pomocą Tensorflow, należy wykonać kilka kroków. Należy przygotować elementy, które mają zostać uwzględnione w modelu. W regresji porównawczej użyjesz oryginalnych danych bez stosowania żadnej transformacji.
Estymator musi mieć listę funkcji do uczenia modelu. Dlatego dane kolumny wymagają konwersji na tensor.
Dobrą praktyką jest zdefiniowanie dwóch list obiektów w oparciu o ich typ, a następnie przekazanie ich w kolumnach feature_columns estymatora.
Zaczniesz od konwersji cech ciągłych, a następnie zdefiniujesz segment z danymi kategorycznymi.
Funkcje zbioru danych mają dwa formaty:
- Liczba całkowita
- przedmiot
Każda funkcja jest wymieniona w dwóch kolejnych zmiennych zgodnie z jej typem.
## Add features to the bucket: ### Define continuous list CONTI_FEATURES = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week'] ### Define the categorical list CATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country']
Feature_column jest wyposażona w obiekt numeric_column, który pomaga w transformacji zmiennych ciągłych na tensor. W poniższym kodzie konwertujesz wszystkie zmienne z CONTI_FEATURES na tensor o wartości liczbowej. Jest to konieczne do skonstruowania modelu. Wszystkie zmienne niezależne należy przekonwertować na odpowiedni typ tensora.
Poniżej piszemy kod, który pozwoli Ci zobaczyć, co dzieje się za feature_column.numeric_column. Wydrukujemy przeliczoną wartość wieku. Służy to celom objaśniającym, dlatego nie ma potrzeby rozumienia kodu Pythona. Aby zrozumieć kody, możesz zapoznać się z oficjalną dokumentacją.
def print_transformation(feature = "age", continuous = True, size = 2):
#X = fc.numeric_column(feature)
## Create feature name
feature_names = [
feature]
## Create dict with the data
d = dict(zip(feature_names, [df_train[feature]]))
## Convert age
if continuous == True:
c = tf.feature_column.numeric_column(feature)
feature_columns = [c]
else:
c = tf.feature_column.categorical_column_with_hash_bucket(feature, hash_bucket_size=size)
c_indicator = tf.feature_column.indicator_column(c)
feature_columns = [c_indicator]
## Use input_layer to print the value
input_layer = tf.feature_column.input_layer(
features=d,
feature_columns=feature_columns
)
## Create lookup table
zero = tf.constant(0, dtype=tf.float32)
where = tf.not_equal(input_layer, zero)
## Return lookup tble
indices = tf.where(where)
values = tf.gather_nd(input_layer, indices)
## Initiate graph
sess = tf.Session()
## Print value
print(sess.run(input_layer))
print_transformation(feature = "age", continuous = True)
[[39.]
[50.]
[38.]
...
[58.]
[22.]
[52.]]
Wartości są dokładnie takie same jak w df_train
continuous_features = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES]
Zgodnie z dokumentacją TensorFlow istnieją różne sposoby konwersji danych kategorycznych. Jeżeli lista słownictwa danej cechy jest znana i nie zawiera zbyt wielu wartości, możliwe jest utworzenie kolumny kategorycznej za pomocą kolumny kategorycznej_z_listą_słownictwa. Przypisuje do wszystkich unikalnych list słownictwa identyfikator.
Na przykład, jeśli status zmiennej ma trzy różne wartości:
- mąż
- Żona
- Jedna
Następnie zostaną przypisane trzy identyfikatory. Na przykład mąż będzie miał identyfikator 1, żona będzie miał identyfikator 2 i tak dalej.
Dla celów ilustracyjnych możesz użyć tego kodu, aby przekonwertować zmienną obiektową na kolumnę kategorialną w TensorFlow.
Funkcja płeć może mieć tylko dwie wartości: mężczyzna lub kobieta. Kiedy przekonwertujemy funkcję płeć, Tensorflow utworzy 2 nowe kolumny, jedną dla mężczyzny i jedną dla kobiety. Jeśli płeć jest równa mężczyźnie, to nowa kolumna mężczyzna będzie równa 1, a kobieta 0. Ten przykład jest wyświetlany w poniższej tabeli:
| wydziwianie | seks | po transformacji | zły | Płeć żeńska |
|---|---|---|---|---|
| 1 | zły | => | 1 | 0 |
| 2 | zły | => | 1 | 0 |
| 3 | Płeć żeńska | => | 0 | 1 |
W tensorflow:
print_transformation(feature = "sex", continuous = False, size = 2)
[[1. 0.]
[1. 0.]
[1. 0.]
...
[0. 1.]
[1. 0.]
[0. 1.]]
relationship = tf.feature_column.categorical_column_with_vocabulary_list(
'relationship', [
'Husband', 'Not-in-family', 'Wife', 'Own-child', 'Unmarried',
'Other-relative'])
Poniżej dodaliśmy Python kod, aby wydrukować kodowanie. Ponownie, nie musisz rozumieć kodu, celem jest zobaczenie transformacji
Jednak szybszym sposobem transformacji danych jest użycie metody categorical_column_with_hash_bucket. Przydatna będzie zmiana zmiennych łańcuchowych w rzadkiej macierzy. Macierz rzadka to macierz zawierająca głównie zero. Metoda zajmuje się wszystkim. Wystarczy określić liczbę segmentów i kolumnę kluczową. Liczba segmentów to maksymalna liczba grup, jakie może utworzyć Tensorflow. Kolumna kluczowa to po prostu nazwa kolumny do konwersji.
W poniższym kodzie tworzysz pętlę obejmującą wszystkie funkcje kategoryczne.
categorical_features = [tf.feature_column.categorical_column_with_hash_bucket(k, hash_bucket_size=1000) for k in CATE_FEATURES]
Krok 3) Wytrenuj klasyfikator
TensorFlow zapewnia obecnie estymator regresji liniowej i klasyfikacji liniowej.
- Regresja liniowa: LinearRegressor
- Klasyfikacja liniowa: LinearClassifier
Składnia klasyfikatora liniowego jest taka sama jak w tutorialu regresji liniowej z wyjątkiem jednego argumentu, n_class. Musisz zdefiniować kolumnę funkcji, katalog modelu i porównać z regresorem liniowym; masz zdefiniowany numer klasy. W przypadku regresji logitowej liczba klas jest równa 2.
Model obliczy wagi kolumn zawartych w parametrach Continuous_features i categorical_features.
model = tf.estimator.LinearClassifier(
n_classes = 2,
model_dir="ongoing/train",
feature_columns=categorical_features+ continuous_features)
Wydajność
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec':
<tensorflow.python.training.server_lib.ClusterSpec object at 0x181f24c898>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
Teraz, gdy klasyfikator jest zdefiniowany, możesz utworzyć funkcję wejściową. Metoda jest taka sama jak w samouczku dotyczącym regresora liniowego. Tutaj używasz partii o rozmiarze 128 i tasujesz dane.
FEATURES = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country']
LABEL= 'label'
def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):
return tf.estimator.inputs.pandas_input_fn(
x=pd.DataFrame({k: data_set[k].values for k in FEATURES}),
y = pd.Series(data_set[LABEL].values),
batch_size=n_batch,
num_epochs=num_epochs,
shuffle=shuffle)
Tworzysz funkcję z argumentami wymaganymi przez estymator liniowy, tj. liczbą epok, liczbą partii i tasujesz zbiór danych lub notatkę. Ponieważ używasz Pandy metodę przekazywania danych do modelu, musisz zdefiniować zmienne X jako ramkę danych pandy. Pamiętaj, że zapętlasz wszystkie dane przechowywane w FUNKCJE.
Wytrenujmy model za pomocą obiektu model.train. Używasz wcześniej zdefiniowanej funkcji, aby zasilić model odpowiednimi wartościami. Należy pamiętać, że rozmiar partii został ustawiony na 128, a liczba epok na Brak. Model zostanie przeszkolony w tysiącu kroków.
model.train(input_fn=get_input_fn(df_train,
num_epochs=None,
n_batch = 128,
shuffle=False),
steps=1000)
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow: Graph was finalized. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Saving checkpoints for 1 into ongoing/train/model.ckpt. INFO:tensorflow:loss = 88.722855, step = 1 INFO:tensorflow:global_step/sec: 65.8282 INFO:tensorflow:loss = 52583.64, step = 101 (1.528 sec) INFO:tensorflow:global_step/sec: 118.386 INFO:tensorflow:loss = 25203.816, step = 201 (0.837 sec) INFO:tensorflow:global_step/sec: 110.542 INFO:tensorflow:loss = 54924.312, step = 301 (0.905 sec) INFO:tensorflow:global_step/sec: 199.03 INFO:tensorflow:loss = 68509.31, step = 401 (0.502 sec) INFO:tensorflow:global_step/sec: 167.488 INFO:tensorflow:loss = 9151.754, step = 501 (0.599 sec) INFO:tensorflow:global_step/sec: 220.155 INFO:tensorflow:loss = 34576.06, step = 601 (0.453 sec) INFO:tensorflow:global_step/sec: 199.016 INFO:tensorflow:loss = 36047.117, step = 701 (0.503 sec) INFO:tensorflow:global_step/sec: 197.531 INFO:tensorflow:loss = 22608.148, step = 801 (0.505 sec) INFO:tensorflow:global_step/sec: 208.479 INFO:tensorflow:loss = 22201.918, step = 901 (0.479 sec) INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train/model.ckpt. INFO:tensorflow:Loss for final step: 5444.363. <tensorflow.python.estimator.canned.linear.LinearClassifier at 0x181f223630>
Należy zauważyć, że strata zmniejszała się stopniowo w ciągu ostatnich 100 kroków, tj. z 901 do 1000.
Ostateczna strata po tysiącu iteracji wynosi 5444. Możesz oszacować swój model na zestawie testowym i zobaczyć jego wydajność. Aby ocenić wydajność swojego modelu, musisz użyć oceny obiektu. Zasilasz model zbiorem testowym i ustawiasz liczbę epok na 1, czyli dane trafią do modelu tylko raz.
model.evaluate(input_fn=get_input_fn(df_test,
num_epochs=1,
n_batch = 128,
shuffle=False),
steps=1000)
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:22
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:23
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.7615626, accuracy_baseline = 0.76377374, auc = 0.63300294, auc_precision_recall = 0.50891197, average_loss = 47.12155, global_step = 1000, label/mean = 0.23622628, loss = 5993.6406, precision = 0.49401596, prediction/mean = 0.18454961, recall = 0.38637546
{'accuracy': 0.7615626,
'accuracy_baseline': 0.76377374,
'auc': 0.63300294,
'auc_precision_recall': 0.50891197,
'average_loss': 47.12155,
'global_step': 1000,
'label/mean': 0.23622628,
'loss': 5993.6406,
'precision': 0.49401596,
'prediction/mean': 0.18454961,
'recall': 0.38637546}
TensorFlow zwraca wszystkie metryki, których nauczyłeś się w części teoretycznej. Bez zaskoczenia dokładność jest duża ze względu na niewyważoną etykietę. W rzeczywistości model działa nieco lepiej niż przypuszczenie losowe. Wyobraźmy sobie, że model przewiduje wszystkie gospodarstwa domowe o dochodach niższych niż 50 tys., wówczas model ma dokładność na poziomie 70 proc. Po bliższej analizie widać, że przewidywanie i zapamiętywanie są dość niskie.
Krok 4) Ulepsz model
Teraz, gdy masz już model wzorcowy, możesz spróbować go ulepszyć, czyli zwiększyć dokładność. W poprzednim samouczku nauczyłeś się, jak poprawić siłę przewidywania za pomocą terminu interakcji. W tym samouczku powrócisz do tego pomysłu, dodając składnik wielomianowy do regresji.
Regresja wielomianowa jest pomocna, gdy dane wykazują nieliniowość. Istnieją dwa sposoby uchwycenia nieliniowości danych.
- Dodaj składnik wielomianowy
- Przekształć zmienną ciągłą w zmienną kategoryczną
Termin wielomianowy
Na poniższym obrazku możesz zobaczyć, czym jest regresja wielomianowa. Jest to równanie z X zmiennymi o różnej mocy. Regresja wielomianowa drugiego stopnia ma dwie zmienne, X i X kwadrat. Trzeci stopień ma trzy zmienne: X, X2i X3
Poniżej skonstruowaliśmy wykres z dwiema zmiennymi, X i Y. Jest oczywiste, że zależność nie jest liniowa. Jeśli dodamy regresję liniową, zobaczymy, że model nie jest w stanie uchwycić wzorca (rysunek po lewej).
Teraz spójrz na lewy obrazek z poniższego obrazka, do regresji dodaliśmy pięcioskładnikowy (czyli y=x+x2+x3+x4+x5. Model teraz znacznie lepiej oddaje wzór. To jest potęga regresji wielomianowej.
Wróćmy do naszego przykładu. Wiek nie ma liniowej zależności od dochodów. W młodym wieku dochód może być stały bliski zeru, ponieważ dzieci i młodzi ludzie nie pracują. Następnie wzrasta w wieku produkcyjnym i maleje w okresie emerytalnym. Zwykle ma kształt odwróconego U. Jednym ze sposobów uchwycenia tego wzorca jest dodanie potęgi dwa do regresji.
Zobaczymy, czy zwiększy to dokładność.
Musisz dodać tę nową funkcję do zbioru danych i na listę funkcji ciągłych.
Dodajesz nową zmienną do zbioru danych pociągu i testu, więc wygodniej jest napisać funkcję.
def square_var(df_t, df_te, var_name = 'age'):
df_t['new'] = df_t[var_name].pow(2)
df_te['new'] = df_te[var_name].pow(2)
return df_t, df_te
Funkcja ma 3 argumenty:
- df_t: zdefiniuj zbiór treningowy
- df_te: zdefiniuj zestaw testowy
- var_name = 'age': Zdefiniuj zmienną do przekształcenia
Możesz użyć obiektu pow(2) do podniesienia zmiennej wieku do kwadratu. Zauważ, że nowa zmienna nosi nazwę „new”
Teraz, gdy funkcja Square_var została napisana, możesz utworzyć nowe zbiory danych.
df_train_new, df_test_new = square_var(df_train, df_test, var_name = 'age')
Jak widać, nowy zbiór danych ma jeszcze jedną funkcję.
print(df_train_new.shape, df_test_new.shape) (32561, 16) (16281, 16)
Zmienna kwadratowa nazywana jest nową w zbiorze danych. Musisz dodać go do listy funkcji ciągłych.
CONTI_FEATURES_NEW = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week', 'new'] continuous_features_new = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES_NEW]
Note że zmieniłeś katalog Graph. Nie można trenować różnych modeli w tym samym katalogu. Oznacza to, że musisz zmienić ścieżkę argumentu katalog_modelu. Jeśli tego nie zrobisz, TensorFlow zgłosi błąd.
model_1 = tf.estimator.LinearClassifier(
model_dir="ongoing/train1",
feature_columns=categorical_features+ continuous_features_new)
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train1', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec':
<tensorflow.python.training.server_lib.ClusterSpec object at 0x1820f04b70>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
FEATURES_NEW = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country', 'new']
def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):
return tf.estimator.inputs.pandas_input_fn(
x=pd.DataFrame({k: data_set[k].values for k in FEATURES_NEW}),
y = pd.Series(data_set[LABEL].values),
batch_size=n_batch,
num_epochs=num_epochs,
shuffle=shuffle)
Teraz, gdy klasyfikator został zaprojektowany przy użyciu nowego zestawu danych, można trenować i oceniać model.
model_1.train(input_fn=get_input_fn(df_train,
num_epochs=None,
n_batch = 128,
shuffle=False),
steps=1000)
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Saving checkpoints for 1 into ongoing/train1/model.ckpt. INFO:tensorflow:loss = 88.722855, step = 1 INFO:tensorflow:global_step/sec: 81.487 INFO:tensorflow:loss = 70077.66, step = 101 (1.228 sec) INFO:tensorflow:global_step/sec: 111.169 INFO:tensorflow:loss = 49522.082, step = 201 (0.899 sec) INFO:tensorflow:global_step/sec: 128.91 INFO:tensorflow:loss = 107120.57, step = 301 (0.776 sec) INFO:tensorflow:global_step/sec: 132.546 INFO:tensorflow:loss = 12814.152, step = 401 (0.755 sec) INFO:tensorflow:global_step/sec: 162.194 INFO:tensorflow:loss = 19573.898, step = 501 (0.617 sec) INFO:tensorflow:global_step/sec: 204.852 INFO:tensorflow:loss = 26381.986, step = 601 (0.488 sec) INFO:tensorflow:global_step/sec: 188.923 INFO:tensorflow:loss = 23417.719, step = 701 (0.529 sec) INFO:tensorflow:global_step/sec: 192.041 INFO:tensorflow:loss = 23946.049, step = 801 (0.521 sec) INFO:tensorflow:global_step/sec: 197.025 INFO:tensorflow:loss = 3309.5786, step = 901 (0.507 sec) INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train1/model.ckpt. INFO:tensorflow:Loss for final step: 28861.898. <tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1820f04c88>
model_1.evaluate(input_fn=get_input_fn(df_test_new,
num_epochs=1,
n_batch = 128,
shuffle=False),
steps=1000)
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:37
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:39
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.7944229, accuracy_baseline = 0.76377374, auc = 0.6093755, auc_precision_recall = 0.54885805, average_loss = 111.0046, global_step = 1000, label/mean = 0.23622628, loss = 14119.265, precision = 0.6682401, prediction/mean = 0.09116262, recall = 0.2576703
{'accuracy': 0.7944229,
'accuracy_baseline': 0.76377374,
'auc': 0.6093755,
'auc_precision_recall': 0.54885805,
'average_loss': 111.0046,
'global_step': 1000,
'label/mean': 0.23622628,
'loss': 14119.265,
'precision': 0.6682401,
'prediction/mean': 0.09116262,
'recall': 0.2576703}
Zmienna kwadratowa poprawiła dokładność z 0.76 do 0.79. Zobaczmy, czy można zrobić lepiej, łącząc razem termin „wiadrowania” i interakcji.
Bucketyzacja i interakcja
Jak widzieliśmy wcześniej, klasyfikator liniowy nie jest w stanie poprawnie uchwycić wzorca dochodów ze względu na wiek. Dzieje się tak dlatego, że uczy się pojedynczej wagi dla każdej cechy. Aby ułatwić klasyfikatorowi, jedną rzeczą, którą możesz zrobić, jest podzielenie tej funkcji. Buckowanie przekształca cechę liczbową w kilka określonych w zależności od zakresu, w jakim się ona znajduje, a każda z tych nowych funkcji wskazuje, czy wiek danej osoby mieści się w tym zakresie.
Dzięki tym nowym funkcjom model liniowy może uchwycić relację, ucząc się różnych wag dla każdego segmentu.
W TensorFlow odbywa się to za pomocą Bucketized_column. Musisz dodać zakres wartości w granicach.
age = tf.feature_column.numeric_column('age')
age_buckets = tf.feature_column.bucketized_column(
age, boundaries=[18, 25, 30, 35, 40, 45, 50, 55, 60, 65])
Już wiesz, że wiek nie zależy od dochodów. Innym sposobem ulepszenia modelu jest interakcja. W języku TensorFlow jest to skrzyżowanie cech. Krzyżowanie cech to sposób na tworzenie nowych cech będących kombinacjami istniejących, co może być pomocne w przypadku klasyfikatora liniowego, który nie może modelować interakcji między cechami.
Możesz podzielić wiek za pomocą innej funkcji, np. Edukacja. Oznacza to, że niektóre grupy prawdopodobnie będą miały wysokie dochody, a inne niskie (pomyśl o doktorancie).
education_x_occupation = [tf.feature_column.crossed_column(
['education', 'occupation'], hash_bucket_size=1000)]
age_buckets_x_education_x_occupation = [tf.feature_column.crossed_column(
[age_buckets, 'education', 'occupation'], hash_bucket_size=1000)]
Aby utworzyć kolumnę zawierającą elementy krzyżowe, użyj kolumny cross_column ze zmiennymi do przekreślenia w nawiasach. Hash_bucket_size wskazuje maksymalne możliwości przekroczenia. Aby stworzyć interakcję pomiędzy zmiennymi (przynajmniej jedna zmienna musi być kategoryczna), możesz użyć tf.feature_column.crossed_column. Aby użyć tego obiektu, należy dodać w nawiasie kwadratowym zmienną, z którą ma nastąpić interakcja, oraz drugi argument, czyli rozmiar wiadra. Rozmiar segmentu to maksymalna liczba grup możliwa w ramach zmiennej. Tutaj ustawiasz ją na 1000, ponieważ nie znasz dokładnej liczby grup
age_buckets musi zostać podniesiony do kwadratu przed dodaniem go do kolumn funkcji. Dodajesz także nowe funkcje do kolumn funkcji i przygotowujesz estymator
base_columns = [
age_buckets,
]
model_imp = tf.estimator.LinearClassifier(
model_dir="ongoing/train3",
feature_columns=categorical_features+base_columns+education_x_occupation+age_buckets_x_education_x_occupation)
Wydajność
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train3', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1823021be0>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
FEATURES_imp = ['age','workclass', 'education', 'education_num', 'marital',
'occupation', 'relationship', 'race', 'sex', 'native_country', 'new']
def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):
return tf.estimator.inputs.pandas_input_fn(
x=pd.DataFrame({k: data_set[k].values for k in FEATURES_imp}),
y = pd.Series(data_set[LABEL].values),
batch_size=n_batch,
num_epochs=num_epochs,
shuffle=shuffle)
Można już przystąpić do oszacowania nowego modelu i sprawdzenia, czy poprawi on dokładność.
model_imp.train(input_fn=get_input_fn(df_train_new,
num_epochs=None,
n_batch = 128,
shuffle=False),
steps=1000)
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Saving checkpoints for 1 into ongoing/train3/model.ckpt. INFO:tensorflow:loss = 88.722855, step = 1 INFO:tensorflow:global_step/sec: 94.969 INFO:tensorflow:loss = 50.334488, step = 101 (1.054 sec) INFO:tensorflow:global_step/sec: 242.342 INFO:tensorflow:loss = 56.153225, step = 201 (0.414 sec) INFO:tensorflow:global_step/sec: 213.686 INFO:tensorflow:loss = 45.792007, step = 301 (0.470 sec) INFO:tensorflow:global_step/sec: 174.084 INFO:tensorflow:loss = 37.485672, step = 401 (0.572 sec) INFO:tensorflow:global_step/sec: 191.78 INFO:tensorflow:loss = 56.48449, step = 501 (0.524 sec) INFO:tensorflow:global_step/sec: 163.436 INFO:tensorflow:loss = 32.528934, step = 601 (0.612 sec) INFO:tensorflow:global_step/sec: 164.347 INFO:tensorflow:loss = 37.438057, step = 701 (0.607 sec) INFO:tensorflow:global_step/sec: 154.274 INFO:tensorflow:loss = 61.1075, step = 801 (0.647 sec) INFO:tensorflow:global_step/sec: 189.14 INFO:tensorflow:loss = 44.69645, step = 901 (0.531 sec) INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train3/model.ckpt. INFO:tensorflow:Loss for final step: 44.18133. <tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1823021cf8>
model_imp.evaluate(input_fn=get_input_fn(df_test_new,
num_epochs=1,
n_batch = 128,
shuffle=False),
steps=1000)
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:52
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train3/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:54
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.8358209, accuracy_baseline = 0.76377374, auc = 0.88401634, auc_precision_recall = 0.69599575, average_loss = 0.35122654, global_step = 1000, label/mean = 0.23622628, loss = 44.67437, precision = 0.68986726, prediction/mean = 0.23320661, recall = 0.55408216
{'accuracy': 0.8358209,
'accuracy_baseline': 0.76377374,
'auc': 0.88401634,
'auc_precision_recall': 0.69599575,
'average_loss': 0.35122654,
'global_step': 1000,
'label/mean': 0.23622628,
'loss': 44.67437,
'precision': 0.68986726,
'prediction/mean': 0.23320661,
'recall': 0.55408216}
Nowy poziom dokładności wynosi 83.58 proc. Jest o cztery procent wyższy od poprzedniego modelu.
Na koniec możesz dodać termin regularyzujący, aby zapobiec nadmiernemu dopasowaniu.
Krok 5) Hiperparametr: Lasso i Ridge
Twój model może cierpieć nadmierne dopasowanie or niedopasowanie.
- Nadmierne dopasowanie: model nie jest w stanie uogólnić prognoz na nowe dane
- Niedopasowanie: model nie jest w stanie uchwycić wzorca danych. tj. regresja liniowa, gdy dane są nieliniowe
Kiedy model ma wiele parametrów i stosunkowo małą ilość danych, prowadzi to do złych przewidywań. Wyobraź sobie, że jedna grupa ma tylko trzy obserwacje; model obliczy wagę dla tej grupy. Waga służy do przewidywania; jeśli obserwacje zbioru testowego dla tej konkretnej grupy różnią się całkowicie od zbioru uczącego, wówczas model dokona błędnej prognozy. Podczas oceny zestawu szkoleniowego dokładność jest dobra, ale niewystarczająca w przypadku zestawu testowego, ponieważ obliczone wagi nie są prawdziwe, co pozwala na uogólnienie wzorca. W tym przypadku nie pozwala na rozsądne przewidywanie na podstawie niewidocznych danych.
Aby zapobiec nadmiernemu dopasowaniu, regularyzacja daje Ci możliwość kontrolowania takiej złożoności i uczynienia jej bardziej uogólnioną. Istnieją dwie techniki regularyzacji:
- L1: Lasso
- L2: Grzbiet
W TensorFlow możesz dodać te dwa hiperparametry w optymalizatorze. Na przykład, im wyższy hiperparametr L2, waga jest zwykle bardzo niska i bliska zeru. Dopasowana linia będzie bardzo płaska, natomiast wartość L2 bliska zeru oznacza, że wagi są zbliżone do regularnej regresji liniowej.
Możesz sam wypróbować inną wartość hiperparametrów i sprawdzić, czy możesz zwiększyć poziom dokładności.
Note że jeśli zmienisz hiperparametr, musisz usunąć folder continuing/train4, w przeciwnym razie model zostanie uruchomiony z poprzednio wytrenowanym modelem.
Zobaczmy, jaka jest dokładność w przypadku szumu
model_regu = tf.estimator.LinearClassifier(
model_dir="ongoing/train4", feature_columns=categorical_features+base_columns+education_x_occupation+age_buckets_x_education_x_occupation,
optimizer=tf.train.FtrlOptimizer(
learning_rate=0.1,
l1_regularization_strength=0.9,
l2_regularization_strength=5))
WYJŚCIE
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train4', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1820d9c128>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
model_regu.train(input_fn=get_input_fn(df_train_new,
num_epochs=None,
n_batch = 128,
shuffle=False),
steps=1000)
WYJŚCIE
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Saving checkpoints for 1 into ongoing/train4/model.ckpt. INFO:tensorflow:loss = 88.722855, step = 1 INFO:tensorflow:global_step/sec: 77.4165 INFO:tensorflow:loss = 50.38778, step = 101 (1.294 sec) INFO:tensorflow:global_step/sec: 187.889 INFO:tensorflow:loss = 55.38014, step = 201 (0.535 sec) INFO:tensorflow:global_step/sec: 201.895 INFO:tensorflow:loss = 46.806694, step = 301 (0.491 sec) INFO:tensorflow:global_step/sec: 217.992 INFO:tensorflow:loss = 38.68271, step = 401 (0.460 sec) INFO:tensorflow:global_step/sec: 193.676 INFO:tensorflow:loss = 56.99398, step = 501 (0.516 sec) INFO:tensorflow:global_step/sec: 202.195 INFO:tensorflow:loss = 33.263622, step = 601 (0.497 sec) INFO:tensorflow:global_step/sec: 216.756 INFO:tensorflow:loss = 37.7902, step = 701 (0.459 sec) INFO:tensorflow:global_step/sec: 240.215 INFO:tensorflow:loss = 61.732605, step = 801 (0.416 sec) INFO:tensorflow:global_step/sec: 220.336 INFO:tensorflow:loss = 46.938225, step = 901 (0.456 sec) INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train4/model.ckpt. INFO:tensorflow:Loss for final step: 43.4942. <tensorflow.python.estimator.canned.linear.LinearClassifier at 0x181ff39e48>
model_regu.evaluate(input_fn=get_input_fn(df_test_new,
num_epochs=1,
n_batch = 128,
shuffle=False),
steps=1000)
Wydajność
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:29:07
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train4/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:29:09
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.83833915, accuracy_baseline = 0.76377374, auc = 0.8869794, auc_precision_recall = 0.7014905, average_loss = 0.34691378, global_step = 1000, label/mean = 0.23622628, loss = 44.12581, precision = 0.69720596, prediction/mean = 0.23662092, recall = 0.5579823
{'accuracy': 0.83833915,
'accuracy_baseline': 0.76377374,
'auc': 0.8869794,
'auc_precision_recall': 0.7014905,
'average_loss': 0.34691378,
'global_step': 1000,
'label/mean': 0.23622628,
'loss': 44.12581,
'precision': 0.69720596,
'prediction/mean': 0.23662092,
'recall': 0.5579823}
Dzięki temu hiperparametrowi nieznacznie zwiększasz metryki dokładności. W następnym samouczku dowiesz się, jak ulepszyć klasyfikator liniowy za pomocą metody jądra.
Podsumowanie
Aby wytrenować model, musisz:
- Zdefiniuj cechy: Zmienne niezależne: X
- Zdefiniuj etykietę: Zmienna zależna: y
- Skonstruuj zestaw pociągowy/testowy
- Określ wagę początkową
- Zdefiniuj funkcję straty: MSE
- Zoptymalizuj model: Zejście gradientowe
- Definiować:
- Wskaźnik uczenia się
- Numer epoki
- Wielkość partii
- Numer klasy
W tym samouczku nauczyłeś się używać interfejsu API wysokiego poziomu w klasyfikatorze regresji liniowej. Musisz zdefiniować:
- Kolumny funkcyjne. Jeśli ciągła: tf.feature_column.numeric_column(). Możesz wypełnić listę ze zrozumieniem listy Pythona
- Estymator: tf.estimator.LinearClassifier(feature_columns, model_dir, n_classes = 2)
- Funkcja importująca dane, wielkość partii i epokę: input_fn()
Następnie możesz już trenować, oceniać i przewidywać za pomocą funkcji train(), Evaluator() i Predict()
Aby poprawić wydajność modelu, możesz:
- Użyj regresji wielomianowej
- Termin interakcji: tf.feature_column.crossed_column
- Dodaj parametr regularyzacji
