def __init__(self, args):
super(SkipThoughtsModel, self).__init__(args)
self.uniform_initializer = tf.random_uniform_initializer(
minval=-self.uniform_init_scale, maxval=self.uniform_init_scale)
with open(args.vocab, 'r') as f:
self.vocab = [l.strip() for l in f]
# Set up input parsing stuff via tf.contrib.learn...
self.vocab_size = len(self.vocab)
encode = layers.sparse_column_with_integerized_feature(
'encode', bucket_size=self.vocab_size)
decode_pre = layers.sparse_column_with_integerized_feature(
'decode_pre', bucket_size=self.vocab_size)
decode_post = layers.sparse_column_with_integerized_feature(
'decode_post', bucket_size=self.vocab_size)
self.features = {
'encode': layers.embedding_column(encode, dimension=100),
'decode_pre': layers.embedding_column(decode_pre, dimension=100),
'decode_post': layers.embedding_column(decode_post, dimension=100),
}
self.feature_spec = tf.contrib.layers.create_feature_spec_for_parsing(
self.features),
# ... or do it the easy way:
self.features = {
'encode': tf.VarLenFeature(dtype=tf.int64),
'decode_pre': tf.VarLenFeature(dtype=tf.int64),
'decode_post': tf.VarLenFeature(dtype=tf.int64),
}
self.feature_spec = self.features
def build_estimator(model_dir, nbuckets, hidden_units):
"""
Build an estimator starting from INPUT COLUMNS.
These include feature transformations and synthetic features.
The model is a wide-and-deep model.
"""
# input columns
(dayofweek, hourofday, latdiff, londiff, euclidean, plon, plat, dlon, dlat, pcount) = INPUT_COLUMNS
# bucketize the lats & lons
latbuckets = np.linspace(38.0, 42.0, nbuckets).tolist()
lonbuckets = np.linspace(-76.0, -72.0, nbuckets).tolist()
b_plat = layers.bucketized_column(plat, latbuckets)
b_dlat = layers.bucketized_column(dlat, latbuckets)
b_plon = layers.bucketized_column(plon, lonbuckets)
b_dlon = layers.bucketized_column(dlon, lonbuckets)
# feature cross
ploc = layers.crossed_column([b_plat, b_plon], nbuckets*nbuckets)
dloc = layers.crossed_column([b_dlat, b_dlon], nbuckets*nbuckets)
pd_pair = layers.crossed_column([ploc, dloc], nbuckets ** 4 )
day_hr = layers.crossed_column([dayofweek, hourofday], 24*7)
# Wide columns and deep columns.
wide_columns = [
# feature crosses
dloc, ploc, pd_pair,
day_hr,
# sparse columns
dayofweek, hourofday,
# anything with a linear relationship
pcount
]
deep_columns = [
# embedding_column to "group" together ...
layers.embedding_column(pd_pair, 10),
layers.embedding_column(day_hr, 10),
# real_valued_column
plat, plon, dlat, dlon,
latdiff, londiff, euclidean
]
return tf.contrib.learn.DNNLinearCombinedRegressor(
model_dir=model_dir,
linear_feature_columns=wide_columns,
dnn_feature_columns=deep_columns,
dnn_hidden_units=hidden_units or [128, 32, 4])
def get_wide_deep():
# define column types
races = ['White', 'Black', 'American Indian', 'Chinese',
'Japanese', 'Hawaiian', 'Filipino', 'Unknown',
'Asian Indian', 'Korean', 'Samaon', 'Vietnamese']
is_male,mother_age,mother_race,plurality,gestation_weeks,mother_married,cigarette_use,alcohol_use = \
[ \
tflayers.sparse_column_with_keys('is_male', keys=['True', 'False']),
tflayers.real_valued_column('mother_age'),
tflayers.sparse_column_with_keys('mother_race', keys=races),
tflayers.real_valued_column('plurality'),
tflayers.real_valued_column('gestation_weeks'),
tflayers.sparse_column_with_keys('mother_married', keys=['True', 'False']),
tflayers.sparse_column_with_keys('cigarette_use', keys=['True', 'False', 'None']),
tflayers.sparse_column_with_keys('alcohol_use', keys=['True', 'False', 'None'])
]
# which columns are wide (sparse, linear relationship to output) and which are deep (complex relationship to output?)
wide = [is_male, mother_race, plurality, mother_married, cigarette_use, alcohol_use]
deep = [\
mother_age,
gestation_weeks,
tflayers.embedding_column(mother_race, 3)
]
return wide, deep
def create_embed(sparse_col):
dim = 10 # default
if hasattr(sparse_col, 'bucket_size'):
nbins = sparse_col.bucket_size
if nbins is not None:
dim = 1 + int(round(np.log2(nbins)))
return tflayers.embedding_column(sparse_col, dimension=dim)
def train_and_eval(train_steps, log_dir, training_set, validation_set, testing_set, ):
sparse_columns = [
layers.sparse_column_with_keys(attribute, training_set[attribute].unique()) for attribute in FEATURE_ATTRIBUTES
]
embedding_columns = [
layers.embedding_column(column, dimension=8) for column in sparse_columns
]
m = learn.DNNClassifier(
hidden_units=[10, 50, ],
feature_columns=embedding_columns,
model_dir=log_dir,
config=learn.RunConfig(save_checkpoints_secs=1, ),
)
validation_metrics = {
"accuracy": learn.MetricSpec(metric_fn=metrics.streaming_accuracy, prediction_key="classes"),
"precision": learn.MetricSpec(metric_fn=metrics.streaming_precision, prediction_key="classes"),
"recall": learn.MetricSpec(metric_fn=metrics.streaming_recall, prediction_key="classes"),
}
monitors = [
learn.monitors.ValidationMonitor(
input_fn=lambda: input_fn(validation_set),
every_n_steps=1000,
metrics=validation_metrics,
early_stopping_rounds=1,
),
]
m.fit(
input_fn=lambda: input_fn(training_set),
steps=train_steps,
monitors=monitors,
)
results = m.evaluate(input_fn=lambda: input_fn(testing_set), steps=1)
for key in sorted(results):
print("%s: %s" % (key, results[key]))
def get_wide_deep():
# define column types
StyleName,quantity, demand, org_ret_price,sell_price, margin, off_orig_retail, total_ots = \
[ \
tflayers.sparse_column_with_hash_bucket('Style_Name', hash_bucket_size = 1000),
tflayers.real_valued_column('Quantity'),
tflayers.real_valued_column('Demand'),
tflayers.real_valued_column('Original_Retail_Price'),
tflayers.real_valued_column('Selling_Price'),
tflayers.real_valued_column('Margin'),
tflayers.real_valued_column('off_Orig_Retail'),
tflayers.real_valued_column('Total_OTS'),
]
# which columns are wide (sparse, linear relationship to output) and which are deep (complex relationship to output?)
wide = [StyleName,quantity, demand]
deep = [\
org_ret_price,
sell_price,
margin,
off_orig_retail,
total_ots,
tflayers.embedding_column(StyleName, 3)
]
return wide, deep
def get_wide_deep():
# define column types
races = ['White', 'Black', 'American Indian', 'Chinese',
'Japanese', 'Hawaiian', 'Filipino', 'Unknown',
'Asian Indian', 'Korean', 'Samaon', 'Vietnamese']
is_male,mother_age,mother_race,plurality,gestation_weeks,mother_married,cigarette_use,alcohol_use = \
[ \
tflayers.sparse_column_with_keys('is_male', keys=['True', 'False']),
tflayers.real_valued_column('mother_age'),
tflayers.sparse_column_with_keys('mother_race', keys=races),
tflayers.real_valued_column('plurality'),
tflayers.real_valued_column('gestation_weeks'),
tflayers.sparse_column_with_keys('mother_married', keys=['True', 'False']),
tflayers.sparse_column_with_keys('cigarette_use', keys=['True', 'False', 'None']),
tflayers.sparse_column_with_keys('alcohol_use', keys=['True', 'False', 'None'])
]
# which columns are wide (sparse, linear relationship to output) and which are deep (complex relationship to output?)
wide = [is_male, mother_race, plurality, mother_married, cigarette_use, alcohol_use]
deep = [\
mother_age,
gestation_weeks,
tflayers.embedding_column(mother_race, 3)
]
return wide, deep
def build_estimator(model_dir, embedding_size=8, hidden_units=None):
(gender, race, education, marital_status, relationship, workclass,
occupation, native_country, age, education_num, capital_gain,
capital_loss, hours_per_week) = INPUT_COLUMNS
"""Build an estimator."""
# Sparse base columns.
# Reused Transformations.
age_buckets = layers.bucketized_column(
age, boundaries=[18, 25, 30, 35, 40, 45, 50, 55, 60, 65])
# Wide columns and deep columns.
wide_columns = [
layers.crossed_column([education, occupation],
hash_bucket_size=int(1e4)),
layers.crossed_column([age_buckets, race, occupation],
hash_bucket_size=int(1e6)),
layers.crossed_column([native_country, occupation],
hash_bucket_size=int(1e4)),
gender,
native_country,
education,
occupation,
workclass,
marital_status,
relationship,
age_buckets,
]
deep_columns = [
layers.embedding_column(workclass, dimension=embedding_size),
layers.embedding_column(education, dimension=embedding_size),
layers.embedding_column(marital_status, dimension=embedding_size),
layers.embedding_column(gender, dimension=embedding_size),
layers.embedding_column(relationship, dimension=embedding_size),
layers.embedding_column(race, dimension=embedding_size),
layers.embedding_column(native_country, dimension=embedding_size),
layers.embedding_column(occupation, dimension=embedding_size),
age,
education_num,
capital_gain,
capital_loss,
hours_per_week,
]
return tf.contrib.learn.DNNLinearCombinedClassifier(
model_dir=model_dir,
linear_feature_columns=wide_columns,
dnn_feature_columns=deep_columns,
dnn_hidden_units=hidden_units or [100, 70, 50, 25])
def generate_tf_columns():
columns = OrderedDict()
for fc in args['fc']:
id_feature = layers.sparse_column_with_hash_bucket(
column_name=fc['feature_name'],
hash_bucket_size=fc['hash_bucket_size'])
embedding = layers.embedding_column(
id_feature,
dimension=fc["embedding_dimension"])
columns[fc['feature_name']] = embedding
return columns
def contrib_learn_classifier_test():
"""Test tf.contrib.learn.DNN_classifier."""
language_column = layers.sparse_column_with_hash_bucket(
"language", hash_bucket_size=20)
feature_columns = [
layers.embedding_column(language_column, dimension=3),
layers.real_valued_column("age", dtype=tf.int64)
]
classifier = learn.DNNClassifier(
n_classes=3,
feature_columns=feature_columns,
hidden_units=[100, 100],
config=learn.RunConfig(tf_random_seed=1,
model_dir="../model_saver/estimators/"
"DNN_classifier_01"),
# optimizer=optimizer_exp_decay
)
classifier.fit(input_fn=_input_fn, steps=10000)
print("variables_names:\n", str(classifier.get_variable_names()))
# scores = classifier.evaluate(input_fn=_input_fn,
# steps=100)
# print("scores:\n", str(scores))
scores = classifier.evaluate(
input_fn=_input_fn,
steps=100,
metrics={
'my_accuracy':
MetricSpec(metric_fn=metrics.streaming_accuracy,
prediction_key="classes"),
'my_precision':
MetricSpec(metric_fn=metrics.streaming_precision,
prediction_key="classes"),
'my_recall':
MetricSpec(metric_fn=metrics.streaming_recall,
prediction_key="classes"),
'my_metric':
MetricSpec(metric_fn=my_metric_op, prediction_key="classes")
})
print("scores:\n", str(scores))
predictions = classifier.predict(input_fn=_input_fn,
outputs=["classes", "probabilities"])
print("predictions")
for prediction in predictions:
print(prediction)
def train_and_eval(model_dir, training_set, testing_set, ):
sparse_columns = [
layers.sparse_column_with_keys(
attribute['name'], pandas.read_csv(attribute['path'], sep='\t')['id'].apply(str),
) for attribute in FEATURE_ATTRIBUTES
]
embedding_columns = [layers.embedding_column(column, dimension=3) for column in sparse_columns]
model = learn.DNNRegressor(
hidden_units=[3, ],
feature_columns=embedding_columns,
model_dir=model_dir,
config=learn.RunConfig(save_checkpoints_secs=100, ),
)
model.fit(input_fn=lambda: input_fn(training_set), steps=20000, )
results = model.evaluate(input_fn=lambda: input_fn(testing_set), steps=1)
for key in sorted(results):
print('%s: %s' % (key, results[key]))
def build_estimator(model_dir, model_type):
"""build an estimator"""
# base sparse feature process
gender = layers.sparse_column_with_keys(column_name='gender', keys=['female', 'male'])
education = layers.sparse_column_with_hash_bucket(column_name='education', hash_bucket_size=1000)
relationship = layers.sparse_column_with_hash_bucket(column_name='relationship', hash_bucket_size=100)
workclass = layers.sparse_column_with_hash_bucket(column_name='workclass', hash_bucket_size=100)
occupation = layers.sparse_column_with_hash_bucket(column_name='occupation', hash_bucket_size=1000)
native_country = layers.sparse_column_with_hash_bucket(column_name='native_country', hash_bucket_size=1000)
# base continuous feature
age = layers.real_valued_column(column_name='age')
education_num = layers.real_valued_column(column_name='education_num')
capital_gain = layers.real_valued_column(column_name='capital_gain')
capital_loss = layers.real_valued_column(column_name='capital_loss')
hours_per_week = layers.real_valued_column(column_name='hours_per_week')
# transformation.bucketization 将连续变量转化为类别标签。从而提高我们的准确性
age_bucket = layers.bucketized_column(source_column=age,
boundaries=[18, 25, 30, 35, 40, 45,50, 55, 60, 65])
# wide columns and deep columns
# 深度模型使用到的特征和广度模型使用到的特征
# 广度模型特征只只用到了分类标签
wide_columns = [gender, native_country, education, relationship, workclass, occupation, age_bucket,
layers.crossed_column(columns=[education, occupation], hash_bucket_size=int(1e4)),
layers.crossed_column(columns=[age_bucket, education, occupation], hash_bucket_size=int(1e6)),
layers.crossed_column(columns=[native_country, occupation], hash_bucket_size=int(1e4))]
deep_columns = [layers.embedding_column(workclass, dimension=8),
layers.embedding_column(education, dimension=8),
layers.embedding_column(gender, dimension=8),
layers.embedding_column(relationship, dimension=8),
layers.embedding_column(native_country, dimension=8),
layers.embedding_column(occupation, dimension=8),
age, education_num, capital_gain, capital_loss, hours_per_week]
if model_type == "wide":
m=learn.LinearClassifier(feature_columns=wide_columns, model_dir=model_dir)
elif model_type == "deep":
m=learn.DNNClassifier(feature_columns=deep_columns, model_dir=model_dir, hidden_units=[100, 50])
else:
m=learn.DNNLinearCombinedClassifier(model_dir=model_dir,
linear_feature_columns=wide_columns,
dnn_feature_columns=deep_columns,
dnn_hidden_units=[256, 128, 64],
dnn_activation_fn=tf.nn.relu)
return m
def build_estimator(model_dir, embedding_size=8, hidden_units=None):
"""Build a wide and deep model for predicting income category.
Wide and deep models use deep neural nets to learn high level abstractions
about complex features or interactions between such features.
These models then combined the outputs from the DNN with a linear regression
performed on simpler features. This provides a balance between power and
speed that is effective on many structured data problems.
You can read more about wide and deep models here:
https://research.googleblog.com/2016/06/wide-deep-learning-better-together-with.html
To define model we can use the prebuilt DNNCombinedLinearClassifier class,
and need only define the data transformations particular to our dataset, and then
assign these (potentially) transformed features to either the DNN, or linear
regression portion of the model.
Args:
model_dir: str, the model directory used by the Classifier for checkpoints
summaries and exports.
embedding_size: int, the number of dimensions used to represent categorical
features when providing them as inputs to the DNN.
hidden_units: [int], the layer sizes of the DNN (input layer first)
Returns:
A DNNCombinedLinearClassifier
"""
(gender, race, education, marital_status, relationship,
workclass, occupation, native_country, age,
education_num, capital_gain, capital_loss, hours_per_week) = INPUT_COLUMNS
"""Build an estimator."""
# Reused Transformations.
# Continuous columns can be converted to categorical via bucketization
age_buckets = layers.bucketized_column(
age, boundaries=[18, 25, 30, 35, 40, 45, 50, 55, 60, 65])
# Wide columns and deep columns.
wide_columns = [
# Interactions between different categorical features can also
# be added as new virtual features.
layers.crossed_column(
[education, occupation], hash_bucket_size=int(1e4)),
layers.crossed_column(
[age_buckets, race, occupation], hash_bucket_size=int(1e6)),
layers.crossed_column(
[native_country, occupation], hash_bucket_size=int(1e4)),
gender,
native_country,
education,
occupation,
workclass,
marital_status,
relationship,
age_buckets,
]
deep_columns = [
layers.embedding_column(workclass, dimension=embedding_size),
layers.embedding_column(education, dimension=embedding_size),
layers.embedding_column(marital_status, dimension=embedding_size),
layers.embedding_column(gender, dimension=embedding_size),
layers.embedding_column(relationship, dimension=embedding_size),
layers.embedding_column(race, dimension=embedding_size),
layers.embedding_column(native_country, dimension=embedding_size),
layers.embedding_column(occupation, dimension=embedding_size),
age,
education_num,
capital_gain,
capital_loss,
hours_per_week,
]
return tf.contrib.learn.DNNLinearCombinedClassifier(
model_dir=model_dir,
linear_feature_columns=wide_columns,
dnn_feature_columns=deep_columns,
dnn_hidden_units=hidden_units or [100, 70, 50, 25])
def build_estimator(model_dir, nbuckets, hidden_units):
"""
Build an estimator starting from INPUT COLUMNS.
These include feature transformations and synthetic features.
The model is a wide-and-deep model.
"""
# input columns
(dayofweek, hourofday, latdiff, londiff, euclidean, plon, plat, dlon, dlat,
pcount) = INPUT_COLUMNS
# bucketize the lats & lons
latbuckets = np.linspace(38.0, 42.0, nbuckets).tolist()
lonbuckets = np.linspace(-76.0, -72.0, nbuckets).tolist()
b_plat = layers.bucketized_column(plat, latbuckets)
b_dlat = layers.bucketized_column(dlat, latbuckets)
b_plon = layers.bucketized_column(plon, lonbuckets)
b_dlon = layers.bucketized_column(dlon, lonbuckets)
# feature cross
ploc = layers.crossed_column([b_plat, b_plon], nbuckets * nbuckets)
dloc = layers.crossed_column([b_dlat, b_dlon], nbuckets * nbuckets)
pd_pair = layers.crossed_column([ploc, dloc], nbuckets**4)
day_hr = layers.crossed_column([dayofweek, hourofday], 24 * 7)
# Wide columns and deep columns.
wide_columns = [
# feature crosses
dloc,
ploc,
pd_pair,
day_hr,
# sparse columns
dayofweek,
hourofday,
# anything with a linear relationship
pcount
]
deep_columns = [
# embedding_column to "group" together ...
layers.embedding_column(pd_pair, 10),
layers.embedding_column(day_hr, 10),
# real_valued_column
plat,
plon,
dlat,
dlon,
latdiff,
londiff,
euclidean
]
return tf.contrib.learn.DNNLinearCombinedRegressor(
model_dir=model_dir,
linear_feature_columns=wide_columns,
dnn_feature_columns=deep_columns,
dnn_hidden_units=hidden_units or [128, 32, 4])
def build_feature_cols():
# Sparse base columns.
gender = tf.contrib.layers.sparse_column_with_keys(column_name="gender",
keys=["female", "male"])
race = tf.contrib.layers.sparse_column_with_keys(column_name="race",
keys=[
"Amer-Indian-Eskimo",
"Asian-Pac-Islander",
"Black", "Other",
"White"
])
education = tf.contrib.layers.sparse_column_with_hash_bucket(
"education", hash_bucket_size=1000)
marital_status = tf.contrib.layers.sparse_column_with_hash_bucket(
"marital_status", hash_bucket_size=100)
relationship = tf.contrib.layers.sparse_column_with_hash_bucket(
"relationship", hash_bucket_size=100)
workclass = tf.contrib.layers.sparse_column_with_hash_bucket(
"workclass", hash_bucket_size=100)
occupation = tf.contrib.layers.sparse_column_with_hash_bucket(
"occupation", hash_bucket_size=1000)
native_country = tf.contrib.layers.sparse_column_with_hash_bucket(
"native_country", hash_bucket_size=1000)
# Continuous base columns.
age = real_valued_column("age")
education_num = real_valued_column("education_num")
capital_gain = real_valued_column("capital_gain")
capital_loss = real_valued_column("capital_loss")
hours_per_week = real_valued_column("hours_per_week")
# Transformations.
age_buckets = tf.contrib.layers.bucketized_column(
age, boundaries=[18, 25, 30, 35, 40, 45, 50, 55, 60, 65])
education_occupation = tf.contrib.layers.crossed_column(
[education, occupation], hash_bucket_size=int(1e4))
age_race_occupation = tf.contrib.layers.crossed_column(
[age_buckets, race, occupation], hash_bucket_size=int(1e6))
country_occupation = tf.contrib.layers.crossed_column(
[native_country, occupation], hash_bucket_size=int(1e4))
# Wide columns and deep columns.
wide_columns = [
gender, native_country, education, occupation, workclass, race,
marital_status, relationship, age_buckets, education_occupation,
age_race_occupation, country_occupation
]
deep_columns = [
embedding_column(gender, dimension=8),
embedding_column(native_country, dimension=8),
embedding_column(education, dimension=8),
embedding_column(occupation, dimension=8),
embedding_column(workclass, dimension=8),
embedding_column(race, dimension=8),
embedding_column(marital_status, dimension=8),
embedding_column(relationship, dimension=8),
embedding_column(age_buckets, dimension=8),
embedding_column(education_occupation, dimension=8),
embedding_column(age_race_occupation, dimension=8),
embedding_column(country_occupation, dimension=8),
age,
education_num,
capital_gain,
capital_loss,
hours_per_week,
]
return wide_columns, deep_columns
def build_estimator(model_dir=MODEL_DIR):
"""
Build an estimator using
CONTINTUOUS_COLUMNS, BINARY_COLUMNS and MULTI_CATEGORY_COLUMNS.
"""
bucketized_columns = \
[sparse_column_with_hash_bucket(col, 1000)
for col in MULTI_CATEGORY_COLUMNS] + \
[sparse_column_with_integerized_feature(col, bucket_size=2)
for col in BINARY_COLUMNS]
real_valued_columns = \
[real_valued_column(col) for col in CONTINUOUS_COLUMNS]
crossed_columns = \
[]
# Wide columns and deep columns.
wide_columns = \
bucketized_columns + \
real_valued_columns + \
crossed_columns
# embedding columns for hash_bucket columns
deep_columns = \
[embedding_column(col, dimension=EMBEDDING_DIMENSION)
for col in bucketized_columns] + \
real_valued_columns + \
crossed_columns
if MODEL_TYPE == "wide":
print('Creating wide LinearClassifier model...\n')
model = tf.contrib.learn.LinearClassifier(
model_dir=model_dir,
n_classes=2,
feature_columns=wide_columns,
# optimizer=tf.train.GradientDescentOptimizer(
# learning_rate=FLAGS.learn_rate)
# optimizer=tf.train.FtrlOptimizer(
# learning_rate=LEARN_RATE,
# l1_regularization_strength=0.0,
# l2_regularization_strength=0.0),
)
elif MODEL_TYPE == "deep":
print('Creating deep DNNClassifier model...\n')
model = tf.contrib.learn.DNNClassifier(
model_dir=model_dir,
n_classes=2,
feature_columns=deep_columns,
hidden_units=HIDDEN_UNITS,
# optimizer=tf.train.FtrlOptimizer(
# learning_rate=LEARN_RATE,
# l1_regularization_strength=0.0,
# l2_regularization_strength=0.0),
)
else:
print('Creating deepNwide DNNLinearCombinedClassifier model...\n')
model = tf.contrib.learn.DNNLinearCombinedClassifier(
model_dir=model_dir,
n_classes=2,
linear_feature_columns=wide_columns,
dnn_feature_columns=deep_columns,
dnn_hidden_units=HIDDEN_UNITS,
# optimizer=tf.train.FtrlOptimizer(
# learning_rate=LEARN_RATE,
# l1_regularization_strength=0.0,
# l2_regularization_strength=0.0),
)
return model
for var in categorical_vars:
le = LabelEncoder().fit(X_train[var])
X_train[var + '_ids'] = le.transform(X_train[var])
X_test[var + '_ids'] = le.transform(X_test[var])
X_train.pop(var)
X_test.pop(var)
categorical_var_encoders[var] = le
### Note: Feature Columns currently (2016/10/22) not working, update is coming.
# Setup feature columns.
CATEGORICAL_EMBED_SIZE = 10 # Note, you can customize this per variable.
feature_columns = [
layers.real_valued_column(var) for var in continues_vars
] + [
layers.embedding_column(
layers.sparse_column_with_integerized_feature(
var + '_ids', len(categorical_var_encoders[var].classes_)),
CATEGORICAL_EMBED_SIZE) for var in
categorical_vars
]
# Linear classifier.
'''
random.seed(42)
tflr = learn.LinearClassifier(n_classes=2,
feature_columns=feature_columns,
optimizer=tf.train.GradientDescentOptimizer(learning_rate=0.05))
tflr.fit(input_fn=train_input_fn, steps=500)
print(list(tflr.predict(input_fn=test_input_fn, as_iterable=True)), y_test)
print(accuracy_score(y_test, list(tflr.predict(input_fn=test_input_fn, as_iterable=True))))
'''
def get_feature_column():
feature_name = 'gender'
sparse_id_column = layers.sparse_column_with_hash_bucket(
column_name=feature_name, hash_bucket_size=100)
feature_column = layers.embedding_column(sparse_id_column, dimension=10)
return feature_column
def build_estimator(model_dir, embedding_size=8, hidden_units=None):
"""Build a wide and deep model for predicting income category.
Wide and deep models use deep neural nets to learn high level abstractions
about complex features or interactions between such features.
These models then combined the outputs from the DNN with a linear regression
performed on simpler features. This provides a balance between power and
speed that is effective on many structured data problems.
You can read more about wide and deep models here:
https://research.googleblog.com/2016/06/wide-deep-learning-better-together-with.html
To define model we can use the prebuilt DNNCombinedLinearClassifier class,
and need only define the data transformations particular to our dataset, and then
assign these (potentially) transformed features to either the DNN, or linear
regression portion of the model.
Args:
model_dir: str, the model directory used by the Classifier for checkpoints
summaries and exports.
embedding_size: int, the number of dimensions used to represent categorical
features when providing them as inputs to the DNN.
hidden_units: [int], the layer sizes of the DNN (input layer first)
Returns:
A DNNCombinedLinearClassifier
"""
(actividad, anio, bueno, dia, lugar, mes, pais) = INPUT_COLUMNS
"""Build an estimator."""
# Reused Transformations.
# Continuous columns can be converted to categorical via bucketization
mes_bucket = layers.bucketized_column(
mes, boundaries=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
# Wide columns and deep columns.
wide_columns = [
# Interactions between different categorical features can also
# be added as new virtual features.
layers.crossed_column([actividad, lugar], hash_bucket_size=int(1e4)),
layers.crossed_column([actividad, mes_bucket],
hash_bucket_size=int(1e4)),
layers.crossed_column([actividad, dia], hash_bucket_size=int(1e4)),
layers.crossed_column([actividad, pais], hash_bucket_size=int(1e4)),
actividad,
dia,
lugar,
mes_bucket,
pais,
]
deep_columns = [
layers.embedding_column(actividad, dimension=embedding_size),
layers.embedding_column(lugar, dimension=embedding_size),
layers.embedding_column(dia, dimension=embedding_size),
layers.embedding_column(pais, dimension=embedding_size),
anio,
mes,
bueno,
]
return tf.contrib.learn.DNNLinearCombinedClassifier(
model_dir=model_dir,
linear_feature_columns=wide_columns,
dnn_feature_columns=deep_columns,
dnn_hidden_units=hidden_units or [100, 70, 50, 25])
def parse_feature_columns_from_examples_test():
"""Construct examples by tf.train.Example.
Then, parse feature columns from examples.
Finally, get input from feature columns.
Returns:
The input tensor transformed from examples in defined feature columns
format.
"""
language_column = layers.sparse_column_with_hash_bucket(
"language", hash_bucket_size=20)
feature_columns = [
layers.embedding_column(language_column, dimension=3),
layers.real_valued_column("age", dtype=tf.int64)
]
example1 = tf.train.Example(features=tf.train.Features(
feature={
"age":
tf.train.Feature(int64_list=tf.train.Int64List(value=[18])),
"language":
tf.train.Feature(bytes_list=tf.train.BytesList(value=[b"en"]))
}))
example2 = tf.train.Example(features=tf.train.Features(
feature={
"age":
tf.train.Feature(int64_list=tf.train.Int64List(value=[20])),
"language":
tf.train.Feature(bytes_list=tf.train.BytesList(value=[b"fr"]))
}))
example3 = tf.train.Example(features=tf.train.Features(
feature={
"age":
tf.train.Feature(int64_list=tf.train.Int64List(value=[25])),
"language":
tf.train.Feature(bytes_list=tf.train.BytesList(value=[b"en"]))
}))
examples = [
example1.SerializeToString(),
example2.SerializeToString(),
example3.SerializeToString()
]
print(examples)
# feature_lists = tf.train.FeatureLists(
# feature_list={
# "age": tf.train.FeatureList(
# feature=[
# tf.train.Feature(int64_list=tf.train.Int64List(value=[18])),
# tf.train.Feature(int64_list=tf.train.Int64List(value=[20])),
# tf.train.Feature(int64_list=tf.train.Int64List(value=[25])),
# ]
# ),
# "language": tf.train.FeatureList(
# feature=[
# tf.train.Feature(bytes_list=tf.train.BytesList(value=[
# b"en"])),
# tf.train.Feature(bytes_list=tf.train.BytesList(value=[
# b"fr"])),
# tf.train.Feature(bytes_list=tf.train.BytesList(value=[
# b"zh"]))
# ]
# )
# }
# )
# print(feature_lists)
# serialized = feature_lists.SerializeToString()
columns_to_tensor = layers.parse_feature_columns_from_examples(
serialized=examples, feature_columns=feature_columns)
input_layer = layers.input_from_feature_columns(
columns_to_tensors=columns_to_tensor, feature_columns=feature_columns)
print("input_layer:\n", str(input_layer))
sess = tf.InteractiveSession()
tf.initialize_all_variables().run(session=sess)
print(input_layer.eval(session=sess))
return input_fn(data)
def testing_fn():
return input_fn(data_test)
data["tmp"]= data["class"].apply(help)
data_test["tmp"]= data_test["class"].apply(help)
buying = layers.sparse_column_with_keys(column_name="buying",keys=["low","med","high","vhigh"])
maint = layers.sparse_column_with_keys(column_name="maint",keys=["low","med","high","vhigh"])
doors = layers.sparse_column_with_keys(column_name="doors",keys=["2","3","4","5more"])
persons = layers.sparse_column_with_keys(column_name="persons",keys=["2","4","more"])
lug_boot = layers.sparse_column_with_keys(column_name="lug_boot",keys=["small","med","big"])
safety = layers.sparse_column_with_keys(column_name="safety",keys=["low","med","high"])
buying_emb = layers.embedding_column(buying,dimension=4)
maint_emb = layers.embedding_column(maint,dimension=4)
doors_emb = layers.embedding_column(doors,dimension=4)
persons_emb = layers.embedding_column(persons,dimension=3)
lug_boot_emb = layers.embedding_column(lug_boot,dimension=3)
safety_emb = layers.embedding_column(safety,dimension=3)
dnn_classifier = learn.DNNClassifier(feature_columns=[buying_emb, maint_emb,doors_emb,persons_emb,lug_boot_emb,safety_emb], hidden_units=[10], n_classes=4, )
#dnn_classifier.fit(X_train, y_train, steps = 1000)
dnn_classifier.fit(input_fn=train_input_fn,steps=1000)
y_test = dnn_classifier.evaluate(input_fn=testing_fn,steps=1)
print("Precision=")
print(y_test['accuracy'])
def build_network_my(self,
num_factor=10,
num_factor_mlp=64,
hidden_dimension=10,
num_neg_sample=30):
print("my network")
self.num_neg_sample = num_neg_sample
self.user_id = tf.placeholder(dtype=tf.string,
shape=[None],
name='user_id')
self.item_id = tf.placeholder(dtype=tf.string,
shape=[None],
name='item_id')
##########################################################################3
self.target_item_id = tf.placeholder(dtype=tf.string,
shape=[None],
name='target_item_id')
self.hot_item_id = tf.placeholder(dtype=tf.string,
shape=[None],
name='hot_item_id')
self.long_item_id = tf.placeholder(dtype=tf.string,
shape=[None],
name='long_item_id')
###########################################################################
self.y = tf.placeholder(dtype=tf.float32, shape=[None], name='y')
self.par = tf.placeholder(dtype=tf.float32)
###################################################################################
##################################################################################
a = {'user': self.user_id}
b = {'item': self.item_id}
c = {'item': self.target_item_id}
d = {'user_low': self.user_id}
e = {'item_low': self.item_id}
f = {'item_low': self.target_item_id}
h = {'item': self.hot_item_id}
l = {'item': self.long_item_id}
with tf.variable_scope(name_or_scope='embedding',
reuse=tf.AUTO_REUSE) as scope:
id_feature1 = layers.sparse_column_with_hash_bucket(
column_name='user',
hash_bucket_size=190000
# use_hashmap=use_hashmap
)
id_feature2 = layers.sparse_column_with_hash_bucket(
column_name='item',
hash_bucket_size=120000
# use_hashmap=use_hashmap
)
shared_embedding_columns1 = layers.embedding_column(
id_feature1, dimension=64, combiner="mean")
#
#
shared_embedding_columns2 = layers.embedding_column(
id_feature2, dimension=64, combiner="mean")
a1 = []
a1.append(shared_embedding_columns1)
b1 = []
b1.append(shared_embedding_columns2)
#
mlp_user_latent_factor = layers.input_from_feature_columns(
a, a1, scope='user')
mlp_item_latent_factor = layers.input_from_feature_columns(
b, b1, scope='item')
mlp_target_item_latent_factor = layers.input_from_feature_columns(
c, b1, scope='item')
#########################################################################################
mlp_hot_item_latent_factor = layers.input_from_feature_columns(
h, b1, scope='item')
mlp_long_item_latent_factor = layers.input_from_feature_columns(
l, b1, scope='item')
#########################################################################################
id_feature3 = layers.sparse_column_with_hash_bucket(
column_name='user_low',
hash_bucket_size=190000
# use_hashmap=use_hashmap
)
id_feature4 = layers.sparse_column_with_hash_bucket(
column_name='item_low',
hash_bucket_size=120000
# use_hashmap=use_hashmap
)
shared_embedding_columns3 = layers.embedding_column(
id_feature3, dimension=10, combiner="mean")
#
#
shared_embedding_columns4 = layers.embedding_column(
id_feature4, dimension=10, combiner="mean")
d1 = []
d1.append(shared_embedding_columns3)
e1 = []
e1.append(shared_embedding_columns4)
#
user_latent_factor = layers.input_from_feature_columns(
d, d1, scope='user_low')
item_latent_factor = layers.input_from_feature_columns(
e, e1, scope='item_low')
target_item_latent_factor = layers.input_from_feature_columns(
f, e1, scope='item_low')
###################################################################################
###################################################################################################
###################################################################################################
GMF = tf.multiply(user_latent_factor, item_latent_factor)
#####################################################################
GMF_target = tf.multiply(user_latent_factor, target_item_latent_factor)
#####################################################################
user_feature = self.user_side(mlp_user_latent_factor)
item_feature = self.item_side(mlp_item_latent_factor)
#########################################################
target_item_feature = self.item_side(mlp_target_item_latent_factor,
reuse=True)
hot_item_feature = self.item_side(mlp_hot_item_latent_factor,
reuse=True)
long_item_feature = self.item_side(mlp_long_item_latent_factor,
reuse=True)
#########################################################
self.pair_loss = 0
self.resort_item = []
self.resort_label = []
for i in range(0, self.batch_size):
temp1 = []
temp2 = []
temp1.append(item_feature[i * self.batch_size:(i + 1) *
self.batch_size, :])
temp2.append(self.y[i * self.batch_size:(i + 1) * self.batch_size])
self.resort_item.append(temp1)
self.resort_label.append(temp2)
discriminative_loss = []
for i in range(0, self.batch_size):
discriminative_loss.append(
get_center_loss(tf.reshape(self.resort_item[i], (-1, 128)),
tf.reshape(self.resort_label[i], (-1, 1)), 2))
for i in range(0, self.batch_size):
self.pair_loss = self.pair_loss + discriminative_loss[
i] / self.batch_size
# #########################################################
# self.userF=user_feature
# self.itemF=item_feature
# #########################################
# # self.pred_y = tf.nn.sigmoid(
# # tf.reduce_sum( 5 * tf.multiply(user_feature, item_feature),1))
# ########################################
self.pred_y = tf.nn.sigmoid(
tf.reduce_sum(
tf.concat([GMF, 5 * tf.multiply(user_feature, item_feature)],
axis=1), 1))
# self.pred_long=tf.nn.sigmoid(tf.reduce_sum(tf.concat([GMF,5*tf.multiply(user_feature, target_item_feature)], axis=1), 1))
avg_GMF = tf.reduce_mean(GMF)
# avg_GMF=tf.stop_gradient(tf.identity(tf.reduce_mean(GMF)))
self.pred_long = tf.nn.sigmoid(avg_GMF + tf.reduce_sum(
5 * tf.multiply(user_feature, target_item_feature), 1))
# self.pred_y = tf.layers.dense(inputs=tf.concat([GMF, MLP], axis=1), units=1, activation=tf.sigmoid, kernel_initializer=tf.random_normal_initializer, kernel_regularizer= tf.contrib.layers.l2_regularizer(scale=self.reg_rate))
#Pseudo label
self.p1 = tf.reshape(
tf.gather(
self.pred_long,
tf.reshape(tf.where(tf.less(self.pred_long, 0.2)), [
-1,
])), [-1, 1])
self.p2 = tf.reshape(
tf.gather(
self.pred_long,
tf.reshape(tf.where(tf.greater(self.pred_long, 0.8)), [
-1,
])), [-1, 1])
self.tar1 = tf.maximum(
0.0,
tf.reduce_mean(-self.p1 * tf.log(
tf.clip_by_value(self.p1, 0.005, 1)))) #/ self.batch_size
self.tar2 = tf.maximum(
0.0,
tf.reduce_mean(-self.p2 * tf.log(
tf.clip_by_value(self.p2, 0.005, 1)))) #/ self.batch_size
self.pseudo_loss = self.tar1 + self.tar2
# self.loss = - tf.reduce_sum(
# self.y * tf.log(self.pred_y + 1e-10) + (1 - self.y) * tf.log(1 - self.pred_y + 1e-10))
self.loss = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(logits=self.pred_y,
labels=self.y))
self.weight_loss = 0.01 * tf.losses.get_regularization_loss(
) #+ self.reg_rate * (
# tf.nn.l2_loss(self.P) + tf.nn.l2_loss(self.Q) + tf.nn.l2_loss(self.mlp_P) + tf.nn.l2_loss(self.mlp_Q))
# self.DAloss=tf.maximum(0.0001,KMMD(hot_item_feature,long_item_feature))
self.DAloss = self.coral_loss(hot_item_feature, long_item_feature)
# self.optimizer = tf.train.AdagradOptimizer(self.learning_rate).minimize(self.loss)
# self.total_loss=self.loss+self.weight_loss+100*self.DAloss
# self.total_loss=self.loss+self.weight_loss+100*self.DAloss
# self.total_loss = self.loss + self.weight_loss
# self.total_loss=self.loss+self.weight_loss+100*self.DAloss+0.001*self.par*self.pseudo_loss+0.001*self.par*self.pair_loss
self.total_loss = self.loss + self.weight_loss + self.A2C_weight * self.DAloss + self.pseudo_weight * self.par * self.pseudo_loss + self.center_weight * self.par * self.pair_loss
self.optimizer = tf.train.AdamOptimizer(0.0001).minimize(
self.total_loss)
return self
def build_estimator(model_dir, model_type):
"""Build an estimator."""
# Sparse base columns.
userID = layers.sparse_column_with_integerized_feature('userID', 2805118)
creativeID = layers.sparse_column_with_integerized_feature(
'creativeID', 6582)
positionID = layers.sparse_column_with_integerized_feature(
'positionID', 7645)
adID = layers.sparse_column_with_integerized_feature('adID', 3616)
camgaignID = layers.sparse_column_with_integerized_feature(
'camgaignID', 720)
advertiserID = layers.sparse_column_with_integerized_feature(
'advertiserID', 91)
appID = layers.sparse_column_with_integerized_feature('appID', 50)
sitesetID = layers.sparse_column_with_integerized_feature('sitesetID', 3)
appCategory = layers.sparse_column_with_integerized_feature(
'appCategory', 14)
appPlatform = layers.sparse_column_with_integerized_feature(
'appPlatform', 2)
education = layers.sparse_column_with_integerized_feature('education', 8)
gender = layers.sparse_column_with_integerized_feature('gender', 3)
haveBaby = layers.sparse_column_with_integerized_feature('haveBaby', 7)
marriageStatus = layers.sparse_column_with_integerized_feature(
'marriageStatus', 4)
positionType = layers.sparse_column_with_integerized_feature(
'positionType', 6)
hometown_c = layers.sparse_column_with_integerized_feature(
'hometown_c', 22)
hometown_p = layers.sparse_column_with_integerized_feature(
'hometown_p', 35)
residence_c = layers.sparse_column_with_integerized_feature(
'residence_c', 22)
residence_p = layers.sparse_column_with_integerized_feature(
'residence_p', 35)
telecomsOperator = layers.sparse_column_with_integerized_feature(
'telecomsOperator', 4)
connectionType = layers.sparse_column_with_integerized_feature(
'connectionType', 5)
clickTime_week = layers.sparse_column_with_integerized_feature(
'clickTime_week', 7)
# Continuous base columns.
age = layers.real_valued_column("age")
inst_app_installed = layers.real_valued_column('inst_app_installed')
inst_cate_percent = layers.real_valued_column('inst_cate_percent')
inst_cnt_appcate = layers.real_valued_column('inst_cnt_appcate')
inst_cnt_installed = layers.real_valued_column('inst_cnt_installed')
inst_is_installed = layers.real_valued_column('inst_is_installed')
action_cate = layers.real_valued_column('action_cate')
action_cate_recent = layers.real_valued_column('action_cate_recent')
action_installed = layers.real_valued_column('action_installed')
tt_cnt_appcate = layers.real_valued_column('tt_cnt_appcate')
tt_is_installed = layers.real_valued_column('tt_is_installed')
clickTime_day = layers.real_valued_column('clickTime_day')
clickTime_hour = layers.real_valued_column('clickTime_hour')
clickTime_minute = layers.real_valued_column('clickTime_minute')
# Transformations.
age_buckets = layers.bucketized_column(
age, boundaries=[18, 25, 30, 35, 40, 45, 50, 55, 60, 65])
inst_app_installed_buckets = layers.bucketized_column(
inst_app_installed,
boundaries=[1000, 5000, 10000, 50000, 100000, 500000])
clickTime_hour_buckets = layers.bucketized_column(
clickTime_hour, boundaries=[8, 11, 14, 17, 19, 22])
# Wide columns and deep columns.
wide_columns = [
userID,
creativeID,
positionID,
adID,
camgaignID,
advertiserID,
appID,
sitesetID,
appCategory,
appPlatform,
education,
gender,
haveBaby,
marriageStatus,
positionType,
hometown_c,
hometown_p,
residence_c,
residence_p,
telecomsOperator,
connectionType,
clickTime_week,
# layers.embedding_column(userID, dimension=8),
# layers.embedding_column(creativeID, dimension=8),
# layers.embedding_column(positionID, dimension=8),
# layers.embedding_column(adID, dimension=8),
# layers.embedding_column(camgaignID, dimension=8),
# layers.embedding_column(advertiserID, dimension=8),
# layers.embedding_column(appID, dimension=8),
# layers.embedding_column(sitesetID, dimension=8),
# layers.embedding_column(appCategory, dimension=8),
# layers.embedding_column(appPlatform, dimension=8),
# layers.embedding_column(education, dimension=8),
# layers.embedding_column(gender, dimension=8),
# layers.embedding_column(haveBaby, dimension=8),
# layers.embedding_column(marriageStatus, dimension=8),
# layers.embedding_column(positionType, dimension=8),
# layers.embedding_column(hometown_c, dimension=8),
# layers.embedding_column(hometown_p, dimension=8),
# layers.embedding_column(residence_c, dimension=8),
# layers.embedding_column(residence_p, dimension=8),
# layers.embedding_column(telecomsOperator, dimension=8),
# layers.embedding_column(connectionType, dimension=8),
# layers.embedding_column(clickTime_week, dimension=8),
# layers.one_hot_column(userID),
# layers.one_hot_column(creativeID),
# layers.one_hot_column(positionID),
# layers.one_hot_column(adID),
# layers.one_hot_column(camgaignID),
# layers.one_hot_column(advertiserID),
# layers.one_hot_column(appID),
# layers.one_hot_column(sitesetID),
# layers.one_hot_column(appCategory),
# layers.one_hot_column(appPlatform),
# layers.one_hot_column(education),
# layers.one_hot_column(gender),
# layers.one_hot_column(haveBaby),
# layers.one_hot_column(marriageStatus),
# layers.one_hot_column(positionType),
# layers.one_hot_column(hometown_c),
# layers.one_hot_column(hometown_p),
# layers.one_hot_column(residence_c),
# layers.one_hot_column(residence_p),
# layers.one_hot_column(telecomsOperator),
# layers.one_hot_column(connectionType),
# layers.one_hot_column(clickTime_week),
age_buckets,
clickTime_hour_buckets,
inst_app_installed_buckets,
]
deep_columns = [
layers.embedding_column(userID, dimension=8),
layers.embedding_column(creativeID, dimension=8),
layers.embedding_column(positionID, dimension=8),
layers.embedding_column(adID, dimension=8),
layers.embedding_column(camgaignID, dimension=8),
layers.embedding_column(advertiserID, dimension=8),
layers.embedding_column(appID, dimension=8),
layers.embedding_column(sitesetID, dimension=8),
layers.embedding_column(appCategory, dimension=8),
layers.embedding_column(appPlatform, dimension=8),
layers.embedding_column(education, dimension=8),
layers.embedding_column(gender, dimension=8),
layers.embedding_column(haveBaby, dimension=8),
layers.embedding_column(marriageStatus, dimension=8),
layers.embedding_column(positionType, dimension=8),
layers.embedding_column(hometown_c, dimension=8),
layers.embedding_column(hometown_p, dimension=8),
layers.embedding_column(residence_c, dimension=8),
layers.embedding_column(residence_p, dimension=8),
layers.embedding_column(telecomsOperator, dimension=8),
layers.embedding_column(connectionType, dimension=8),
layers.embedding_column(clickTime_week, dimension=8),
age,
action_cate,
action_cate_recent,
action_installed,
inst_app_installed,
inst_cate_percent,
inst_cnt_appcate,
inst_cnt_installed,
inst_is_installed,
tt_cnt_appcate,
tt_is_installed,
clickTime_day,
clickTime_hour,
clickTime_minute,
]
if model_type == "wide":
m = tf.contrib.learn.LinearClassifier(model_dir=model_dir,
feature_columns=wide_columns)
elif model_type == "deep":
m = tf.contrib.learn.DNNClassifier(model_dir=model_dir,
feature_columns=deep_columns,
hidden_units=[100, 50])
else:
m = tf.contrib.learn.DNNLinearCombinedClassifier(
model_dir=model_dir,
linear_feature_columns=wide_columns,
dnn_feature_columns=deep_columns,
dnn_hidden_units=[100, 50, 1],
fix_global_step_increment_bug=True)
return m
median_distance_buckets = bucketized_column(median_distance, boundaries=[10,50,100,200,300])
population = real_valued_column("population")
population_buckets = bucketized_column(population, boundaries=[0, 1, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000])
popularity = real_valued_column("popularity")
admin_level_x_median_distance = crossed_column([admin_level, median_distance_buckets], hash_bucket_size=int(1e4))
admin_level_x_cluster_frequency = crossed_column([admin_level, cluster_frequency_buckets], hash_bucket_size=int(1e4))
admin_level_x_country_code = crossed_column([admin_level, country_code], hash_bucket_size=int(1e4))
#number_of_other_points_in_country = sparse_column_with_hash_bucket("number_of_other_points_in_country", hash_bucket_size=1000)
#number_of_other_points_in_admin1 = sparse_column_with_hash_bucket("number_of_other_points_in_admin1", hash_bucket_size=1000)
#number_of_other_points_in_admin2 = sparse_column_with_hash_bucket("number_of_other_points_in_admin2", hash_bucket_size=1000)
#feature_columns = [admin_level, cluster_frequency_buckets, country_code, country_rank, edit_distance, is_lowest_admin_level, has_mpoly, has_pcode, matches_topic, median_distance, median_distance_buckets, population_buckets, popularity, admin_level_x_cluster_frequency, admin_level_x_country_code, admin_level_x_median_distance]
#print "feature_columns:", feature_columns
wide_columns = [admin_level, cluster_frequency_buckets, country_code, country_rank, edit_distance, is_country, is_highest_population, is_lowest_admin_level, has_mpoly, has_pcode, matches_topic, median_distance, median_distance_buckets, population_buckets, popularity, admin_level_x_cluster_frequency, admin_level_x_country_code, admin_level_x_median_distance]
deep_columns = [
embedding_column(admin_level, dimension=8),
cluster_frequency,
cluster_frequency_buckets,
embedding_column(country_code, dimension=8),
country_rank,
embedding_column(has_mpoly, dimension=8),
embedding_column(has_pcode, dimension=8),
embedding_column(is_country, dimension=8),
embedding_column(is_lowest_admin_level, dimension=8),
embedding_column(is_highest_population, dimension=8),
median_distance_buckets,
population_buckets,
popularity
]
def build_feature_cols():
# Sparse base columns.
gender = tf.contrib.layers.sparse_column_with_keys(
column_name="gender",
keys=["female", "male"])
race = tf.contrib.layers.sparse_column_with_keys(
column_name="race",
keys=["Amer-Indian-Eskimo",
"Asian-Pac-Islander",
"Black", "Other",
"White"])
education = tf.contrib.layers.sparse_column_with_hash_bucket(
"education", hash_bucket_size=1000)
marital_status = tf.contrib.layers.sparse_column_with_hash_bucket(
"marital_status", hash_bucket_size=100)
relationship = tf.contrib.layers.sparse_column_with_hash_bucket(
"relationship", hash_bucket_size=100)
workclass = tf.contrib.layers.sparse_column_with_hash_bucket(
"workclass", hash_bucket_size=100)
occupation = tf.contrib.layers.sparse_column_with_hash_bucket(
"occupation", hash_bucket_size=1000)
native_country = tf.contrib.layers.sparse_column_with_hash_bucket(
"native_country", hash_bucket_size=1000)
# Continuous base columns.
age = real_valued_column("age")
education_num = real_valued_column("education_num")
capital_gain = real_valued_column("capital_gain")
capital_loss = real_valued_column("capital_loss")
hours_per_week = real_valued_column("hours_per_week")
# Transformations.
age_buckets = tf.contrib.layers.bucketized_column(
age, boundaries=[18, 25, 30, 35, 40, 45, 50, 55, 60, 65])
education_occupation = tf.contrib.layers.crossed_column(
[education, occupation], hash_bucket_size=int(1e4))
age_race_occupation = tf.contrib.layers.crossed_column(
[age_buckets, race, occupation], hash_bucket_size=int(1e6))
country_occupation = tf.contrib.layers.crossed_column(
[native_country, occupation], hash_bucket_size=int(1e4))
# Wide columns and deep columns.
wide_columns = [gender, native_country, education,
occupation, workclass, race,
marital_status, relationship,
age_buckets,
education_occupation,
age_race_occupation,
country_occupation]
deep_columns = [
embedding_column(gender, dimension=8),
embedding_column(native_country, dimension=8),
embedding_column(education, dimension=8),
embedding_column(occupation, dimension=8),
embedding_column(workclass, dimension=8),
embedding_column(race, dimension=8),
embedding_column(marital_status, dimension=8),
embedding_column(relationship, dimension=8),
embedding_column(age_buckets, dimension=8),
embedding_column(education_occupation, dimension=8),
embedding_column(age_race_occupation, dimension=8),
embedding_column(country_occupation, dimension=8),
age,
education_num,
capital_gain,
capital_loss,
hours_per_week,
]
return wide_columns, deep_columns
for var in categorical_vars:
le = LabelEncoder().fit(X_train[var])
X_train[var + '_ids'] = le.transform(X_train[var])
X_test[var + '_ids'] = le.transform(X_test[var])
X_train.pop(var)
X_test.pop(var)
categorical_var_encoders[var] = le
### Note: Feature Columns currently (2016/10/22) not working, update is coming.
# Setup feature columns.
CATEGORICAL_EMBED_SIZE = 10 # Note, you can customize this per variable.
feature_columns = [layers.real_valued_column(var)
for var in continues_vars] + [
layers.embedding_column(
layers.sparse_column_with_integerized_feature(
var + '_ids',
len(categorical_var_encoders[var].classes_)),
CATEGORICAL_EMBED_SIZE) for var in categorical_vars
]
# Linear classifier.
'''
random.seed(42)
tflr = learn.LinearClassifier(n_classes=2,
feature_columns=feature_columns,
optimizer=tf.train.GradientDescentOptimizer(learning_rate=0.05))
tflr.fit(input_fn=train_input_fn, steps=500)
print(list(tflr.predict(input_fn=test_input_fn, as_iterable=True)), y_test)
print(accuracy_score(y_test, list(tflr.predict(input_fn=test_input_fn, as_iterable=True))))
'''
return examples
vocab = Vocab(base_dir + '/vocab.txt')
vocab_size = len(vocab)
if tf_layers:
encode = layers.sparse_column_with_integerized_feature(
'encode', bucket_size=vocab_size)
decode_pre = layers.sparse_column_with_integerized_feature(
'decode_pre', bucket_size=vocab_size)
decode_post = layers.sparse_column_with_integerized_feature(
'decode_post', bucket_size=vocab_size)
features = {
'encode': encode,
'encode_emb': layers.embedding_column(encode, dimension=100),
'decode_pre': layers.embedding_column(decode_pre, dimension=100),
'decode_post': layers.embedding_column(decode_post, dimension=100),
}
features = tf.contrib.layers.create_feature_spec_for_parsing(features)
else:
# This little dict seems equivalent to the waay more verbose
# tf.contrib.layers approach. But apparently the latter helps,
# especially when it comes to tf serving. Still to see the benefit...
features = {
"encode": tf.VarLenFeature(dtype=tf.int64),
"decode_pre": tf.VarLenFeature(dtype=tf.int64),
"decode_post": tf.VarLenFeature(dtype=tf.int64),
}
i = get_input(base_dir + '/validation-00000-of-00001', features)
