Klasyfikacja binarna w TensorFlow: Przykład klasyfikatora liniowego

Dwa najczęstsze nadzorowane zadania uczenia się to regresja liniowa i klasyfikator liniowy. Regresja liniowa przewiduje wartość, podczas gdy klasyfikator liniowy przewiduje klasę. Ten samouczek koncentruje się na klasyfikatorze liniowym.

Co to jest klasyfikator liniowy?

Liniowy klasyfikator w Machine learning to metoda na znalezienie klasę obiektu, na podstawie jego cech klasyfikacji statystycznej. Podejmuje decyzję klasyfikacyjną na podstawie wartości liniowej kombinacji cech obiektu. Klasyfikator liniowy jest używany w praktycznych problemach, takich jak klasyfikacja dokumentów i problemy z wieloma zmiennymi.

Problemy z klasyfikacją stanowią około 80 procent zadań uczenia maszynowego. Klasyfikacja ma na celu przewidywanie prawdopodobieństwa wystąpienia każdej klasy przy danym zestawie danych wejściowych. Etykieta (tj. Zmienna zależna) jest wartością dyskretną, zwaną klasą.

1. Jeśli etykieta ma tylko dwie klasy, algorytmem uczącym się jest klasyfikator binarny.
2. Klasyfikator wieloklasowy obsługuje etykiety z więcej niż dwiema klasami.

Na przykład typowym problemem klasyfikacji binarnej jest przewidywanie prawdopodobieństwa, że ​​klient dokona drugiego zakupu. Przewidywanie typu zwierzęcia wyświetlanego na obrazie to problem klasyfikacji wieloklasowej, ponieważ istnieją więcej niż dwie odmiany zwierząt.

Część teoretyczna tego samouczka kładzie główny nacisk na klasę binarną. Dowiesz się więcej o funkcji wyjścia wieloklasowego w przyszłym samouczku.

W tym samouczku dowiesz się

• Co to jest klasyfikator liniowy?
• Jak działa klasyfikator binarny?
• Jak zmierzyć wydajność klasyfikatora liniowego?
• Precyzja
• Macierz zamieszania
• Precyzja i czułość
• Klasyfikator liniowy z TensorFlow
• Krok 1) Zaimportuj dane
• Krok 2) Konwersja danych
• Krok 3) Trenuj klasyfikatora
• Krok 4) Popraw model
• Krok 5) Hyperparameter: Lasso & Ridge

Jak działa klasyfikator binarny?

W poprzednim samouczku dowiedziałeś się, że funkcja składa się z dwóch rodzajów zmiennych: zmiennej zależnej i zestawu funkcji (zmiennych niezależnych). W regresji liniowej zmienną zależną jest liczba rzeczywista bez zakresu. Podstawowym celem jest przewidzenie jego wartości poprzez zminimalizowanie 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]. Na przykład celem jest 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, tj. Potencjalnego nabywcy lub nie.

Prawdopodobieństwo sukcesu oblicza się za pomocą regresji logistycznej . Algorytm obliczy prawdopodobieństwo na podstawie cechy X i przewiduje sukces, gdy prawdopodobieństwo to przekroczy 50%. Bardziej formalnie prawdopodobieństwo jest obliczane zgodnie z poniższym przykładem klasyfikacji binarnej TensorFlow:

gdzie 0 to zbiór wag, cechy, a b to 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 x _i . Jeśli model nie ma cech, prognoza jest równa odchyleniu, b.

Wagi wskazują kierunek korelacji między cechami x _i a etykietą y. Dodatnia korelacja zwiększa prawdopodobieństwo wystąpienia klasy dodatniej, podczas gdy korelacja ujemna przybliża prawdopodobieństwo do zera (tj. Klasy ujemnej).

Model liniowy zwraca tylko liczbę rzeczywistą, która jest niezgodna z miarą prawdopodobieństwa przedziału [0,1]. Funkcja logistyczna jest wymagana do konwersji wyników modelu liniowego na prawdopodobieństwo,

Funkcja logistyczna

Funkcja logistyczna lub funkcja sigmoidalna ma kształt litery S, a wyjście tej funkcji jest zawsze z zakresu od 0 do 1.

Przykład funkcji logistycznej

Wynik regresji liniowej można łatwo zastąpić funkcją sigmoidalną. Daje to nową liczbę 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?

Precyzja

