def __init__(self, model_vgg_path = config.MODEL_VGG_PATH,\ model_dnn_path = config.MODEL_DNN_PATH, \ uid_path = config.UID_PATH): lr = 1e-4 feature_columns = [ tf.contrib.layers.real_valued_column("", dimension=4) ] self.classifier = learn.DNNClassifier( model_dir=model_dnn_path, feature_columns=feature_columns, hidden_units=[4096, 2048], n_classes=69, activation_fn=tf.nn.sigmoid, optimizer=tf.train.AdamOptimizer(learning_rate=lr)) self.sess = tf.Session() self.vgg = vgg16.Vgg16(model_vgg_path) self.images = tf.placeholder("float", [None, 224, 224, 3]) with tf.name_scope("content_vgg"): self.vgg.build(self.images) self.uid = [] with open(uid_path, 'rt') as f: for it in f: self.uid.append(it.replace('\n', ''))
def load_classifer(model_path): labels_file = os.path.join(model_path, 'labels_list.txt') f = open(labels_file, 'r') labels = f.read().splitlines() f.close() classifier_config_file = os.path.join(model_path, 'classifier_config.txt') f = open(classifier_config_file, 'r') classifier_config_data = f.read().splitlines() f.close() hidden_units = map(int, classifier_config_data[0].split( ",")) # split string and convert to numeric list inputs_dimension = int(classifier_config_data[1]) model_dir = classifier_config_data[2] n_classes = int(classifier_config_data[3]) feature_columns = [ tf.contrib.layers.real_valued_column("", dimension=inputs_dimension) ] classifier = skflow.DNNClassifier(hidden_units=hidden_units, n_classes=n_classes, feature_columns=feature_columns, model_dir=model_dir) return classifier, labels
def testIrisMomentum(self): random.seed(42) iris = datasets.load_iris() x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=42) def custom_optimizer(): return momentum_lib.MomentumOptimizer(learning_rate=0.01, momentum=0.9) classifier = learn.DNNClassifier( hidden_units=[10, 20, 10], feature_columns=learn.infer_real_valued_columns_from_input( x_train), n_classes=3, optimizer=custom_optimizer, config=learn.RunConfig(tf_random_seed=1)) classifier.fit(x_train, y_train, steps=400) predictions = np.array(list(classifier.predict_classes(x_test))) score = accuracy_score(y_test, predictions) self.assertGreater(score, 0.65, "Failed with score = {0}".format(score))
def get_classification_score(train_encodings, train_labels, test_encodings, test_labels, steps): feature_columns = learn.infer_real_valued_columns_from_input(train_encodings) classifier = learn.DNNClassifier(hidden_units=[32], n_classes=10, feature_columns=feature_columns) classifier.fit(train_encodings, train_labels, steps=steps, batch_size=batch_size) # For measuring accuracy test_predictions = list(classifier.predict(test_encodings, as_iterable=True)) return metrics.accuracy_score(test_labels, test_predictions)
def testNoCheckpoints(self): random.seed(42) iris = datasets.load_iris() cont_features = [tf.contrib.layers.real_valued_column('', dimension=4)] classifier = learn.DNNClassifier(feature_columns=cont_features, hidden_units=[10, 20, 10], n_classes=3) classifier.fit(iris.data, iris.target, max_steps=100)
def initGraph(model_dir, lr=1e-4): feature_columns = [tf.contrib.layers.real_valued_column("", dimension=4)] classifier = learn.DNNClassifier( model_dir=model_dir, feature_columns=feature_columns, hidden_units=[4096, 2048], n_classes=NUM_PID, activation_fn=tf.nn.sigmoid, optimizer=tf.train.AdamOptimizer(learning_rate=lr) ) return classifier
def testIrisDNN(self): if HAS_SKLEARN: random.seed(42) iris = datasets.load_iris() feature_columns = learn.infer_real_valued_columns_from_input( iris.data) classifier = learn.DNNClassifier(feature_columns=feature_columns, hidden_units=[10, 20, 10], n_classes=3) grid_search = GridSearchCV(classifier, {'hidden_units': [[5, 5], [10, 10]]}, scoring='accuracy', fit_params={'steps': [50]}) grid_search.fit(iris.data, iris.target) score = accuracy_score(iris.target, grid_search.predict(iris.data)) self.assertGreater(score, 0.5, 'Failed with score = {0}'.format(score))
def testIrisMomentum(self): random.seed(42) iris = datasets.load_iris() x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=42) def custom_optimizer(): return tf.train.MomentumOptimizer(learning_rate=0.01, momentum=0.9) cont_features = [tf.contrib.layers.real_valued_column("", dimension=4)] classifier = learn.DNNClassifier( feature_columns=cont_features, hidden_units=[10, 20, 10], n_classes=3, optimizer=custom_optimizer, config=learn.RunConfig(tf_random_seed=1)) classifier.fit(x_train, y_train, steps=400) score = accuracy_score(y_test, classifier.predict(x_test)) self.assertGreater(score, 0.65, "Failed with score = {0}".format(score))
def testIrisES(self): random.seed(42) iris = datasets.load_iris() x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=42) x_train, x_val, y_train, y_val = train_test_split(x_train, y_train, test_size=0.2, random_state=42) val_monitor = learn.monitors.ValidationMonitor( x_val, y_val, every_n_steps=50, early_stopping_rounds=100, early_stopping_metric='loss', early_stopping_metric_minimize=False) feature_columns = learn.infer_real_valued_columns_from_input(iris.data) # classifier without early stopping - overfitting classifier1 = learn.DNNClassifier(feature_columns=feature_columns, hidden_units=[10, 20, 10], n_classes=3) classifier1.fit(x_train, y_train, steps=1000) _ = accuracy_score(y_test, classifier1.predict(x_test)) # Full 1000 steps, 19 summaries and no evaluation summary: # 1 summary of net at step 1 # 9 x (1 summary of net and 1 summary of global step) for steps 101, 201,... self.assertEqual(19, len(_get_summary_events(classifier1.model_dir))) with self.assertRaises(ValueError): _get_summary_events(classifier1.model_dir + '/eval') # classifier with early stopping - improved accuracy on testing set classifier2 = learn.DNNClassifier( hidden_units=[10, 20, 10], feature_columns=feature_columns, n_classes=3, config=tf.contrib.learn.RunConfig(save_checkpoints_secs=1)) classifier2.fit(x_train, y_train, monitors=[val_monitor], steps=2000) _ = accuracy_score(y_val, classifier2.predict(x_val)) _ = accuracy_score(y_test, classifier2.predict(x_test)) # Note, this test is unstable, so not checking for equality. # See stability_test for examples of stability issues. if val_monitor.early_stopped: self.assertLess(val_monitor.best_step, 2000) # Note, due to validation monitor stopping after the best score occur, # the accuracy at current checkpoint is less. # TODO(ipolosukhin): Time machine for restoring old checkpoints? # flaky, still not always best_value better then score2 value. # self.assertGreater(val_monitor.best_value, score2_val) # Early stopped, unstable so checking only < then max. self.assertLess(len(_get_summary_events(classifier2.model_dir)), 21) # Eval typically has ~6 events, but it varies based on the run. self.assertLess( len(_get_summary_events(classifier2.model_dir + '/eval')), 8)
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' ''' 使用tensorflow的高级API来训练MLP 用tensorflow训练MLP的最简单方式是使用他的高级API TF.Learn,这和Scikit的API非常类似 用DNNClassifier训练一个有这任意隐藏层,并包含一个用来计算类别概率的softmax输出层的深度神经网络 eg:下面训练一个用于分类的两个隐藏层(一个300个神经元,另一个100个),以及一个softmax输出层的具有10个神经元的DNN ''' X_train, Y_train = get_mnist_train() feature_cloumns = learn.infer_real_valued_columns_from_input(X_train) dnn_clf = learn.DNNClassifier(hidden_units=[300, 100], n_classes=10, feature_columns=feature_cloumns) try: if get_serialize_data('dnn_clf', mode=1) is None: serialize_data(dnn_clf, 'dnn_clf', mode=1) except FileNotFoundError as e: serialize_data(dnn_clf, 'dnn_clf', mode=1) ''' batch_size:小批量X的size steps:循环次数 ''' dnn_clf.fit(X_train, Y_train.astype(np.int), batch_size=50, steps=40000) ''' 评估准确率 ''' X_test, Y_test = get_mnist_test()
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Thu Mar 14 23:46:58 2019 @author: sameepshah """ from sklearn.datasets import load_iris iris = load_iris() X = iris['data'] y = iris['target'] y.dtype from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3) import tensorflow.contrib.learn.python.learn as learn classifier = learn.DNNClassifier(hidden_units=[10, 20, 10], n_classes=3) classifier.fit(X_train, y_train, steps=200, batch_size=32) iris_predictions = classifier.predict(X_test) from sklearn.metrics import classification_report, confusion_matrix print(classification_report(y_test, iris_predictions)) print(confusion_matrix(y_test, iris_predictions))
# Create results vector (a home win = 1, a home loss or tie = 0) y = np.array(np.where(df['home_score'] > df['away_score'], 1, 0)) # Delete the dataframe to clear memory del df # Split out training and testing data sets X_train, X_test, y_train, y_test = cross_validation.train_test_split(X,y,test_size=0.2,random_state=42) # Remove the 'week' 'home_team' and 'away_team' columns from matchups as they are not used in the algorithm matchups.drop(['week', 'home_team', 'away_team'], axis=1, inplace=True) # Build 3 layer fully connected DNN with 50, 50, 50 units respectively. feature_columns = learn.infer_real_valued_columns_from_input(X_train) classifier = learn.DNNClassifier(feature_columns=feature_columns, hidden_units=[300, 300, 300], optimizer='Adagrad')#, model_dir = '/Classifier_Runs') # Fit classifier.fit(X_train, y_train, steps=1000, batch_size=100) # Predict and score y_predicted = list(classifier.predict_proba(x=scaler.transform(matchups), as_iterable=True)) vfunc = np.vectorize(spread_conversion) predicted_spreads = np.apply_along_axis(vfunc,0,np.array(y_predicted)[:,0]) bet_vector = np.array(np.where(predicted_spreads > spreads,0,1)) result = np.array(np.where(bet_vector == game_result,1,0)) prob_result = float(np.sum(result)) / len(result)
y = data['Class'] x = x.as_matrix() y = y.as_matrix() from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3) #tensorflow contrib learn checking(DNN Classifier) import tensorflow.contrib.learn.python.learn as learn feature_columns = tf.contrib.learn.infer_real_valued_columns_from_input( x_train) classifier = learn.DNNClassifier(hidden_units=[10, 20, 10], n_classes=2, feature_columns=feature_columns) classifier = classifier.fit(x_train, y_train, steps=200, batch_size=20) predictions = list(classifier.predict(x_test, as_iterable=True)) #evaluation the model from sklearn import metrics from sklearn.metrics import classification_report, confusion_matrix print(confusion_matrix(y_test, predictions)) print(classification_report(y_test, predictions)) Accuracy = metrics.accuracy_score(y_test, predictions) print('Accuracy: {0:f}'.format(Accuracy)) #checking RandomForestClassifier
feature_columns = learn.infer_real_valued_columns_from_input(X_train) # Build 3 layer DNN with 10, 20, 10 units respectively. try: shutil.rmtree('/home/ysj/Downloads/deeplearning/cronos123_beat_like') except OSError as e: if e.errno == 2: # 파일이나 디렉토리가 없음! print('No such file or directory to remove') pass else: raise classifier = learn.DNNClassifier( hidden_units=[10, 20, 10], n_classes=2, feature_columns=feature_columns, model_dir="/home/ysj/Downloads/deeplearning/cronos123_beat_like") # Fit model. classifier.fit(x=X_train, y=y_train, steps=3000) #y_test2 = y_test X_test = np.array(X_test) y_test = np.array(y_test) # Evaluate accuracy. #accuracy_score = classifier.evaluate(x=X_test, # y=y_test)["accuracy"] #print('Accuracy: {0:f}'.format(accuracy_score)) # Classify two new flower samples.
def main(): if USE_ECG_ID: if FEATURES_RECALCULATION: fp.feature_preparation(ecgID_DataDir, ecgID_FeaturesPath) # prepare train and test sets targets, inputs, labels = sktools.load_ecg_featuers(ecgID_FeaturesPath) train_targets, train_inputs, test_targets, test_inputs = sktools.split_features( targets, inputs) elif USE_eHEALTH_ECG: if RANDOM_SPLIT: if FEATURES_RECALCULATION: fp.feature_preparation(eHealth_DataDir, eHealth_FeaturesPath) # prepare train and test sets targets, inputs, labels = sktools.load_ecg_featuers( eHealth_FeaturesPath) train_targets, train_inputs, test_targets, test_inputs = sktools.split_features_random( targets, inputs) else: if FEATURES_RECALCULATION: fp.feature_preparation(ecgTrainDataDir, trainFeaturesPath, PARTICIPANT_LIST) fp.feature_preparation(ecgTestDataDir, testFeaturesPath, PARTICIPANT_LIST) # prepare train and test sets train_targets, train_inputs, labels = sktools.load_ecg_featuers( trainFeaturesPath) test_targets, test_inputs, _ = sktools.load_ecg_featuers( testFeaturesPath) train_targets, train_inputs = sktools.randomize_features( train_targets, train_inputs) # defining model path if not os.path.exists(MODELS_DIR): os.makedirs(MODELS_DIR) model_path = os.path.join(MODELS_DIR, model_name) # create DNN model tf.logging.set_verbosity(tf.logging.ERROR) # suspend Tensorflow Warnings num_classes = len(labels) inputs_dimension = train_inputs.shape[1] layers = [70, 50, 30] num_epochs = 3000 feature_columns = [ tf.contrib.layers.real_valued_column("", dimension=inputs_dimension) ] classifier = skflow.DNNClassifier(hidden_units=layers, n_classes=num_classes, feature_columns=feature_columns, model_dir=model_path) sktools.save_classifer(classifier, labels) # fit and save model print "\nDisplaying DNN training flow:" print "training started" classifier.fit(train_inputs, train_targets, steps=num_epochs, batch_size=1) print "training finished" # accuracy evaluation train_outputs = classifier.predict(train_inputs) test_outputs = classifier.predict(test_inputs) train_score = metrics.accuracy_score(train_targets, train_outputs) test_score = metrics.accuracy_score(test_targets, test_outputs) if DISPLAY_TRAINING_DETAILS: print("\nDisplaying training details") print('Accuracy on train set: {0:f}'.format(train_score)) print('Accuracy on test set: {0:f}'.format(test_score)) # displaying predictions (for debug and details estimation) test_outputs = classifier.predict(test_inputs) if DISPLAY_PREDICTIONS: print "\nDisplaying DNN prediction" print "predicted: expected:" for i in xrange(len(test_outputs)): print labels[test_outputs[i].astype(int)], labels[ test_targets[i].astype(int)]