def multi_output_model():
vocabulary_size = 50000
num_income_groups = 10
posts_input = Input(shape=(None,), dtype='int32', name='posts')
embedded_posts = layers.Embedding(256, vocabulary_size)(posts_input)
x = layers.Conv1D(128, 5, activation='relu')(embedded_posts)
x = layers.MaxPooling1D(5)(x)
x = layers.Conv1D(256, 5, activation='relu')(x)
x = layers.Conv1D(256, 5, activation='relu')(x)
x = layers.MaxPooling1D(5)(x)
x = layers.Conv1D(256, 5, activation='relu')(x)
x = layers.Conv1D(256, 5, activation='relu')(x)
x = layers.GlobalMaxPooling1D()(x)
x = layers.Dense(128, activation='relu')(x)
# 两个输出
age_prediction = layers.Dense(1, name='age')(x)
income_prediction = layers.Dense(num_income_groups,
activation='softmax',
name='income')(x)
gender_prediction = layers.Dense(1, activation='sigmoid', name='gender')(x)
model = Model(posts_input,
[age_prediction, income_prediction, gender_prediction])
'''
#编译时选择多个损失标准
model.compile(optimizer='rmsprop',
loss=['mse', 'categorical_crossentropy', 'binary_crossentropy'])
model.compile(optimizer='rmsprop',
loss={'age': 'mse',
'income': 'categorical_crossentropy',
'gender': 'binary_crossentropy'})
model.compile(optimizer='rmsprop',
loss=['mse', 'categorical_crossentropy', 'binary_crossentropy'],
loss_weights=[0.25, 1., 10.])
model.compile(optimizer='rmsprop',
loss={'age': 'mse',
'income': 'categorical_crossentropy',
'gender': 'binary_crossentropy'},
loss_weights={'age': 0.25,
'income': 1.,
'gender': 10.})
model.fit(posts, [age_targets, income_targets, gender_targets],
epochs=10, batch_size=64)
model.fit(posts, {'age': age_targets,
'income': income_targets,
'gender': gender_targets},
epochs=10, batch_size=64)
'''
return model
def main():
vocabulary_size = 10000
maxlen = 24
model = Sequential()
model.add(layers.Embedding(vocabulary_size, 64, name="text"))
model.add(
layers.Conv1D(64, 4, padding='valid', activation='relu', strides=1))
model.add(layers.MaxPooling1D(pool_size=3))
model.add(layers.LSTM(64))
model.add(layers.Dense(32, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))
# # if use keras not tf.keras
# model = tf.keras.models.Model(model)
model.compile(optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['acc'])
estimator_model = tf.keras.estimator.model_to_estimator(keras_model=model)
data, labels = mr_load_data(max_word_num=vocabulary_size)
data = pad_sequences(data, padding="pre", maxlen=maxlen)
labels = np.asarray(labels).reshape(-1, 1)
print(labels.shape)
x_train, y_train = data, labels
input_dict = {"text_input": x_train}
input_fn = train_input_fn(input_dict, y_train, batch_size=32)
print(input_fn)
#
# estimator_model.train(input_fn=input_fn, steps=10000)
estimator_model.train(input_fn=input_function(input_dict, y_train),
steps=10000)
def create_lstm():
model = tf.keras.Sequential()
model.add(layers.Embedding(MAX_WORDS, 64, input_length=MAX_LEN))
model.add(layers.Conv1D(32, 3, padding='same', activation='relu'))
model.add(layers.MaxPooling1D(pool_size=4))
model.add(layers.LSTM(64))
model.add(layers.Dense(250, activation='relu'))
model.add(layers.Dense(1, activation="sigmoid"))
return model
def __call__(self, model):
with tf.name_scope("Convs") as scope:
sc = KL.MaxPooling1D(8)(KL.Conv1D(self.dim * 3,
8,
activation='relu',
padding="same")(model))
model = KL.MaxPooling1D(2)(KL.Conv1D(self.dim,
4,
activation='relu',
padding="same")(model))
model = KL.MaxPooling1D(2)(KL.Conv1D(self.dim * 2,
4,
activation='relu',
padding="same")(model))
model = KL.MaxPooling1D(2)(KL.Conv1D(self.dim * 3,
4,
activation='relu',
padding="same")(model))
model = KL.add([model, sc])
model = KL.Dropout(0.25)(model)
return model
Y = complain_data['Satisfaction'].values
X_train, X_test, Y_train, Y_test = train_test_split(
X, Y, test_size=0.33, random_state=42)
# print(X_train.shape,Y_train.shape)
# print(X_test.shape,Y_test.shape)
embedding_vector_length = 32
model = Sequential()
model.add(layers.Embedding(max_features,
embedding_vector_length, input_length=maxlen))
model.add(layers.Conv1D(filters=32, kernel_size=3,
padding='same', activation='relu'))
model.add(layers.MaxPooling1D(pool_size=2))
model.add(layers.LSTM(100, recurrent_activation='sigmoid'))
model.add(layers.Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer='adam', metrics=['accuracy'])
model.summary()
filename = os.path.join(current_dir, 'data', 'complain_model.h5')
is_training = False
if is_training:
model.fit(X_train, Y_train, validation_data=(
X_test, Y_test), epochs=20, batch_size=64)
# Evaluate the model
scores = model.evaluate(X_test, Y_test, verbose=0)
print("Evaluation Accuracy: %.2f%%" % (scores[1]*100))
def _train(mutated, module_name):
mutated = mutated[mutated['mod_keys_found_string'] == module_name]
train_set, val_set, test_set = np.split(
mutated.sample(frac=1),
[int(.6 * len(mutated)),
int(.8 * len(mutated))])
tasks_sent_train = [row for row in train_set['task_complete']]
model_tasks3 = Word2Vec(tasks_sent_train,
sg=0,
size=100,
window=6,
min_count=1,
workers=4,
iter=1000)
train_set['task_complete_one_string'] = train_set['task_complete'].apply(
lambda x: list_to_string(x))
test_set['task_complete_one_string'] = test_set['task_complete'].apply(
lambda x: list_to_string(x))
val_set['task_complete_one_string'] = val_set['task_complete'].apply(
lambda x: list_to_string(x))
y_train = train_set['consistent'].astype(int)
print(y_train.value_counts(), y_train.shape)
y_test = test_set['consistent'].astype(int)
print(y_test.value_counts(), y_test.shape)
y_val = val_set['consistent'].astype(int)
tokenizer_train = Tokenizer(lower=False)
tokenizer_train.fit_on_texts(train_set['task_complete'])
print(tokenizer_train)
tokenizer_train = Tokenizer(lower=False)
tokenizer_train.fit_on_texts(train_set['task_complete'])
print(tokenizer_train)
tokenizer_test = Tokenizer(lower=False)
tokenizer_test.fit_on_texts(test_set['task_complete'])
print(tokenizer_test)
tokenizer_val = Tokenizer(lower=False)
tokenizer_val.fit_on_texts(val_set['task_complete'])
tasks_train_tokens = tokenizer_train.texts_to_sequences(
train_set['task_complete_one_string'])
tasks_test_tokens = tokenizer_test.texts_to_sequences(
test_set['task_complete_one_string'])
tasks_val_tokens = tokenizer_val.texts_to_sequences(
val_set['task_complete_one_string'])
num_tokens = [len(tokens) for tokens in tasks_train_tokens]
num_tokens = np.array(num_tokens)
np.max(num_tokens)
np.argmax(num_tokens)
max_tokens = np.mean(num_tokens) + 2 * np.std(num_tokens)
max_tokens = int(max_tokens)
tasks_train_pad = pad_sequences(tasks_train_tokens,
maxlen=max_tokens,
padding='post')
tasks_test_pad = pad_sequences(tasks_test_tokens,
maxlen=max_tokens,
padding='post')
tasks_val_pad = pad_sequences(tasks_val_tokens,
maxlen=max_tokens,
padding='post')
embedding_size = 100
num_words = len(list(tokenizer_train.word_index)) + 1
embedding_matrix = np.random.uniform(-1, 1, (num_words, embedding_size))
for word, i in tokenizer_train.word_index.items():
if i < num_words:
embedding_vector = model_tasks3[word]
if embedding_vector is not None:
embedding_matrix[i] = embedding_vector
sequence_length = max_tokens
batch_size = 256
tensorflow.compat.v1.disable_eager_execution()
# CNN architecture
num_classes = 2
# Training params
num_epochs = 20
# Model parameters
num_filters = 64
weight_decay = 1e-4
print("training CNN ...")
model = Sequential()
# Model add word2vec embedding
model.add(
Embedding(
input_dim=num_words,
output_dim=embedding_size,
weights=[embedding_matrix],
input_length=max_tokens,
trainable=True, # the layer is trained
name='embedding_layer'))
model.add(
layers.Conv1D(filters=num_filters,
kernel_size=max_tokens,
activation='relu',
padding='same',
kernel_regularizer=regularizers.l2(weight_decay)))
model.add(layers.MaxPooling1D(2))
model.add(Dropout(0.25))
model.add(
layers.Conv1D(filters=num_filters + num_filters,
kernel_size=max_tokens,
activation='relu',
padding='same',
kernel_regularizer=regularizers.l2(weight_decay)))
model.add(layers.GlobalMaxPooling1D())
model.add(Dropout(0.25))
model.add(layers.Flatten())
model.add(
layers.Dense(128,
activation='relu',
kernel_regularizer=regularizers.l2(weight_decay)))
model.add(layers.Dense(num_classes, activation='softmax'))
sgd = SGD(lr=1e-2, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss=tensorflow.keras.losses.MeanAbsoluteError(),
optimizer=sgd,
metrics=['accuracy'])
model.summary()
model.fit(tasks_train_pad,
to_categorical(y_train),
batch_size=batch_size,
epochs=num_epochs,
validation_data=(tasks_test_pad, to_categorical(y_test)),
shuffle=True,
verbose=2)
score = model.evaluate(tasks_val_pad, to_categorical(y_val), verbose=0)
print('loss:', score[0])
print('Validation accuracy:', score[1])
y_pred = model.predict_classes(tasks_val_pad)
cm = confusion_matrix(y_val, y_pred)
tp = cm[1][1]
fp = cm[0][1]
fn = cm[1][0]
tn = cm[0][0]
precision = round(tp / (tp + fp), 2)
print('Consistent: precision=%.3f' % (precision))
recall = round(tp / (tp + fn), 2)
print('Consistent: recall=%.3f' % (recall))
f1_score = (2 * precision * recall) / (precision + recall)
print('Consistent: f1_score=%.3f' % (f1_score))
precision_neg = round(tn / (tn + fn), 2)
print('Inconsistent: precision=%.3f' % (precision_neg))
recall_neg = round(tn / (tn + fp), 2)
print('Inconsistent: recall=%.3f' % (recall_neg))
f1_score_neg = (2 * precision_neg * recall_neg) / (precision_neg +
recall_neg)
print('Inconsistent: f1_score=%.3f' % (f1_score_neg))
ns_probs = [0 for _ in range(len(y_val))]
ns_auc = roc_auc_score(y_val, ns_probs)
lr_auc = roc_auc_score(y_val, y_pred)
mcc = matthews_corrcoef(y_val, y_pred)
print(precision)
print('No Skill: ROC AUC=%.3f' % (ns_auc))
print('Our model: ROC AUC=%.3f' % (lr_auc))
print('Our model: MCC=%.3f' % (mcc))
json_out = {"module": module_name, "MCC": mcc, "AUC": lr_auc}
model.save('models/' + module_name)
return json_out
#define rnn model rnn = Sequential(name='rnn') rnn.add(layers.BatchNormalization(input_shape=(None, num_channels*30*FreqSample/step))) rnn.add(layers.LSTM(1000,dropout=0.1, recurrent_dropout=0.1,return_sequences=True)) rnn.add(layers.LSTM(1000,dropout=0.1, recurrent_dropout=0.1,return_sequences=True)) rnn.add(layers.LSTM(1000,dropout=0.1, recurrent_dropout=0.1,return_sequences=True)) rnn.add(layers.LSTM(1000,dropout=0.1, recurrent_dropout=0.1,return_sequences=True)) rnn.add(layers.LSTM(1000,dropout=0.1, recurrent_dropout=0.1)) rnn.add(layers.Dense(5, activation="softmax")) rnn.summary() #define rcnn model rcnn = Sequential(name='rcnn') rcnn.add(layers.BatchNormalization(input_shape=(None, num_channels*30*FreqSample/step))) rcnn.add(layers.Conv1D(32, 3, activation='relu')) rcnn.add(layers.MaxPooling1D(2)) rcnn.add(layers.Conv1D(64, 3, activation='relu')) rcnn.add(layers.LSTM(1000,dropout=0.1, recurrent_dropout=0.1,return_sequences=True)) rcnn.add(layers.LSTM(1000,dropout=0.1, recurrent_dropout=0.1,return_sequences=True)) rcnn.add(layers.LSTM(1000,dropout=0.1, recurrent_dropout=0.1,return_sequences=True)) rcnn.add(layers.LSTM(1000,dropout=0.1, recurrent_dropout=0.1)) rcnn.add(layers.Dense(5, activation="softmax")) rcnn.summary() conv.load_weights(cnn_model) rnn.load_weights(rnn_model) rcnn.load_weights(rcnn_model) sl = SuperLearner([conv,rnn,rcnn],['cnn','rnn','rcnn'], loss='nloglik') # fit the super learner to learn the best coefficient num_batches = 0
train_loss = history.history['loss']
val_loss = history.history['val_loss']
train_acc = history.history['acc']
val_acc = history.history['val_acc']
print(train_loss)
print(val_loss)
print(train_acc)
print(val_acc)
model = Sequential(name='rcnn')
model.add(
layers.BatchNormalization(input_shape=(None, num_channels * 30 *
FreqSample / step)))
model.add(layers.Conv1D(32, 3, activation='relu'))
model.add(layers.MaxPooling1D(2))
model.add(layers.Conv1D(64, 3, activation='relu'))
model.add(
layers.LSTM(1000,
dropout=0.1,
recurrent_dropout=0.1,
return_sequences=True))
model.add(
layers.LSTM(1000,
dropout=0.1,
recurrent_dropout=0.1,
return_sequences=True))
model.add(
layers.LSTM(1000,
dropout=0.1,
recurrent_dropout=0.1,
# Resulting data split indices.
train_ind, other_ind = next(
splitter1.split(sarcasm_feature_sequence, sarcasm_target_numpy))
val_ind, accest_ind = next(
splitter2.split(sarcasm_feature_sequence[other_ind],
sarcasm_target_numpy[other_ind]))
the_cnn_layers = [
layers.Embedding(dict_len, 64, input_length=seq_length),
layers.Dropout(0.2),
layers.SeparableConv1D(32,
5,
activation='sigmoid',
bias_initializer='random_uniform',
depthwise_initializer='random_uniform',
padding='same'),
layers.MaxPooling1D(5),
layers.SeparableConv1D(32,
5,
activation='sigmoid',
bias_initializer='random_uniform',
depthwise_initializer='random_uniform',
padding='same'),
layers.GlobalMaxPooling1D(),
layers.Dense(1, activation='sigmoid')
]
networkCNN = Sequential(layers=the_cnn_layers)
# Configure the network in preparation for training.
networkCNN.compile(optimizer='adam',
metrics=['accuracy'],
loss='binary_crossentropy')
x_train_pad = pad_sequences(x_train_tokens, maxlen=max_tokens,
padding=pad, truncating=pad)
x_test_pad = pad_sequences(x_test_tokens, maxlen=max_tokens,
padding=pad, truncating=pad)
model = Sequential()
embedding_size = 8
model.add(Embedding(input_dim=num_words,
output_dim=embedding_size,
input_length=max_tokens,
name='layer_embedding'))
#model.add(LSTM(units=128))
model.add(layers.Conv1D(128, 5, activation='relu'))
model.add(layers.MaxPooling1D(5))
model.add(layers.Conv1D(64, 5, activation='relu'))
model.add(layers.MaxPooling1D(5))
model.add(layers.Conv1D(32, 5, activation='relu'))
model.add(layers.MaxPooling1D(5))
model.add(layers.Flatten())
model.add(Dense(3, activation='softmax'))
tensorboard = TensorBoard(log_dir="logs/{}".format(time()))
optimizer = Adam(lr=0.008)
model.compile(loss='sparse_categorical_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
model.fit(x_train_pad, y_train, validation_split=0.05, epochs=10, batch_size=5000, callbacks=[tensorboard])