Ogólną wydajność klasyfikatora mierzy się za pomocą miernika 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.

Zmierz wydajność klasyfikatora liniowego za pomocą miernika dokładności

Możesz zauważyć niedociągnięcia w tym wskaźniku, szczególnie w przypadku klasy nierównowagi. Zbiór danych dotyczących nierównowagi występuje, gdy liczba obserwacji na grupę nie jest równa. Powiedzmy; próbujesz sklasyfikować rzadkie zdarzenie za pomocą funkcji logistycznej. Wyobraź sobie, że klasyfikator próbuje oszacować śmierć pacjenta w następstwie choroby. Według danych 5 procent pacjentów umiera. Możesz wyszkolić klasyfikatora, aby przewidywał liczbę zgonów i używał miernika dokładności do oceny wyników. Jeśli klasyfikator przewiduje śmierć 0 dla całego zbioru danych, będzie to poprawne w 95 procentach przypadku.

Macierz zamieszania

Lepszym sposobem oceny wydajności klasyfikatora jest przyjrzenie się macierzy nieporozumień.

Zmierz wydajność klasyfikatora liniowego za pomocą macierzy nieporozumień

Macierz pomyłki wizualizuje dokładność klasyfikatora poprzez porównanie klas rzeczywistych i przewidywanych, jak pokazano w powyższym przykładzie klasyfikatora liniowego. Binarna macierz pomyłek składa się z kwadratów:

• TP: True Positive: Przewidywane wartości prawidłowo przewidywane jako rzeczywiste pozytywne
• FP: Przewidywane wartości nieprawidłowo przewidywały faktyczny wynik dodatni. tj. wartości ujemne przewidywane jako pozytywne
• FN: Fałszywie ujemne: dodatnie wartości przewidywane jako ujemne
• TN: True Negative: Przewidywane wartości prawidłowo przewidywane jako rzeczywiste ujemne

Z macierzy nieporozumień łatwo jest porównać klasę rzeczywistą i przewidywaną.

Precyzja i czułość

Macierz pomyłki zapewnia dobry wgląd w wyniki prawdziwie pozytywne i fałszywie pozytywne. W niektórych przypadkach lepiej jest mieć bardziej zwięzłe dane.

Precyzja

Metryka precyzji pokazuje dokładność klasy dodatniej. Mierzy prawdopodobieństwo, że prognoza klasy pozytywnej jest poprawna.

Maksymalny wynik to 1, gdy klasyfikator doskonale klasyfikuje wszystkie dodatnie wartości. Sama precyzja nie jest zbyt pomocna, ponieważ pomija klasę negatywną. Metryka jest zwykle łączona z metryką Przywróć. Przypomnienie jest również nazywane czułością lub prawdziwym współczynnikiem dodatnim.

Wrażliwość

Czułość oblicza stosunek poprawnie wykrytych klas dodatnich. Ta miara określa, jak dobry jest model w rozpoznawaniu pozytywnej klasy.

Klasyfikator liniowy z TensorFlow

W tym samouczku użyjemy zbioru danych spisu. Celem jest wykorzystanie zmiennych ze zbioru danych spisu do przewidzenia poziomu dochodu. Zwróć uwagę, że dochód jest zmienną binarną

• o wartości 1, jeśli dochód> 50 tys
• 0 jeśli dochód <50 tys.

Ta zmienna jest Twoją etykietą

Ten zbiór danych zawiera osiem zmiennych kategorialnych:

• 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
• capital_loss
• hours_week

Dzięki temu przykładowi klasyfikacji TensorFlow dowiesz się, jak trenować liniowe klasyfikatory TensorFlow z estymatorem TensorFlow i jak poprawić metrykę dokładności.

Będziemy postępować następująco:

• Krok 1) Zaimportuj dane
• Krok 2) Konwersja danych
• Krok 3) Wytrenuj klasyfikator
• Krok 4) Popraw model
• Krok 5) Hyperparameter: Lasso & Ridge

Krok 1) Zaimportuj dane

Najpierw zaimportujesz biblioteki używane podczas samouczka.

import tensorflow as tfimport pandas as pd 

Następnie importujesz dane z archiwum UCI i definiujesz nazwy kolumn. Będziesz używać COLUMNS do nazwania kolumn w ramce danych pandy.

Pamiętaj, że będziesz szkolić klasyfikator przy użyciu ramki danych Pandas.

