model = BERT_NER(param)
model.build(input_shape=(3, param.batch_size, param.maxlen))
model.summary()
# 写入数据 通过check_exist=True参数控制仅在第一次调用时写入
writer = TFWriter(param.maxlen, vocab_file,
modes=["valid"], check_exist=False)
ner_load = TFLoader(param.maxlen, param.batch_size, epoch=3)
# Metrics
f1score = Metric.SparseF1Score(average="macro")
precsionscore = Metric.SparsePrecisionScore(average="macro")
recallscore = Metric.SparseRecallScore(average="macro")
accuarcyscore = Metric.SparseAccuracy()
# 保存模型
checkpoint = tf.train.Checkpoint(model=model)
checkpoint.restore(tf.train.latest_checkpoint('./save'))
# For test model
Batch = 0
f1s = []
precisions = []
recalls = []
accuracys = []
for X, token_type_id, input_mask, Y in ner_load.load_valid():
predict = model.predict([X, token_type_id, input_mask]) # [batch_size, max_length,label_size]
def call(self, node, adj, batch, edge_attr, training=True):
feature = tf.nn.embedding_lookup(self.embedding, node)
predict = self.model(feature, adj, batch, edge_attr, training=training)
return predict
def predict(self, nodes, adj, batch, edge_attr, training=False):
return self(nodes, adj, batch, edge_attr, training)
accs_all = []
for i in range(10):
model = TextSAGEynamicWeight(dim, num_class, drop_rate)
optimize = tf.optimizers.Adam(lr)
cross_entropy = Losess.MaskSparseCategoricalCrossentropy()
acc_score = Metric.SparseAccuracy()
stop_monitor = EarlyStopping(monitor="loss",
patience=10,
restore_best_weights=False)
for i in range(epoch):
t = time.time()
for node, label, adj, edge_attr, batch in data.load(nodes[:-500],
adjs[:-500],
labels[:-500],
edge_attrs[:-500],
batchs[:-500],
batch_size=32):
node, label, adj, edge_attr, batch = merge_batch_graph(
node, label, adj, edge_attr, batch)
import numpy as np
import tensorflow as tf
from nlpgnn.datas.graphloader import TuckERLoader
from nlpgnn.metrics import Metric
from nlpgnn.models import tucker
lr = 0.005
label_smoothing = 0.1
batch_size = 128
training = True
loader = TuckERLoader(base_path="data")
er_vocab, er_vocab_pairs = loader.data_dump("train")
evaluate = Metric.HitN_MR_MRR(loader, mode="valid")
model = tucker.TuckER(loader)
lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(lr,
decay_steps=2000,
decay_rate=0.995)
optimizer = tf.keras.optimizers.Adam(learning_rate=lr_schedule)
# 构建损失函数
binary_loss = tf.keras.losses.BinaryCrossentropy(
from_logits=False, label_smoothing=label_smoothing)
# 保存模型
checkpoint = tf.train.Checkpoint(model=model)
manager = tf.train.CheckpointManager(checkpoint,
return predict
model = BERT_NER(param)
model.build(input_shape=(4, param.batch_size, param.maxlen))
model.summary()
# 写入数据 通过check_exist=True参数控制仅在第一次调用时写入
writer = TFWriter(param.maxlen, vocab_file, modes=["valid"], check_exist=True)
ner_load = TFLoader(param.maxlen, param.batch_size)
# Metrics
f1score = Metric.SparseF1Score("macro", predict_sparse=True)
precsionscore = Metric.SparsePrecisionScore("macro", predict_sparse=True)
recallscore = Metric.SparseRecallScore("macro", predict_sparse=True)
accuarcyscore = Metric.SparseAccuracy(predict_sparse=True)
# 保存模型
checkpoint = tf.train.Checkpoint(model=model)
checkpoint.restore(tf.train.latest_checkpoint('./save'))
# For test model
# print(dir(checkpoint))
Batch = 0
f1s = []
precisions = []
recalls = []
accuracys = []
for X, token_type_id, input_mask, Y in ner_load.load_valid():
drop_rate = 0.5
epoch = 200
early_stopping = 10
penalty = 5e-4
# cora, pubmed, citeseer
data = Planetoid(name="citeseer", loop=True, norm=True)
features, adj, y_train, y_val, y_test, train_mask, val_mask, test_mask = data.load(
)
model = GCNLayer(hidden_dim, num_class, drop_rate)
optimizer = tf.keras.optimizers.Adam(0.01)
crossentropy = Losess.MaskCategoricalCrossentropy()
accscore = Metric.MaskAccuracy()
stop_monitor = EarlyStopping(monitor="loss", patience=early_stopping)
# ---------------------------------------------------------
# For train
for p in range(epoch):
t = time.time()
with tf.GradientTape() as tape:
predict = model(features, adj, training=True)
loss = crossentropy(y_train, predict, train_mask)
loss += penalty * tf.nn.l2_loss(model.variables[0])
grads = tape.gradient(loss, model.variables)
optimizer.apply_gradients(grads_and_vars=zip(grads, model.variables))
predict_v = model.predict(features, adj)
writer = TFWriter(param.maxlen,
vocab_file,
modes=["train"],
check_exist=False,
task='cls',
tokenizer="sentencepiece",
spm_model_file=spm_model_file)
ner_load = TFLoader(param.maxlen, param.batch_size, task='cls', epoch=3)
# 训练模型
# 使用tensorboard
summary_writer = tf.summary.create_file_writer("./tensorboard")
# Metrics
accuarcyscore = Metric.SparseAccuracy()
# 保存模型
checkpoint = tf.train.Checkpoint(model=model)
manager = tf.train.CheckpointManager(checkpoint,
directory="./save",
checkpoint_name="model.ckpt",
max_to_keep=3)
# For train model
Batch = 0
for X, token_type_id, input_mask, Y in ner_load.load_train():
with tf.GradientTape() as tape:
predict = model([X, token_type_id, input_mask])
loss = sparse_categotical_loss(Y, predict)
accuracy = accuarcyscore(Y, predict)
if Batch % 100 == 0:
