def testIrisClassWeight(self):
iris = datasets.load_iris()
classifier = skflow.TensorFlowLinearClassifier(
n_classes=3, class_weight=[0.1, 0.8, 0.1])
classifier.fit(iris.data, iris.target)
score = accuracy_score(iris.target, classifier.predict(iris.data))
self.assertLess(score, 0.7, "Failed with score = {0}".format(score))
def testIrisSummaries(self):
random.seed(42)
iris = datasets.load_iris()
classifier = skflow.TensorFlowLinearClassifier(n_classes=3)
classifier.fit(iris.data, iris.target, logdir='/tmp/skflow_tests/')
score = accuracy_score(classifier.predict(iris.data), iris.target)
self.assertGreater(score, 0.5, "Failed with score = {0}".format(score))
def testIrisStreaming(self):
iris = datasets.load_iris()
def iris_data():
while True:
for x in iris.data:
yield x
def iris_predict_data():
for x in iris.data:
yield x
def iris_target():
while True:
for y in iris.target:
yield y
classifier = skflow.TensorFlowLinearClassifier(n_classes=3, steps=100)
classifier.fit(iris_data(), iris_target())
score1 = accuracy_score(iris.target, classifier.predict(iris.data))
score2 = accuracy_score(iris.target,
classifier.predict(iris_predict_data()))
self.assertGreater(score1, 0.5,
"Failed with score = {0}".format(score1))
self.assertEqual(
score2, score1, "Scores from {0} iterator doesn't "
"match score {1} from full "
"data.".format(score2, score1))
def testIrisContinueTraining(self):
random.seed(42)
iris = datasets.load_iris()
classifier = skflow.TensorFlowLinearClassifier(n_classes=3,
learning_rate=0.05, continue_training=True)
classifier.fit(iris.data, iris.target)
score1 = accuracy_score(classifier.predict(iris.data), iris.target)
classifier.fit(iris.data, iris.target)
score2 = accuracy_score(classifier.predict(iris.data), iris.target)
self.assertGreater(score2, score1,
"Failed with score = {0}".format(score2))
def testIris(self):
path = '/tmp/tmp.saver'
random.seed(42)
iris = datasets.load_iris()
classifier = skflow.TensorFlowLinearClassifier(n_classes=3)
classifier.fit(iris.data, iris.target)
classifier.save(path)
new_classifier = skflow.TensorFlowEstimator.restore(path)
self.assertEqual(type(new_classifier), type(classifier))
score = accuracy_score(iris.target, new_classifier.predict(iris.data))
self.assertGreater(score, 0.5, "Failed with score = {0}".format(score))
def test_pandas_series(self):
if HAS_PANDAS:
random.seed(42)
iris = datasets.load_iris()
data = pd.DataFrame(iris.data)
labels = pd.Series(iris.target)
classifier = skflow.TensorFlowLinearClassifier(n_classes=3)
classifier.fit(data, labels)
score = accuracy_score(labels, classifier.predict(data))
self.assertGreater(score, 0.5,
"Failed with score = {0}".format(score))
def test_pandas_dataframe(self):
if HAS_PANDAS:
random.seed(42)
iris = datasets.load_iris()
data = pd.DataFrame(iris.data)
labels = pd.DataFrame(iris.target)
classifier = skflow.TensorFlowLinearClassifier(n_classes=3)
classifier.fit(data, labels)
score = accuracy_score(classifier.predict(data), labels)
self.assertGreater(score, 0.5,
"Failed with score = {0}".format(score))
else:
print("No pandas installed. test_pandas_dataframe skipped.")
def testIrisStreaming(self):
iris = datasets.load_iris()
def iris_data():
while True:
for x in iris.data:
yield x
def iris_target():
while True:
for y in iris.target:
yield y
classifier = skflow.TensorFlowLinearClassifier(n_classes=3, steps=100)
classifier.fit(iris_data(), iris_target())
score = accuracy_score(classifier.predict(iris.data), iris.target)
self.assertGreater(score, 0.5, "Failed with score = {0}".format(score))
def test_dask_iris_classification(self):
if HAS_DASK and HAS_PANDAS:
random.seed(42)
iris = datasets.load_iris()
data = pd.DataFrame(iris.data)
data = dd.from_pandas(data, npartitions=2)
labels = pd.DataFrame(iris.target)
labels = dd.from_pandas(labels, npartitions=2)
classifier = skflow.TensorFlowLinearClassifier(n_classes=3)
classifier.fit(data, labels)
predictions = data.map_partitions(classifier.predict).compute()
score = accuracy_score(labels.compute(), predictions)
self.assertGreater(score, 0.5,
"Failed with score = {0}".format(score))
# to firstly draw sample batches and then load into memory for training.
# Load dataset.
iris = datasets.load_iris()
X_train, X_test, y_train, y_test = cross_validation.train_test_split(
iris.data, iris.target, test_size=0.2, random_state=42)
# Note that we use iris here just for demo purposes
# You can load your own large dataset into a out-of-core dataframe
# using dask's methods, e.g. read_csv() in dask
# details please see: http://dask.pydata.org/en/latest/dataframe.html
# We firstly load them into pandas dataframe and then convert into dask dataframe
X_train, y_train, X_test, y_test = [
pd.DataFrame(data) for data in [X_train, y_train, X_test, y_test]
]
X_train, y_train, X_test, y_test = [
dd.from_pandas(data, npartitions=2)
for data in [X_train, y_train, X_test, y_test]
]
# Intialize a TensorFlow linear classifier
classifier = skflow.TensorFlowLinearClassifier(n_classes=3)
# Fit the model using training set
classifier.fit(X_train, y_train)
# Make predictions on each partitions of testing data
predictions = X_test.map_partitions(classifier.predict).compute()
# Calculate accuracy
score = metrics.accuracy_score(y_test.compute(), predictions)
train = pandas.read_csv('data/titanic_train.csv')
y, X = train['Survived'], train[['Age', 'SibSp', 'Fare']].fillna(0)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.2,
random_state=42)
lr = LogisticRegression()
lr.fit(X_train, y_train)
print(accuracy_score(lr.predict(X_test), y_test))
# Linear classifier.
random.seed(42)
tflr = skflow.TensorFlowLinearClassifier(n_classes=2,
batch_size=128,
steps=500,
learning_rate=0.05)
tflr.fit(X_train, y_train)
print(accuracy_score(tflr.predict(X_test), y_test))
# 3 layer neural network with rectified linear activation.
random.seed(42)
classifier = skflow.TensorFlowDNNClassifier(hidden_units=[10, 20, 10],
n_classes=2,
batch_size=128,
steps=500,
learning_rate=0.05)
classifier.fit(X_train, y_train)
print(accuracy_score(classifier.predict(X_test), y_test))
import random
from sklearn import metrics
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import skflow
### Download and load MNIST data.
mnist = input_data.read_data_sets('MNIST_data')
### Linear classifier.
classifier = skflow.TensorFlowLinearClassifier(
n_classes=10, batch_size=100, steps=1000, learning_rate=0.01)
classifier.fit(mnist.train.images, mnist.train.labels)
score = metrics.accuracy_score(mnist.test.labels, classifier.predict(mnist.test.images))
print('Accuracy: {0:f}'.format(score))
### Convolutional network
def max_pool_2x2(tensor_in):
return tf.nn.max_pool(tensor_in, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1],
padding='SAME')
def conv_model(X, y):
X = tf.reshape(X, [-1, 28, 28, 1])
with tf.variable_scope('conv_layer1'):
h_conv1 = skflow.ops.conv2d(X, n_filters=32, filter_shape=[5, 5],
bias=True, activation=tf.nn.relu)
def testIris(self):
iris = datasets.load_iris()
classifier = skflow.TensorFlowLinearClassifier(n_classes=3)
classifier.fit(iris.data, [float(x) for x in iris.target])
score = accuracy_score(iris.target, classifier.predict(iris.data))
self.assertGreater(score, 0.7, "Failed with score = {0}".format(score))
def lin_model(X_train, X_test, y_train, y_test):
classifier = skflow.TensorFlowLinearClassifier(n_classes=2)
return classifier.fit(X_train, y_train)
