def test_CIN(layer_size, activation, split_half):
with CustomObjectScope({'CIN': layers.CIN}):
layer_test(layers.CIN, kwargs={"layer_size": layer_size, "activation":
activation, "split_half": split_half}, input_shape=(
BATCH_SIZE, FIELD_SIZE, EMBEDDING_SIZE))
def test_BiLSTM(merge_mode):
with CustomObjectScope({'BiLSTM': sequence.BiLSTM}):
layer_test(sequence.BiLSTM, kwargs={'merge_mode': merge_mode, 'units': EMBEDDING_SIZE, 'dropout_rate': 0.0},
# todo 0.5
input_shape=(BATCH_SIZE, SEQ_LENGTH, EMBEDDING_SIZE))
def test_test_CIN_invalid(layer_size):
with pytest.raises(ValueError):
with CustomObjectScope({'CIN': layers.CIN}):
layer_test(layers.CIN,
kwargs={"layer_size": layer_size},
input_shape=(BATCH_SIZE, FIELD_SIZE, EMBEDDING_SIZE))
def test_test_PredictionLayer_invalid():
# with pytest.raises(ValueError):
with CustomObjectScope({'PredictionLayer': layers.PredictionLayer}):
layer_test(layers.PredictionLayer, kwargs={'use_bias': True,
}, input_shape=(BATCH_SIZE, 2, 1))
def test_AttentionSequencePoolingLayer(weight_normalization):
with CustomObjectScope({'AttentionSequencePoolingLayer': sequence.AttentionSequencePoolingLayer}):
layer_test(sequence.AttentionSequencePoolingLayer, kwargs={'weight_normalization': weight_normalization},
input_shape=[(BATCH_SIZE, 1, EMBEDDING_SIZE), (BATCH_SIZE, SEQ_LENGTH, EMBEDDING_SIZE),
(BATCH_SIZE, 1)])
def test_FM():
with CustomObjectScope({'FM': layers.FM}):
layer_test(layers.FM,
kwargs={},
input_shape=(BATCH_SIZE, FIELD_SIZE, EMBEDDING_SIZE))
def test_DNN(hidden_units, use_bn):
with CustomObjectScope({'DNN': layers.DNN}):
layer_test(layers.DNN, kwargs={'hidden_units': hidden_units, 'use_bn': use_bn, 'dropout_rate': 0.5},
input_shape=(
BATCH_SIZE, EMBEDDING_SIZE))
from tfutils import Recorder
from tensorflow.python.keras.models import Model, load_model, Sequential
from tensorflow.python.keras import optimizers
from tensorflow.python.keras.layers import Dropout, Flatten, Dense, GlobalAveragePooling2D
from tensorflow.python.keras.applications.mobilenet import MobileNet
from tensorflow.python.keras.utils import CustomObjectScope
from tensorflow.python.keras.backend import relu
tf.logging.set_verbosity(tf.logging.INFO)
def relu6(x):
return relu(x, max_value=6)
with CustomObjectScope({'relu6': relu6}):
base_model = MobileNet(weights='imagenet',
include_top=False,
input_shape=(224, 224, 3))
mid_start = 5
all_layers = base_model.layers
for i in range(0, mid_start):
print(i)
# all_layers[i].add(Flatten())
all_layers[i].trainable = False
#x=base_model.output
#x=Flatten()(x)
#x=Dense(128,activation='relu')(x)
#x=Dropout(0.5)(x)
#pred = Dense(2,activation='softmax')(x)
def test_FEFMLayer():
with CustomObjectScope({'FEFMLayer': layers.FEFMLayer}):
layer_test(layers.FEFMLayer,
kwargs={'regularizer': 0.000001},
input_shape=(BATCH_SIZE, FIELD_SIZE, EMBEDDING_SIZE))
def test_LocalActivationUnit(hidden_size, activation):
with CustomObjectScope({'LocalActivationUnit': layers.LocalActivationUnit}):
layer_test(layers.LocalActivationUnit, kwargs={'hidden_size': hidden_size, 'activation': activation},
input_shape=[(BATCH_SIZE, 1, EMBEDDING_SIZE), (BATCH_SIZE, SEQ_LENGTH, EMBEDDING_SIZE)])
def test_MLP(hidden_size, use_bn):
with CustomObjectScope({'MLP': layers.MLP}):
layer_test(layers.MLP, kwargs={'hidden_size': hidden_size, 'use_bn': use_bn}, input_shape=(
BATCH_SIZE, EMBEDDING_SIZE))
def test_CrossNet_invalid():
with pytest.raises(ValueError):
with CustomObjectScope({'CrossNet': layers.CrossNet}):
layer_test(layers.CrossNet, kwargs={
'layer_num': 1, 'l2_reg': 0}, input_shape=(2, 3, 4))
def test_CrossNet(layer_num, l2_reg,):
with CustomObjectScope({'CrossNet': layers.CrossNet}):
layer_test(layers.CrossNet, kwargs={
'layer_num': layer_num, 'l2_reg': l2_reg}, input_shape=(2, 3))
def test_InteractingLayer(head_num, use_res,):
with CustomObjectScope({'InteractingLayer': layers.InteractingLayer}):
layer_test(layers.InteractingLayer, kwargs={"head_num": head_num, "use_res":
use_res, }, input_shape=(
BATCH_SIZE, FIELD_SIZE, EMBEDDING_SIZE))
def test_OutterProductLayer(kernel_type):
with CustomObjectScope({'OutterProductLayer': layers.OutterProductLayer}):
layer_test(layers.OutterProductLayer,
kwargs={'kernel_type': kernel_type},
input_shape=[(BATCH_SIZE, 1, EMBEDDING_SIZE)] * FIELD_SIZE)
def test_SequencePoolingLayer(mode, supports_masking, input_shape):
with CustomObjectScope({'SequencePoolingLayer': sequence.SequencePoolingLayer}):
layer_test(sequence.SequencePoolingLayer, kwargs={'mode': mode, 'supports_masking': supports_masking},
input_shape=input_shape, supports_masking=supports_masking)
def test_BiInteractionPooling():
with CustomObjectScope(
{'BiInteractionPooling': layers.BiInteractionPooling}):
layer_test(layers.BiInteractionPooling,
kwargs={},
input_shape=(BATCH_SIZE, FIELD_SIZE, EMBEDDING_SIZE))
def test_Transformer():
with CustomObjectScope({'Transformer': sequence.Transformer}):
layer_test(sequence.Transformer, kwargs={'att_embedding_size': 1, 'head_num': 8, 'use_layer_norm': True, 'supports_masking': False,'dropout_rate':0.5},
input_shape=[(BATCH_SIZE, SEQ_LENGTH, EMBEDDING_SIZE), (BATCH_SIZE, SEQ_LENGTH, EMBEDDING_SIZE), (BATCH_SIZE, 1), (BATCH_SIZE, 1)])
def test_AFMLayer():
with CustomObjectScope({'AFMLayer': layers.AFMLayer}):
layer_test(layers.AFMLayer,
kwargs={'dropout_rate': 0.5},
input_shape=[(BATCH_SIZE, 1, EMBEDDING_SIZE)] * FIELD_SIZE)
def qt_InceptionV3(weights):
with CustomObjectScope({'softmax': softmax}):
json_string = open("/content/InceptionV3.json", "r").read()
model = model_from_json(json_string)
model.load_weights(weights)
return model
def test_PredictionLayer(task, use_bias):
with CustomObjectScope({'PredictionLayer': layers.PredictionLayer}):
layer_test(layers.PredictionLayer, kwargs={'task': task, 'use_bias': use_bias
}, input_shape=(BATCH_SIZE, 1))
import tensorflow as tf
from tensorflow.python.keras.models import load_model
from tensorflow.python.keras.utils import CustomObjectScope
def Hswish(x):
return x * tf.nn.relu6(x + 3) / 6
def relu6(x):
return tf.nn.relu6(x)
if __name__ == "__main__":
with CustomObjectScope({'Hswish': Hswish, 'relu6': relu6}):
# 需要转换的h5模型
h5file = 'trained_89_1530.h5'
kerasmodel = load_model(h5file)
tflite_model = tf.lite.TFLiteConverter.from_keras_model(kerasmodel)
# 参数量化
# tflite_model.optimizations = [tf.lite.Optimize.OPTIMIZE_FOR_SIZE]
# 整数量化
# tflite_model.optimizations = [tf.lite.Optimize.DEFAULT]
# tflite_model.representative_dataset = representative_data_gen
model = tflite_model.convert()
def test_PositionEncoding(pos_embedding_trainable, zero_pad):
with CustomObjectScope({'PositionEncoding': sequence.PositionEncoding}):
layer_test(sequence.PositionEncoding,
kwargs={'pos_embedding_trainable': pos_embedding_trainable, 'zero_pad': zero_pad},
input_shape=(BATCH_SIZE, SEQ_LENGTH, EMBEDDING_SIZE))
import tensorflow.keras.backend as K
from tensorflow.python.keras.utils import CustomObjectScope
from os.path import join
QUANTIZE = True
custom_loss = K.categorical_crossentropy
# convert teacher
converter = tf.lite.TFLiteConverter.from_keras_model_file(
join("Best", "teacher_model9278475.h5"))
tflite_model = converter.convert()
open(join("Best", "teacher.tflite"), "wb").write(tflite_model)
# convert student
with CustomObjectScope({'custom_loss': custom_loss}):
converter = tf.lite.TFLiteConverter.from_keras_model_file(
join("Best", "student_model2830427.h5"))
tflite_model = converter.convert()
open(join("Best", "student.tflite"), "wb").write(tflite_model)
# convert student
bs = 1
if QUANTIZE:
with CustomObjectScope({'custom_loss': custom_loss}):
converter = tf.lite.TFLiteConverter.from_keras_model_file(
join("Best", "student_model2830427.h5"),
input_shapes={'reshape_input': [bs, 2, 128]})
converter.post_training_quantize = True
tflite_model = converter.convert()
open(join("Best", "student8-{0}.tflite".format(bs)), "wb").write(tflite_model)
def test_SequencePoolingLayer(mode, supports_masking, input_shape):
if version.parse(tf.__version__) >= version.parse('1.14.0') and mode != 'sum': # todo check further version
return
with CustomObjectScope({'SequencePoolingLayer': sequence.SequencePoolingLayer}):
layer_test(sequence.SequencePoolingLayer, kwargs={'mode': mode, 'supports_masking': supports_masking},
input_shape=input_shape, supports_masking=supports_masking)
def load_model(self):
with CustomObjectScope({'GlorotUniform': glorot_uniform()}):
self.model = load_model(self.model_path)
self.graph = get_default_graph()
def test_KMaxPooling():
with CustomObjectScope({'KMaxPooling': sequence.KMaxPooling}):
layer_test(sequence.KMaxPooling, kwargs={'k': 3, 'axis': 1},
input_shape=(BATCH_SIZE, SEQ_LENGTH, EMBEDDING_SIZE, 2))
def test_BilinearInteraction(bilinear_type):
with CustomObjectScope({'BilinearInteraction':
layers.BilinearInteraction}):
layer_test(layers.BilinearInteraction,
kwargs={'bilinear_type': bilinear_type},
input_shape=[(BATCH_SIZE, 1, EMBEDDING_SIZE)] * FIELD_SIZE)
def test_InnerProductLayer(reduce_sum):
with CustomObjectScope({'InnerProductLayer': layers.InnerProductLayer}):
layer_test(layers.InnerProductLayer,
kwargs={'reduce_sum': reduce_sum},
input_shape=[(BATCH_SIZE, 1, EMBEDDING_SIZE)] * FIELD_SIZE)
def test_dice():
with CustomObjectScope({'Dice': activation.Dice}):
layer_test(activation.Dice, kwargs={},
input_shape=(2, 3))