## Define path dataCOLUMNS = ['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 między skład pociągu 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)

Zbiór pociągu zawiera 32 561 obserwacji, a zestaw testowy 16 281

print(df_train.shape, df_test.shape)print(df_train.dtypes)(32561, 15) (16281, 15)age int64workclass objectfnlwgt int64education objecteducation_num int64marital objectoccupation objectrelationship objectrace objectsex objectcapital_gain int64capital_loss int64hours_week int64native_country objectlabel objectdtype: object

Tensorflow wymaga wartości logicznej, aby wytrenować klasyfikator. Musisz rzutować wartości z łańcucha na liczbę całkowitą. Etykieta jest przechowywana jako obiekt, jednak należy ją przekonwertować na wartość liczbową. Poniższy kod tworzy słownik z wartościami do konwersji i pętli po elemencie kolumny. Zauważ, że wykonujesz tę operację dwukrotnie, jedną dla testu pociągu, jedną 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 o pociągach jest 24 720 dochodów niższych niż 50 tys. I 7841 powyżej. Współczynnik jest prawie taki sam dla zestawu testowego. Więcej informacji znajdziesz w tym samouczku dotyczącym aspektów.

print(df_train["label"].value_counts())### The model will be correct in atleast 70% of the caseprint(df_test["label"].value_counts())## Unbalanced labelprint(df_train.dtypes)0 247201 7841Name: label, dtype: int640 124351 3846Name: label, dtype: int64age int64workclass objectfnlwgt int64education objecteducation_num int64marital objectoccupation objectrelationship objectrace objectsex objectcapital_gain int64capital_loss int64hours_week int64native_country objectlabel int64dtype: object

Krok 2) Konwersja danych

Zanim zaczniesz trenować klasyfikator liniowy za pomocą Tensorflow, musisz wykonać kilka kroków. Musisz przygotować funkcje do uwzględnienia w modelu. W regresji wzorcowej użyjesz oryginalnych danych bez stosowania jakiejkolwiek transformacji.

Estymator musi mieć listę cech, aby wytrenować model. W związku z tym dane kolumny wymagają konwersji na tensor.

Dobrą praktyką jest zdefiniowanie dwóch list cech w oparciu o ich typ, a następnie przekazanie ich w kolumnie feature_columns estymatora.

Zaczniesz od konwersji elementów ciągłych, a następnie zdefiniujesz zasobnik z danymi kategorycznymi.

Funkcje zbioru danych mają dwa formaty:

• Liczba całkowita
• Obiekt

Każda funkcja jest wymieniona w następnych dwóch zmiennych zgodnie z ich typami.

## Add features to the bucket:### Define continuous listCONTI_FEATURES = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week']### Define the categorical listCATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country']

Kolumna_funkcji jest wyposażona w obiekt numeric_column, który pomaga w przekształcaniu zmiennych ciągłych w tensor. W poniższym kodzie konwertujesz wszystkie zmienne z CONTI_FEATURES na tensor z wartością liczbową. Jest to obowiązkowe do zbudowania 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 kolumną feature_column.numeric_column. Wydrukujemy przekonwertowaną wartość wieku. Jest to cel wyjaśniający, dlatego nie ma potrzeby rozumienia kodu Pythona. Możesz zapoznać się z oficjalną dokumentacją, aby zrozumieć kody.

def print_transformation(feature = "age", continuous = True, size = 2):#X = fc.numeric_column(feature)## Create feature namefeature_names = [feature]## Create dict with the datad = dict(zip(feature_names, [df_train[feature]]))## Convert ageif 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 valueinput_layer = tf.feature_column.input_layer(features=d,feature_columns=feature_columns)## Create lookup tablezero = tf.constant(0, dtype=tf.float32)where = tf.not_equal(input_layer, zero)## Return lookup tbleindices = tf.where(where)values = tf.gather_nd(input_layer, indices)## Initiate graphsess = tf.Session()## Print valueprint(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 konwertowania danych kategorycznych. Jeśli lista słownictwa funkcji jest znana i nie ma wielu wartości, można utworzyć kolumnę kategorialną z categorical_column_with_vocabulary_list. Przypisuje identyfikator do wszystkich unikalnych list słownictwa.

Na przykład, jeśli status zmiennej ma trzy różne wartości:

• Mąż
• Żona
• Pojedynczy

