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 "***************************************************"