def fit(self, X, y, **param):
self.neural_shape = []
if (param.has_key('neural_shape')):
self.neural_shape = param.get("neural_shape")
self.n_output = self.neural_shape[-1]
self.n_hidden = self.neural_shape[1:-1]
self.number_of_layers = len(self.neural_shape)
else:
self.n_input = len(X[0])
self.n_output = len(y[0])
self.neural_shape = self.hidden_nodes.tolist()
self.neural_shape.insert(0, self.n_input)
self.neural_shape.append(self.n_output)
self.n_hidden = self.hidden_nodes
self.kFold = KFold(X.shape[0], n_folds=5)
self.weights_matrix = param.get('weights_matrix')
self.weight_layers = [(self.neural_shape[t - 1], self.neural_shape[t])
for t in range(1, len(self.neural_shape))]
self.bias_layers = [
self.neural_shape[t] for t in range(1, len(self.neural_shape))
]
self.total_nodes_per_layer = zip(self.weight_layers, self.bias_layers)
self.total_nodes = 0
for layer in self.total_nodes_per_layer:
self.total_nodes += (layer[0][0] + 1) * layer[0][1]
# If weights are None then initialize randomly
if (self.weights_matrix == None):
self.W, self.b = initialize_param(self.weight_layers,
self.bias_layers,
self.uniform_init)
else:
self.W, self.b = self.set_weights(self.weights_matrix)
# Iterator for weights and bias
self.W_iter = iter(self.W)
self.b_iter = iter(self.b)
# Initialize neural network layers
self.X = tf.placeholder("float", [None, self.neural_shape[0]],
name="input")
self.y = tf.placeholder("float", [None, self.neural_shape[-1]],
name="output")
#self.config_addon = skflow.addons.ConfigAddon(num_cores=4, gpu_memory_fraction=0.6)
self.network = skflow.TensorFlowEstimator(
model_fn=self.model_fn,
n_classes=0,
steps=self.steps,
learning_rate=self.learning_rate,
batch_size=self.batch_size,
optimizer=self.optimize,
verbose=self.verbose,
continue_training=True)
if (self.cross_validation):
for train, test in self.kFold:
self.network.fit(X[train], y[train])
else:
self.network.fit(X, y)
return self
def train(DIR = "", saveDIR = "/Users/xxximgs/DRNmodel" ):
print('trainingLABELs... paste it to predictFunc!!\n', [clsdir for clsdir in os.listdir(DIR) if not clsdir in set(['.DS_Store'])])
images, labels = convData(DIR)
data_train, data_test, label_train, label_test = cross_validation.train_test_split(images, labels)
# Train a resnet classifier
classifier = skflow.TensorFlowEstimator(
model_fn=res_net, n_classes=10, batch_size=100, steps=20000,
learning_rate=0.001)
while True:
classifier.fit(data_train, label_train, logdir='/Users/xxxx')
score = metrics.accuracy_score(label_test, classifier.predict(data_test))
print('Accuracy: {0:f}'.format(score))
classifier.save(saveDIR)
def dnn(nn_lr=0.1, nn_steps=5000, hidden_units=[30, 30]):
def tanh_dnn(X, y):
features = skflow.ops.dnn(X,
hidden_units=hidden_units,
activation=skflow.tf.tanh)
return skflow.models.linear_regression(features, y)
regressor = skflow.TensorFlowEstimator(model_fn=tanh_dnn,
n_classes=0,
steps=nn_steps,
learning_rate=nn_lr,
batch_size=100)
return regressor
def custom_dnn_model(X_train, y_train):
def _model_fn(X, y):
layers = skflow.ops.dnn(X, [50, 50, 50], keep_prob=0.5)
return skflow.models.logistic_regression(layers, y)
classifier = skflow.TensorFlowEstimator(
model_fn=_model_fn,
#keep_prob=0.5,
n_classes=2,
batch_size=50,
learning_rate=1.5,
steps=2000)
return classifier.fit(X_train, y_train)
def testCustomModel(self):
path = '/tmp/tmp.saver2'
random.seed(42)
iris = datasets.load_iris()
def custom_model(X, y):
return skflow.models.logistic_regression(X, y)
classifier = skflow.TensorFlowEstimator(model_fn=custom_model,
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 train(DIR = "/XXXXXX", logdir = /XXXXXX'):
print('trainingLABELs... paste it to predictFunc!!\n', [clsdir for clsdir in os.listdir(DIR) if not clsdir in set(['.DS_Store'])])
images, labels = conv_data(DIR)
data_train, data_test, label_train, label_test = cross_validation.train_test_split(images, labels, test_size=0.2, random_state=42)
classifier = skflow.TensorFlowEstimator(
model_fn = cnn_model, n_classes=NUM_CLASSES, batch_size=10, steps=1000,
learning_rate=1e-4, optimizer='Adam', continue_training=True)
# classifier = skflow.TensorFlowDNNClassifier(hidden_units=[10, 20, 10],
# n_classes=NUM_CLASSES, steps=1000,
# early_stopping_rounds=200)
while True:
classifier.fit(data_train, label_train, logdir=logdir)
score = metrics.accuracy_score(label_test, classifier.predict(data_test))
print('Accuracy: {0:f}'.format(score))
classifier.save(save_dir)
def fit(self, X, y, **param):
self.neural_shape = param.get("neural_shape")
self.weights_matrix = param.get('weights_matrix')
self.n_input = self.neural_shape[0]
self.n_output = self.neural_shape[-1]
self.n_hidden = self.neural_shape[1]
self.number_of_layers = len(self.neural_shape)
self.weight_layers = [(self.neural_shape[t - 1], self.neural_shape[t])
for t in range(1, len(self.neural_shape))]
self.bias_layers = [
self.neural_shape[t] for t in range(1, len(self.neural_shape))
]
self.total_nodes_per_layer = zip(self.weight_layers, self.bias_layers)
self.total_nodes = 0
for layer in self.total_nodes_per_layer:
self.total_nodes += (layer[0][0] + 1) * layer[0][1]
# If weights are None then initialize randomly
if (self.weights_matrix == None):
self.W, self.b = initialize_param(self.weight_layers,
self.bias_layers,
self.uniform_init)
else:
self.W, self.b = self.set_weights(self.weights_matrix)
#Iterator for weights and bias
self.W_iter = iter(self.W)
self.b_iter = iter(self.b)
#Initialize neural network layers
self.X = tf.placeholder("float", [None, self.neural_shape[0]],
name="input")
self.y = tf.placeholder("float", [None, self.neural_shape[-1]],
name="output")
self.config_addon = skflow.addons.ConfigAddon(num_cores=4,
gpu_memory_fraction=0.6)
self.network = skflow.TensorFlowEstimator(
model_fn=self.model_fn,
n_classes=0,
steps=self.steps,
learning_rate=self.learning_rate,
batch_size=self.batch_size,
optimizer=self.optimize,
config_addon=self.config_addon,
verbose=0)
return self.network.fit(X, y)
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))
# 3 layer neural network with hyperbolic tangent activation.
def dnn_tanh(X, y):
layers = skflow.ops.dnn(X, [10, 20, 10], tf.tanh)
return skflow.models.logistic_regression(layers, y)
random.seed(42)
classifier = skflow.TensorFlowEstimator(model_fn=dnn_tanh,
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))
vocab_processor = skflow.preprocessing.ByteProcessor(
max_document_length=MAX_DOCUMENT_LENGTH)
X_iter = ["some sentence", "some other sentence"]
X_pred = ["some sentence", "some other sentence"]
Y_iter = ["some sentence", "some other sentence"]
x_iter = vocab_processor.transform(X_iter)
y_iter = vocab_processor.transform(Y_iter)
xpred = np.array(list(vocab_processor.transform(X_pred)))
PATH = '/tmp/tf_examples/ntm/'
if os.path.exists(PATH):
translator = skflow.TensorFlowEstimator.restore(PATH)
else:
translator = skflow.TensorFlowEstimator(model_fn=translate_model,
n_classes=256,
continue_training=True)
# print(zip(xpred, xpred_inp, predictions, text_outputs))
translator.fit(x_iter, y_iter, logdir=PATH)
# translator.save(PATH)
predictions = translator.predict(xpred, axis=2)
xpred_inp = vocab_processor.reverse(xpred)
text_outputs = vocab_processor.reverse(predictions)
try:
for inp_data, input_text, pred, output_text in zip(
xpred, xpred_inp, predictions, text_outputs):
print(input_text, output_text)
print(inp_data, pred)
except Exception as e:
print(e)
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import random
import skflow
from sklearn import datasets, metrics, cross_validation
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)
random.seed(42)
def my_model(X, y):
"""This is DNN with 10, 20, 10 hidden layers, and dropout of 0.5 probability."""
layers = skflow.ops.dnn(X, [10, 20, 10], keep_prob=0.5)
return skflow.models.logistic_regression(layers, y)
classifier = skflow.TensorFlowEstimator(model_fn=my_model, n_classes=3)
classifier.fit(X_train, y_train)
score = metrics.accuracy_score(classifier.predict(X_test), y_test)
print('Accuracy: {0:f}'.format(score))
def average_model(X, y):
word_vectors = skflow.ops.categorical_variable(
X, n_classes=n_words, embedding_size=EMBEDDING_SIZE, name='words')
features = tf.reduce_max(word_vectors, reduction_indices=1)
return skflow.models.logistic_regression(features, y)
def rnn_model(X, y):
word_vectors = skflow.ops.categorical_variable(
X, n_classes=n_words, embedding_size=EMBEDDING_SIZE, name='words')
word_list = [
tf.squeeze(w, [1])
for w in tf.split(1, MAX_DOCUMENT_LENGTH, word_vectors)
]
cell = rnn_cell.GRUCell(EMBEDDING_SIZE)
_, encoding = rnn.rnn(cell, word_list, dtype=tf.float32)
return skflow.models.logistic_regression(encoding[-1], y)
classifier = skflow.TensorFlowEstimator(model_fn=rnn_model,
n_classes=15,
steps=1000,
continue_training=True)
# Continuesly train for 1000 steps & predict on test set.
while True:
classifier.fit(X_train, y_train)
score = metrics.accuracy_score(classifier.predict(X_test), y_test)
print("Accuracy: %f" % score)
# Create random dataset.
rng = np.random.RandomState(1)
X = np.sort(200 * rng.rand(100, 1) - 100, axis=0)
y = np.array([np.pi * np.sin(X).ravel(), np.pi * np.cos(X).ravel()]).T
# Fit regression DNN models.
regressors = []
options = [[2], [10, 10], [20, 20]]
for hidden_units in options:
def tanh_dnn(X, y):
features = skflow.ops.dnn(X, hidden_units=hidden_units,
activation=skflow.tf.tanh)
return skflow.models.linear_regression(features, y)
regressor = skflow.TensorFlowEstimator(model_fn=tanh_dnn, n_classes=0,
steps=500, learning_rate=0.1, batch_size=100)
regressor.fit(X, y)
score = mean_squared_error(regressor.predict(X), y)
print("Mean Squared Error for {0}: {1:f}".format(str(hidden_units), score))
regressors.append(regressor)
# Predict on new random Xs.
X_test = np.arange(-100.0, 100.0, 0.1)[:, np.newaxis]
y_1 = regressors[0].predict(X_test)
y_2 = regressors[1].predict(X_test)
y_3 = regressors[2].predict(X_test)
# Plot the results
plt.figure()
plt.scatter(y[:, 0], y[:, 1], c="k", label="data")
plt.scatter(y_1[:, 0], y_1[:, 1], c="g",
word_vectors = skflow.ops.categorical_variable(X, n_classes=n_words,
embedding_size=EMBEDDING_SIZE, name='words')
in_X, in_y, out_y = skflow.ops.seq2seq_inputs(
word_list, y, MAX_DOCUMENT_LENGTH, MAX_DOCUMENT_LENGTH)
cell = tf.nn.rnn_cell.OutputProjectionWrapper(tf.nn.rnn_cell.GRUCell(HIDDEN_SIZE), 256)
decoding, _, sampling_decoding, _ = skflow.ops.rnn_seq2seq(in_X, in_y, cell)
return skflow.ops.sequence_classifier(decoding, out_y, sampling_decoding)
PATH = '/tmp/tf_examples/ntm_words/'
if os.path.exists(PATH):
translator = skflow.TensorFlowEstimator.restore(PATH)
else:
translator = skflow.TensorFlowEstimator(model_fn=translate_model,
n_classes=n_words,
optimizer='Adam', learning_rate=0.01, batch_size=128,
continue_training=True)
while True:
translator.fit(X_train, y_train, logdir=PATH)
translator.save(PATH)
predictions = translator.predict(xpred, axis=2)
xpred_inp = X_vocab_processor.reverse(xpred)
text_outputs = y_vocab_processor.reverse(predictions)
for inp_data, input_text, pred, output_text, gold in zip(xpred, xpred_inp,
predictions, text_outputs, ygold):
print('English: %s. French (pred): %s, French (gold): %s' %
(input_text, output_text, gold.decode('utf-8')))
print(inp_data, pred)
def testUnfitted(self):
estimator = skflow.TensorFlowEstimator(model_fn=None, n_classes=1)
with self.assertRaises(base.NotFittedError):
estimator.predict([1, 2, 3])
with self.assertRaises(base.NotFittedError):
estimator.save('/tmp/path')
except IndexError:
pass
net = tf.nn.avg_pool(net,
ksize=[1, net.get_shape().as_list()[1],
net.get_shape().as_list()[2], 1],
strides=[1, 1, 1, 1], padding='VALID')
net = tf.reshape(
net,
[-1, net.get_shape().as_list()[1] *
net.get_shape().as_list()[2] *
net.get_shape().as_list()[3]])
return skflow.models.logistic_regression(net, y)
# Download and load MNIST data.
mnist = input_data.read_data_sets('MNIST_data')
# Train a resnet classifier
classifier = skflow.TensorFlowEstimator(
model_fn=res_net, n_classes=10, batch_size=100, steps=20000,
learning_rate=0.001)
classifier.fit(mnist.train.images, mnist.train.labels)
# Calculate accuracy
score = metrics.accuracy_score(mnist.test.labels, classifier.predict(mnist.test.images))
print('Accuracy: {0:f}'.format(score))
random.seed(42)
# Load dataset and split it into train / test subsets.
digits = datasets.load_digits()
X = digits.images
y = digits.target
X_train, X_test, y_train, y_test = cross_validation.train_test_split(
X, y, test_size=0.2, random_state=42)
# TensorFlow model using Scikit Flow ops
def conv_model(X, y):
X = tf.expand_dims(X, 3)
features = tf.reduce_max(skflow.ops.conv2d(X, 12, [3, 3]), [1, 2])
features = tf.reshape(features, [-1, 12])
return skflow.models.logistic_regression(features, y)
# Create a classifier, train and predict.
classifier = skflow.TensorFlowEstimator(model_fn=conv_model,
n_classes=10,
steps=500,
learning_rate=0.05,
batch_size=128)
classifier.fit(X_train, y_train)
score = metrics.accuracy_score(classifier.predict(X_test), y_test)
print('Accuracy: {0:f}'.format(score))
with tf.variable_scope('conv2'):
conv2 = skflow.ops.conv2d(pool1,
n_filters=64,
filter_shape=[5, 5],
bias=True,
activation=tf.nn.relu)
pool2 = max_pool_2x2(conv2)
pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 64])
fc1 = skflow.ops.dnn(pool2_flat, [1024],
activation=tf.nn.relu,
keep_prob=0.5)
return skflow.models.logistic_regression(fc1, y)
classifier_cnn = skflow.TensorFlowEstimator(model_fn=conv_model,
n_classes=10,
batch_size=100,
steps=20000,
learning_rate=0.001)
classifier_cnn.fit(X_train, y_train)
cnn_y_predict = []
for i in range(100, 28001, 100):
cnn_y_predict = np.append(cnn_y_predict,
classifier_cnn.predict(X_test[i - 100:i]))
cnn_submission = pd.DataFrame({
'ImageId': range(1, 28001),
'Label': np.int32(cnn_y_predict)
})
cnn_submission.to_csv('cnn_submission.csv')
return skflow.models.logistic_regression(h_fc1, y, class_weight=None)
def CNNmodel(X, y):
keep_prob = tf.placeholder(tf.float32)
return conv_model(X, y, keep_prob = keep_prob)
### Linear classifier.
# classifier = skflow.TensorFlowLinearClassifier(
# n_classes=NUM_CLASSES, batch_size=100, steps=1000, learning_rate=0.01)
# classifier.fit(data_train, label_train)
# score = metrics.accuracy_score(label_test, classifier.predict(data_test))
# print('Accuracy: {0:f}'.format(score))
def train(DIR = "", saveDIR = "/Users/xxxx'):
print('trainingLABELs... paste it to predictFunc!!\n', [clsdir for clsdir in os.listdir(DIR) if not clsdir in set(['.DS_Store'])])
images, labels = convData(DIR)
data_train, data_test, label_train, label_test = cross_validation.train_test_split(images, labels)
classifier = skflow.TensorFlowEstimator(
model_fn = CNNmodel, n_classes=NUM_CLASSES, batch_size=10, steps=200,
learning_rate=1e-4, optimizer='Adam', continue_training=True)
while True:
classifier.fit(data_train, label_train, logdir=logdir)
score = metrics.accuracy_score(label_test, classifier.predict(data_test))
print('Accuracy: {0:f}'.format(score))
classifier.save(saveDIR)
# ['chino', 'eri', 'hanayo', 'honoka', 'kotori', 'maki', 'niko', 'nozomi', 'rin', 'umi']
def predictAns(filename = "rin/show.png", isShow = True, model = '/Users/xxxx']):
classifier = skflow.TensorFlowEstimator.restore(model)
# imgaddress = "rin/images-10.jpeg"
# imgaddress = '/Users/xxxx'
img, altfilename, frame, FACEflag = openCVmod.FaceRecognition(filename, isShow = isShow, saveStyle = 'whole', workDIR = '')
img = openCVmod.adjustIMG(img, isHC = True, K = 0, size = (28, 28))
result = classifier.predict(img)
anslabel = label[result]
yield u"какое-то приложение"
yield u"какое-то другое приложение"
# Translation model
hidden_size = 10
def translate_model(X, y):
print X.get_shape(), y.get_shape()
# in_X, in_y, out_y = skflow.ops.seq2seq_inputs(X, y)
# cell = tf.rnn_cell.GRUCell(hidden_size)
# decoding = seq2seq.basic_rnn_seq2seq(in_X, in_y, cell)
# return skflow.ops.sequence_classifier(decoding, out_y)
return X, y
vocab_processor = skflow.preprocessing.VocabularyProcessor(
max_document_length=3)
vocab_processor.fit(["some sentence", "some other sentence"])
xiter = vocab_processor.transform(X_iter())
yiter = vocab_processor.transform(y_iter())
translator = skflow.TensorFlowEstimator(model_fn=translate_model,
n_classes=128)
translator.fit(xiter, yiter)
print translator.predict(X_iter())
net = tf.reshape(net, [-1, net_shape[1] * net_shape[2] * net_shape[3]])
return skflow.models.logistic_regression(net, y)
# Download and load MNIST data.
mnist = input_data.read_data_sets('MNIST_data')
# Restore model if graph is saved into a folder.
if os.path.exists("models/resnet/graph.pbtxt"):
classifier = skflow.TensorFlowEstimator.restore("models/resnet/")
else:
# Create a new resnet classifier.
classifier = skflow.TensorFlowEstimator(model_fn=res_net,
n_classes=10,
batch_size=100,
steps=100,
learning_rate=0.001,
continue_training=True)
while True:
# Train model and save summaries into logdir.
classifier.fit(mnist.train.images,
mnist.train.labels,
logdir="models/resnet/")
# Calculate accuracy.
score = metrics.accuracy_score(
mnist.test.labels, classifier.predict(mnist.test.images,
batch_size=64))
print('Accuracy: {0:f}'.format(score))
h_pool3 = max_pool_2x2(h_conv3)
# reshape tensor into a batch of vectors
h_pool3_flat = tf.reshape(
h_pool3, [-1, IMAGE_SIZE // 8 * IMAGE_SIZE // 8 * 128])
# densely connected layer with 1024 neurons
h_fc1 = skflow.ops.dnn(h_pool3_flat, [500, 500],
activation=tf.nn.relu,
keep_prob=0.5)
return skflow.models.linear_regression(h_fc1, y)
estimator = skflow.TensorFlowEstimator(
model_fn=cnn_model,
n_classes=0,
batch_size=BATCH_SIZE,
early_stopping_rounds=EARLY_STOP_PATIENCE,
steps=10,
optimizer='Adam',
learning_rate=exp_decay,
continue_training=True)
title = 'learning curve for cnn'
# to plot the learning curve, continue_training must be set False
# generate_learning_curve(estimator, title, 'mean_squared_error', train_dataset, train_labels)
# Continuesly train for 100 steps & predict on test set.
for i in xrange(0, 100):
estimator.fit(train_dataset, train_labels, logdir='log')
score = metrics.mean_squared_error(validation_labels,
estimator.predict(validation_dataset))
print('mean squared error: {0:f}'.format(score))
def train(DataSet,
saveDIR="/XXXXXX",
logdir='/tmp/tf_examples/word_rnn',
splittype='char'):
def average_model(X, y):
word_vectors = skflow.ops.categorical_variable(
X, n_classes=n_words, embedding_size=EMBEDDING_SIZE, name='words')
features = tf.reduce_max(word_vectors, reduction_indices=1)
return skflow.models.logistic_regression(features, y)
def rnn_model(X, y):
"""Recurrent neural network model to predict from sequence of words
to a class."""
# Convert indexes of words into embeddings.
# This creates embeddings matrix of [n_words, EMBEDDING_SIZE] and then
# maps word indexes of the sequence into [batch_size, sequence_length,
# EMBEDDING_SIZE].
word_vectors = skflow.ops.categorical_variable(
X, n_classes=n_words, embedding_size=EMBEDDING_SIZE, name='words')
# Split into list of embedding per word, while removing doc length dim.
# word_list results to be a list of tensors [batch_size, EMBEDDING_SIZE].
word_list = skflow.ops.split_squeeze(1, MAX_DOCUMENT_LENGTH,
word_vectors)
# Create a Gated Recurrent Unit cell with hidden size of EMBEDDING_SIZE.
cell = rnn_cell.GRUCell(EMBEDDING_SIZE)
# Create an unrolled Recurrent Neural Networks to length of
# MAX_DOCUMENT_LENGTH and passes word_list as inputs for each unit.
_, encoding = rnn.rnn(cell, word_list, dtype=tf.float32)
# Given encoding of RNN, take encoding of last step (e.g hidden size of the
# neural network of last step) and pass it as features for logistic
# regression over output classes.
return skflow.models.logistic_regression(encoding[-1], y)
MAX_DOCUMENT_LENGTH = 140
if splittype == 'ma':
DataSet = [(' '.join([
w[0] for w in natural_language_processing.MA.get_mecabCP(pair[0])
]), pair[1]) for pair in DataSet]
else:
DataSet = [(' '.join(list(pair[0])), pair[1]) for pair in DataSet]
X_train, X_test, y_train, y_test = cross_validation.train_test_split(
[train[0] for train in DataSet], [train[1] for train in DataSet])
vocab_processor = skflow.preprocessing.VocabularyProcessor(
MAX_DOCUMENT_LENGTH)
X_train = np.array(list(vocab_processor.fit_transform(X_train)))
X_test = np.array(list(vocab_processor.transform(X_test)))
n_words = len(vocab_processor.vocabulary_)
print('Total words: %d' % n_words)
### Models
EMBEDDING_SIZE = 50
classifier = skflow.TensorFlowEstimator(model_fn=rnn_model,
n_classes=3,
steps=10,
optimizer='Adam',
learning_rate=0.01,
continue_training=True)
while True:
classifier.fit(X_train, y_train, logdir=logdir)
classifier.save(saveDIR)
score = metrics.accuracy_score(y_test, classifier.predict(X_test))
print('Accuracy: {0:f}'.format(score))
# maps word indexes of the sequence into [batch_size, sequence_length,
# EMBEDDING_SIZE].
word_vectors = skflow.ops.categorical_variable(
X, n_classes=n_words, embedding_size=EMBEDDING_SIZE, name='words')
# Split into list of embedding per word, while removing doc length dim.
# word_list results to be a list of tensors [batch_size, EMBEDDING_SIZE].
word_list = skflow.ops.split_squeeze(1, MAX_DOCUMENT_LENGTH, word_vectors)
# Create a Gated Recurrent Unit cell with hidden size of EMBEDDING_SIZE.
cell = rnn_cell.GRUCell(EMBEDDING_SIZE)
# Create an unrolled Recurrent Neural Networks to length of
# MAX_DOCUMENT_LENGTH and passes word_list as inputs for each unit.
_, encoding = rnn.rnn(cell, word_list, dtype=tf.float32)
# Given encoding of RNN, take encoding of last step (e.g hidden size of the
# neural network of last step) and pass it as features for logistic
# regression over output classes.
return skflow.models.logistic_regression(encoding[-1], y)
classifier = skflow.TensorFlowEstimator(model_fn=rnn_model,
n_classes=15,
steps=1000,
optimizer='Adam',
learning_rate=0.01,
continue_training=True)
# Continuesly train for 1000 steps & predict on test set.
while True:
classifier.fit(X_train, y_train, logdir='/tmp/tf_examples/word_rnn')
score = metrics.accuracy_score(classifier.predict(X_test), y_test)
print('Accuracy: {0:f}'.format(score))
in_X, in_y, encoder_cell, decoder_cell)
return skflow.ops.sequence_classifier(decoding, out_y, sampling_decoding)
def get_language_model(hidden_size):
"""Returns a language model with given hidden size."""
def language_model(X, y):
inputs = skflow.ops.one_hot_matrix(X, 256)
inputs = skflow.ops.split_squeeze(1, MAX_DOC_LENGTH, inputs)
target = skflow.ops.split_squeeze(1, MAX_DOC_LENGTH, y)
encoder_cell = tf.nn.rnn_cell.OutputProjectionWrapper(
tf.nn.rnn_cell.GRUCell(hidden_size), 256)
output, _ = tf.nn.rnn(encoder_cell, inputs, dtype=tf.float32)
return skflow.ops.sequence_classifier(output, target)
return language_model
### Training model.
estimator = skflow.TensorFlowEstimator(
model_fn=get_language_model(HIDDEN_SIZE),
n_classes=256,
optimizer='Adam',
learning_rate=0.01,
steps=1000,
batch_size=64,
continue_training=True)
estimator.fit(X, y)