Następnie zostaną przypisane trzy identyfikatory. Na przykład Mąż będzie miał ID 1, Żona ID 2 i tak dalej.

W celach ilustracyjnych można użyć tego kodu, aby przekonwertować zmienną obiektu na kolumnę kategorialną w TensorFlow.

Płeć cechy może mieć tylko dwie wartości: mężczyzna lub kobieta. Kiedy przekonwertujemy płeć funkcji, Tensorflow utworzy 2 nowe kolumny, jedną dla mężczyzn i jedną dla kobiet. Jeśli płeć jest równa płci męskiej, wówczas nowa kolumna mężczyzna będzie równa 1, a kobieta - 0. Ten przykład jest przedstawiony w poniższej tabeli:

wydziwianie	seks	po transformacji	męski	Płeć żeńska
1	męski	=>	1	0
2	męski	=>	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 kod Pythona, aby wydrukować kodowanie. Ponownie, nie musisz rozumieć kodu, celem jest zobaczenie transformacji

Jednak szybszym sposobem przekształcenia danych jest użycie metody categorical_column_with_hash_bucket. Przydatna będzie zmiana zmiennych łańcuchowych w rzadkiej macierzy. Rzadka macierz to macierz z przeważnie zerem. Metoda dba o wszystko. Musisz tylko określić liczbę segmentów i kolumnę kluczową. Liczba segmentów to maksymalna liczba grup, które może utworzyć Tensorflow. Kolumna kluczowa to po prostu nazwa kolumny do konwersji.

W poniższym kodzie utworzysz pętlę dla wszystkich cech kategorialnych.

categorical_features = [tf.feature_column.categorical_column_with_hash_bucket(k, hash_bucket_size=1000) for k in CATE_FEATURES]

Krok 3) Trenuj klasyfikatora

Obecnie TensorFlow zapewnia estymator regresji liniowej i klasyfikacji liniowej.

• Regresja liniowa: LinearRegressor
• Klasyfikacja liniowa: LinearClassifier

Składnia klasyfikatora liniowego jest taka sama, jak w samouczku dotyczącym regresji liniowej, z wyjątkiem jednego argumentu, n_class. Musisz zdefiniować kolumnę cech, katalog modelu i porównać z regresorem liniowym; masz zdefiniować liczbę klas. W przypadku regresji logit liczba klas jest równa 2.

Model obliczy wagi kolumn zawartych w Continuous_features i categorical_features.

model = tf.estimator.LinearClassifier(n_classes = 2,model_dir="ongoing/train",feature_columns=categorical_features+ continuous_features)

WYNIK:

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':, '_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}

Po zdefiniowaniu klasyfikatora możesz utworzyć funkcję wejściową. Metoda jest taka sama, jak w samouczku dotyczącym regresora liniowego. Tutaj używasz rozmiaru partii 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 metody Pandas do przekazywania danych do modelu, musisz zdefiniować zmienne X jako ramkę danych pandy. Zwróć uwagę, że przeglądasz wszystkie dane przechowywane w FEATURES.

Wytrenujmy model za pomocą obiektu model.train. Używasz wcześniej zdefiniowanej funkcji, aby zasilać model odpowiednimi wartościami. Zwróć uwagę, że ustawiłeś rozmiar wsadu na 128, a liczbę epok na Brak. Model będzie trenował ponad tysiąc 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 = 1INFO:tensorflow:global_step/sec: 65.8282INFO:tensorflow:loss = 52583.64, step = 101 (1.528 sec)INFO:tensorflow:global_step/sec: 118.386INFO:tensorflow:loss = 25203.816, step = 201 (0.837 sec)INFO:tensorflow:global_step/sec: 110.542INFO:tensorflow:loss = 54924.312, step = 301 (0.905 sec)INFO:tensorflow:global_step/sec: 199.03INFO:tensorflow:loss = 68509.31, step = 401 (0.502 sec)INFO:tensorflow:global_step/sec: 167.488INFO:tensorflow:loss = 9151.754, step = 501 (0.599 sec)INFO:tensorflow:global_step/sec: 220.155INFO:tensorflow:loss = 34576.06, step = 601 (0.453 sec)INFO:tensorflow:global_step/sec: 199.016INFO:tensorflow:loss = 36047.117, step = 701 (0.503 sec)INFO:tensorflow:global_step/sec: 197.531INFO:tensorflow:loss = 22608.148, step = 801 (0.505 sec)INFO:tensorflow:global_step/sec: 208.479INFO: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.

