def constructModel(corpus, classList, features, modelOutput):
"""
Trains a Decision Tree model on the test corpus.
Args:
corpus: A list of lists, containing the GC content, coverage, and class number.
classList: A list of class names.
features: List of variables used by each contig.
modelOutput: Location to save model as GraphViz DOT, or False to save no model.
Returns:
classifier: A DecisionTreeClassifier object that has been trained on the test corpus.
"""
corpus.sort() # just in case
X = []
Y = []
for item in corpus:
X.append(item[:-1]) # all but the last item
Y.append(item[-1]) # only the last item
X_train, X_test, Y_train, Y_test = mscv.train_test_split(X, Y, test_size=0.3, random_state=0)
# TODO: implement classifier testing and comparison, now only baggingClassifier is used as per paper
#treeClassifier = tree.DecisionTreeClassifier()
#treeClassifier = treeClassifier.fit(X_train, Y_train)
#click.echo("Decision tree classifier built, score is %s out of 1.00" % treeClassifier.score(X_test, Y_test))
baggingClassifier = ensemble.BaggingClassifier()
baggingClassifier = baggingClassifier.fit(X_train, Y_train)
click.echo("Bagging classifier built, score is %s out of 1.00" % baggingClassifier.score(X_test, Y_test))
#forestClassifier = ensemble.RandomForestClassifier(n_estimators=10)
#forestClassifier = forestClassifier.fit(X_train, Y_train)
#click.echo("Random forest classifier built, score is %s out of 1.00" % forestClassifier.score(X_test, Y_test))
#adaClassifier = ensemble.AdaBoostClassifier(n_estimators=100)
#adaClassifier = adaClassifier.fit(X_train, Y_train)
#click.echo("AdaBoost classifier built, score is %s out of 1.00" % adaClassifier.score(X_test, Y_test))
#gradientClassifier = ensemble.GradientBoostingClassifier(n_estimators=100)
#gradientClassifier = gradientClassifier.fit(X_train, Y_train)
#click.echo("Gradient tree boosting classifier built, score is %s out of 1.00" % gradientClassifier.score(X_test, Y_test))
if modelOutput:
with open(modelOutput, 'w') as dotfile:
tree.export_graphviz(baggingClassifier, out_file=dotfile, feature_names=features,
class_names=classList, filled=True, rounded=True, special_characters=True)
return baggingClassifier
python类train_test_split()的实例源码
def train_test():
df = pd.read_csv("data_preprocessed.csv",header=None)
label_cols = df.columns[0:2]
Y = df[label_cols]
feature_cols = df.columns[2:len(df.columns)]
X = df[feature_cols]
X_train, X_test, y_train, y_test = train_test_split(X, Y, random_state=1)
train_df = pd.concat([y_train,X_train],axis=1)
test_df = pd.concat([y_test,X_test], axis=1)
return train_df, test_df
def train():
os.chdir(dname)
for selected_stock in onlyfiles:
df = pd.read_csv(os.path.join('data_files',selected_stock))
#preprocessing the data
df = df[['Adj. Open', 'Adj. High', 'Adj. Low', 'Adj. Close', 'Adj. Volume']]
#measure of volatility
df['HL_PCT'] = (df['Adj. High'] - df['Adj. Low']) / df['Adj. Low'] * 100.0
df['PCT_change'] = (df['Adj. Close'] - df['Adj. Open']) / df['Adj. Open'] * 100.0
df = df[['Adj. Close', 'HL_PCT', 'PCT_change', 'Adj. Volume']]
forecast_col = 'Adj. Close'
df.fillna(value=-99999, inplace=True)
forecast_out = int(math.ceil(0.01 * len(df)))
df['label'] = df[forecast_col].shift(-forecast_out)
X = np.array(df.drop(['label'],1))
X = preprocessing.scale(X)
X_lately = X[-forecast_out:]
X = X[:-forecast_out]
df.dropna(inplace=True)
y = np.array(df['label'])
X_train, X_test, y_train, y_test = cross_validation.train_test_split(X, y, test_size=0.2)
svr = SVR()
pickle.dump(svr,open(join(dname+'/models/svr_unfit/', selected_stock+'svr.sav'),'wb'))
svr.fit(X_train, y_train)
lr = LinearRegression()
pickle.dump(lr,open(join(dname+'/models/lr_unfit/', selected_stock+'lr.sav'),'wb'))
lr.fit(X_train, y_train)
mlp = MLPRegressor()
pickle.dump(mlp,open(join(dname+'/models/mlp_unfit/', selected_stock+'mlp.sav'),'wb'))
mlp.fit(X_train, y_train)
pickle.dump(svr,open(join(dname+'/models/svr_fit/', selected_stock+'svr.sav'),'wb'))
pickle.dump(lr,open(join(dname+'/models/lr_fit/', selected_stock+'lr.sav'),'wb'))
pickle.dump(mlp,open(join(dname+'/models/mlp_fit/', selected_stock+'mlp.sav'),'wb'))
print(selected_stock+" - trained")
def read(self, nb_classes, img_rows=IMAGE_SIZE, img_cols=IMAGE_SIZE, img_channels=3):
images, labels = extract_data('./train/')
labels = np.reshape(labels, [-1])
# numpy.reshape
X_train, X_test, y_train, y_test = train_test_split(images, labels, test_size=0.3, random_state=random.randint(0, 100))
X_valid, X_test, y_valid, y_test = train_test_split(images, labels, test_size=0.5, random_state=random.randint(0, 100))
X_train = X_train.reshape(X_train.shape[0], img_rows, img_cols, 3)
X_valid = X_valid.reshape(X_valid.shape[0], img_rows, img_cols, 3)
X_test = X_test.reshape(X_test.shape[0], img_rows, img_cols, 3)
input_shape = (img_rows, img_cols, 3)
# the data, shuffled and split between train and test sets
print('X_train shape:', X_train.shape)
print(X_train.shape[0], 'train samples')
print(X_valid.shape[0], 'valid samples')
print(X_test.shape[0], 'test samples')
# convert class vectors to binary class matrices
Y_train = np_utils.to_categorical(y_train, nb_classes)
Y_valid = np_utils.to_categorical(y_valid, nb_classes)
Y_test = np_utils.to_categorical(y_test, nb_classes)
X_train = X_train.astype('float32')
X_valid = X_valid.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_valid /= 255
X_test /= 255
self.X_train = X_train
self.X_valid = X_valid
self.X_test = X_test
self.Y_train = Y_train
self.Y_valid = Y_valid
self.Y_test = Y_test
def create_train_test_split(xs, ys, num_catagories, train_test_split_percentage):
train_test_split_idxs = np.array([itm for itm in range(0, xs.shape[0])])
[idxs_train, idxs_test, temp1, temp2] = train_test_split(train_test_split_idxs, train_test_split_idxs, test_size=train_test_split_percentage, random_state=42)
xs_train, xs_test = xs[idxs_train], xs[idxs_test]
ys_train, ys_test = ys[idxs_train], ys[idxs_test]
ys_train = one_hot(ys_train, num_catagories)
ys_test = one_hot(ys_test, num_catagories)
return [xs_train, xs_test, ys_train, ys_test]
def splitData(features, labels, testSize = 0.3):
'''
Split data into train and test sets
@param features: Features generated from data
@param labels: symptom severity label for each note
@param testSize: fraction of data to use for testing models
@return feats_train: the features for training
@return feats_test: the features for testing
@return labels_train: symptom severity labels corresponding to training features
@return labels_test: symptom severity labels corresponding to test features
'''
feats_train, feats_test, labels_train, labels_test = cross_validation.train_test_split(features, labels, test_size=testSize, random_state=15)
return(feats_train, feats_test, labels_train, labels_test)
def naive_bayes(X, t):
# leave-one-out strategy to get average accuracy
n = len(t)
true_num = 0
for i in range(n):
X_train = list(X)
del X_train[i]
y_train = list(t)
del y_train[i]
X_test = X[i]
y_test = [t[i]]
prior, likelihood, num = train_naive_bayes(X_train, y_train)
if test_naive_bayes(X_test, y_test, prior, likelihood, num):
true_num += 1
accuracy = 1.0 * true_num / n
# 8/2 split
pre = []
rec = []
for _ in range(100):
X_train, X_test, t_train, t_test = train_test_split(X, t, test_size=0.2)
prior, likelihood, num = train_naive_bayes(X_train, t_train)
precision, recall = test_naive_bayes(X_test, t_test, prior, likelihood, num)
pre.append(precision)
rec.append(recall)
pre = sum(pre) / len(pre)
rec = sum(rec) / len(rec)
F = 2 / (1/pre + 1/rec)
return accuracy, pre, rec, F
def lession_4():
iris = datasets.load_iris()
iris_X = iris.data
iris_y = iris.target
# print iris_X[:2]
# print iris_y
X_train,X_test,y_train,y_test = train_test_split(iris_X,iris_y,test_size=0.3)
knn = KNeighborsClassifier()
knn.fit(X_train,y_train)
print knn.predict(X_test)
print y_test
# dataset usage
def case1():
from sklearn import datasets
news = datasets.fetch_20newsgroups(subset='all')
# print len(news.data)
# print len(news.target)
# print '*'*10
# print news.data[0]
# print '*'*10
# print news.target[0]
from sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer
vec = CountVectorizer()
x = vec.fit_transform(news.data)
# print x.shape
# print x[:2]
print x[:10,:10].toarray()
TFIDF = TfidfTransformer()
x_tfidf = TFIDF.fit_transform(x)
print x_tfidf[:10,:10].toarray()
from sklearn.cross_validation import train_test_split
Xtrain, Xtest, ytrain,ytest =train_test_split(x,news.target,test_size = 0.3,random_state=233)
tf_Xtrain, tf_Xtest, tf_ytrain,tf_ytest =train_test_split(x_tfidf,news.target,test_size = 0.3,random_state=233)
from sklearn.naive_bayes import MultinomialNB
mnb =MultinomialNB()
tf_mnb = MultinomialNB()
mmb.fit(Xtrain,ytrain)
tf_mnb.fit(tf_Xtrain,tf_ytrain)
def main():
digits = load_digits()
x_train, x_test, y_train_, y_test_ = cross_validation.train_test_split(digits.data, digits.target, test_size=0.2,
random_state=0)
lb = preprocessing.LabelBinarizer()
lb.fit(digits.target)
y_train = lb.transform(y_train_)
y_test = lb.transform(y_test_)
sess = tf.InteractiveSession()
x = tf.placeholder(tf.float32, shape=[None, 64])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
w_1 = weight_variable([64, 32])
b_1 = bias_variable([32])
h_1 = tf.nn.relu(tf.matmul(x, w_1) + b_1)
w_2 = weight_variable([32, 10])
b_2 = bias_variable([10])
y = tf.nn.softmax(tf.matmul(h_1, w_2) + b_2)
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
sess.run(tf.initialize_all_variables())
for i in range(1000):
train_step.run(feed_dict={x: x_train, y_: y_train})
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print(accuracy.eval(feed_dict={x: x_test, y_: y_test}))
def main():
digits = load_digits()
x_train, x_test, y_train_, y_test_ = cross_validation.train_test_split(digits.data, digits.target, test_size=0.2,
random_state=0)
lb = preprocessing.LabelBinarizer()
lb.fit(digits.target)
y_train = lb.transform(y_train_)
y_test = lb.transform(y_test_)
sess = tf.InteractiveSession()
x = tf.placeholder(tf.float32, shape=[None, 64])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
phase_train = tf.placeholder(tf.bool, name='phase_train')
w_1 = weight_variable([64, 32])
b_1 = bias_variable([32])
t_1 = tf.matmul(x, w_1) + b_1
bn = batch_norm(t_1, 1, phase_train)
h_1 = binarized_ops.binarized(bn)
w_2 = weight_variable([32, 10])
b_2 = bias_variable([10])
y = tf.nn.softmax(tf.matmul(h_1, w_2) + b_2)
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
sess.run(tf.initialize_all_variables())
for i in range(1000):
train_step.run(feed_dict={x: x_train, y_: y_train, phase_train: True})
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print(accuracy.eval(feed_dict={x: x_test, y_: y_test, phase_train: False}))
def main():
digits = load_digits()
x_train, x_test, y_train_, y_test_ = cross_validation.train_test_split(digits.data, digits.target, test_size=0.2,
random_state=0)
lb = preprocessing.LabelBinarizer()
lb.fit(digits.target)
y_train = lb.transform(y_train_)
y_test = lb.transform(y_test_)
sess = tf.InteractiveSession()
x = tf.placeholder(tf.float32, shape=[None, 64])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
w_1 = weight_variable([64, 32])
b_1 = bias_variable([32])
h_1 = tf.nn.relu(tf.matmul(x, w_1) + b_1)
w_2 = weight_variable([32, 10])
b_2 = bias_variable([10])
y = tf.nn.softmax(tf.matmul(h_1, w_2) + b_2)
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
sess.run(tf.initialize_all_variables())
for i in range(1000):
train_step.run(feed_dict={x: x_train, y_: y_train})
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print(accuracy.eval(feed_dict={x: x_test, y_: y_test}))
def main():
digits = load_digits()
x_train, x_test, y_train_, y_test_ = cross_validation.train_test_split(digits.data, digits.target, test_size=0.2,
random_state=0)
lb = preprocessing.LabelBinarizer()
lb.fit(digits.target)
y_train = lb.transform(y_train_)
y_test = lb.transform(y_test_)
sess = tf.InteractiveSession()
x = tf.placeholder(tf.float32, shape=[None, 64])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
phase_train = tf.placeholder(tf.bool, name='phase_train')
w_1 = weight_variable([64, 32])
b_1 = bias_variable([32])
t_1 = tf.matmul(x, w_1) + b_1
bn = batch_norm(t_1, 1, phase_train)
h_1 = binarized_ops.binarized(bn)
w_2 = weight_variable([32, 10])
b_2 = bias_variable([10])
y = tf.nn.softmax(tf.matmul(h_1, w_2) + b_2)
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
sess.run(tf.initialize_all_variables())
for i in range(1000):
train_step.run(feed_dict={x: x_train, y_: y_train, phase_train: True})
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print(accuracy.eval(feed_dict={x: x_test, y_: y_test, phase_train: False}))
def main():
digits = load_digits()
x_train, x_test, y_train_, y_test_ = cross_validation.train_test_split(digits.data, digits.target, test_size=0.2,
random_state=0)
lb = preprocessing.LabelBinarizer()
lb.fit(digits.target)
y_train = lb.transform(y_train_)
y_test = lb.transform(y_test_)
sess = tf.InteractiveSession()
x = tf.placeholder(tf.float32, shape=[None, 64])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
w_1 = weight_variable([64, 32])
b_1 = bias_variable([32])
h_1 = tf.nn.relu(tf.matmul(x, w_1) + b_1)
w_2 = weight_variable([32, 10])
b_2 = bias_variable([10])
y = tf.nn.softmax(tf.matmul(h_1, w_2) + b_2)
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
sess.run(tf.initialize_all_variables())
for i in range(1000):
train_step.run(feed_dict={x: x_train, y_: y_train})
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print(accuracy.eval(feed_dict={x: x_test, y_: y_test}))
def main():
digits = load_digits()
x_train, x_test, y_train_, y_test_ = cross_validation.train_test_split(digits.data, digits.target, test_size=0.2,
random_state=0)
lb = preprocessing.LabelBinarizer()
lb.fit(digits.target)
y_train = lb.transform(y_train_)
y_test = lb.transform(y_test_)
sess = tf.InteractiveSession()
x = tf.placeholder(tf.float32, shape=[None, 64])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
w_1 = weight_variable([64, 32])
b_1 = bias_variable([32])
h_1 = tf.nn.relu(tf.matmul(x, w_1) + b_1)
w_2 = weight_variable([32, 10])
b_2 = bias_variable([10])
y = tf.nn.softmax(tf.matmul(h_1, w_2) + b_2)
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
sess.run(tf.initialize_all_variables())
for i in range(1000):
train_step.run(feed_dict={x: x_train, y_: y_train})
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print(accuracy.eval(feed_dict={x: x_test, y_: y_test}))
def main():
digits = load_digits()
x_train, x_test, y_train_, y_test_ = cross_validation.train_test_split(digits.data, digits.target, test_size=0.2,
random_state=0)
lb = preprocessing.LabelBinarizer()
lb.fit(digits.target)
y_train = lb.transform(y_train_)
y_test = lb.transform(y_test_)
sess = tf.InteractiveSession()
x = tf.placeholder(tf.float32, shape=[None, 64])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
phase_train = tf.placeholder(tf.bool, name='phase_train')
w_1 = weight_variable([64, 32])
b_1 = bias_variable([32])
t_1 = tf.matmul(x, w_1) + b_1
bn = batch_norm(t_1, 1, phase_train)
h_1 = binarized_ops.binarized(bn)
w_2 = weight_variable([32, 10])
b_2 = bias_variable([10])
y = tf.nn.softmax(tf.matmul(h_1, w_2) + b_2)
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
sess.run(tf.initialize_all_variables())
for i in range(1000):
train_step.run(feed_dict={x: x_train, y_: y_train, phase_train: True})
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print(accuracy.eval(feed_dict={x: x_test, y_: y_test, phase_train: False}))
def main():
digits = load_digits()
x_train, x_test, y_train_, y_test_ = cross_validation.train_test_split(digits.data, digits.target, test_size=0.2,
random_state=0)
lb = preprocessing.LabelBinarizer()
lb.fit(digits.target)
y_train = lb.transform(y_train_)
y_test = lb.transform(y_test_)
sess = tf.InteractiveSession()
x = tf.placeholder(tf.float32, shape=[None, 64])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
w_1 = weight_variable([64, 32])
b_1 = bias_variable([32])
h_1 = tf.nn.relu(tf.matmul(x, w_1) + b_1)
w_2 = weight_variable([32, 10])
b_2 = bias_variable([10])
y = tf.nn.softmax(tf.matmul(h_1, w_2) + b_2)
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
sess.run(tf.initialize_all_variables())
for i in range(1000):
train_step.run(feed_dict={x: x_train, y_: y_train})
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print(accuracy.eval(feed_dict={x: x_test, y_: y_test}))
def main():
digits = load_digits()
x_train, x_test, y_train_, y_test_ = cross_validation.train_test_split(digits.data, digits.target, test_size=0.2,
random_state=0)
lb = preprocessing.LabelBinarizer()
lb.fit(digits.target)
y_train = lb.transform(y_train_)
y_test = lb.transform(y_test_)
sess = tf.InteractiveSession()
x = tf.placeholder(tf.float32, shape=[None, 64])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
phase_train = tf.placeholder(tf.bool, name='phase_train')
w_1 = weight_variable([64, 32])
b_1 = bias_variable([32])
t_1 = tf.matmul(x, w_1) + b_1
bn = batch_norm(t_1, 1, phase_train)
h_1 = binarized_ops.binarized(bn)
w_2 = weight_variable([32, 10])
b_2 = bias_variable([10])
y = tf.nn.softmax(tf.matmul(h_1, w_2) + b_2)
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
sess.run(tf.initialize_all_variables())
for i in range(1000):
train_step.run(feed_dict={x: x_train, y_: y_train, phase_train: True})
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print(accuracy.eval(feed_dict={x: x_test, y_: y_test, phase_train: False}))
def main():
digits = load_digits()
x_train, x_test, y_train_, y_test_ = cross_validation.train_test_split(digits.data, digits.target, test_size=0.2,
random_state=0)
lb = preprocessing.LabelBinarizer()
lb.fit(digits.target)
y_train = lb.transform(y_train_)
y_test = lb.transform(y_test_)
sess = tf.InteractiveSession()
x = tf.placeholder(tf.float32, shape=[None, 64])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
w_1 = weight_variable([64, 32])
b_1 = bias_variable([32])
h_1 = tf.nn.relu(tf.matmul(x, w_1) + b_1)
w_2 = weight_variable([32, 10])
b_2 = bias_variable([10])
y = tf.nn.softmax(tf.matmul(h_1, w_2) + b_2)
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
sess.run(tf.initialize_all_variables())
for i in range(1000):
train_step.run(feed_dict={x: x_train, y_: y_train})
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print(accuracy.eval(feed_dict={x: x_test, y_: y_test}))
def main():
digits = load_digits()
x_train, x_test, y_train_, y_test_ = cross_validation.train_test_split(digits.data, digits.target, test_size=0.2,
random_state=0)
lb = preprocessing.LabelBinarizer()
lb.fit(digits.target)
y_train = lb.transform(y_train_)
y_test = lb.transform(y_test_)
sess = tf.InteractiveSession()
x = tf.placeholder(tf.float32, shape=[None, 64])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
w_1 = weight_variable([64, 32])
b_1 = bias_variable([32])
h_1 = tf.nn.relu(tf.matmul(x, w_1) + b_1)
w_2 = weight_variable([32, 10])
b_2 = bias_variable([10])
y = tf.nn.softmax(tf.matmul(h_1, w_2) + b_2)
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
sess.run(tf.initialize_all_variables())
for i in range(1000):
train_step.run(feed_dict={x: x_train, y_: y_train})
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print(accuracy.eval(feed_dict={x: x_test, y_: y_test}))
