with strategy.scope():
max_seq_length = 128
initializer = tf.keras.initializers.TruncatedNormal(
stddev=bert_config.initializer_range)
bert_encoder = bert.bert_models.get_transformer_encoder(
bert_config, max_seq_length)
input_word_ids = tf.keras.layers.Input(
shape=(max_seq_length,), dtype=tf.int32, name='input_word_ids')
input_mask = tf.keras.layers.Input(
shape=(max_seq_length,), dtype=tf.int32, name='input_mask')
input_type_ids = tf.keras.layers.Input(
shape=(max_seq_length,), dtype=tf.int32, name='input_type_ids')
bert_model = hub.KerasLayer("https://tfhub.dev/tensorflow/bert_multi_cased_L-12_H-768_A-12/2",
trainable=True)
#bert_model = hub.KerasLayer(hub_url_bert, trainable=True)
pooled_output, seq_output = bert_model([input_word_ids, input_mask, input_type_ids])
output1 = tf.keras.layers.Dropout(rate=bert_config.hidden_dropout_prob)(
pooled_output)
output1 = tf.keras.layers.Dense(
2, kernel_initializer=initializer, name='output1')(
output1)
output2 = tf.keras.layers.Dropout(rate=bert_config.hidden_dropout_prob)(
pooled_output)
output2 = tf.keras.layers.Dense(
3, kernel_initializer=initializer, name='output2')(
output2)
image = tf.image.resize(image, (IMAGE_RES, IMAGE_RES)) / 255.0
return image, label
num_examples = info.splits['train'].num_examples
BATCH_SIZE = 32
IMAGE_RES = 224
train_batches = train_examples.cache().shuffle(
num_examples // 4).map(format_image).batch(BATCH_SIZE).prefetch(1)
validation_batches = validation_examples.cache().map(format_image).batch(
BATCH_SIZE).prefetch(1)
URL = "https://tfhub.dev/google/tf2-preview/mobilenet_v2/feature_vector/4"
feature_extractor = hub.KerasLayer(URL, input_shape=(IMAGE_RES, IMAGE_RES, 3))
feature_extractor.trainable = False
model = tf.keras.Sequential([feature_extractor, layers.Dense(2)])
model.summary()
model.compile(optimizer='adam',
loss=tf.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
EPOCHS = 3
history = model.fit(train_batches,
epochs=EPOCHS,
validation_data=validation_batches)
import math
import random
import re
import numpy as np
import pandas as pd
import tensorflow as tf
import tensorflow_hub as hub
from model import SentimentModel
import bert
# Tokenize
BertTokenizer = bert.bert_tokenization.FullTokenizer
bert_layer = hub.KerasLayer(
"https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/1",
trainable=False)
vocabulary_file = bert_layer.resolved_object.vocab_file.asset_path.numpy()
to_lower_case = bert_layer.resolved_object.do_lower_case.numpy()
tokenizer = BertTokenizer(vocabulary_file, to_lower_case)
VOCAB_LENGTH = len(tokenizer.vocab)
EMB_DIM = 200
CNN_FILTERS = 100
DNN_UNITS = 256
OUTPUT_CLASSES = 6
DROPOUT_RATE = 0.2
NB_EPOCHS = 8
model = SentimentModel(vocabulary_size=VOCAB_LENGTH,
embedding_dimensions=EMB_DIM,
def __init__(
self,
model_link="https://tfhub.dev/tensorflow/cord-19/swivel-128d/3"):
self.embedder = hub.KerasLayer(model_link)
print(f"Loaded pre-trained model {model_link} successfully!")
directory=train_dir,
shuffle=True,
target_size=(IMG_SHAPE, IMG_SHAPE),
class_mode='binary')
val_data_gen = validation_image_generator.flow_from_directory(
batch_size=BATCH_SIZE,
directory=validation_dir,
shuffle=False,
target_size=(IMG_SHAPE, IMG_SHAPE),
class_mode='binary')
# getting MobileNet
URL = "https://tfhub.dev/google/tf2-preview/mobilenet_v2/feature_vector/4"
mobile_net = hub.KerasLayer(URL, input_shape=(IMG_SHAPE, IMG_SHAPE, 3))
mobile_net.trainable = False
model = tf.keras.models.Sequential([
mobile_net,
tf.keras.layers.Dropout(0.5),
tf.keras.layers.Dense(3, activation='softmax') # [0, 1] or [1, 0]
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.summary()
train_data, validation_data, test_data = tfds.load(name="imdb_reviews",
split=('train[:60%]',
'train[60%:]',
'test'),
as_supervised=True)
train_examples_batch, train_labels_batch = next(iter(train_data.batch(10)))
#print(train_examples_batch)
#print(train_labels_batch)
embedding = "https://tfhub.dev/google/tf2-preview/nnlm-en-dim128/1"
hub_layer = hub.KerasLayer(embedding,
input_shape=[],
dtype=tf.string,
trainable=True)
# print(hub_layer(train_examples_batch[:3]))
model = tf.keras.Sequential()
model.add(hub_layer)
model.add(tf.keras.layers.Dense(16, activation='relu'))
model.add(tf.keras.layers.Dense(1))
model.summary()
model.compile(optimizer='adam',
loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
metrics=['accuracy'])
def squad_model(bert_config,
max_seq_length,
float_type,
initializer=None,
hub_module_url=None):
"""Returns BERT Squad model along with core BERT model to import weights.
Args:
bert_config: BertConfig, the config defines the core Bert model.
max_seq_length: integer, the maximum input sequence length.
float_type: tf.dtype, tf.float32 or tf.bfloat16.
initializer: Initializer for weights in BertSquadLogitsLayer.
hub_module_url: TF-Hub path/url to Bert module.
Returns:
Two tensors, start logits and end logits, [batch x sequence length].
"""
unique_ids = tf.keras.layers.Input(shape=(1, ),
dtype=tf.int32,
name='unique_ids')
input_word_ids = tf.keras.layers.Input(shape=(max_seq_length, ),
dtype=tf.int32,
name='input_ids')
input_mask = tf.keras.layers.Input(shape=(max_seq_length, ),
dtype=tf.int32,
name='input_mask')
input_type_ids = tf.keras.layers.Input(shape=(max_seq_length, ),
dtype=tf.int32,
name='segment_ids')
if hub_module_url:
core_model = hub.KerasLayer(hub_module_url, trainable=True)
_, sequence_output = core_model(
[input_word_ids, input_mask, input_type_ids])
# Sets the shape manually due to a bug in TF shape inference.
# TODO(hongkuny): remove this once shape inference is correct.
sequence_output.set_shape(
(None, max_seq_length, bert_config.hidden_size))
else:
core_model = modeling.get_bert_model(input_word_ids,
input_mask,
input_type_ids,
config=bert_config,
name='bert_model',
float_type=float_type)
# `BertSquadModel` only uses the sequnce_output which
# has dimensionality (batch_size, sequence_length, num_hidden).
sequence_output = core_model.outputs[1]
if initializer is None:
initializer = tf.keras.initializers.TruncatedNormal(
stddev=bert_config.initializer_range)
squad_logits_layer = BertSquadLogitsLayer(initializer=initializer,
float_type=float_type,
name='squad_logits')
start_logits, end_logits = squad_logits_layer(sequence_output)
squad = tf.keras.Model(inputs={
'unique_ids': unique_ids,
'input_ids': input_word_ids,
'input_mask': input_mask,
'segment_ids': input_type_ids,
},
outputs=[unique_ids, start_logits, end_logits],
name='squad_model')
return squad, core_model
def classifier_model(bert_config,
num_labels,
max_seq_length,
final_layer_initializer=None,
hub_module_url=None,
hub_module_trainable=True):
"""BERT classifier model in functional API style.
Construct a Keras model for predicting `num_labels` outputs from an input with
maximum sequence length `max_seq_length`.
Args:
bert_config: BertConfig or AlbertConfig, the config defines the core BERT or
ALBERT model.
num_labels: integer, the number of classes.
max_seq_length: integer, the maximum input sequence length.
final_layer_initializer: Initializer for final dense layer. Defaulted
TruncatedNormal initializer.
hub_module_url: TF-Hub path/url to Bert module.
hub_module_trainable: True to finetune layers in the hub module.
Returns:
Combined prediction model (words, mask, type) -> (one-hot labels)
BERT sub-model (words, mask, type) -> (bert_outputs)
"""
if final_layer_initializer is not None:
initializer = final_layer_initializer
else:
initializer = tf.keras.initializers.TruncatedNormal(
stddev=bert_config.initializer_range)
if not hub_module_url:
bert_encoder = get_transformer_encoder(bert_config, max_seq_length)
return models.BertClassifier(
bert_encoder,
num_classes=num_labels,
dropout_rate=bert_config.hidden_dropout_prob,
initializer=initializer), bert_encoder
input_word_ids = tf.keras.layers.Input(shape=(max_seq_length, ),
dtype=tf.int32,
name='input_word_ids')
input_mask = tf.keras.layers.Input(shape=(max_seq_length, ),
dtype=tf.int32,
name='input_mask')
input_type_ids = tf.keras.layers.Input(shape=(max_seq_length, ),
dtype=tf.int32,
name='input_type_ids')
bert_model = hub.KerasLayer(hub_module_url, trainable=hub_module_trainable)
pooled_output, _ = bert_model([input_word_ids, input_mask, input_type_ids])
output = tf.keras.layers.Dropout(
rate=bert_config.hidden_dropout_prob)(pooled_output)
output = tf.keras.layers.Dense(num_labels,
kernel_initializer=initializer,
name='output')(output)
return tf.keras.Model(inputs={
'input_word_ids': input_word_ids,
'input_mask': input_mask,
'input_type_ids': input_type_ids
},
outputs=output), bert_model
keras.layers.Lambda(lambda images: tf.cast(images, tf.float32)),
keras.layers.Dense(10, activation="softmax")])
model.compile(loss="sparse_categorical_crossentropy",
optimizer=keras.optimizers.SGD(lr=1e-3),
metrics=["accuracy"])
model.fit(mnist_train, steps_per_epoch=60000 // 32, epochs=5)
# TensorFlow Hub
keras.backend.clear_session()
np.random.seed(42)
tf.random.set_seed(42)
import tensorflow_hub as hub
hub_layer = hub.KerasLayer("https://tfhub.dev/google/tf2-preview/nnlm-en-dim50/1",
output_shape=[50], input_shape=[], dtype=tf.string)
model = keras.Sequential()
model.add(hub_layer)
model.add(keras.layers.Dense(16, activation='relu'))
model.add(keras.layers.Dense(1, activation='sigmoid'))
model.summary()
sentences = tf.constant(["It was a great movie", "The actors were amazing"])
embeddings = hub_layer(sentences)
embeddings
# Exercises
AUTOTUNE = tf.data.experimental.AUTOTUNE
train = train.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE)
val = val.cache().prefetch(buffer_size=AUTOTUNE)
# %%
# PARTIE IMAGE NET
IMAGE_SHAPE = (224, 224)
classifier = tf.keras.Sequential([
#hub.KerasLayer(classifier_model, input_shape=IMAGE_SHAPE+(3,))
keras.layers.experimental.preprocessing.Rescaling(1. / 255,
input_shape=(img_size,
img_size,
3)),
hub.KerasLayer(classifier_model),
keras.layers.Dropout(0.2),
keras.layers.Dense(15)
])
classifier.compile(
optimizer=keras.optimizers.Adam(),
loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=["accuracy"])
#%%
root_logdir = os.path.join(os.curdir, "my_logs")
def get_run_logdir():
run_id = time.strftime("run_%Y_%m_%d-%H_%M_%S")
def main():
url = "https://tfhub.dev/tensorflow/tfjs-model/deeplab/cityscapes/1/default/1"
url = "D:/Academic/Computer_Science/Street_Evaluation/deeplabv3_1_default_1.tflite"
# loaded = tf.saved_model.load("D:\ProgrammeFiles\deeplab_cityscapes_1_default_1.tar")
deeplab_v3 = hub.KerasLayer(url, trainable=True)
X_strt1d_test = strt1d_test["review"]
Y_strt1d_test = np.array(strt1d_test['sentiment'].tolist())
# ******************************************************* #
# NEURAL NETWORK LANGUAGE TOKEN EMBEDDINGS MODEL (NNLM) #
# ******************************************************* #
nnlm_stats = Stats()
# If the module doesn't download automatically, then please download it manualy via the curl request and provide
# the hub.KerasLayer with the path to the module folder
# curl -L "https://tfhub.dev/google/nnlm-en-dim128-with-normalization/2?tf-hub-format=compressed" | tar -zxvC tf_hub_modules/nnlm
nnlm_model = tf.keras.Sequential([
# hub.KerasLayer("https://tfhub.dev/google/nnlm-en-dim128-with-normalization/2", input_shape=[], dtype=tf.string, trainable=False),
hub.KerasLayer("tf_hub_modules/nnlm",
input_shape=[],
dtype=tf.string,
trainable=False),
tf.keras.layers.Dense(128, activation=tf.nn.relu, use_bias=True),
tf.keras.layers.Dense(64, activation=tf.nn.relu, use_bias=True),
tf.keras.layers.Dense(1, activation=tf.nn.sigmoid)
])
nnlm_model.compile(loss=losses.binary_crossentropy,
optimizer='adam',
metrics=['accuracy'])
print(nnlm_model.summary())
nnlm_model.fit(X_strt1d_train,
Y_strt1d_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(X_strt1d_eval, Y_strt1d_eval),
import tensorflow_hub as hub
import tensorflow_datasets as tfds
# Split the training set into 60% and 40%, so we'll end up with 15,000 examples
# for training, 10,000 examples for validation and 25,000 examples for testing.
train_validation_split = tfds.Split.TRAIN.subsplit([6, 4])
(train_data,
validation_data), test_data = tfds.load(name="imdb_reviews",
split=(train_validation_split,
tfds.Split.TEST),
as_supervised=True)
handle = 'https://tfhub.dev/google/tf2-preview/gnews-swivel-20dim/1'
hub_layer = hub.KerasLayer(handle,
input_shape=[],
dtype=tf.string,
trainable=True)
model = tf.keras.models.Sequential()
model.add(hub_layer)
model.add(tf.keras.layers.Dense(16, activation='relu'))
model.add(tf.keras.layers.Dense(1, activation='sigmoid'))
#model.summary()
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
model.fit(train_data.shuffle(1).batch(512),
epochs=20,
#print(i)
df = df_list[i]
for j in range(len(df)):
#if(type(df['Utterance'][j]) == str and type(df['Type'][j]) == str):
if (df['Num Type'][j] != 3):
test_x.append(df['Utterance'][j])
one_hot_label = [0, 0, 0]
one_hot_index = int(df['Num Type'][j])
one_hot_label[one_hot_index] = 1
test_y.append(one_hot_label)
#test_y.append(int(df['Num Type'][j]))
#print(train_y)
#print(np.array(train_y).shape)
bert_preprocess_model = hub.KerasLayer(
'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3')
bert_model = hub.KerasLayer(
'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-128_A-2/1')
encoder_inputs = bert_preprocess_model(train_x)
outputs = bert_model(encoder_inputs)
pooled_output = outputs["pooled_output"]
sequence_output = outputs["sequence_output"]
print(pooled_output)
#print(sequence_output)
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(40, activation='sigmoid'))
model.add(tf.keras.layers.Dense(20, activation='sigmoid'))
model.add(tf.keras.layers.Dense(3, activation='softmax'))
import numpy as np
import os
import sys
sys.path.append(os.getcwd())
from utils.prepareGPU import prepareGPU
from utils.prepareCatDogDataset import prepareDataset, prepareTraingAndValSet
session = prepareGPU()
train_dir, val_dir, total_train, total_val = prepareDataset()
CLASSIFIER_URL = "https://tfhub.dev/google/tf2-preview/mobilenet_v2/classification/2"
IMAGE_RES = 224
BATCH_SIZE = 32
URL = "https://tfhub.dev/google/tf2-preview/mobilenet_v2/feature_vector/2"
all_layers_except_the_last = hub.KerasLayer(URL,
input_shape=(IMAGE_RES, IMAGE_RES,
3))
all_layers_except_the_last.trainable = False
model = keras.Sequential(
[all_layers_except_the_last,
keras.layers.Dense(2, activation="softmax")])
model.summary()
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
train_data_gen, val_data_gen = prepareTraingAndValSet(BATCH_SIZE, IMAGE_RES)
# Pre-trained Model auswählen (aus TF-Hub)
model_name = "mobilenet_v2_100_224"
model_handle_map = {"mobilenet_v2_100_224": "https://tfhub.dev/google/imagenet/mobilenet_v2_100_224/feature_vector/4",}
model_handle = model_handle_map.get(model_name)
IMAGE_SIZE = (224, 224, 3)
BATCH_SIZE = 32
print(f"\nAusgewaehltes model: {model_name} : {model_handle}")
print(f"\nBild-Groesse {IMAGE_SIZE}")
# CNN zusammenstellen mit ANzahl Klassen wie im Datenset
print("\nModell erstellen mit", model_handle)
model = tf.keras.Sequential([
tf.keras.layers.InputLayer(input_shape=(IMAGE_SIZE)),
hub.KerasLayer(model_handle, trainable=False),
tf.keras.layers.Dropout(rate=0.2),
tf.keras.layers.Dense(len(class_names),
kernel_regularizer=tf.keras.regularizers.l2(0.0001))
])
model.build((None,)+IMAGE_SIZE)
model.summary()
# Trainieren des Modells
model.compile(
optimizer=tf.keras.optimizers.SGD(lr=0.005, momentum=0.9),
loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True, label_smoothing=0.1),
metrics=['accuracy'])
history = model.fit(
train_ds,
queries_docs[idd] = doc + max(
0, args.num_eval_docs - len(doc)) * [('000000000', 'FAKE DOC', 0)]
writer = tf.io.TFRecordWriter(args.output_folder + "/eval_ds.tf")
map_ids_file = open(args.output_folder + "/query_doc_ids_eval.txt")
for i, (query_id, docs) in tqdm(enumerate(queries_docs.items())):
doc_ids, docs, labels = zip(*docs)
query = query_map[query_id]
write_to_tf_record(writer=writer,
tokenizer=tokenizer,
query=query,
docs=docs,
labels=labels,
ids_file=map_ids_file,
query_id=query_id,
doc_ids=doc_ids)
map_ids_file.close()
writer.close()
if __name__ == "__main__":
print("downloading layer...")
bert_layer = hub.KerasLayer(args.bert_model_hub, trainable=True)
print("Layer downloaded...")
vocab_file = bert_layer.resolved_object.vocab_file.asset_path.numpy()
do_lower_case = bert_layer.resolved_object.do_lower_case.numpy()
tokenizer = tokenization.FullTokenizer(vocab_file, do_lower_case)
create_dir(args.output_folder)
convert_train_ds(tokenizer)
convert_eval_ds(tokenizer)
plt.figure(figsize = (10, 9))
plt.subplots_adjust(hspace = 0.5)
for idx in range(30):
plt.subplot(6, 5, idx + 1)
plt.imshow(image_batch[idx])
plt.title(predicted_class[idx])
plt.axis('off')
plt.suptitle('ImageNet Predictions')
plt.show()
'''
#Use a model without the top classification layer
feature_extractor_url = "https://tfhub.dev/google/tf2-preview/mobilenet_v2/feature_vector/2"
feature_extractor_layer = hub.KerasLayer(feature_extractor_url,
input_shape=(224, 224, 3))
'''
FREEZE THE VARIABLES IN THE FEATURE EXTRACTOR LAYER, SO THAT THE TRAINING ONLY MODIFIES THE NEW CLASSIFIER LAYER
'''
feature_extractor_layer.trainable = False
#add a calssification head
model = tf.keras.Sequential(
[feature_extractor_layer,
layers.Dense(image_data.num_classes)])
model.summary()
model.compile(optimizer=tf.keras.optimizers.Adam(),
loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
print(os.path.join(dirname, filename))
print(tf.__version__)
# Any results you write to the current directory are saved as output.
BASE_PATH = "/content/gdrive/My Drive/Colab Notebooks/Disaster/"
train =pd.read_csv(BASE_PATH + "train.csv")
train.head()
test =pd.read_csv(BASE_PATH + "test.csv")
test.head()
%%time
module_url = "https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/1"
bert_layer = hub.KerasLayer(module_url, trainable=True)
vocab_file = bert_layer.resolved_object.vocab_file.asset_path.numpy()
do_lower_case = bert_layer.resolved_object.do_lower_case.numpy()
tokenizer = tokenization.FullTokenizer(vocab_file, do_lower_case)
text = "This is a Goat, and I am riding a Boat...."
tokenize_ = tokenizer.tokenize(text)
print("Text after tokenization: ")
print(tokenize_)
max_len = 25
text = tokenize_[:max_len-2]
input_sequence = ["[CLS]"] + text + ["[SEP]"]
pad_len = max_len - len(input_sequence)
import tensorflow as tf
import tensorflow_hub as hub
import numpy as np
import PIL.Image
classifier_url = "https://tfhub.dev/google/tf2-preview/mobilenet_v2/classification/2" #@param {type:"string"}
IMAGE_SHAPE = (224, 224)
classifier = tf.keras.Sequential(
[hub.KerasLayer(classifier_url, input_shape=IMAGE_SHAPE + (3, ))])
inputs = np.empty((10, 224, 224, 3))
for i in range(0, 5):
cat = PIL.Image.open(f'../data/cat.{i}.jpg').resize(IMAGE_SHAPE)
dog = PIL.Image.open(f'../data/dog.{i}.jpg').resize(IMAGE_SHAPE)
cat = np.array(cat) / 255.0
dog = np.array(dog) / 255.0
inputs[i] = cat
inputs[i + 5] = dog
results = classifier.predict(inputs)
pred_classes = []
pred_labels = []
labels_path = tf.keras.utils.get_file(
'ImageNetLabels.txt',
def load_model(model_signature: str, **params) -> object:
"""
NOTE: Keras常见陷阱：1.TF卷积核与Theano卷积核shape相同，加载时需用测试样本验证其表现，Keras无法区别
:param model_signature:
:param params:
"""
model = None
inputs, outputs = {}, {} # {name: shape} dicts
if model_signature == _ModelSignature.TFSavedModel.signature:
import tensorflow as tf # IMPROVE: check availability of ml backends
# format_ = ModelManager._validate_format(params['format'], _ModelSignature.TFSavedModel)
path = ModelManager._validate_path(params.get('path', None))
model = tf.saved_model.load(path, params.get('tags', None)) # == core ==
if params.get('signature_', None) is not None:
model = model.signatures[params['signature_']]
# TODO: append inputs, outputs spec to model object? so that predict() can adapt the fed inputs
if hasattr(model, 'inputs') and hasattr(model, 'structured_outpus'):
inputs = {model.inputs[0].name: model.inputs[0].shape}
outputs = {'default': model.structured_outputs['default']} # IMPROVE: iterate
pass
elif model_signature == _ModelSignature.TLDyamicModel.signature:
params_model = Params(model_func=None, model_args=None, weights_path=None).update_to(params)
import tensorflow as tf
import os.path as osp
if params_model.model_func is None:
raise ValueError(f"model_func must be specified for a '{model_signature}' model")
idx_last_sep = params_model.model_func.rfind('.')
module = safe_import_module(params_model.model_func[:idx_last_sep])
model_func = getattr(module, params_model.model_func[idx_last_sep+1:])
model = model_func(**params_model.model_args)
if params_model.weights_path is not None:
weights_path = ModelManager._validate_path(params_model.weights_path)
model.load_weights(weights_path, skip=True)
elif model_signature == _ModelSignature.TFHub_KerasLayer.signature:
import tensorflow_hub as tf_hub
# format_ = ModelManager._validate_format(params['format'], _ModelSignature.TFSavedModel)
path = ModelManager._validate_path(params.get('path', None))
params_model = Params(input_shape=None, trainable=False).update_to(params)
if params_model.input_shape.__len__() == 4:
params_model.input_shape = params_model.input_shape[1:]
# NOTE: it will be delayed-build pattern when `input_shape` is None. no weights info available until build.
model = tf_hub.KerasLayer(path, input_shape=params_model.input_shape)
model.trainable = params_model.trainable
pass
elif model_signature == _ModelSignature.KerasSequential.signature:
# IMPROVE: check availability of ml backends
from tensorflow.keras import Sequential, layers
name = params['name']
# IMPROVE：parse name -> layers, or use structural config for iteration
if name == '{conv-pool}*2-flat-dense-drop-dense':
# NOTE: only for _test_\TF_1x_to_2x_3, output is len=10 logits
model = Sequential([
# NOTE: 1.TF2.x已无需限定Input层的维度，甚至各层间都能自动衔接
# 2.Conv层中无需设定上一层的(h,w)，只需设定filter数、kernel维度、padding(使h,w保持)等
# 3.但若不指定input_shape，Optimizer将无法加载其之前被保存的参数，只能重新初始化
layers.Conv2D(32, (5, 5), strides=(1, 1), padding='same', activation='relu'),
layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
layers.Conv2D(64, (5, 5), strides=(1, 1), padding='same', activation='relu'),
layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
layers.Flatten(), # 下面的神经网络需要1维的数据
layers.Dense(1024, activation='relu'),
layers.Dropout(0.5), # TODO: 关闭Dropout @evluate,predict
layers.Dense(10, activation='softmax')
])
elif name == 'dense-dense_softmax':
params_model = Params(embedding_size=1024, class_count=None).update_to(params)
if params_model.class_count is None:
raise ValueError('class_count must be specified')
model = Sequential([
layers.Dense(params_model.embedding_size, activation='relu'),
layers.Dense(params_model.class_count, activation='softmax')
])
# TODO: need to return intermediate tf.Tensor required by embedding, loss calculation and evaluation.
else:
raise ValueError(f"Undefined model: {name}")
pass
elif model_signature == _ModelSignature.KerasModels_LoadModel.signature:
import tensorflow as tf # IMPROVE: check availability of ml backends
format_ = ModelManager._validate_format(params['format'], _ModelSignature.KerasModels_LoadModel)
params_model = Params(path='', path_formatted='').update_to(params)
path = ModelManager._validate_path(params_model.path)
model = tf.keras.models.load_model(path) # == core ==
elif model_signature == _ModelSignature.TF_ImportGraphDef.signature:
import tensorflow as tf # IMPROVE: check availability of ml backends
format_ = ModelManager._validate_format(params['format'], _ModelSignature.TF_ImportGraphDef)
params_model = Params(inputs='', outputs='').update_to(params)
path = ModelManager._validate_path(params_model.path)
# import PB model (frozen) in TF2.x. ref:https://www.tensorflow.org/guide/migrate#a_graphpb_or_graphpbtxt
# ref:https://www.tensorflow.org/api_docs/python/tf/compat/v1/wrap_function
def wrap_frozen_graph(pb_path, inputs, outputs, prefix=""):
def _imports_graph_def():
tf.compat.v1.import_graph_def(graph_def, name=prefix) # turn off the default prefix "import/"
graph_def = tf.compat.v1.GraphDef()
loaded = graph_def.ParseFromString(open(pb_path, 'rb').read()) # == core ==
wrapped_import = tf.compat.v1.wrap_function(_imports_graph_def, []) # == core ==
import_graph = wrapped_import.graph
return wrapped_import.prune(
tf.nest.map_structure(import_graph.as_graph_element, inputs),
tf.nest.map_structure(import_graph.as_graph_element, outputs))
model = wrap_frozen_graph(path, inputs=params_model.inputs, outputs=params_model.outputs)
test_img = tf.ones([1, 224, 224, 3], dtype=tf.float32) # fixed shape is for test ONLY
DEBUG(f"wrap_func test result: {model(test_img).shape}")
else:
raise ValueError(f"Unsupported model signature: {model_signature}")
INFO(f"type of loaded model={type(model)}")
INFO(f" inputs={inputs}, outputs={outputs}")
return model
padding='same',
kernel_initializer='he_uniform')(x)
block_3_output = add([x, block_2_output])
x = Conv2D(64, 3, activation='relu',
kernel_initializer='he_uniform')(block_3_output)
x = GlobalAveragePooling2D()(x)
x = Dense(256, activation='relu', kernel_initializer='he_uniform')(x)
x = Dropout(0.5)(x)
outputs = Dense(2)(x)
model_cnnB = tf.keras.Model(inputs, outputs, name='toy_resnet')
resnetv2 = tf.keras.Sequential([
hub.KerasLayer(
"https://tfhub.dev/google/imagenet/resnet_v2_101/feature_vector/4",
trainable=True,
arguments=dict(batch_norm_momentum=0.99)), # Can be True, see below.
tf.keras.layers.Dense(2, activation='softmax')
])
resnetv2.build([None, 100, 100, 3]) # Batch input shape.
inceptionv3nat = tf.keras.Sequential([
hub.KerasLayer(
"https://tfhub.dev/google/inaturalist/inception_v3/feature_vector/4",
trainable=True,
arguments=dict(batch_norm_momentum=0.99)), # Can be True, see below.
tf.keras.layers.Dense(2, activation='softmax')
])
inceptionv3nat.build([None, 100, 100, 3]) # Batch input shape.
inceptionv3 = tf.keras.Sequential([
def _create_embedding_layer(hub_url):
return hub.KerasLayer(hub_url,
output_shape=[128],
input_shape=[],
dtype=tf.string)
def analyze_images(images,
model_name,
layer_name=None,
pooling=None,
do_crop=False,
subsampling=None,
do_pca=False):
if model_name == 'color_lab':
return analyze_images_colors(images,
colorspace='lab',
subsampling=subsampling)
elif model_name == 'color' or model_name == 'color_rgb':
return analyze_images_colors(images,
colorspace='rgb',
subsampling=subsampling)
num_images = len(images)
include_top = (layer_name is not None)
model_lookup_table = {
'densenet121': {
'model_class': keras.applications.densenet.DenseNet121,
'input_shape': (224, 224),
'preprocess_input': keras.applications.densenet.preprocess_input
},
'densenet169': {
'model_class': keras.applications.densenet.DenseNet169,
'input_shape': (224, 224),
'preprocess_input': keras.applications.densenet.preprocess_input
},
'densenet201': {
'model_class': keras.applications.densenet.DenseNet201,
'input_shape': (224, 224),
'preprocess_input': keras.applications.densenet.preprocess_input
},
'inceptionresnetv2': {
'model_class':
keras.applications.inception_resnet_v2.InceptionResNetV2,
'input_shape': (299, 299),
'preprocess_input':
keras.applications.inception_resnet_v2.preprocess_input
},
'inceptionv3': {
'model_class': keras.applications.inception_v3.InceptionV3,
'input_shape': (299, 299),
'preprocess_input':
keras.applications.inception_v3.preprocess_input
},
'resnet50': {
'model_class': keras.applications.resnet.ResNet50,
'input_shape': (224, 224),
'preprocess_input': keras.applications.resnet.preprocess_input
},
'resnet101': {
'model_class': keras.applications.resnet.ResNet101,
'input_shape': (224, 224),
'preprocess_input': keras.applications.resnet.preprocess_input
},
'resnet152': {
'model_class': keras.applications.resnet.ResNet152,
'input_shape': (224, 224),
'preprocess_input': keras.applications.resnet.preprocess_input
},
'vgg16': {
'model_class': keras.applications.vgg16.VGG16,
'input_shape': (224, 224),
'preprocess_input': keras.applications.vgg16.preprocess_input
},
'vgg19': {
'model_class': keras.applications.vgg19.VGG19,
'input_shape': (224, 224),
'preprocess_input': keras.applications.vgg19.preprocess_input
},
'inceptionv3': {
'model_class': keras.applications.xception.Xception,
'input_shape': (299, 299),
'preprocess_input': keras.applications.xception.preprocess_input
},
}
is_bit = False
is_clip = False
if model_name.startswith("bit"):
model_url = f"https://tfhub.dev/google/{model_name}/1"
input_shape = None
preprocess_input = bit_preprocess_image
model = hub.KerasLayer(model_url)
is_bit = True
elif model_name.startswith("clip"):
import clip
import torch
from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize
model_type = "ViT-B/32"
if len(model_name) > 4:
parts = model_name.split(":")
model_type = parts[1]
model, preprocess = clip.load(model_type)
print(preprocess)
input_size = model.input_resolution.item()
input_shape = (input_size, input_size)
preprocess_input = None
is_clip = True
elif model_name in model_lookup_table:
model_class = model_lookup_table[model_name]['model_class']
input_shape = model_lookup_table[model_name]['input_shape']
preprocess_input = model_lookup_table[model_name]['preprocess_input']
model = model_class(weights='imagenet', include_top=include_top)
else:
print("Error: model {} not found".format(model_name))
sys.exit(1)
if layer_name is None:
feat_extractor = model
elif layer_name == "show" or layer_name == "list":
for i, layer in enumerate(model.layers):
print("{} layer {:03d}: {}".format(model_name, i, layer.name))
sys.exit(0)
else:
feat_extractor = Model(inputs=model.input,
outputs=model.get_layer(layer_name).output)
# analyze images and grab activations
activations = []
for idx in tqdm(range(len(images))):
file_path = images[idx]
img = get_image(file_path, input_shape, do_crop, is_bit)
if img is not None:
# preprocess
if preprocess_input is not None:
img = preprocess_input(img)
# print("getting activations for %s %d/%d" % (file_path,idx,num_images))
if is_bit:
acts = model(img)[0].numpy()
elif is_clip:
batch_item = img[0] / 255.0
transform2 = Compose([
ToTensor(),
Normalize((0.48145466, 0.4578275, 0.40821073),
(0.26862954, 0.26130258, 0.27577711)),
])
zimages = []
im = transform2(batch_item)
zimages.append(im)
im_batch = torch.stack(zimages)
acts = model.encode_image(im_batch)[0].detach().cpu().numpy()
else:
acts = feat_extractor.predict(img)[0]
if len(activations) == 0:
print("Collecting vectors of size {}".format(
acts.flatten().shape))
activations.append(acts.flatten())
# run PCA firt
features = np.array(activations)
if do_pca:
print("Running PCA on features: {}".format(features.shape))
pca = PCA(n_components=300)
pca.fit(features)
pca_features = pca.transform(features)
return np.asarray(pca_features)
else:
return features
def classifier_model(bert_config,
float_type,
num_labels,
max_seq_length,
final_layer_initializer=None,
hub_module_url=None):
"""BERT classifier model in functional API style.
Construct a Keras model for predicting `num_labels` outputs from an input with
maximum sequence length `max_seq_length`.
Args:
bert_config: BertConfig, the config defines the core BERT model.
float_type: dtype, tf.float32 or tf.bfloat16.
num_labels: integer, the number of classes.
max_seq_length: integer, the maximum input sequence length.
final_layer_initializer: Initializer for final dense layer. Defaulted
TruncatedNormal initializer.
hub_module_url: (Experimental) TF-Hub path/url to Bert module.
Returns:
Combined prediction model (words, mask, type) -> (one-hot labels)
BERT sub-model (words, mask, type) -> (bert_outputs)
"""
input_word_ids = tf.keras.layers.Input(shape=(max_seq_length, ),
dtype=tf.int32,
name='input_word_ids')
input_mask = tf.keras.layers.Input(shape=(max_seq_length, ),
dtype=tf.int32,
name='input_mask')
input_type_ids = tf.keras.layers.Input(shape=(max_seq_length, ),
dtype=tf.int32,
name='input_type_ids')
if hub_module_url:
bert_model = hub.KerasLayer(hub_module_url, trainable=True)
pooled_output, _ = bert_model(
[input_word_ids, input_mask, input_type_ids])
else:
bert_model = modeling.get_bert_model(input_word_ids,
input_mask,
input_type_ids,
config=bert_config,
float_type=float_type)
pooled_output = bert_model.outputs[0]
if final_layer_initializer is not None:
initializer = final_layer_initializer
else:
initializer = tf.keras.initializers.TruncatedNormal(
stddev=bert_config.initializer_range)
output = tf.keras.layers.Dropout(
rate=bert_config.hidden_dropout_prob)(pooled_output)
output = tf.keras.layers.Dense(num_labels,
kernel_initializer=initializer,
name='output',
dtype=float_type)(output)
return tf.keras.Model(inputs={
'input_word_ids': input_word_ids,
'input_mask': input_mask,
'input_type_ids': input_type_ids
},
outputs=output), bert_model
for n in range(25):
ax = plt.subplot(5, 5, n + 1)
plt.imshow(batch[0][n])
plt.title(class_names[batch[1][n].numpy()].title())
plt.axis('off')
show_batch(batch)
# In[7]:
# building the model
# InceptionV3 model & pre-trained weights
module_url = "https://tfhub.dev/google/tf2-preview/inception_v3/feature_vector/4"
m = tf.keras.Sequential([
hub.KerasLayer(module_url, output_shape=[2048], trainable=False),
tf.keras.layers.Dense(1, activation="sigmoid")
])
m.build([None, 299, 299, 3])
m.compile(loss="binary_crossentropy",
optimizer=optimizer,
metrics=["accuracy"])
m.summary()
# In[9]:
# model_name = f"benign-vs-malignant_{batch_size}_{optimizer}"
# tensorboard = tf.keras.callbacks.TensorBoard(log_dir=os.path.join("logs", model_name))
# # saves model checkpoint whenever we reach better weights
# modelcheckpoint = tf.keras.callbacks.ModelCheckpoint(model_name + "_{val_loss:.3f}.h5", save_best_only=True, verbose=1)
else:
data_gen = ImageDataGenerator(rescale=1./255)
data = data_gen.flow_from_directory(
data_folder,
target_size=IMG_SIZE,
batch_size=BATCH_SIZE,
class_mode="binary",
)
return data
ds_train = gen_new_data(TRAIN_DIR, augmented=True)
ds_val = gen_new_data(VAL_DIR, augmented=False)
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, InputLayer
mobilenet_url = "https://tfhub.dev/google/tf2-preview/mobilenet_v2/feature_vector/4"
mobile = Sequential()
mobile.add(InputLayer(input_shape=INP_SHAPE))
mobile.add(hub.KerasLayer(mobilenet_url, trainable=False))
mobile.add(Dense(1, activation="sigmoid"))
mobile.summary()
mobile.compile(optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['acc'])
mobile.fit(ds_train, epochs=3, verbose=1, validation_data=ds_val)
while i < len(data['audience']):
a = data['audience'][i]
if a == '':
data['audience'][i] = ['Anyone']
else:
data['audience'][i] = a.split(';')
i += 1
data = field_first_to_row(data)
titles = []
desc = []
i = 0
while i < len(data):
titles.append(data[i]['title'])
desc.append(data[i]['desc_clean'])
i += 1
module_url = "https://tfhub.dev/google/universal-sentence-encoder/4"
embed = hub.KerasLayer(module_url)
embeddings_desc = embed(desc)
embeddings_titles = embed(titles)
i = 0
while i < len(data):
data[i]['embedding_desc'] = embeddings_desc[i]
data[i]['embedding_title'] = embeddings_titles[i]
i += 1
pickle.dump(data, open("../processed/courses.p", "wb"))
'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
'experts_wiki_books':
'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
'talking-heads_base':
'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
}
tfhub_handle_encoder = map_name_to_handle[bert_model_name]
tfhub_handle_preprocess = map_model_to_preprocess[bert_model_name]
print(f'BERT model selected : {tfhub_handle_encoder}')
print(f'Preprocess model auto-selected: {tfhub_handle_preprocess}')
# 전처리 모델
bert_preprocess_model = hub.KerasLayer(tfhub_handle_preprocess)
text_test = ['this is such an amazing movie!']
text_preprocessed = bert_preprocess_model(text_test)
print(f'Keys : {list(text_preprocessed.keys())}')
print(f'Shape : {text_preprocessed["input_word_ids"].shape}')
print(f'Word Ids : {text_preprocessed["input_word_ids"][0, :12]}')
print(f'Input Mask : {text_preprocessed["input_mask"][0, :12]}')
print(f'Type Ids : {text_preprocessed["input_type_ids"][0, :12]}')
# bert 모델 사용
bert_model = hub.KerasLayer(tfhub_handle_encoder)
bert_results = bert_model(text_preprocessed)
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Conv2D(filters=32, kernel_size=(4, 4), input_shape=(128, 128, 3),activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Conv2D(filters=16, kernel_size=(3, 3), input_shape=(128, 128, 3), activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dense(128, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(16, activation='relu'))
model.add(Dense(2, activation='softmax'))
'''
model = tf.keras.Sequential([
hub.KerasLayer(
"https://tfhub.dev/google/tf2-preview/mobilenet_v2/feature_vector/4",
output_shape=[1280],
trainable=False), # Can be True, see below.
tf.keras.layers.Dense(2, activation='softmax')
])
model.build([4, 224, 224, 3])
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
# see the summary of the model structure
print(model.summary())
# adding early stop
from tensorflow.keras.callbacks import EarlyStopping