Zwróć uwagę, że strata zmniejszyła się później w ciągu ostatnich 100 kroków, tj. Z 901 do 1000.

Ostateczna strata po tysiącu iteracji to 5444. Możesz oszacować swój model na zbiorze testowym i zobaczyć wydajność. Aby ocenić wydajność swojego modelu, musisz użyć oceny obiektu. Zasilasz model zestawem 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:22INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train/model.ckpt-1000INFO: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:23INFO: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 niezrównoważoną etykietę. W rzeczywistości model działa nieco lepiej niż przypadkowe przypuszczenie. Wyobraź sobie, że model przewiduje wszystkie gospodarstwa domowe z dochodami poniżej 50 tys., A wtedy model ma dokładność 70 procent. Przy bliższej analizie widać, że przewidywania i przypominanie są dość niskie.

Krok 4) Popraw model

Teraz, gdy masz model porównawczy, możesz spróbować go ulepszyć, czyli zwiększyć dokładność. W poprzednim samouczku nauczyłeś się, jak poprawić moc przewidywania za pomocą terminu interakcji. W tym samouczku powrócisz do tego pomysłu, dodając do regresji człon wielomianowy.

Regresja wielomianowa jest instrumentalna, gdy w danych występuje nieliniowość. Istnieją dwa sposoby na wychwycenie nieliniowości w danych.

• Dodaj termin wielomianowy
• Podziel zmienną ciągłą na zmienną kategorialną

Termin wielomianowy

Na poniższym obrazku możesz zobaczyć, czym jest regresja wielomianowa. Jest to równanie ze zmiennymi X o różnej mocy. Regresja wielomianowa drugiego stopnia ma dwie zmienne, X i X do kwadratu. Trzeci stopień ma trzy zmienne, X, X ² i X ³

Co to jest regresja wielomianowa

Poniżej utworzyliś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ć wzoru (lewy rysunek).

Teraz spójrz na lewe zdjęcie z poniższego obrazka, dodaliśmy do regresji pięć członów (to jest y = x + x ² + x ³ + x ⁴ + x ^5. Model teraz lepiej oddaje wzór. To jest siła regresji wielomianowej.

Wróćmy do naszego przykładu. Wiek nie jest liniowo zależny od dochodu. Osoby w młodym wieku mogą mieć stały dochód bliski zeru, ponieważ dzieci i młodzież nie pracują. Następnie wzrasta w wieku produkcyjnym i maleje na emeryturze. Zwykle jest to kształt odwróconej litery U. Jednym ze sposobów uchwycenia tego wzorca jest dodanie potęgi dwa do regresji.

Zobaczmy, czy zwiększy to dokładność.

Musisz dodać tę nową funkcję do zestawu danych i do listy funkcji ciągłych.

Dodajesz nową zmienną do zestawu danych pociągu i testujesz, 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 zestaw uczący
• df_te: zdefiniuj zestaw testowy
• var_name = 'age': Zdefiniuj zmienną do przekształcenia

Możesz użyć obiektu pow (2), aby podnieść zmienną wiek do kwadratu. Zwróć uwagę, że nowa zmienna nosi nazwę „nowa”

Teraz, gdy funkcja square_var jest zapisana, możesz utworzyć nowe zestawy 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 w zbiorze danych nazywa się nowa. 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]

Zwróć uwagę , że zmieniłeś katalog Graph. Nie możesz trenować różnych modeli w tym samym katalogu. Oznacza to, że musisz zmienić ścieżkę argumentu model_dir. Jeśli tego nie zrobisz, TensorFlow wyświetli 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':, '_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 z nowym zestawem danych, możesz 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 = 1INFO:tensorflow:global_step/sec: 81.487INFO:tensorflow:loss = 70077.66, step = 101 (1.228 sec)INFO:tensorflow:global_step/sec: 111.169INFO:tensorflow:loss = 49522.082, step = 201 (0.899 sec)INFO:tensorflow:global_step/sec: 128.91INFO:tensorflow:loss = 107120.57, step = 301 (0.776 sec)INFO:tensorflow:global_step/sec: 132.546INFO:tensorflow:loss = 12814.152, step = 401 (0.755 sec)INFO:tensorflow:global_step/sec: 162.194INFO:tensorflow:loss = 19573.898, step = 501 (0.617 sec)INFO:tensorflow:global_step/sec: 204.852INFO:tensorflow:loss = 26381.986, step = 601 (0.488 sec)INFO:tensorflow:global_step/sec: 188.923INFO:tensorflow:loss = 23417.719, step = 701 (0.529 sec)INFO:tensorflow:global_step/sec: 192.041INFO:tensorflow:loss = 23946.049, step = 801 (0.521 sec)INFO:tensorflow:global_step/sec: 197.025INFO: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.

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:37INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train1/model.ckpt-1000INFO: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:39INFO: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żesz zrobić to lepiej, łącząc ze sobą podział na segmenty i pojęcie interakcji.

