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)]
