def tensorflow_fitting(train_indices, test_indices, validation_indices, input_data, target_data):
layers = 6
hidden_units = []
for i in range(layers):
hidden_units.append(2 ** (5 + layers - i))
classifier = learn.DNNRegressor(
feature_columns=[tf.contrib.layers.real_valued_column("", dimension=input_data.shape[1])],
hidden_units=hidden_units)
classifier.fit(input_fn=lambda: input_fn(input_data[train_indices], target_data[train_indices]), steps=2000)
training_strategy_score = list(classifier.predict(
input_fn=lambda: input_fn(input_data[train_indices], target_data[train_indices])))
fitted_strategy_score = list(classifier.predict(
input_fn=lambda: input_fn(input_data[test_indices], target_data[test_indices])))
validation_strategy_score = list(classifier.predict(
input_fn=lambda: input_fn(input_data[validation_indices], target_data[validation_indices])))
error = mean_squared_error(target_data[train_indices], training_strategy_score)
fitting_dictionary = {
'training_strategy_score': training_strategy_score,
'fitted_strategy_score': fitted_strategy_score,
'validation_strategy_score': validation_strategy_score,
'error': error,
}
return fitting_dictionary, error
def tensorflow_fitting(train_indices, test_indices, input_data, target_data):
classifier = learn.DNNRegressor(
feature_columns=[
tf.contrib.layers.real_valued_column("",
dimension=input_data.shape[1])
],
hidden_units=[2048, 1024, 512, 256, 128, 64])
classifier.fit(input_fn=lambda: input_fn(input_data[train_indices],
target_data[train_indices]),
steps=2000)
error = classifier.evaluate(input_fn=lambda: input_fn(
input_data[train_indices], target_data[train_indices]),
steps=1)
error = error['loss']
training_strategy_score = list(
classifier.predict(input_data[train_indices]))
fitted_strategy_score = list(classifier.predict(input_data[test_indices]))
fitting_dictionary = {
'training_strategy_score': training_strategy_score,
'fitted_strategy_score': fitted_strategy_score,
'error': error,
}
return fitting_dictionary, error
def main(unused_argv):
# Load dataset
boston = learn.datasets.load_dataset('boston')
x, y = boston.data, boston.target
# Split dataset into train / test
x_train, x_test, y_train, y_test = cross_validation.train_test_split(
x, y, test_size=0.2, random_state=42)
# Scale data (training set) to 0 mean and unit standard deviation.
scaler = preprocessing.StandardScaler()
x_train = scaler.fit_transform(x_train)
# Build 2 layer fully connected DNN with 10, 10 units respectively.
feature_columns = learn.infer_real_valued_columns_from_input(x_train)
regressor = learn.DNNRegressor(feature_columns=feature_columns,
hidden_units=[10, 10])
# Fit
regressor.fit(x_train, y_train, steps=5000, batch_size=1)
# Predict and score
y_predicted = regressor.predict(scaler.transform(x_test))
score = metrics.mean_squared_error(y_predicted, y_test)
print('MSE: {0:f}'.format(score))
def rank_compare_experiment(x, y, names, ranker1, ranker2):
x_train, x_test, y_train, y_test = train_test_split(x,
y,
test_size=0.25,
random_state=42)
# Get/clear a directory to store the neural network to
model_dir = get_model_dir('mpg', True)
# Create a deep neural network
feature_columns = [
tf.contrib.layers.real_valued_column("", dimension=x.shape[0])
]
model = learn.DNNRegressor(model_dir=model_dir,
feature_columns=feature_columns,
hidden_units=HIDDEN_UNITS)
# Early stopping
early_stop = tf.contrib.learn.monitors.ValidationMonitor(
x_test,
y_test,
every_n_steps=50,
# metrics=validation_metrics,
early_stopping_metric="loss",
early_stopping_metric_minimize=True,
early_stopping_rounds=200)
model.fit(x_train, y_train, monitors=[early_stop], steps=10000)
pred = list(model.predict(x_test, as_iterable=True))
rmse = metrics.mean_squared_error(y_test, pred)
print("RMSE: {}".format(rmse))
print()
print("*** {} ***".format(ranker1.__name__))
l1 = ranker1(names).rank(x, y, model)
for itm in l1:
print(itm)
print()
print("*** {} ***".format(ranker2.__name__))
l2 = ranker2(names).rank(x, y, model)
display_rank_line(l2)
for itm in l2:
print(itm)
print()
print("Difference: {}".format(rank_diff(l1, l2)))
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 model(x, y):
x_train, x_test, y_train, y_test = train_test_split(x,
y,
test_size=0.25,
random_state=42)
#hidden_units=[10,20,10] mean 10,20,10 nodes per layer
#this is rnn that i use
#get_train_inputs(x_train, y_train)
print('got all x and y ')
FEATURES = ['duration', 'protocol_type', 'service', 'flag', 'src_bytes']
feature_cols = [tf.contrib.layers.real_valued_column(k) for k in FEATURES]
LABEL = 'label'
#classifier = learn.DNNClassifier(feature_columns=feature_columns, hidden_units=[10, 20, 10], n_classes=3)
my_feature_columns = [
tf.contrib.layers.real_valued_column("", dimension=4)
]
classifier = learn.DNNRegressor(feature_columns=my_feature_columns,
hidden_units=[10, 20, 10])
print('training the model')
#classifier.fit(input_fn=train_input_fn(x_train.astype(str)), steps=10)
print('the classifier is working...')
classifier.fit(x_train, y_train, steps=10)
print('the classifier is working...')
classifier.evaluate(y_test.astype(bytes))
predictions = classifier.predict(x_test)
print('predictions.,,,,,,', 'and the type ', type(predictions))
print(predictions)
print('classification report ')
print(classification_report(y_test, predictions))
print(confusion_matrix(y_test, predictions))
tf_confusion_metrics_npr(
classifier,
n_classes,
tf.Session(),
)
return predictions
if y != 35:
#print("added %d" %y)
inputs.append(x)
else:
target.append(x)
y += 1
total_inputs, total_output = df.as_matrix(inputs).astype(
np.float32), df.as_matrix([target]).astype(
np.float32) #important float in output
train_inputs, test_inputs, train_output, test_output = train_test_split(
total_inputs, total_output, test_size=0.2, random_state=42)
feature_columns = [
tf.contrib.layers.real_valued_column("", dimension=train_inputs.shape[1])
]
print(feature_columns)
regressor = learn.DNNRegressor(feature_columns=feature_columns,
hidden_units=[50, 25, 10])
tf.logging.set_verbosity(tf.logging.INFO) # ts logging to normal
logging.getLogger().setLevel(logging.INFO) # print train evolution
regressor.fit(train_inputs, train_output, steps=1000)
tf.logging.set_verbosity(tf.logging.ERROR)
# Measure RMSE error. RMSE is common for regression.
pred = list(regressor.predict(test_inputs, as_iterable=True))
score = np.sqrt(metrics.mean_squared_error(pred, test_output))
print("Test score (RMSE): {}".format(score))
batch_size=1,
num_epochs=None,
shuffle=True)
test_input_fn = tf.estimator.inputs.numpy_input_fn(x={'x': x_test},
y=y_test,
num_epochs=1,
shuffle=False)
# Define the model with Estimator
feature_columns = [
tf.feature_column.numeric_column('x', shape=np.array(x_train).shape[1:])
]
# regressor = tflearn.LinearRegressor(feature_columns=feature_columns, model_dir='linear_reg/')
regressor = tflearn.DNNRegressor(feature_columns=feature_columns,
hidden_units=[13, 10],
model_dir='dnn_reg')
# Train.
regressor.fit(input_fn=train_input_fn, steps=10000)
# Predict
predictions = regressor.predict(input_fn=test_input_fn)
y_predictions = []
for _, p in enumerate(predictions):
y_predictions.append(p)
# Score with sklearn.
score_sklearn = metrics.mean_squared_error(y_predictions, y_test)
print('MSE (sklearn): {0:f}'.format(score_sklearn))
# test data length
train_len = round(3 * data_len / 4)
x_train = data[0:train_len, :, :]
# start with just predicting the opening value the next day
y_train = data[1:train_len + 1, :, 1]
x_test = data[train_len + 1:-1, :, :]
# start with just predicting the opening value the next day
y_test = data[train_len + 2:, :, 1]
# let's start by just flattening the data
x_train = np.reshape(x_train, (train_len, -1))
x_test = np.reshape(x_test, (len(y_test), -1))
# Specify that all features have real-value data
feature_columns = [
tf.contrib.layers.real_valued_column("", dimension=x_train.shape[1])
]
classifier = SKCompat(
learn.DNNRegressor(label_dimension=y_train.shape[1],
feature_columns=feature_columns,
hidden_units=[100, 50, 20]))
classifier.fit(x_train, y_train, steps=100000, batch_size=100)
score = metrics.r2_score(y_test, classifier.predict(x_test)['scores'])
accuracy = metrics.mean_squared_error(y_test,
classifier.predict(x_test)['scores'])
# score= np.linalg.norm(y_test-classifier.predict(x_test)['scores'])/np.linalg.norm(y_test)
print("Score: %f, Accuracy: %f" % (score, accuracy))
y_train = df_ordered.loc[mask, 'units']
X_train = df_ordered.loc[mask, df_ordered.columns != 'units']
mask = ((df_orderedtest['item_nbr'] == item) &
(df_orderedtest['store_nbr'] == store))
X_test = df_orderedtest.loc[mask, df_orderedtest.columns != 'units']
if X_test.empty == 0:
if y_train.max() != 0:
scaling = MinMaxScaler(feature_range=(0, 1)).fit(X_train)
X_train = scaling.transform(X_train)
X_test = scaling.transform(X_test)
reg3 = skflow.DNNRegressor(
feature_columns=tf.contrib.learn.
infer_real_valued_columns_from_input(X_train),
hidden_units=[35, 35, 35],
optimizer='Adam')
reg3.fit(X_train, y_train, steps=600)
y_predict = reg3.predict(X_test)
predictions = list(
itertools.islice(y_predict,
len(df_orderedtest.loc[mask, 'units'])))
df_orderedtest.loc[mask, 'units'] = predictions
print store, item
result = df_orderedtest['units']
result = result.reset_index()
mask = (result['units'] < 0)
def build_estimator(model_dir):
"""Build an Estimator"""
# Sparse base Columns
gender = tf.contrib.layers.sparse_column_with_keys(column_name="sex",
keys=["F", "M"])
unknown = tf.contrib.layers.sparse_column_with_keys(column_name="unknown",
keys=['Y', 'N'])
action = tf.contrib.layers.sparse_column_with_keys(column_name="action",
keys=['Y', 'N'])
adventure = tf.contrib.layers.sparse_column_with_keys(
column_name="adventure", keys=['Y', 'N'])
animation = tf.contrib.layers.sparse_column_with_keys(
column_name="animation", keys=['Y', 'N'])
children = tf.contrib.layers.sparse_column_with_keys(
column_name="children", keys=['Y', 'N'])
comedy = tf.contrib.layers.sparse_column_with_keys(column_name="comedy",
keys=['Y', 'N'])
crime = tf.contrib.layers.sparse_column_with_keys(column_name="crime",
keys=['Y', 'N'])
documentary = tf.contrib.layers.sparse_column_with_keys(
column_name="documentary", keys=['Y', 'N'])
drama = tf.contrib.layers.sparse_column_with_keys(column_name="drama",
keys=['Y', 'N'])
fantasy = tf.contrib.layers.sparse_column_with_keys(column_name="fantasy",
keys=['Y', 'N'])
filmnoir = tf.contrib.layers.sparse_column_with_keys(
column_name="filmnoir", keys=['Y', 'N'])
horror = tf.contrib.layers.sparse_column_with_keys(column_name="horror",
keys=['Y', 'N'])
musical = tf.contrib.layers.sparse_column_with_keys(column_name="musical",
keys=['Y', 'N'])
mystery = tf.contrib.layers.sparse_column_with_keys(column_name="mystery",
keys=['Y', 'N'])
romance = tf.contrib.layers.sparse_column_with_keys(column_name="romance",
keys=['Y', 'N'])
scifi = tf.contrib.layers.sparse_column_with_keys(column_name="scifi",
keys=['Y', 'N'])
thriller = tf.contrib.layers.sparse_column_with_keys(
column_name="thriller", keys=['Y', 'N'])
war = tf.contrib.layers.sparse_column_with_keys(column_name="war",
keys=['Y', 'N'])
western = tf.contrib.layers.sparse_column_with_keys(column_name="western",
keys=['Y', 'N'])
occupation = tf.contrib.layers.sparse_column_with_hash_bucket(
column_name="occupation", hash_bucket_size=1000)
# Continuous Columns
age = tf.contrib.layers.real_valued_column("age")
time_diff = tf.contrib.layers.real_valued_column("time_diff")
# Transformations
age_buckets = tf.contrib.layers.bucketized_column(
age, boundaries=[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])
# Wide Columns and Deep Columns
wide_columns = [
gender, occupation, age_buckets, unknown, action, adventure, animation,
children, comedy, crime, documentary, drama, fantasy, filmnoir, horror,
musical, mystery, romance, scifi, thriller, war, western,
tf.contrib.layers.crossed_column([gender, occupation],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([gender, action],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([gender, adventure],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([gender, animation],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([gender, children],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([gender, comedy],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([gender, crime],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([gender, drama],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([gender, fantasy],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([gender, horror],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([gender, musical],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([gender, mystery],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([gender, romance],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([gender, scifi],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([gender, thriller],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, gender],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, action],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, adventure],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, animation],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, children],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, comedy],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, crime],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, drama],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, fantasy],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, horror],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, musical],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, mystery],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, romance],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, scifi],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, thriller],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, gender, romance],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, action, adventure],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, animation, children],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, animation, comedy],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, children, comedy],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column(
[age_buckets, animation, children, comedy],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column(
[age_buckets, crime, action, adventure],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, drama, mystery],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([age_buckets, scifi, thriller],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([action, adventure],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([animation, children],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([animation, comedy],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([children, comedy],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([animation, children, comedy],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([crime, action, adventure],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([drama, mystery],
hash_bucket_size=int(1e4)),
tf.contrib.layers.crossed_column([scifi, thriller],
hash_bucket_size=int(1e4))
]
deep_columns = [
tf.contrib.layers.embedding_column(gender, dimension=8),
tf.contrib.layers.embedding_column(occupation, dimension=8),
tf.contrib.layers.embedding_column(unknown, dimension=8),
tf.contrib.layers.embedding_column(action, dimension=8),
tf.contrib.layers.embedding_column(adventure, dimension=8),
tf.contrib.layers.embedding_column(animation, dimension=8),
tf.contrib.layers.embedding_column(children, dimension=8),
tf.contrib.layers.embedding_column(comedy, dimension=8),
tf.contrib.layers.embedding_column(crime, dimension=8),
tf.contrib.layers.embedding_column(documentary, dimension=8),
tf.contrib.layers.embedding_column(drama, dimension=8),
tf.contrib.layers.embedding_column(fantasy, dimension=8),
tf.contrib.layers.embedding_column(filmnoir, dimension=8),
tf.contrib.layers.embedding_column(horror, dimension=8),
tf.contrib.layers.embedding_column(musical, dimension=8),
tf.contrib.layers.embedding_column(mystery, dimension=8),
tf.contrib.layers.embedding_column(romance, dimension=8),
tf.contrib.layers.embedding_column(scifi, dimension=8),
tf.contrib.layers.embedding_column(thriller, dimension=8),
tf.contrib.layers.embedding_column(war, dimension=8),
tf.contrib.layers.embedding_column(western, dimension=8), time_diff,
age
]
# # Optimizers
# linear_optimizer = tf.train.FtrlOptimizer(learning_rate=0.1,
# l1_regularization_strength=0.01, l2_regularization_strength=0.01)
# dnn_optimizer = tf.train.ProximalAdagradOptimizer(learning_rate=0.1,
# l1_regularization_strength=0.001, l2_regularization_strength=0.001)
if FLAGS.model_type == "wide":
m = tflearn.LinearRegressor(model_dir=model_dir,
feature_columns=wide_columns)
# m = tflearn.LinearClassifier(model_dir=model_dir, feature_columns=wide_columns)
elif FLAGS.model_type == "deep":
m = tflearn.DNNRegressor(model_dir=model_dir,
feature_columns=deep_columns,
hidden_units=[64, 32, 16])
# m = tflearn.DNNClassifier(model_dir=model_dir, feature_columns=deep_columns, hidden_units=[100, 50])
elif FLAGS.model_type == "logistic":
m = tflearn.LogisticRegressor()
else:
m = tflearn.DNNLinearCombinedRegressor(
model_dir=model_dir,
linear_feature_columns=wide_columns,
dnn_feature_columns=deep_columns,
dnn_hidden_units=[64, 32, 16])
# m = tflearn.DNNLinearCombinedClassifier(model_dir=model_dir, linear_feature_columns=wide_columns,
# dnn_feature_columns=deep_columns, dnn_hidden_units=[100, 50])
return m
def train_model(self, x_train, y_train, x_val, y_val):
print(type(x_train))
if type(x_train) is not np.ndarray:
x_train = x_train.as_matrix().astype(np.float32)
if type(y_train) is not np.ndarray:
y_train = y_train.as_matrix().astype(np.int32)
if x_val is not None:
if type(x_val) is not np.ndarray:
x_val = x_val.as_matrix().astype(np.float32)
if type(y_val) is not np.ndarray:
y_val = y_val.as_matrix().astype(np.int32)
# Get/clear a directory to store the neural network to
model_dir = get_model_dir('dnn_kaggle', True)
# Create a deep neural network
feature_columns = [
tf.contrib.layers.real_valued_column("",
dimension=x_train.shape[1])
]
if FIT_TYPE == FIT_TYPE_REGRESSION:
classifier = learn.DNNRegressor(
optimizer=self.params['opt'],
dropout=self.params['dropout'],
model_dir=model_dir,
config=tf.contrib.learn.RunConfig(save_checkpoints_secs=60),
hidden_units=self.params['hidden'],
feature_columns=feature_columns)
else:
classifier = learn.DNNClassifier(
optimizer=self.params['opt'],
dropout=self.params['dropout'],
model_dir=model_dir,
config=tf.contrib.learn.RunConfig(save_checkpoints_secs=60),
hidden_units=self.params['hidden'],
n_classes=self.params['n_classes'],
feature_columns=feature_columns)
if x_val is not None:
# Early stopping
validation_monitor = tf.contrib.learn.monitors.ValidationMonitor(
x_val,
y_val,
every_n_steps=100,
#metrics=validation_metrics,
early_stopping_metric="loss",
early_stopping_metric_minimize=True,
early_stopping_rounds=500)
# Fit/train neural network
classifier.fit(x_train,
y_train,
monitors=[validation_monitor],
steps=100000,
batch_size=1000)
self.steps = validation_monitor._best_value_step
else:
classifier.fit(x_train,
y_train,
steps=100000,
batch_size=self.rounds)
#self.classifier = clr.best_iteration
return classifier
return np.array(input), np.array(target)
train_data, valid_data, test_data = get_data()
train_x, train_y = sequence_iterator(train_data, conf.num_steps)
valid_x, valid_y = sequence_iterator(valid_data, conf.num_steps)
test_x, test_y = sequence_iterator(test_data, conf.num_steps)
feature_columns = [
tensorflow.contrib.layers.real_valued_column("", dimension=1)
]
regressor = learn.DNNRegressor(
feature_columns=feature_columns,
hidden_units=[10, 10],
optimizer=tensorflow.train.ProximalAdagradOptimizer(
learning_rate=0.03, l1_regularization_strength=0.001))
regressor.fit(train_x, train_y, steps=2000)
predicted = list(regressor.predict(test_x, as_iterable=True))
mae = mean_absolute_error(test_y, predicted)
print("Error: %f" % mae)
#print('predictions: {}'.format(str(predicted)))
plot_predicted, = plt.plot(predicted, label='predicted')
plot_test, = plt.plot(test_y, label='test')
plt.legend(handles=[plot_predicted, plot_test])
plt.show()
# label_dimension=1,
# hidden_units=hidden_layers,
# model_dir=MODEL_PATH,
# dropout=dropout,
# config=test_config,
# optimizer=tf.train.ProximalAdagradOptimizer(
# learning_rate=0.1,
# l1_regularization_strength=0.001)
# )
regressor = skflow.DNNRegressor(
feature_columns=feature_columns,
label_dimension=1,
hidden_units=hidden_layers,
model_dir=MODEL_PATH,
dropout=dropout,
config=test_config,
optimizer=tf.train.AdamOptimizer(learning_rate=0.0005)
#optimizer=tf.train.AdadeltaOptimizer()
#optimizer=tf.train.MomentumOptimizer(learning_rate=0.001, momentum=0.9)
)
#regressor = sskflow. BoostedTreesRegressor(
# feature_columns=feature_columns,
# n_batches_per_layer=100,
# n_trees=100,
#)
#regressor = skflow.LinearRegressor(feature_columns = feature_columns, model_dir=MODEL_PATH)
# Train it
MODEL_PATH = './DNNRegressors/'
for hl in hidden_layers:
MODEL_PATH += '%s_' % hl
MODEL_PATH += 'D0%s' % (int(dropout * 10))
logging.info('Saving to %s' % MODEL_PATH)
# Validation and Test Configuration
validation_metrics = {"MSE": tf.contrib.metrics.streaming_mean_squared_error}
test_config = skflow.RunConfig(save_checkpoints_steps=100,
save_checkpoints_secs=None)
# Building the Network
regressor = skflow.DNNRegressor(feature_columns=feature_columns,
label_dimension=1,
hidden_units=hidden_layers,
dropout=dropout,
config=test_config)
# Train it
logging.info('Train the DNN Regressor...\n')
MSEs = [] # for plotting
STEPS = [] # for plotting
for epoch in range(EPOCHS + 1):
# Fit the DNNRegressor (This is where the magic happens!!!)
regressor.fit(input_fn=training_input_fn(batch_size=BATCH_SIZE),
steps=STEPS_PER_EPOCH)
# Thats it -----------------------------
tf.logging.set_verbosity(tf.logging.INFO)
df = pcs_data_loader.shape_pps_data(pcs_data_loader.load_corn_rows_mssql())
df.drop(['Area'], axis=1, inplace=True)
y = df['Dry_Yield']
X = df.drop(['Dry_Yield'], axis=1)
X_train, X_validation, y_train, y_validation = \
train_test_split(X, y, test_size=.3, random_state=7)
scaler = StandardScaler()
scaler.fit(X)
feature_cols = [tf.feature_column.numeric_column(c) for c in X.columns.tolist()]
label = 'Dry_Yield'
nn = tf_learn.DNNRegressor(
(1024, 512, 256), feature_cols,
model_dir='./results/20170824_tf_dnn_reg/tf_dat')
def train_input_fn():
return tf.estimator.inputs.pandas_input_fn(
pd.DataFrame(scaler.transform(X_train), columns=X.columns.tolist()),
y_train,
shuffle=False
)
nn.fit(input_fn=train_input_fn(), steps=5000)
# Build a 2 layer fully connected DNN with 10 and 5 units respectively
model = Sequential()
model.add(Dense(10, input_dim=7, init='normal', activation='relu'))
model.add(Dense(5, init='normal', activation='relu'))
model.add(Dense(1, init='normal'))
#Compile the model, whith the mean squared error as a loss function
model.compile(loss='mean_squared_error', optimizer='adam')
#Fit the model, in 1000 epochs
model.fit(X_train,
y_train,
nb_epoch=100,
validation_split=0.33,
shuffle=True,
verbose=2)
#Tensorflow方法
feature_columns = [tf.contrib.layers.real_valued_column("", dimension=8)]
nregressor = learn.DNNRegressor(hidden_units=[10, 5],
feature_columns=feature_columns)
nregressor.fit(X_train, y_train, steps=100)
print(nregressor.evaluate(scaler.transform(X_test), y_test))
#score=metrics.mean_squared_error(y_test,nregressor.predict(scaler.transform(X_test)))
#print('Total mean squared error:'+str(score))
plt.show()
a = input()
fc.encode_text_index(df_test, 'store_and_fwd_flag')
fc.encode_numeric_zscore(df_test, 'passenger_count')
fc.encode_numeric_zscore(df_test, 'pickup_longitude')
fc.encode_numeric_zscore(df_test, 'pickup_latitude')
fc.encode_numeric_zscore(df_test, 'dropoff_longitude')
fc.encode_numeric_zscore(df_test, 'dropoff_latitude')
x = df_test.as_matrix().astype(np.float32)
model_dir = "./dnn/NYC"
feature_columns = [
tf.contrib.layers.real_valued_column("", dimension=x.shape[1])
]
print("building network")
regressor = learn.DNNRegressor(
model_dir=model_dir,
config=tf.contrib.learn.RunConfig(save_checkpoints_secs=1),
feature_columns=feature_columns,
hidden_units=[50, 25, 10])
#hidden_units=[2, 5, 1])
print("predict")
pred = list(regressor.predict(x, as_iterable=True))
df_submit = pd.DataFrame(pred)
df_submit.insert(0, 'id', id)
df_submit.columns = ['id', 'trip_duration']
df_submit['trip_duration'] = df_submit['trip_duration'].abs()
df_submit.to_csv(filename_submit, index=False)
def rank_stability_experiment(x, y, names, ranker_class):
# Step 1, see how far to train, using holdout set
x_train, x_test, y_train, y_test = train_test_split(x,
y,
test_size=0.25,
random_state=45)
random.seed(42)
# Get/clear a directory to store the neural network to
model_dir = get_model_dir('mpg', True)
# Create a deep neural network
feature_columns = [
tf.contrib.layers.real_valued_column("", dimension=x.shape[0])
]
model = learn.DNNRegressor(model_dir=model_dir,
feature_columns=feature_columns,
hidden_units=HIDDEN_UNITS)
# Early stopping
early_stop = tf.contrib.learn.monitors.ValidationMonitor(
x_test,
y_test,
every_n_steps=50,
# metrics=validation_metrics,
early_stopping_metric="loss",
early_stopping_metric_minimize=True,
early_stopping_rounds=200)
model.fit(x_train, y_train, monitors=[early_stop], steps=10000)
pred = list(model.predict(x_test, as_iterable=True))
score = np.sqrt(metrics.mean_squared_error(pred, y_test))
print("RMSE: {}".format(score))
baseline_rank = InputPerturbationRank(names).rank(x, y, model)
steps_needed = int(early_stop._last_successful_step)
steps_inc = int(steps_needed / 20)
# Step 2, rate stability up to that point
ranker_base = InputPerturbationRank(names)
ranker = ranker_class(names)
with codecs.open("rank_stability.csv", "w", ENCODING) as fh:
writer = csv.writer(fh)
if SHOW_RANKS:
writer.writerow(['steps', 'target_ptrb', 'target_hyb'] +
[x for x in names])
else:
writer.writerow(['steps', 'target_ptrb', 'target_hyb'] +
[x + 1 for x in range(len(names))])
for i in range(20):
steps = i * steps_inc
random.seed(42)
feature_columns = [
tf.contrib.layers.real_valued_column("", dimension=x.shape[0])
]
model = learn.DNNRegressor(model_dir=model_dir,
feature_columns=feature_columns,
hidden_units=HIDDEN_UNITS)
r_base = ranker_base.rank(x, y, model)
r_test = ranker.rank(x, y, model)
d_base = rank_diff(baseline_rank, r_base)
d_test = rank_diff(baseline_rank, r_test)
if SHOW_RANKS:
r_base.sort(key=lambda x: x[2])
r_test.sort(key=lambda x: x[2])
print("{}:{}:{}".format(steps, d_test,
display_rank_num_line(r_test)))
writer.writerow([steps, d_base, d_test] +
display_rank_num_line(r_test) +
[ranker.change_amount, ranker.delta_weight])
else:
print("{}:{}:{}".format(steps, d_test,
display_rank_line(r_test)))
writer.writerow([steps, d_base, d_test] +
display_rank_line(r_test))
expert_data = bc.expert('experts/Ant-v1.pkl', 'Ant-v1', num_rollouts=400)
observations = expert_data["observations"]
actions = expert_data["actions"]
actions = np.squeeze(actions)
_, num_actions = np.shape(actions)
_, dim = np.shape(observations)
# print ("***************************************************")
# print (num_actions,dim)
# print ("***************************************************")
feature_columns = [layers.real_valued_column("", dimension=dim)]
classifier = learn.DNNRegressor(feature_columns=feature_columns,
hidden_units=[128, 64, 32],
label_dimension=num_actions,
optimizer=tf.train.AdamOptimizer)
# def get_train_inputs():
# x = tf.constant(observations)
# y = tf.constant(actions)
# return x,y
# x = tf.constant(observations)
# y = tf.constant(actions)
classifier.fit(x=observations, y=actions, steps=2000, batch_size=50)
# classifier.fit(input_fn=get_train_inputs,steps=2000,batch_size=50)
expert_data = evaluation.cloning(classifier, 'Ant-v1', num_rollouts=20)
# print "***************************************************"
# print "***************************************************"