Bucketyzacja i interakcja

Jak widzieliście wcześniej, klasyfikator liniowy nie jest w stanie prawidłowo uchwycić wzorca wieku i dochodu. Dzieje się tak, ponieważ uczy się pojedynczej wagi dla każdej funkcji. Aby ułatwić klasyfikator, jedną rzeczą, którą możesz zrobić, to zebrać tę funkcję. Bucketing przekształca cechę liczbową w kilka pewnych na podstawie zakresu, w jakim się ona znajduje, a każda z tych nowych funkcji wskazuje, czy wiek osoby mieści się w tym zakresie.

Dzięki tym nowym funkcjom model liniowy może uchwycić zależność, 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])

Wiesz już, że wiek jest nieliniowy w stosunku do dochodu. Innym sposobem ulepszenia modelu jest interakcja. Mówiąc słowami TensorFlow, jest to krzyżowanie cech. Skrzyżowanie cech to sposób na tworzenie nowych funkcji, które są 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, takiej jak edukacja. Oznacza to, że niektóre grupy mają prawdopodobnie wysokie dochody, a inne niskie (pomyśl o doktorantach).

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ę krzyżową, należy użyć kolumny cross_column ze zmiennymi do skrzyżowania w nawiasie. Hash_bucket_size wskazuje maksymalne możliwości przecięcia. Aby stworzyć interakcję między zmiennymi (przynajmniej jedna zmienna musi być kategoryczna), możesz użyć tf.feature_column.crossed_column. Aby użyć tego obiektu, musisz dodać w nawiasach kwadratowych zmienną do interakcji i drugi argument, rozmiar wiadra. Rozmiar zasobnika to maksymalna możliwa liczba grup w zmiennej. Tutaj ustawiasz go na 1000, ponieważ nie znasz dokładnej liczby grup

age_buckets musi zostać podniesione do kwadratu przed dodaniem go do kolumn funkcji. Dodajesz również 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)

WYNIK

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': , '_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)

Jesteś gotowy, aby oszacować nowy model i sprawdzić, 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 = 1INFO:tensorflow:global_step/sec: 94.969INFO:tensorflow:loss = 50.334488, step = 101 (1.054 sec)INFO:tensorflow:global_step/sec: 242.342INFO:tensorflow:loss = 56.153225, step = 201 (0.414 sec)INFO:tensorflow:global_step/sec: 213.686INFO:tensorflow:loss = 45.792007, step = 301 (0.470 sec)INFO:tensorflow:global_step/sec: 174.084INFO:tensorflow:loss = 37.485672, step = 401 (0.572 sec)INFO:tensorflow:global_step/sec: 191.78INFO:tensorflow:loss = 56.48449, step = 501 (0.524 sec)INFO:tensorflow:global_step/sec: 163.436INFO:tensorflow:loss = 32.528934, step = 601 (0.612 sec)INFO:tensorflow:global_step/sec: 164.347INFO:tensorflow:loss = 37.438057, step = 701 (0.607 sec)INFO:tensorflow:global_step/sec: 154.274INFO:tensorflow:loss = 61.1075, step = 801 (0.647 sec)INFO:tensorflow:global_step/sec: 189.14INFO: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.

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:52INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train3/model.ckpt-1000INFO: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:54INFO: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 to 83,58 procent. Jest o cztery procent wyższy niż w poprzednim modelu.

Na koniec możesz dodać termin regularyzacyjny, aby zapobiec nadmiernemu dopasowaniu.

Krok 5) Hyperparameter: Lasso & Ridge

Twój model może cierpieć z powodu nadmiernego lub niedopasowania .

