def build_nce_model(num_words, num_docs, doc_embedding_size=doc_embedding_size, word_embedding_size=word_embedding_size):
X1 = tflearn.input_data(shape=[None, 1])
X2 = tflearn.input_data(shape=[None, 3])
Y = tf.placeholder(tf.float32, [None, 1])
d1, = tflearn.embedding(X1, input_dim=num_docs, output_dim=doc_embedding_size)
w1, w2, w3 = tflearn.embedding(X2, input_dim=num_words, output_dim=word_embedding_size)
embedding_layer = tflearn.merge([d1, w1, w2, w3], mode='concat')
num_classes = num_words
dim = doc_embedding_size + 3*word_embedding_size
with tf.variable_scope("NCELoss"):
weights = tflearn.variables.variable('W', [num_classes, dim])
biases = tflearn.variables.variable('b', [num_classes])
batch_loss = tf.nn.nce_loss(weights, biases, embedding_layer, Y, num_sampled=100, num_classes=num_classes)
loss = tf.reduce_mean(batch_loss)
optimizer = tf.train.AdamOptimizer(learning_rate=0.001)
trainop = tflearn.TrainOp(loss=loss, optimizer=optimizer,
metric=None, batch_size=32)
trainer = tflearn.Trainer(train_ops=trainop, tensorboard_verbose=0, checkpoint_path='embedding_model_nce')
return trainer, X1, X2, Y
def do_cnn_doc2vec(trainX, testX, trainY, testY):
global max_features
print "CNN and doc2vec"
#trainX = pad_sequences(trainX, maxlen=max_features, value=0.)
#testX = pad_sequences(testX, maxlen=max_features, value=0.)
# Converting labels to binary vectors
trainY = to_categorical(trainY, nb_classes=2)
testY = to_categorical(testY, nb_classes=2)
# Building convolutional network
network = input_data(shape=[None,max_features], name='input')
network = tflearn.embedding(network, input_dim=1000000, output_dim=128,validate_indices=False)
branch1 = conv_1d(network, 128, 3, padding='valid', activation='relu', regularizer="L2")
branch2 = conv_1d(network, 128, 4, padding='valid', activation='relu', regularizer="L2")
branch3 = conv_1d(network, 128, 5, padding='valid', activation='relu', regularizer="L2")
network = merge([branch1, branch2, branch3], mode='concat', axis=1)
network = tf.expand_dims(network, 2)
network = global_max_pool(network)
network = dropout(network, 0.8)
network = fully_connected(network, 2, activation='softmax')
network = regression(network, optimizer='adam', learning_rate=0.001,
loss='categorical_crossentropy', name='target')
# Training
model = tflearn.DNN(network, tensorboard_verbose=0)
model.fit(trainX, trainY,
n_epoch=5, shuffle=True, validation_set=(testX, testY),
show_metric=True, batch_size=100,run_id="review")
def do_rnn(trainX, testX, trainY, testY):
global n_words
# Data preprocessing
# Sequence padding
print "GET n_words embedding %d" % n_words
trainX = pad_sequences(trainX, maxlen=MAX_DOCUMENT_LENGTH, value=0.)
testX = pad_sequences(testX, maxlen=MAX_DOCUMENT_LENGTH, value=0.)
# Converting labels to binary vectors
trainY = to_categorical(trainY, nb_classes=2)
testY = to_categorical(testY, nb_classes=2)
# Network building
net = tflearn.input_data([None, MAX_DOCUMENT_LENGTH])
net = tflearn.embedding(net, input_dim=n_words, output_dim=128)
net = tflearn.lstm(net, 128, dropout=0.8)
net = tflearn.fully_connected(net, 2, activation='softmax')
net = tflearn.regression(net, optimizer='adam', learning_rate=0.001,
loss='categorical_crossentropy')
# Training
model = tflearn.DNN(net, tensorboard_verbose=3)
model.fit(trainX, trainY, validation_set=(testX, testY), show_metric=True,
batch_size=32,run_id="maidou")
def do_rnn(trainX, testX, trainY, testY):
max_document_length=64
y_test=testY
trainX = pad_sequences(trainX, maxlen=max_document_length, value=0.)
testX = pad_sequences(testX, maxlen=max_document_length, value=0.)
# Converting labels to binary vectors
trainY = to_categorical(trainY, nb_classes=2)
testY = to_categorical(testY, nb_classes=2)
# Network building
net = tflearn.input_data([None, max_document_length])
net = tflearn.embedding(net, input_dim=10240000, output_dim=64)
net = tflearn.lstm(net, 64, dropout=0.1)
net = tflearn.fully_connected(net, 2, activation='softmax')
net = tflearn.regression(net, optimizer='adam', learning_rate=0.001,
loss='categorical_crossentropy')
# Training
model = tflearn.DNN(net, tensorboard_verbose=0,tensorboard_dir="dga_log")
model.fit(trainX, trainY, validation_set=(testX, testY), show_metric=True,
batch_size=10,run_id="dga",n_epoch=1)
y_predict_list = model.predict(testX)
#print y_predict_list
y_predict = []
for i in y_predict_list:
print i[0]
if i[0] > 0.5:
y_predict.append(0)
else:
y_predict.append(1)
print(classification_report(y_test, y_predict))
print metrics.confusion_matrix(y_test, y_predict)
def do_rnn(x,y):
global max_document_length
print "RNN"
trainX, testX, trainY, testY = train_test_split(x, y, test_size=0.4, random_state=0)
y_test=testY
trainX = pad_sequences(trainX, maxlen=max_document_length, value=0.)
testX = pad_sequences(testX, maxlen=max_document_length, value=0.)
# Converting labels to binary vectors
trainY = to_categorical(trainY, nb_classes=2)
testY = to_categorical(testY, nb_classes=2)
# Network building
net = tflearn.input_data([None, max_document_length])
net = tflearn.embedding(net, input_dim=10240000, output_dim=128)
net = tflearn.lstm(net, 128, dropout=0.8)
net = tflearn.fully_connected(net, 2, activation='softmax')
net = tflearn.regression(net, optimizer='adam', learning_rate=0.001,
loss='categorical_crossentropy')
# Training
model = tflearn.DNN(net, tensorboard_verbose=0)
model.fit(trainX, trainY, validation_set=0.1, show_metric=True,
batch_size=10,run_id="webshell",n_epoch=5)
y_predict_list=model.predict(testX)
y_predict=[]
for i in y_predict_list:
if i[0] > 0.5:
y_predict.append(0)
else:
y_predict.append(1)
do_metrics(y_test, y_predict)
def do_cnn(trainX, trainY,testX, testY):
global n_words
# Data preprocessing
# Sequence padding
trainX = pad_sequences(trainX, maxlen=MAX_DOCUMENT_LENGTH, value=0.)
testX = pad_sequences(testX, maxlen=MAX_DOCUMENT_LENGTH, value=0.)
# Converting labels to binary vectors
trainY = to_categorical(trainY, nb_classes=2)
testY = to_categorical(testY, nb_classes=2)
# Building convolutional network
network = input_data(shape=[None, MAX_DOCUMENT_LENGTH], name='input')
network = tflearn.embedding(network, input_dim=n_words+1, output_dim=128)
branch1 = conv_1d(network, 128, 3, padding='valid', activation='relu', regularizer="L2")
branch2 = conv_1d(network, 128, 4, padding='valid', activation='relu', regularizer="L2")
branch3 = conv_1d(network, 128, 5, padding='valid', activation='relu', regularizer="L2")
network = merge([branch1, branch2, branch3], mode='concat', axis=1)
network = tf.expand_dims(network, 2)
network = global_max_pool(network)
network = dropout(network, 0.5)
network = fully_connected(network, 2, activation='softmax')
network = regression(network, optimizer='adam', learning_rate=0.001,
loss='categorical_crossentropy', name='target')
# Training
model = tflearn.DNN(network, tensorboard_verbose=0)
model.fit(trainX, trainY, n_epoch = 20, shuffle=True, validation_set=(testX, testY), show_metric=True, batch_size=32)
def generate_net(embedding):
net = tflearn.input_data([None, 200])
net = tflearn.embedding(net, input_dim=300000, output_dim=128)
net = tflearn.lstm(net, 128)
net = tflearn.dropout(net, 0.5)
net = tflearn.fully_connected(net, 2, activation='softmax')
net = tflearn.regression(net, optimizer='adam',
loss='categorical_crossentropy')
return net
def build_model(num_words, num_docs,
doc_embedding_size=doc_embedding_size, word_embedding_size=word_embedding_size):
input_layer1 = tflearn.input_data(shape=[None, 1])
input_layer2 = tflearn.input_data(shape=[None, 3])
d1, = tflearn.embedding(input_layer1, input_dim=num_docs, output_dim=doc_embedding_size)
w1, w2, w3 = tflearn.embedding(input_layer2, input_dim=num_words, output_dim=word_embedding_size)
embedding_layer = tflearn.merge([d1, w1, w2, w3], mode='concat')
softmax = tflearn.fully_connected(embedding_layer, num_words, activation='softmax')
optimizer = tflearn.optimizers.Adam(learning_rate=0.001)
# optimizer = tflearn.optimizers.SGD(learning_rate=0.1)
metric = tflearn.metrics.Accuracy()
net = tflearn.regression(softmax, optimizer=optimizer, metric=metric, batch_size=16,
loss='categorical_crossentropy')
model = tflearn.DNN(net, tensorboard_verbose=0, checkpoint_path='embedding_model')
return model
def build(embedding_size=(400000, 50), train_embedding=False, hidden_dims=128,
learning_rate=0.001):
net = tflearn.input_data([None, 200])
net = tflearn.embedding(net, input_dim=embedding_size[0],
output_dim=embedding_size[1],
trainable=train_embedding, name='EmbeddingLayer')
net = tflearn.lstm(net, hidden_dims)
net = tflearn.dropout(net, 0.5)
net = tflearn.fully_connected(net, 2, activation='softmax')
net = tflearn.regression(net, optimizer='adam', learning_rate=learning_rate,
loss='categorical_crossentropy')
return net
def do_cnn(x,y):
global max_document_length
print "CNN and tf"
trainX, testX, trainY, testY = train_test_split(x, y, test_size=0.4, random_state=0)
y_test=testY
trainX = pad_sequences(trainX, maxlen=max_document_length, value=0.)
testX = pad_sequences(testX, maxlen=max_document_length, value=0.)
# Converting labels to binary vectors
trainY = to_categorical(trainY, nb_classes=2)
testY = to_categorical(testY, nb_classes=2)
# Building convolutional network
network = input_data(shape=[None,max_document_length], name='input')
network = tflearn.embedding(network, input_dim=1000000, output_dim=128)
branch1 = conv_1d(network, 128, 3, padding='valid', activation='relu', regularizer="L2")
branch2 = conv_1d(network, 128, 4, padding='valid', activation='relu', regularizer="L2")
branch3 = conv_1d(network, 128, 5, padding='valid', activation='relu', regularizer="L2")
network = merge([branch1, branch2, branch3], mode='concat', axis=1)
network = tf.expand_dims(network, 2)
network = global_max_pool(network)
network = dropout(network, 0.8)
network = fully_connected(network, 2, activation='softmax')
network = regression(network, optimizer='adam', learning_rate=0.001,
loss='categorical_crossentropy', name='target')
model = tflearn.DNN(network, tensorboard_verbose=0)
#if not os.path.exists(pkl_file):
# Training
model.fit(trainX, trainY,
n_epoch=5, shuffle=True, validation_set=0.1,
show_metric=True, batch_size=100,run_id="webshell")
# model.save(pkl_file)
#else:
# model.load(pkl_file)
y_predict_list=model.predict(testX)
#y_predict = list(model.predict(testX,as_iterable=True))
y_predict=[]
for i in y_predict_list:
print i[0]
if i[0] > 0.5:
y_predict.append(0)
else:
y_predict.append(1)
print 'y_predict_list:'
print y_predict_list
print 'y_predict:'
print y_predict
#print y_test
do_metrics(y_test, y_predict)
def run():
net = tflearn.input_data([None, 100])
net = tflearn.embedding(net, input_dim=20000, output_dim=128)
net = tflearn.bidirectional_rnn(
net, tflearn.BasicLSTMCell(128), tflearn.BasicLSTMCell(128))
net = tflearn.dropout(net, 0.5)
net = tflearn.fully_connected(net, 2, activation='softmax')
net = tflearn.regression(
net, optimizer='adam', loss='categorical_crossentropy')
m = tflearn.DNN(net, clip_gradients=0., tensorboard_verbose=2)
m.fit(trainX, trainY, validation_set=0.1, show_metric=True, batch_size=64)
m.save('models/bidirectional_rnn.tfl')
def build():
network = input_data([None, Meta.max_string_len])
network = embedding(network, input_dim=Meta.max_one_hot, output_dim=128)
branch1 = conv_1d(network, 128, 3, padding='valid', activation='relu', regularizer="L2")
branch2 = conv_1d(network, 128, 4, padding='valid', activation='relu', regularizer="L2")
branch3 = conv_1d(network, 128, 5, padding='valid', activation='relu', regularizer="L2")
network = merge([branch1, branch2, branch3], mode='concat', axis=1)
network = dropout(network, 0.5)
network = lstm(network, 128)
# network = fully_connected(network, 20)
network = fully_connected(network, 2, activation='softmax')
network = tflearn.regression(network, optimizer='adam', learning_rate=0.001, loss='categorical_crossentropy')
model = tflearn.DNN(network, tensorboard_verbose=0)
return model
def test_recurrent_layers(self):
X = [[1, 3, 5, 7], [2, 4, 8, 10], [1, 5, 9, 11], [2, 6, 8, 0]]
Y = [[0., 1.], [1., 0.], [0., 1.], [1., 0.]]
with tf.Graph().as_default():
g = tflearn.input_data(shape=[None, 4])
g = tflearn.embedding(g, input_dim=12, output_dim=4)
g = tflearn.lstm(g, 6)
g = tflearn.fully_connected(g, 2, activation='softmax')
g = tflearn.regression(g, optimizer='sgd', learning_rate=1.)
m = tflearn.DNN(g)
m.fit(X, Y, n_epoch=300, snapshot_epoch=False)
self.assertGreater(m.predict([[5, 9, 11, 1]])[0][1], 0.9)
def do_rnn(trainX, testX, trainY, testY):
global max_sequences_len
global max_sys_call
# Data preprocessing
# Sequence padding
trainX = pad_sequences(trainX, maxlen=max_sequences_len, value=0.)
testX = pad_sequences(testX, maxlen=max_sequences_len, value=0.)
# Converting labels to binary vectors
trainY = to_categorical(trainY, nb_classes=2)
testY_old=testY
testY = to_categorical(testY, nb_classes=2)
# Network building
print "GET max_sequences_len embedding %d" % max_sequences_len
print "GET max_sys_call embedding %d" % max_sys_call
net = tflearn.input_data([None, max_sequences_len])
net = tflearn.embedding(net, input_dim=max_sys_call+1, output_dim=128)
net = tflearn.lstm(net, 128, dropout=0.3)
net = tflearn.fully_connected(net, 2, activation='softmax')
net = tflearn.regression(net, optimizer='adam', learning_rate=0.1,
loss='categorical_crossentropy')
# Training
model = tflearn.DNN(net, tensorboard_verbose=3)
model.fit(trainX, trainY, validation_set=(testX, testY), show_metric=True,
batch_size=32,run_id="maidou")
y_predict_list = model.predict(testX)
#print y_predict_list
y_predict = []
for i in y_predict_list:
#print i[0]
if i[0] > 0.5:
y_predict.append(0)
else:
y_predict.append(1)
#y_predict=to_categorical(y_predict, nb_classes=2)
print(classification_report(testY_old, y_predict))
print metrics.confusion_matrix(testY_old, y_predict)
def bi_lstm(trainX, trainY,testX, testY):
trainX = pad_sequences(trainX, maxlen=200, value=0.)
testX = pad_sequences(testX, maxlen=200, value=0.)
# Converting labels to binary vectors
trainY = to_categorical(trainY, nb_classes=2)
testY = to_categorical(testY, nb_classes=2)
# Network building
net = tflearn.input_data(shape=[None, 200])
net = tflearn.embedding(net, input_dim=20000, output_dim=128)
net = tflearn.bidirectional_rnn(net, BasicLSTMCell(128), BasicLSTMCell(128))
net = tflearn.dropout(net, 0.5)
net = tflearn.fully_connected(net, 2, activation='softmax')
net = tflearn.regression(net, optimizer='adam', loss='categorical_crossentropy')
# Training
model = tflearn.DNN(net, clip_gradients=0., tensorboard_verbose=2)
model.fit(trainX, trainY, validation_set=0.1, show_metric=True, batch_size=64,run_id="rnn-bilstm")
def run():
net = tflearn.input_data([None, 100])
# embed int vector to compact real vector
net = tflearn.embedding(net, input_dim=10000, output_dim=128)
# f*****g magic of rnn
# if dynamic lstm, backprop thru time till the seq ends,
# but padding is needed to feed input dim; tail not used
net = tflearn.lstm(net, 128, dropout=0.8, dynamic=True)
net = tflearn.fully_connected(net, 2, activation='softmax')
net = tflearn.regression(net, optimizer='adam',
learning_rate=0.001,
loss='categorical_crossentropy')
m = tflearn.DNN(net)
m.fit(trainX, trainY, validation_set=(testX, testY),
show_metric=True, batch_size=32)
m.save('models/lstm.tfl')
run()
def do_cnn_word2vec_2d_345(trainX, testX, trainY, testY):
global max_features
global max_document_length
print "CNN and word2vec_2d_345"
y_test = testY
trainY = to_categorical(trainY, nb_classes=2)
testY = to_categorical(testY, nb_classes=2)
# Building convolutional network
network = input_data(shape=[None,max_document_length,max_features,1], name='input')
network = tflearn.embedding(network, input_dim=1, output_dim=128,validate_indices=False)
branch1 = conv_2d(network, 128, 3, padding='valid', activation='relu', regularizer="L2")
branch2 = conv_2d(network, 128, 4, padding='valid', activation='relu', regularizer="L2")
branch3 = conv_2d(network, 128, 5, padding='valid', activation='relu', regularizer="L2")
network = merge([branch1, branch2, branch3], mode='concat', axis=1)
network = tf.expand_dims(network, 2)
network = global_max_pool_2d(network)
network = dropout(network, 0.8)
network = fully_connected(network, 2, activation='softmax')
network = regression(network, optimizer='adam', learning_rate=0.001,
loss='categorical_crossentropy', name='target')
# Training
model = tflearn.DNN(network, tensorboard_verbose=0)
model.fit(trainX, trainY,
n_epoch=5, shuffle=True, validation_set=(testX, testY),
show_metric=True, batch_size=100,run_id="sms")
y_predict_list = model.predict(testX)
print y_predict_list
y_predict = []
for i in y_predict_list:
print i[0]
if i[0] > 0.5:
y_predict.append(0)
else:
y_predict.append(1)
print(classification_report(y_test, y_predict))
print metrics.confusion_matrix(y_test, y_predict)
def lstm(trainX, trainY,testX, testY):
# Data preprocessing
# Sequence padding
trainX = pad_sequences(trainX, maxlen=100, value=0.)
testX = pad_sequences(testX, maxlen=100, value=0.)
# Converting labels to binary vectors
trainY = to_categorical(trainY, nb_classes=2)
testY = to_categorical(testY, nb_classes=2)
# Network building
net = tflearn.input_data([None, 100])
net = tflearn.embedding(net, input_dim=10000, output_dim=128)
net = tflearn.lstm(net, 128, dropout=0.8)
net = tflearn.fully_connected(net, 2, activation='softmax')
net = tflearn.regression(net, optimizer='adam', learning_rate=0.001,
loss='categorical_crossentropy')
# Training
model = tflearn.DNN(net, tensorboard_verbose=0)
model.fit(trainX, trainY, validation_set=(testX, testY), show_metric=True,
batch_size=32,run_id="rnn-lstm")
def do_rnn_wordbag(trainX, testX, trainY, testY):
global max_document_length
print "RNN and wordbag"
trainX = pad_sequences(trainX, maxlen=max_document_length, value=0.)
testX = pad_sequences(testX, maxlen=max_document_length, value=0.)
# Converting labels to binary vectors
trainY = to_categorical(trainY, nb_classes=2)
testY = to_categorical(testY, nb_classes=2)
# Network building
net = tflearn.input_data([None, max_document_length])
net = tflearn.embedding(net, input_dim=10240000, output_dim=128)
net = tflearn.lstm(net, 128, dropout=0.8)
net = tflearn.fully_connected(net, 2, activation='softmax')
net = tflearn.regression(net, optimizer='adam', learning_rate=0.001,
loss='categorical_crossentropy')
# Training
model = tflearn.DNN(net, tensorboard_verbose=0)
model.fit(trainX, trainY, validation_set=(testX, testY), show_metric=True,
batch_size=10,run_id="review",n_epoch=5)
yTr = numpy.reshape(yTr, (yTr.shape[0], 1))
yTe = numpy.reshape(yTe, (yTe.shape[0], 1))
print(xTr.shape, xTe.shape, yTr.shape, yTe.shape)
x = tf.placeholder(shape=(None, 9), dtype=tf.float32)
y_ = tf.placeholder(shape=(None, 1), dtype=tf.float32)
keep_prob = tf.placeholder(tf.float32)
batch_size = 75
epochs = 800
lr = 0.00001
net = tflearn.input_data(placeholder=x)
net = tflearn.embedding(net,
input_dim=21,
output_dim=32,
weights_init='xavier')
net = tflearn.fully_connected(net, 100, activation='prelu')
net = tflearn.layers.normalization.batch_normalization(net)
net = tflearn.dropout(net, 0.1)
net = tflearn.fully_connected(net, 1, activation='sigmoid')
loss = tf.reduce_mean(tf.square(net - y_))
train_op = tf.train.RMSPropOptimizer(lr).minimize(loss)
accuracy = tf.contrib.metrics.streaming_root_mean_squared_error(net, y_)
with tf.Session() as sess:
sess.run(tf.initialize_all_variables())
sess.run(tf.initialize_local_variables())
tflearn.is_training(True, session=sess)
# Create train, validation, and test sets
train_x, train_y = features[train_index], labels[train_index]
val_x, val_y = features[test_index], labels[test_index]
test_x, test_y = features[validation_index], labels[validation_index]
print("\t\t\tFeature Shapes:")
print("Train set: \t\t{}".format(train_x.shape),
"\nValidation set: \t{}".format(val_x.shape),
"\nTest set: \t\t{}".format(test_x.shape))
'''
# Create Recurrant Neural Network Model
# input dim = vocab size
# fully connected size = no of unique y labels
net = tflearn.input_data([None, max_length])
net = tflearn.embedding(net, input_dim=vocab_size, output_dim=128)
net = tflearn.lstm(net, 128, dropout=0.8)
net = tflearn.fully_connected(net, no_of_unique_y_labels, activation='softmax')
net = tflearn.regression(net, optimizer='adam', learning_rate=0.001,
loss='categorical_crossentropy')
model = tflearn.DNN(net, tensorboard_verbose=0)
# Train the RNN with train and test data
model.fit(train_x, train_y, validation_set=(test_x, test_y), show_metric=True)
'''
# Manually save the model
# need to make folder SavedModels
model.save('SavedModels/model.tfl')
print(colored('Model Saved!', 'red'))
trainY = to_categorical(trainY, nb_classes=2)
testY = to_categorical(testY, nb_classes=2)
#basically OHE.
# Network building
"""Another confusing part. A normal FFNN will not suffice for this problem, so a
recurrent neural network is employed in order to capture the sequential order of text (Like in a movie review!)
and is programmed below. An important piece of a RNN is the LSTM which helps "remember" the sequence.
Will be further covered....
"""
net = tflearn.input_data([None,
100]) #input layer, [batch_size, size of input]
net = tflearn.embedding(
net, input_dim=10000, output_dim=128
) #we use the previous layers output as the next layers input.
# in an embedding, words are represented by dense vectors where
#a vector represents the projection of the word into a continuous
#vector space. There are 10k words in these reviews, so that is how many dim are needed.
#The position of a word in the learned vector space is referred to as its embedding.
# a word embedding can be learned as part of a deep learning model.
#This can be a slower approach, but tailors the model to a specific
#training dataset.
net = tflearn.lstm(net, 128, dropout=0.8)
"""Quick summary:
Every review is padded so that it has 100 dimensions, and the words in the each review (there are 10k total words)
doc=doc.split('\n')
doc=map(lambda s: s.split('.'),doc)
doc=[item for sublist in doc for item in sublist]
splitDoc = map(makeWindows,doc)
docX=[item for sublist in splitDoc for item in sublist]
X=map(lambda t: t[0],docX)
Y=map(lambda t: t[1],docX)
# TEST. DELETE AFTER THIS LINE
net = tflearn.input_data([None, WINDOW_SIZE -1])
# Masking is not required for embedding, sequence length is computed prior to
# the embedding op and assigned as 'seq_length' attribute to the returned Tensor.
net = tflearn.embedding(net, input_dim=3, output_dim=3)
net = tflearn.lstm(net, 12, dropout=0.8)
net = tflearn.fully_connected(net, 2, activation='softmax')
net = tflearn.regression(net, optimizer='adam', learning_rate=0.001,loss='categorical_crossentropy')
X=np.array([
[0,0,1],
[0,0,1],
[0,1,1],
[0,1,0],
[1,0,0]])
Y=np.array([1,1,0,0,0])
trainY
# In[19]:
pd.DataFrame(trainY).tail()
# # Network Building
# In[20]:
# The first element is the "batch size" which we set to "None"
# The second element is set to "100" coz we set the max sequence length to "100"
net = tflearn.input_data([None, 100])
net = tflearn.embedding(net, input_dim=10000, output_dim=128) # input_dim: Vocabulary size (number of ids)
net = tflearn.lstm(net, 128, dropout=0.8) # Long Short Term Memory Recurrent Layer
net = tflearn.fully_connected(net, 2, activation='softmax')
net = tflearn.regression(net,
optimizer='adam',
learning_rate=1e-4,
loss='categorical_crossentropy')
# # Training
# In[21]:
model = tflearn.DNN(net, tensorboard_verbose=0)
model.fit(trainX, trainY, validation_set=(testX, testY), show_metric=True, batch_size=32)
vocab_size = len(word_dict)
Xtrain = [] # input word
Ytrain = [] # output word
for data_word in data:
tempx = to_one_hot(word_dict[data_word[0]], vocab_size)
tempy = to_one_hot(word_dict[data_word[1]], vocab_size)
Xtrain.append(tempx)
Ytrain.append(tempy)
# convert them to numpy arrays
Xtrain = np.asarray(Xtrain)
Ytrain = np.asarray(Ytrain)
g = tflearn.input_data(shape=[None, max_len_seq])
g = tflearn.embedding(g, input_dim=len(word_dict), output_dim=128)
g = tflearn.lstm(g, 512, return_seq=True)
g = tflearn.dropout(g, 0.5)
g = tflearn.lstm(g, 512)
g = tflearn.dropout(g, 0.5)
g = tflearn.fully_connected(g, len(word_dict), activation='softmax')
g = tflearn.regression(g,
optimizer='adam',
loss='categorical_crossentropy',
learning_rate=0.001)
m = tflearn.SequenceGenerator(g,
dictionary=word_dict,
seq_maxlen=max_len_seq,
clip_gradients=5.0,
checkpoint_path='./checkpoints/sayton_model')
n_words = len(vocab_processor.vocabulary_)
print('Total words: %d' % n_words)
# pickle.dump (X_train, open ("xtrain.p", b))
# pickle.dump (X_test, open ("xtest.p", b))
# X_train = pickle.load (open ("xtrain.p", rb))
# X_test = pickle.load (open ("xtest.p", rb))
### Models
print('Build model')
net = tflearn.input_data([None, model_size])
net = tflearn.embedding(net, input_dim=n_words, output_dim=lstm_size[0])
for i in range(len(lstm_size)):
if i < len(lstm_size) - 1:
net = tflearn.gru(net,
lstm_size[i],
activation=activation_function,
return_seq=True)
net = tflearn.dropout(net, dropout_ratio)
else:
net = tflearn.gru(net, lstm_size[i], activation=activation_function)
net = tflearn.dropout(net, dropout_ratio)
net = tflearn.fully_connected(net, len(qualities), activation='softmax')
net = tflearn.regression(net,
optimizer='adam',
learning_rate=0.001,
loss='categorical_crossentropy')
# print(train_x[0:2], train_y[0:2])
# 转化为固定长度的向量，这里固定长度为100
train_x = pad_sequences(train_x, maxlen=100, value=0)
# print(train_x[0:2])
test_x = pad_sequences(test_x, maxlen=100, value=0)
# 二值化向量
train_y = to_categorical(train_y, nb_classes=2) # [0]=>[1. 0.]
test_y = to_categorical(test_y, nb_classes=2) # [1]=>[0. 1.]
# print(train_y[0:2])
# 构建卷积神经网络，使用1d卷积
input = input_data(shape=[None, 100], name='input')
embedding = tflearn.embedding(input, input_dim=10000, output_dim=128)
branch1 = conv_1d(embedding, 128, 3, padding='valid', activation='relu', regularizer='L2')
branch2 = conv_1d(embedding, 128, 4, padding='valid', activation='relu', regularizer='L2')
branch3 = conv_1d(embedding, 128, 5, padding='valid', activation='relu', regularizer='L2')
network = merge([branch1, branch2, branch3], mode='concat', axis=1)
network = tf.expand_dims(network, 2)
network = global_max_pool(network)
network = dropout(network, 0.5)
network = fully_connected(network, 2, activation='softmax')
network = regression(network, optimizer='adam', learning_rate=0.001,
loss='categorical_crossentropy', name='target')
"""
训练开始
"""
model = tflearn.DNN(network, tensorboard_verbose=0, tensorboard_dir='logs')
model.fit(train_x, train_y, n_epoch=1, shuffle=True, validation_set=(test_x, test_y), show_metric=True, batch_size=32)
# import our chat-bot
with open('dataset_chatbot_helptree.json') as json_data:
intents = json.load(json_data)
# clean up all of our data structures
data = pickle.load(open("training_data", "rb"))
words_data = data['words']
classes = data['classes']
x_train = data['train_x']
y_train = data['train_y']
# reset underlying graph data
ops.reset_default_graph()
# Build neural network
layer = tflearn.input_data(shape=[None, len(x_train[0])])
layer = tflearn.embedding(layer, input_dim=10000, output_dim=128)
layer = tflearn.lstm(layer, 256, dropout=0.8)
layer = tflearn.fully_connected(layer, len(y_train[0]), activation='softmax')
layer = tflearn.regression(layer,
optimizer='adam',
learning_rate=0.001,
loss='categorical_crossentropy')
# Define model and setup tensorboard
model = tflearn.DNN(layer, tensorboard_dir='tflearn_logs')
# load our saved model
model.load('./model.tflearn')
def clean_up_sentence(sentence):
# tokenize the pattern
from __future__ import division, print_function, absolute_import import tflearn from tflearn.data_utils import to_categorical, pad_sequences from tflearn.datasets import imdb train, test, _= imdb.load_data(path='imdb.pkl', n_words=10000, valid_portion=0.1) trainX, trainY = train testX, testY = test trainX = pad_sequences(trainX, maxlen=100, value=0.) testX = pad_sequences(testX, maxlen=100, value=0.) trainY = to_categorical(trainY, nb_classes=2) testY = to_categorical(testY, nb_classes=2) net = tflearn.input_data([None,100]) net = tflearn.embedding(net, input_dim=10000, output_dim=128) net = tflearn.lstm(net, 128, dropout=0.8) net = tflearn.fully_connected(net, 2, activation='softmax') net = tflearn.regression(net, optimizer='adam', learning_rate=0.001, loss='categorical_crossentrophy') model = tflearn.DNN(net, tensorboard_verbose=0) model.fit(trainX, trainY, validation_set=(testX, testY), show_metric=True, batch_size=32)
train_split_proportion = 0.8
validation_split_proporiton = 0.5
split = int(len(features) * train_split_proportion)
trainX, testX = features[:split], features[split:]
trainY, testY = labels[:split], labels[split:]
#print(trainY)
trainY = to_categorical(trainY, 2)
testY = to_categorical(testY, 2)
tf.reset_default_graph()
tflearn.config.init_training_mode()
net = tflearn.input_data([None, MAX_SENTENCE_LENGHT])
net = tflearn.embedding(net,
input_dim=NUM_DICTIONARY_WORDS + 1,
output_dim=100)
net = tflearn.lstm(net, 128, dropout=0.8)
net = tflearn.fully_connected(net, 2, activation='softmax')
net = tflearn.regression(net,
optimizer='adam',
learning_rate=0.001,
loss='categorical_crossentropy')
SubjectivityLSTM_model = tflearn.DNN(net, tensorboard_verbose=0)
if TRAIN:
SubjectivityLSTM_model.fit(trainX,
trainY,
validation_set=(testX, testY),
n_epoch=8,
# valid_y = [y[s] for s in sidx[n_train:]]
train_x = x[:(n_samples - 8000)] # last 8k is all travel
train_y = y[:(n_samples - 8000)]
valid_x = x[(n_samples - 8000):]
valid_y = y[(n_samples - 8000):]
trainX = pad_sequences(train_x, maxlen=120, value=0.)
validX = pad_sequences(valid_x, maxlen=120, value=0.)
trainY = pad_sequences(train_y, maxlen=120, value=0.)
validY = pad_sequences(valid_y, maxlen=120, value=0.)
print("generating model...")
g = tflearn.input_data([None, 120])
g = tflearn.embedding(g, input_dim=10000, output_dim=256)
g = tflearn.lstm(g, 256, activation='tanh')
g = tflearn.dropout(g, 0.3)
# g = tflearn.lstm(g, 128, dynamic=True)
# g = tflearn.dropout(g, 0.3)
g = tflearn.fully_connected(g, 120, activation='softmax')
g = tflearn.regression(g,
optimizer='adam',
loss='categorical_crossentropy',
learning_rate=0.001)
m = tflearn.DNN(g, clip_gradients=5.0)
val = len(vp.vocabulary_)
print(val)
tweets_parsed = vp.transform(tweets)
vp.save('my_dictionary')
print(vp)
trainX = tweets_parsed
trainY = tflearn.data_utils.to_categorical(content1, nb_classes=0)
filtered_gen = (item for item in trainX)
gen_to_list = list(filtered_gen)
trainX1 = pad_sequences(gen_to_list, maxlen=120, value=0.)
#print(trainX1)
# Network building
net = tflearn.input_data([None, 120])
net = tflearn.embedding(net, input_dim=val, output_dim=64)
net = tflearn.lstm(net, 64)
net = tflearn.dropout(net, 0.5)
net = tflearn.fully_connected(net, 2, activation='softmax')
net = tflearn.regression(net, optimizer='adam',loss='binary_crossentropy')
# Training
model = tflearn.DNN(net, clip_gradients=0., tensorboard_verbose=0)
model.fit(trainX1, trainY, show_metric=True, batch_size=64)
X_train = pad_sequences(X_train, maxlen=model_size, value=0.)
X_test = pad_sequences(X_test, maxlen=model_size, value=0.)
n_words = len(vocab_processor.vocabulary_)
print('Total words: %d' % n_words)
# pickle.dump (X_train, open ("xtrain.p", b))
# pickle.dump (X_test, open ("xtest.p", b))
# X_train = pickle.load (open ("xtrain.p", rb))
# X_test = pickle.load (open ("xtest.p", rb))
### Models
print('Build model')
net = tflearn.input_data([None, model_size])
net = tflearn.embedding(net, input_dim=n_words, output_dim=128)
# net = tflearn.lstm(net, 512, dropout=0.5, return_seq=True)
net = tflearn.lstm(net, 512, dropout=0.5)
net = tflearn.fully_connected(net, len (qualities), activation='softmax')
net = tflearn.regression(net, optimizer='adam', learning_rate=0.001,
loss='categorical_crossentropy')
print ('Train model')
model = tflearn.DNN(net, tensorboard_verbose=3, tensorboard_dir = "logdir/lstm")
print ('Predict')
model.fit(X_train, Y_train, validation_set=(X_test, Y_test), show_metric=True,
batch_size=32, n_epoch = nb_epochs)
test3_protein = prepare_data(data_dir, "./data/test3_sps", vocab_size_protein,
vocab_protein, protein_MAX_size, 1)
test3_compound = prepare_data(data_dir, "./data/test3_smile",
vocab_size_compound, vocab_compound,
comp_MAX_size, 0)
test3_IC50 = read_labels("./data/test3_ic50")
## separating train,dev, test data
compound_train, compound_dev, IC50_train, IC50_dev, protein_train, protein_dev = train_dev_split(
train_protein, train_compound, train_IC50, dev_perc, comp_MAX_size,
protein_MAX_size, batch_size)
## RNN for protein
prot_data = input_data(shape=[None, protein_MAX_size])
prot_embd = tflearn.embedding(prot_data,
input_dim=vocab_size_protein,
output_dim=GRU_size_prot)
prot_gru_1 = tflearn.gru(prot_embd,
GRU_size_prot,
initial_state=prot_init_state_1,
trainable=True,
return_seq=True,
restore=False)
prot_gru_1 = tf.stack(prot_gru_1, axis=1)
prot_gru_2 = tflearn.gru(prot_gru_1,
GRU_size_prot,
initial_state=prot_init_state_2,
trainable=True,
return_seq=True,
restore=False)
prot_gru_2 = tf.stack(prot_gru_2, axis=1)
# IMDB Dataset loading
train, test, _ = imdb.load_data(path='imdb.pkl', n_words=10000,
valid_portion=0.1)
trainX, trainY = train
testX, testY = test
# Data preprocessing
# Sequence padding
trainX = pad_sequences(trainX, maxlen=100, value=0.)
testX = pad_sequences(testX, maxlen=100, value=0.)
# Converting labels to binary vectors
trainY = to_categorical(trainY)
testY = to_categorical(testY)
# Building convolutional network
network = input_data(shape=[None, 100], name='input')
network = tflearn.embedding(network, input_dim=10000, output_dim=128)
branch1 = conv_1d(network, 128, 3, padding='valid', activation='relu', regularizer="L2")
branch2 = conv_1d(network, 128, 4, padding='valid', activation='relu', regularizer="L2")
branch3 = conv_1d(network, 128, 5, padding='valid', activation='relu', regularizer="L2")
network = merge([branch1, branch2, branch3], mode='concat', axis=1)
network = tf.expand_dims(network, 2)
network = global_max_pool(network)
network = dropout(network, 0.5)
network = fully_connected(network, 2, activation='softmax')
network = regression(network, optimizer='adam', learning_rate=0.001,
loss='categorical_crossentropy', name='target')
# Training
model = tflearn.DNN(network, tensorboard_verbose=0)
model.fit(trainX, trainY, n_epoch = 5, shuffle=True, validation_set=(testX, testY), show_metric=True, batch_size=32)
def create_model(self,
l,
tN,
N=100000,
d=10,
K=5,
H=1000,
m=0.05,
reuse=False):
'''
N = 1000000 (Paper)
d = Unknown
'''
with tf.variable_scope('TagSpace', reuse=reuse):
lr = tf.placeholder('float32', shape=[1], name='lr')
doc = tf.placeholder('float32', shape=[None, l], name='doc')
tag_flag = tf.placeholder('float32',
shape=[None, tN],
name='tag_flag')
doc_embed = tflearn.embedding(doc, input_dim=N, output_dim=d)
self.lt_embed = lt_embed = tf.Variable(
tf.random_normal([tN, d], stddev=0.1))
net = tflearn.conv_1d(doc_embed, H, K, activation='tanh')
net = tflearn.max_pool_1d(net, K)
net = tflearn.tanh(net)
self.logit = logit = tflearn.fully_connected(net,
d,
activation=None)
zero_vector = tf.zeros(shape=(1, 1), dtype=tf.float32)
logit = tf.expand_dims(logit, 1)
logit_set = tf.concat([logit for i in range(tN)], axis=1)
tag_flag_ex = tf.expand_dims(tag_flag, 2)
tg = tf.concat([tag_flag_ex for i in range(d)], axis=2)
self.tag_logit = tf.reduce_sum(tf.multiply(
logit_set, tf.multiply(tf.ones_like(tg), lt_embed)),
axis=2)
self.positive_logit = positive_logit = tf.reduce_sum(tf.multiply(
logit_set, tf.multiply(tg, lt_embed)),
axis=2)
self.f_positive = f_positive = tf.map_fn(
lambda x: (tf.boolean_mask(x[0], x[1]), True),
(positive_logit, tf.not_equal(positive_logit, zero_vector)))
positive = tf.reduce_min(f_positive[0], axis=1)
self.positive = positive
tag_flag_ex = tf.expand_dims(1 - tag_flag, 2)
tg = tf.concat([tag_flag_ex for i in range(d)], axis=2)
negative_logit = tf.reduce_sum(tf.multiply(
logit_set, tf.multiply(tg, lt_embed)),
axis=2)
self.f_negative = f_negative = tf.map_fn(
lambda x: (tf.boolean_mask(x[0], x[1]), True),
(negative_logit, tf.not_equal(negative_logit, zero_vector)))
self.negative = negative = tf.reduce_max(f_negative[0], axis=1)
self.f_loss = f_loss = tf.reduce_mean(
tf.reduce_max([
tf.reduce_min([
tf.expand_dims(m - positive + negative, 1),
tf.expand_dims(tf.fill([tf.shape(doc)[0]], 10e7), 1)
],
axis=0),
tf.zeros([tf.shape(doc)[0], 1])
],
axis=0))
params = tf.trainable_variables()
opt = tf.train.AdamOptimizer(learning_rate=lr[0])
gradients = tf.gradients(f_loss, params)
clipped_gradients, _ = tf.clip_by_global_norm(gradients, 1.0)
self.op = opt.apply_gradients(zip(clipped_gradients, params))
Codice algoritmo in Python 2.7 from __future__ import division, print_function, absolute_import import tflearn from tflearn.data_utils import to_categorical, pad_sequences from tflearn.datasets import imdb # IMDB Dataset loading train, test, _ = imdb.load_data(path=’imdb.pkl’, n_words=10000, valid_portion=0.1) trainX, trainY = train testX, testY = test # Data preprocessing # Sequence padding trainX = pad_sequences(trainX, maxlen=100, value=0.) testX = pad_sequences(testX, maxlen=100, value=0.) # Converting labels to binary vectors trainY = to_categorical(trainY, nb_classes=2) testY = to_categorical(testY, nb_classes=2) # Network building net = tflearn.input_data([None, 100]) net = tflearn.embedding(net, input_dim=10000, output_dim=128) net = tflearn.lstm(net, 128, dropout=0.8) net = tflearn.fully_connected(net, 2, activation=’softmax’) net = tflearn.regression(net, optimizer=’adam’, learning_rate=0.001, loss=’categorical_crossentropy’) # Training model = tflearn.DNN(net, tensorboard_verbose=0) model.fit(trainX, trainY, validation_set=(testX, testY), show_metric=True, batch_size=32)
# Converting labels to binary vectors
trainY = to_categorical(trainY, nb_classes=number_classes) #y as one hot
testY = to_categorical(testY, nb_classes=number_classes) #y as one hot
print("end padding & transform to one hot...")
#--------------------------------------------------------------------------------------------------
# cache trainX,trainY,testX,testY for next time use.
# with open(f_cache, 'w') as f:
# pickle.dump((trainX,trainY,testX,testY,vocab_size),f)
#else:
# print("traning data exists in cache. going to use it.")
# 3.Building convolutional network
######################################MODEL:1.conv-2.conv-3.conv-4.max_pool-5.dropout-6.FC##############################################################################################
#(shape=None, placeholder=None, dtype=tf.float32,data_preprocessing=None, data_augmentation=None,name="InputData")
network = input_data(shape=[None, 100], name='input') #[None, 100] `input_data` is used as a data entry (placeholder) of a network. This placeholder will be feeded with data when training
network = tflearn.embedding(network, input_dim=vocab_size, output_dim=128) #TODO [None, 100,128].embedding layer for a sequence of ids. network: Incoming 2-D Tensor. input_dim: vocabulary size, oput_dim:embedding size
#conv_1d(incoming,nb_filter,filter_size)
branch1 = conv_1d(network, 128, 1, padding='valid', activation='relu', regularizer="L2")
branch2 = conv_1d(network, 128, 2, padding='valid', activation='relu', regularizer="L2")
branch3 = conv_1d(network, 128, 3, padding='valid', activation='relu', regularizer="L2") # [batch_size, new steps1, nb_filters]. padding:"VALID",only ever drops the right-most columns
branch4 = conv_1d(network, 128, 4, padding='valid', activation='relu', regularizer="L2") # [batch_size, new steps2, nb_filters]
branch5 = conv_1d(network, 128, 5, padding='valid', activation='relu', regularizer="L2") # [batch_size, new steps3, nb_filters]
network = merge([branch1, branch2, branch3,branch4,branch5], mode='concat', axis=1) # merge a list of `Tensor` into a single one.===>[batch_size, new steps1+new step2+new step3, nb_filters]
network = tf.expand_dims(network, 2) #[batch_size, new steps1+new step2+new step3,1, nb_filters] Inserts a dimension of 1 into a tensor's shape
network = global_max_pool(network) #[batch_size, pooled dim]
network = dropout(network, 0.5) #[batch_size, pooled dim]
network = fully_connected(network, number_classes, activation='softmax') #matmul([batch_size, pooled_dim],[pooled_dim,2])---->[batch_size,number_classes]
top5 = tflearn.metrics.Top_k(k=5)
network = regression(network, optimizer='adam', learning_rate=0.001,loss='categorical_crossentropy', name='target') #metric=top5
######################################MODEL:1.conv-2.conv-3.conv-4.max_pool-5.dropout-6.FC################################################################################################
# 4.Training
# IMDB Dataset loading train, test, _ = imdb.load_data(path="imdb.pkl", n_words=10000, valid_portion=0.1) trainX, trainY = train testX, testY = test # Data preprocessing # NOTE: Padding is required for dimension consistency. This will pad sequences # with 0 at the end, until it reaches the max sequence length. 0 is used as a # masking value by dynamic RNNs in TFLearn; a sequence length will be # retrieved by counting non zero elements in a sequence. Then dynamic RNN step # computation is performed according to that length. trainX = pad_sequences(trainX, maxlen=100, value=0.0) testX = pad_sequences(testX, maxlen=100, value=0.0) # Converting labels to binary vectors trainY = to_categorical(trainY, nb_classes=2) testY = to_categorical(testY, nb_classes=2) # Network building net = tflearn.input_data([None, 100]) # Masking is not required for embedding, sequence length is computed prior to # the embedding op and assigned as 'seq_length' attribute to the returned Tensor. net = tflearn.embedding(net, input_dim=10000, output_dim=128) net = tflearn.lstm(net, 128, dropout=0.8, dynamic=True) net = tflearn.fully_connected(net, 2, activation="softmax") net = tflearn.regression(net, optimizer="adam", learning_rate=0.001, loss="categorical_crossentropy") # Training model = tflearn.DNN(net, tensorboard_verbose=0) model.fit(trainX, trainY, validation_set=(testX, testY), show_metric=True, batch_size=32)
# IMDB Dataset loading
train, test, _ = imdb.load_data(path='imdb.pkl', n_words=10000,
valid_portion=0.1)
trainX, trainY = train
testX, testY = test
# Data preprocessing
# Sequence padding
trainX = pad_sequences(trainX, maxlen=100, value=0.)
testX = pad_sequences(testX, maxlen=100, value=0.)
# Converting labels to binary vectors
trainY = to_categorical(trainY)
testY = to_categorical(testY)
# Building convolutional network
network = input_data(shape=[None, 100], name='input')
network = tflearn.embedding(network, input_dim=10000, output_dim=128)
branch1 = conv_1d(network, 128, 3, padding='valid', activation='relu', regularizer="L2")
branch2 = conv_1d(network, 128, 4, padding='valid', activation='relu', regularizer="L2")
branch3 = conv_1d(network, 128, 5, padding='valid', activation='relu', regularizer="L2")
network = merge([branch1, branch2, branch3], mode='concat', axis=1)
network = tf.expand_dims(network, 2)
network = global_max_pool(network)
network = dropout(network, 0.5)
network = fully_connected(network, 2, activation='softmax')
network = regression(network, optimizer='adam', learning_rate=0.001,
loss='categorical_crossentropy', name='target')
# Training
model = tflearn.DNN(network, tensorboard_verbose=0)
model.fit(trainX, trainY, n_epoch = 5, shuffle=True, validation_set=(testX, testY), show_metric=True, batch_size=32)
train_X.append(current_mixture)
train_Y.append(int(row['is_linked']))
train_X = pad_sequences(train_X)
train_Y = to_categorical(train_Y, 2)
test_X = train_X[:testing_set]
train_X = train_X[testing_set:]
test_Y = train_Y[:testing_set]
train_Y = train_Y[testing_set:]
# Building convolutional network
network = input_data(shape=[None, max_mixture_size], name='input')
network = tflearn.embedding(network, input_dim=len(corpora), output_dim=128)
branch1 = conv_1d(network,
128,
3,
padding='valid',
activation='relu',
regularizer="L2")
branch2 = conv_1d(network,
128,
4,
padding='valid',
activation='relu',
regularizer="L2")
branch3 = conv_1d(network,
128,
5,
def createCombined1dConvNetNeuralNetworkModelForFutureResourceUtilisation(
input_size_states, output_size_actions, learningRate,
rowsFutureResourceUtilisationMatrix,
columnsFutureResourceUtilisationMatrix):
# Specify the log directory
logdir = 'log/1d_combined/' + datetime.now().strftime("%Y%m%d-%H%M%S")
# tflearn.init_graph(num_cores=1, gpu_memory_fraction=0.8)
#### 1d-convolutional layers for currentState ####
convnetCurrentState = input_data(shape=[None, input_size_states],
name='input_currentState')
convnetCurrentState = tflearn.embedding(convnetCurrentState,
input_dim=input_size_states,
output_dim=2)
convnetCurrentState = conv_1d(convnetCurrentState,
nb_filter=16,
filter_size=5,
strides=1,
padding='valid',
activation='relu')
convnetCurrentState = max_pool_1d(convnetCurrentState,
kernel_size=2,
strides=2,
padding='valid')
convnetCurrentState = conv_1d(convnetCurrentState,
nb_filter=16,
filter_size=3,
strides=1,
padding='valid',
activation='relu')
convnetCurrentState = max_pool_1d(convnetCurrentState,
kernel_size=2,
strides=2,
padding='valid')
convnetCurrentState = conv_1d(convnetCurrentState,
nb_filter=32,
filter_size=3,
strides=1,
padding='valid',
activation='relu')
convnetCurrentState = max_pool_1d(convnetCurrentState,
kernel_size=2,
strides=2,
padding='valid')
convnetCurrentState = flatten(convnetCurrentState)
#### 2d-convolutional layers for FutureResourceUtilisationMatrix ####
# How to configure input_data: https://stackoverflow.com/questions/48482746/tflearn-what-is-input-data
convnetResourceUtilisation = input_data(
shape=[
None, rowsFutureResourceUtilisationMatrix,
columnsFutureResourceUtilisationMatrix, 1
],
name='input_futureResourceUtilisationMatrix')
convnetResourceUtilisation = conv_2d(convnetResourceUtilisation,
nb_filter=16,
filter_size=[4, 1],
strides=1,
padding='same',
activation='relu')
convnetResourceUtilisation = max_pool_2d(convnetResourceUtilisation,
kernel_size=[1, 10],
strides=1,
padding='valid')
convnetResourceUtilisation = flatten(convnetResourceUtilisation)
# merging the outputs of both convolutional nets
finalNet = merge_outputs([convnetResourceUtilisation, convnetCurrentState],
'concat') # axis=0 is concatenation
#### final fully connected layers ####
finalNet = fully_connected(finalNet,
n_units=256,
weights_init='truncated_normal',
activation='relu')
finalNet = dropout(finalNet, 0.5)
finalNet = fully_connected(finalNet,
n_units=128,
weights_init='truncated_normal',
activation='relu')
finalNet = dropout(finalNet, 0.5)
finalNet = fully_connected(finalNet,
n_units=output_size_actions,
activation='softmax')
finalNet = regression(finalNet,
optimizer='adam',
learning_rate=learningRate,
loss='categorical_crossentropy',
name='targets')
model = tflearn.DNN(finalNet,
tensorboard_dir=logdir,
tensorboard_verbose=0)
return model
# loading data
train, test, _ = imdb.load_data(path="datasets/imdb/imdb.pkl",
n_words=10000,
valid_portion=0.1)
x_train, y_train = train
x_test, y_test = test
# sequence padding and converting labels to binary vectors
x_train = pad_sequences(x_train, maxlen=100, value=0.)
y_train = to_categorical(y_train, nb_classes=2)
x_test = pad_sequences(x_test, maxlen=100, value=0.)
y_test = to_categorical(y_test, nb_classes=2)
# building LSTM network
RNN = tflearn.input_data([None, 100])
RNN = tflearn.embedding(RNN, input_dim=10000, output_dim=128)
RNN = tflearn.lstm(RNN, 128, dropout=0.8)
RNN = tflearn.fully_connected(RNN, 2, activation='softmax')
RNN = tflearn.regression(RNN, optimizer='adam', learning_rate=0.001,
loss='categorical_crossentropy')
# traning the network
model = tflearn.DNN(RNN, tensorboard_verbose=0)
model.fit(x_train, y_train, validation_set=(x_test,y_test),
show_metric=True, batch_size=32)
# %% [markdown]
# ## Keras
def comment_predict(data):
"""
根据已有模型对评论倾向进行预测
:return:
"""
# 建立模型时用到的评论数据
predict_data = pd.read_csv("courses.csv")
def chinese_word_cut(text):
"""
使用结巴分词对中文进行切分转化为独立的词语
:param text: 完整的评论
:return: 切分后的评论
"""
return " ".join(jieba.cut(text))
# 进行分词并新建一列保存结果
predict_data["cut_name"] = predict_data.name.apply(chinese_word_cut)
# 确定评论部分(X)和标签部分(y)
X = predict_data["cut_name"]
y = predict_data["type"]
# 对数据集进行切分，分为训练集(train)和测试集(test)
# 这里随机数种子要和建立模型时的随机数种子一样
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.1,
random_state=42)
def get_custom_stopwords(stop_words_file):
"""
得到停用词表
:param stop_words_file:
:return: 停用词表list
"""
with open(stop_words_file, encoding="utf-8") as f:
stopwords = f.read()
stopwords_list = stopwords.split("\n")
custom_stopwords_list = [i for i in stopwords_list]
return custom_stopwords_list
# 得到停用词表
stop_words_file = "./stop_words/哈工大停用词表.txt"
stopwords = get_custom_stopwords(stop_words_file)
# 计算特征数值
vect = CountVectorizer(token_pattern=u'(?u)\\b\\w+\\b',
stop_words=frozenset(stopwords))
vect.fit(X_train)
vocab = vect.vocabulary_
def convert_X_to_X_word_ids(X):
"""
将评论(文字部分)转化为id集(数值序列)
:param X:评论集合
:return:数值序列
"""
return X.apply(lambda x: [
vocab[w] for w in [w.lower().strip() for w in x.split()]
if w in vocab
])
# 序列扩充，统一延长到长度为20的序列，使得评论序列格式相同，不足的用0代替
X_train_word_ids = convert_X_to_X_word_ids(X_train)
X_train_padded_seqs = pad_sequences(X_train_word_ids, maxlen=20, value=0)
# 标签集处理
unique_y_labels = list(y_train.value_counts().index)
le = preprocessing.LabelEncoder()
le.fit(unique_y_labels)
# 构造网络
size_of_each_vector = X_train_padded_seqs.shape[1]
vocab_size = len(vocab)
no_of_unique_y_labels = len(unique_y_labels)
net = tflearn.input_data([None, size_of_each_vector])
net = tflearn.embedding(net, input_dim=vocab_size, output_dim=128)
net = tflearn.lstm(net, 128, dropout=0.6)
net = tflearn.fully_connected(net,
no_of_unique_y_labels,
activation='softmax')
net = tflearn.regression(net,
optimizer='adam',
learning_rate=1e-4,
loss='categorical_crossentropy')
# 初始化
model = tflearn.DNN(net,
tensorboard_verbose=0,
tensorboard_dir="./tflearn_data/tflearn_logs/")
# 加载模型
model.load(
"./tflearn_data/tflearn_models/2019-07-08 11.51.40.170202(200, 42)/model"
)
# ———————————————————————————————————————预测部分———————————————————————————————————————
# 待预测的评论数据
predict_data = data
# 对评论数据进行分词
predict_data["cut_name"] = predict_data.name.apply(chinese_word_cut)
# 设置预测集
predict_X = predict_data["cut_name"]
vect.fit(predict_X)
# 转化为数值序列
predict_X_word_ids = convert_X_to_X_word_ids(predict_X)
predict_X_padded_seqs = pad_sequences(predict_X_word_ids,
maxlen=20,
value=0)
# 进行预测并得到结果
predict_Y = model.predict(predict_X_padded_seqs)
# 输出结果
# print(predict_Y)
get_type(predict_Y)
