Двоична класификация на TensorFlow: Пример за линеен класификатор
Евелин Кларк
Двата най-често срещани контролирано обучение задачи са линейна регресия и линеен класификатор. Линейната регресия прогнозира стойност, докато линейният класификатор прогнозира клас. Този урок е фокусиран върху линейните класификатори.
Какво е линеен класификатор?
A Линеен класификатор в машинното обучение е метод за намиране на клас на обект въз основа на неговите характеристики за статистическа класификация. Той взема решение за класификация въз основа на стойността на линейна комбинация от характеристики на обект. Линейният класификатор се използва при практически проблеми като класификация на документи и проблеми с много променливи.
Проблемите с класификацията представляват приблизително 80 процента от задачата за машинно обучение. Класификацията има за цел да предскаже вероятността за всеки клас, даден набор от входни данни. Етикетът (т.е. зависимата променлива) е дискретна стойност, наречена клас.
- Ако етикетът има само два класа, алгоритъмът за обучение е двоичен класификатор.
- Мултикласовият класификатор се справя с етикети с повече от два класа.
Например типичен проблем с двоичната класификация е да се предвиди вероятността клиентът да направи втора покупка. Предсказването на типа животно, показано на снимка, е проблем за многокласова класификация, тъй като съществуват повече от две разновидности на животните.
Теоретичната част на този урок поставя основен фокус върху двоичния клас. Ще научите повече за мултикласовата изходна функция в бъдещ урок.
Как работи двоичният класификатор?
В предишния урок научихте, че функцията е съставена от два вида променливи, зависима променлива и набор от функции (независими променливи). При линейната регресия зависимата променлива е реално число без диапазон. Основната цел е да се предвиди неговата стойност чрез минимизиране на средната квадратна грешка.
За TensorFlow Binary Classifier етикетът може да има две възможни цели числа. В повечето случаи е или [0,1], или [1,2]. Например, целта е да се предвиди дали клиентът ще купи продукт или не. Етикетът се дефинира, както следва:
- Y = 1 (клиентът е закупил продукта)
- Y = 0 (клиентът не купува продукта)
Моделът използва характеристиките X, за да класифицира всеки клиент в най-вероятния клас, към който принадлежи, а именно потенциален купувач или не.
Вероятността за успех се изчислява с логистична регресия. Алгоритъмът ще изчисли вероятност въз основа на характеристиката X и ще прогнозира успех, когато тази вероятност е над 50 процента. По-формално, вероятността се изчислява, както е показано в примера за бинарна класификация на TensorFlow по-долу:
където 0 е наборът от тегла, характеристиките и b отклонението.
Функцията може да се разложи на две части:
- Линейният модел
- Логистичната функция
Линеен модел
Вече сте запознати с начина, по който се изчисляват теглата. Теглата се изчисляват с точков продукт:
Y е линейна функция на всички характеристики xi. Ако моделът няма характеристики, прогнозата е равна на отклонението, b.
Теглата показват посоката на корелацията между характеристиките xi и етикета y. Положителната корелация увеличава вероятността за положителния клас, докато отрицателната корелация води вероятността по-близо до 0 (т.е. отрицателен клас).
Линейният модел връща само реално число, което не е в съответствие с вероятностната мярка за диапазон [0,1]. Логистичната функция е необходима за преобразуване на изхода на линейния модел във вероятност,
Логистична функция
Логистичната функция или сигмоидната функция има S-образна форма и изходът на тази функция винаги е между 0 и 1.
Лесно е да замените резултата от линейната регресия в сигмоидната функция. Това води до ново число с вероятност между 0 и 1.
Класификаторът може да трансформира вероятността в клас
- Стойности между 0 и 0.49 стават клас 0
- Стойности между 0.5 и 1 стават клас 1
Как да измерите ефективността на линейния класификатор?
Точност
Цялостната производителност на класификатора се измерва с показателя за точност. Точността събира всички правилни стойности, разделени на общия брой наблюдения. Например, стойност на точност от 80 процента означава, че моделът е правилен в 80 процента от случаите.
Можете да забележите недостатък с този показател, особено за клас на дисбаланс. Набор от данни за дисбаланс възниква, когато броят на наблюденията за група не е равен. Да кажем; опитвате се да класифицирате рядко събитие с логистична функция. Представете си, че класификаторът се опитва да оцени смъртта на пациент след заболяване. Според данните 5 процента от пациентите умират. Можете да обучите класификатор да предсказва броя на смъртните случаи и да използвате показателя за точност, за да оцените представянето. Ако класификаторът прогнозира 0 смъртни случая за целия набор от данни, той ще бъде правилен в 95 процента от случаите.
Матрица на объркването
По-добър начин за оценка на ефективността на класификатора е да се разгледа матрицата на объркване.
- матрица на объркване визуализира точността на класификатор чрез сравняване на действителните и прогнозираните класове, както е показано в горния пример за линеен класификатор. Двоичната матрица на объркване е съставена от квадрати:
- TP: Истински положителен: Прогнозираните стойности са правилно прогнозирани като действително положителни
- FP: Прогнозираните стойности неправилно прогнозират действително положително. т.е. отрицателните стойности, предвидени като положителни
- FN: False Negative: Положителните стойности се предвиждат като отрицателни
- TN: Истински отрицателен: Прогнозираните стойности са правилно прогнозирани като действително отрицателни
От матрицата на объркването е лесно да се сравни действителният клас и прогнозираният клас.
Прецизност и чувствителност
Матрицата на объркването осигурява добра представа за истинските положителни и фалшивите положителни резултати. В някои случаи е за предпочитане да имате по-кратък показател.
Прецизност
Метриката за прецизност показва точността на положителния клас. Той измерва колко вероятно прогнозата за положителния клас е правилна.
Максималният резултат е 1, когато класификаторът класифицира перфектно всички положителни стойности. Само прецизността не е много полезна, защото игнорира отрицателния клас. Метриката обикновено се съчетава с метриката за извикване. Припомнянето се нарича още чувствителност или истински положителен процент.
Чувствителност
Чувствителността изчислява съотношението на правилно откритите положителни класове. Този показател показва колко добър е моделът за разпознаване на положителен клас.
Линеен класификатор с TensorFlow
За този урок ще използваме набора от данни от преброяването. Целта е да се използват променливите в набора от данни от преброяването, за да се предвиди нивото на доходите. Имайте предвид, че доходът е двоична променлива
- със стойност 1, ако доходът е > 50k
- 0, ако доход < 50k.
Тази променлива е вашият етикет
Този набор от данни включва осем категорични променливи:
- работното място
- образование
- брачен
- окупация
- връзка
- раса
- секс
- родна_страна
освен това шест непрекъснати променливи:
- възраст
- fnlwgt
- образование_номер
- капиталова_печалба
- капиталова_загуба
- часове_седмица
Чрез този пример за класификация на TensorFlow ще разберете как да обучавате линейни класификатори на TensorFlow с оценител на TensorFlow и как да подобрите показателя за точност.
Ще продължим както следва:
- Стъпка 1) Импортирайте данните
- Стъпка 2) Преобразуване на данни
- Стъпка 3) Обучете класификатора
- Стъпка 4) Подобрете модела
- Стъпка 5) Хиперпараметър: ласо и било
Стъпка 1) Импортирайте данните
Първо импортирате библиотеките, използвани по време на урока.
import tensorflow as tf import pandas as pd
След това импортирате данните от архива на UCI и дефинирате имената на колоните. Ще използвате КОЛОНИТЕ, за да наименувате колоните в рамка с данни на pandas.
Имайте предвид, че ще обучите класификатора, като използвате рамка от данни на 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"
Данните, съхранени онлайн, вече са разделени между набор от влакове и набор от тестове.
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)
Наборът от влакове съдържа 32,561 16,281 наблюдения, а тестовият комплект 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 изисква булева стойност за обучение на класификатора. Трябва да прехвърлите стойностите от низ към цяло число. Етикетът се съхранява като обект, но трябва да го преобразувате в числова стойност. Кодът по-долу създава речник със стойностите за преобразуване и цикъл върху елемента на колоната. Имайте предвид, че изпълнявате тази операция два пъти, един за теста на влака, един за тестовия набор
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]
В данните за влака има 24,720 50 дохода под 7841k и XNUMX по-високи. Съотношението е почти същото за тестовия комплект. Моля, вижте този урок за Facets за повече.
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
Стъпка 2) Преобразуване на данни
Необходими са няколко стъпки, преди да обучите линеен класификатор с Tensorflow. Трябва да подготвите характеристиките, които да включите в модела. В регресията на бенчмарка ще използвате оригиналните данни, без да прилагате никаква трансформация.
Оценителят трябва да има списък с функции, за да обучи модела. Следователно данните от колоната трябва да бъдат преобразувани в тензор.
Добра практика е да се дефинират два списъка с характеристики въз основа на техния тип и след това да се подадат в feature_columns на оценителя.
Ще започнете с преобразуване на непрекъснати характеристики, след което ще дефинирате кофа с категоричните данни.
Функциите на набора от данни имат два формата:
- цяло число
- Обект
Всяка функция е посочена в следващите две променливи според техните типове.
## 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 е снабден с обект numeric_column, за да помогне при трансформирането на непрекъснатите променливи в тензор. В кода по-долу преобразувате всички променливи от CONTI_FEATURES в тензор с числова стойност. Това е задължително за конструирането на модела. Всички независими променливи трябва да бъдат преобразувани в правилния тип тензор.
По-долу пишем код, за да ви позволим да видите какво се случва зад feature_column.numeric_column. Ще отпечатаме преобразуваната стойност за възраст. Това е с обяснителна цел, следователно не е необходимо да разбирате кода на Python. Можете да се обърнете към официалната документация, за да разберете кодовете.
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.]]
Стойностите са точно същите като в df_train
continuous_features = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES]
Според документацията на TensorFlow има различни начини за конвертиране на категорични данни. Ако списъкът с речници на функция е известен и няма много стойности, възможно е да се създаде категорична колона с categorical_column_with_vocabulary_list. Той ще присвои ID на всички уникални речникови списъци.
Например, ако състояние на променлива има три различни стойности:
- съпруг
- Съпруга
- единичен
След това ще бъдат приписани три ID. Например съпругът ще има ID 1, съпругата ID 2 и т.н.
За целите на илюстрацията можете да използвате този код, за да конвертирате обектна променлива в категорична колона в TensorFlow.
Характерният пол може да има само две стойности: мъжки или женски. Когато преобразуваме пола на функцията, Tensorflow ще създаде 2 нови колони, една за мъже и една за жени. Ако полът е равен на мъжки, тогава новата колона мъжки ще бъде равна на 1, а женски на 0. Този пример е показан в таблицата по-долу:
| редове | секс | след трансформация | мъж | женски пол |
|---|---|---|---|---|
| 1 | мъж | => | 1 | 0 |
| 2 | мъж | => | 1 | 0 |
| 3 | женски пол | => | 0 | 1 |
В 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'])
По-долу добавихме Python код за отпечатване на кодирането. Отново, не е необходимо да разбирате кода, целта е да видите трансформацията
Въпреки това, по-бърз начин за трансформиране на данните е използването на метода categorical_column_with_hash_bucket. Промяната на низови променливи в разредена матрица ще бъде полезна. Разредената матрица е матрица с предимно нула. Методът се грижи за всичко. Трябва само да посочите броя на кофите и ключовата колона. Броят кофи е максималният брой групи, които Tensorflow може да създаде. Ключовата колона е просто името на колоната за преобразуване.
В кода по-долу създавате цикъл върху всички категориални характеристики.
categorical_features = [tf.feature_column.categorical_column_with_hash_bucket(k, hash_bucket_size=1000) for k in CATE_FEATURES]
Стъпка 3) Обучете класификатора
В момента TensorFlow предоставя оценител за линейна регресия и линейна класификация.
- Линейна регресия: LinearRegressor
- Линейна класификация: LinearClassifier
Синтаксисът на линейния класификатор е същият като в урока за линейна регресия с изключение на един аргумент, n_class. Трябва да дефинирате колоната с характеристики, директорията на модела и да сравните с линейния регресор; вие трябва да определите номера на класа. За логит регресия номерът на класа е равен на 2.
Моделът ще изчисли теглата на колоните, съдържащи се в continuous_features и categorical_features.
model = tf.estimator.LinearClassifier(
n_classes = 2,
model_dir="ongoing/train",
feature_columns=categorical_features+ continuous_features)
Продукция
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}
Сега, когато класификаторът е дефиниран, можете да създадете функцията за въвеждане. Методът е същият като в урока за линеен регресор. Тук използвате размер на партида от 128 и разбърквате данните.
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)
Създавате функция с аргументите, изисквани от линейния оценител, т.е. брой епохи, брой партиди и разбърквате набора от данни или бележката. Тъй като използвате Пандите метод за предаване на данните в модела, трябва да дефинирате X променливите като рамка с данни на pandas. Имайте предвид, че преминавате през всички данни, съхранени във FEATURES.
Нека обучим модела с обекта model.train. Използвате дефинираната преди това функция, за да захраните модела с подходящите стойности. Имайте предвид, че сте задали размера на пакета на 128 и броя на епохите на Няма. Моделът ще бъде обучен на хиляда стъпки.
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>
Обърнете внимание, че загубата е намаляла впоследствие през последните 100 стъпки, т.е. от 901 на 1000.
Крайната загуба след хиляда итерации е 5444. Можете да оцените вашия модел на тестовия набор и да видите производителността. За да оцените производителността на вашия модел, трябва да използвате обектната оценка. Захранвате модела с тестовия набор и задавате броя на епохите на 1, т.е. данните ще отидат до модела само веднъж.
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 връща всички показатели, които научихте в теоретичната част. Без изненада, точността е голяма поради небалансирания етикет. Всъщност моделът се представя малко по-добре от случайно предположение. Представете си, че моделът предвижда всички домакинства с доход под 50 70, тогава моделът има точност от XNUMX процента. При по-внимателен анализ можете да видите, че прогнозата и припомнянето са доста ниски.
Стъпка 4) Подобрете модела
Сега, когато имате бенчмарк модел, можете да опитате да го подобрите, тоест да увеличите точността. В предишния урок научихте как да подобрите силата на прогнозиране с термин за взаимодействие. В този урок ще преразгледате тази идея, като добавите полиномен член към регресията.
Полиномиалната регресия е полезна, когато има нелинейност в данните. Има два начина за улавяне на нелинейността в данните.
- Добавете член на полином
- Разпределете непрекъснатата променлива в категориална променлива
Полиномен член
От снимката по-долу можете да видите какво е полиномиална регресия. Това е уравнение с X променливи с различна степен. Полиномна регресия от втора степен има две променливи, X и X на квадрат. Третата степен има три променливи, X, X2, и X3
По-долу построихме графика с две променливи, X и Y. Очевидно е, че връзката не е линейна. Ако добавим линейна регресия, можем да видим, че моделът не е в състояние да улови модела (лявата снимка).
Сега погледнете лявата снимка от снимката по-долу, добавихме пет члена към регресията (това е y=x+x2+x3+x4+x5. Сега моделът улавя много по-добре модела. Това е силата на полиномната регресия.
Да се върнем към нашия пример. Възрастта не е в линейна връзка с доходите. В ранна възраст може да има равен доход, близък до нулата, защото децата или младите хора не работят. След това се увеличава в трудоспособна възраст и намалява при пенсиониране. Обикновено това е форма с обърнато U. Един от начините за улавяне на този модел е чрез добавяне на степен две към регресията.
Да видим дали ще увеличи точността.
Трябва да добавите тази нова функция към набора от данни и в списъка с непрекъснати характеристики.
Добавяте новата променлива в набора от данни за обучение и тест, така че е по-удобно да напишете функция.
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
Функцията има 3 аргумента:
- df_t: дефинирайте набора за обучение
- df_te: дефинирайте тестовия набор
- var_name = 'age': Дефинирайте променливата за трансформиране
Можете да използвате обекта pow(2), за да повдигнете на квадрат променливата възраст. Имайте предвид, че новата променлива е наречена „нова“
След като функцията square_var е написана, можете да създадете новите набори от данни.
df_train_new, df_test_new = square_var(df_train, df_test, var_name = 'age')
Както можете да видите, новият набор от данни има още една функция.
print(df_train_new.shape, df_test_new.shape) (32561, 16) (16281, 16)
Квадратната променлива се нарича new в набора от данни. Трябва да го добавите към списъка с непрекъснати функции.
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]
Забележка че сте променили директорията на Graph. Не можете да тренирате различни модели в една и съща директория. Това означава, че трябва да промените пътя на аргумента model_dir. Ако не го направите, TensorFlow ще изведе грешка.
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)
Сега, когато класификаторът е проектиран с новия набор от данни, можете да обучите и оцените модела.
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}
Променливата на квадрат подобри точността от 0.76 на 0.79. Нека да видим дали можете да се справите по-добре, като комбинирате заедно термина за групиране и взаимодействие.
Бакетизация и взаимодействие
Както видяхте преди, линеен класификатор не е в състояние да улови правилно модела възраст-доход. Това е така, защото научава едно тегло за всяка функция. За да улесните класификатора, едно нещо, което можете да направите, е да отделите функцията в кофа. Групирането трансформира числова характеристика в няколко определени въз основа на диапазона, в който попада, и всяка от тези нови характеристики показва дали възрастта на дадено лице попада в този диапазон.
С тези нови функции линейният модел може да улови връзката, като научи различни тегла за всяка кофа.
В TensorFlow това се прави с bucketized_column. Трябва да добавите диапазона от стойности в границите.
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])
Вече знаете, че възрастта не зависи от дохода. Друг начин за подобряване на модела е чрез взаимодействие. По думите на TensorFlow, това е пресичане на функции. Пресичането на функции е начин за създаване на нови характеристики, които са комбинации от съществуващи, което може да бъде полезно за линеен класификатор, който не може да моделира взаимодействията между характеристиките.
Можете да разделите възрастта с друга функция като образованието. Това означава, че е вероятно някои групи да имат висок доход, а други нисък (помислете за докторанта).
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)]
За да създадете кръстосана колона с функции, използвате crossed_column с променливите за кръстосване в скоба. Размерът на hash_bucket_size показва максималните възможности за пресичане. За да създадете взаимодействие между променливи (поне една променлива трябва да е категорична), можете да използвате tf.feature_column.crossed_column. За да използвате този обект, трябва да добавите в квадратни скоби променливата за взаимодействие и втори аргумент, размера на кофата. Размерът на кофата е максималният възможен брой групи в една променлива. Тук го задавате на 1000, тъй като не знаете точния брой групи
age_buckets трябва да бъде повдигнат на квадрат, преди да се добави към колоните с функции. Вие също така добавяте новите функции към колоните с характеристики и подготвяте оценката
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)
Продукция
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)
Готови сте да оцените новия модел и да видите дали подобрява точността.
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}
Новото ниво на точност е 83.58 процента. Той е с четири процента по-висок от предишния модел.
И накрая, можете да добавите термин за регулиране, за да предотвратите пренастройването.
Стъпка 5) Хиперпараметър: ласо и било
Вашият модел може да страда от свръхоборудване or недостатъчно оборудване.
- Пренастройване: Моделът не е в състояние да обобщи прогнозата към нови данни
- Недостатъчно приспособяване: Моделът не може да улови модела на данните. т.е. линейна регресия, когато данните са нелинейни
Когато един модел има много параметри и относително малко количество данни, това води до лоши прогнози. Представете си, една група има само три наблюдения; моделът ще изчисли тегло за тази група. Теглото се използва, за да се направи прогноза; ако наблюденията на набора от тестове за тази конкретна група са напълно различни от набора за обучение, тогава моделът ще направи грешна прогноза. По време на оценката с обучителния набор точността е добра, но не е добра с тестовия набор, тъй като изчислените тегла не са верните за обобщаване на модела. В този случай той не прави разумна прогноза за невидяни данни.
За да предотвратите пренастройването, регулирането ви дава възможност да контролирате такава сложност и да я направите по-обобщаема. Има две техники за регулиране:
- L1: Ласо
- L2: Гребен
В TensorFlow можете да добавите тези два хиперпараметъра в оптимизатора. Например, колкото по-висок е хиперпараметърът L2, теглото има тенденция да бъде много ниско и близо до нула. Построената линия ще бъде много плоска, докато L2 близо до нула предполага, че теглата са близки до нормалната линейна регресия.
Можете сами да опитате различната стойност на хиперпараметрите и да видите дали можете да увеличите нивото на точност.
Забележка че ако промените хиперпараметъра, трябва да изтриете папката ongoing/train4, в противен случай моделът ще започне с предварително обучения модел.
Нека да видим каква е точността с рекламата
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))
ИЗХОД
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)
ИЗХОД
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)
Продукция
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}
С този хиперпараметър леко увеличавате показателите за точност. В следващия урок ще научите как да подобрите линеен класификатор с помощта на метод на ядрото.
Oбобщение
За да обучите модел, трябва:
- Дефинирайте характеристиките: Независими променливи: X
- Дефинирайте етикета: Зависима променлива: y
- Конструирайте комплект влак/тест
- Определете първоначалното тегло
- Дефинирайте функцията на загубата: MSE
- Оптимизиране на модела: градиентно спускане
- Определете:
- Скорост на обучение
- Номер на епохата
- Размер на партидата
- Номер на класа
В този урок научихте как да използвате API от високо ниво за класификатор на линейна регресия. Трябва да дефинирате:
- Колони с характеристики. Ако е непрекъснато: tf.feature_column.numeric_column(). Можете да попълните списък с разбиране на списък на python
- Оценителят: tf.estimator.LinearClassifier(feature_columns, model_dir, n_classes = 2)
- Функция за импортиране на данните, размера на партидата и епохата: input_fn()
След това сте готови да обучавате, оценявате и правите прогнози с train(), evaluate() и predict()
За да подобрите производителността на модела, можете:
- Използвайте полиномна регресия
- Термин на взаимодействие: tf.feature_column.crossed_column
- Добавете параметър за регулиране