• Nadmierne dopasowanie: model nie jest w stanie uogólnić prognozy na nowe dane
• Niedopasowanie: model nie może uchwycić wzoru danych. tj. regresja liniowa, gdy dane są nieliniowe

Gdy model ma wiele parametrów i stosunkowo małą ilość danych, prowadzi to do słabych prognoz. Wyobraź sobie, że jedna grupa ma tylko trzy obserwacje; model obliczy wagę dla tej grupy. Waga jest używana do przewidywania; jeśli obserwacje ze zbioru testowego dla tej konkretnej grupy są zupełnie inne niż ze zbioru uczącego, to model będzie błędnie przewidywał. Podczas oceny ze zbiorem uczącym dokładność jest dobra, ale nie dobra w przypadku zestawu testowego, ponieważ obliczone wagi nie są prawdziwe, aby uogólnić wzorzec. W takim przypadku nie przewiduje rozsądnych prognoz dotyczących niewidocznych danych.

Aby zapobiec nadmiernemu dopasowaniu, regularyzacja daje możliwości kontrolowania takiej złożoności i uczynienia jej bardziej uogólniającą. Istnieją dwie techniki regularyzacji:

• L1: Lasso
• L2: Grzbiet

W TensorFlow można dodać te dwa hiperparametry do optymalizatora. Na przykład im wyższy hiperparametr L2, tym ciężar jest bardzo niski i bliski zeru. Dopasowana linia będzie bardzo płaska, podczas gdy wartość L2 bliska zeru oznacza, że ​​wagi są bliskie regularnej regresji liniowej.

Możesz samodzielnie wypróbować różne wartości hiperparametrów i sprawdzić, czy możesz zwiększyć poziom dokładności.

Zwróć uwagę, że jeśli zmienisz hiperparametr, musisz usunąć folder trwający / pociąg4, w przeciwnym razie model rozpocznie się od wcześniej wytrenowanego modelu.

Zobaczmy, jaka jest dokładność z szumem

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': , '_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 = 1INFO:tensorflow:global_step/sec: 77.4165INFO:tensorflow:loss = 50.38778, step = 101 (1.294 sec)INFO:tensorflow:global_step/sec: 187.889INFO:tensorflow:loss = 55.38014, step = 201 (0.535 sec)INFO:tensorflow:global_step/sec: 201.895INFO:tensorflow:loss = 46.806694, step = 301 (0.491 sec)INFO:tensorflow:global_step/sec: 217.992INFO:tensorflow:loss = 38.68271, step = 401 (0.460 sec)INFO:tensorflow:global_step/sec: 193.676INFO:tensorflow:loss = 56.99398, step = 501 (0.516 sec)INFO:tensorflow:global_step/sec: 202.195INFO:tensorflow:loss = 33.263622, step = 601 (0.497 sec)INFO:tensorflow:global_step/sec: 216.756INFO:tensorflow:loss = 37.7902, step = 701 (0.459 sec)INFO:tensorflow:global_step/sec: 240.215INFO:tensorflow:loss = 61.732605, step = 801 (0.416 sec)INFO:tensorflow:global_step/sec: 220.336INFO: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.

model_regu.evaluate(input_fn=get_input_fn(df_test_new,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)

WYNIK

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:07INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train4/model.ckpt-1000INFO: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:09INFO: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 pociąg / zestaw testowy
• Określ wagę początkową
• Zdefiniuj funkcję straty: MSE
• Zoptymalizuj model: Zejście gradientowe
• Definiować:
  • Szybkość uczenia się
  • Liczba epok
  • Wielkość partii
  • Liczba zajęć

W tym samouczku nauczyłeś się, jak używać interfejsu API wysokiego poziomu do klasyfikatora regresji liniowej. Musisz zdefiniować:

1. Kolumny funkcji. Jeśli ciągłe: tf.feature_column.numeric_column (). Listę można wypełnić za pomocą funkcji rozumienia list w języku Python
2. Estymator: tf.estimator.LinearClassifier (kolumny_funkcji, katalog_modelu, n_klasy = 2)
3. Funkcja do importu danych, rozmiaru partii i epoki: input_fn ()

Następnie możesz trenować, oceniać i prognozować za pomocą metody train (), oceny () i przewidywania ()

Aby poprawić wydajność modelu, możesz:

• Użyj regresji wielomianowej
• Termin interakcji: tf.feature_column.crossed_column
• Dodaj parametr regularyzacji