class TestLogin:
# 2.定义初始化方法
def setup_class(self):
# 获取自媒体端的浏览器驱动对象并且赋给driver的实例属性
self.driver = DriverUtils.get_mp_driver()
# 创建业务层对象
self.login_proxy = LoginPorxy()
# 3.定义销毁方法
def teardown_class(self):
time.sleep(2)
# 关闭浏览器
DriverUtils.quit_mp_driver()
# 4.定义测试方法
@parameterized.expand(build_data())
def test_login(self, mobile, code):
# 5.定义测试数据
# mobile = "13911111111"
# code = "246810"
# 6.调用业务方法
logging.info("{}用户开始执行登陆".format(mobile))
self.login_proxy.test_login(mobile, code)
# 7.执行断言结果
logging.info("开始执行mp端登陆结果断言")
is_suc = element_is_exist(driver=self.driver, text="江苏传智播客教育科技")
assert is_suc
def train(STEP_SIZE_DISCRIMINATOR, STEP_SIZE_G_D, BATCH_SIZE, TOTAL_ITERATIONS,
NOISE_SIZE, D_UPDATES_PER_G_UPDATE, run):
X_Y_train, X_train = utils.build_data()
discriminator_network = discriminator.discriminator_class(
STATE_SHAPE, STEP_SIZE_DISCRIMINATOR)
generator_network = generator.generator_class(STATE_SHAPE, NOISE_SIZE)
g_d_network = g_d.g_d_network(generator_network, discriminator_network,
STEP_SIZE_G_D)
for iteration_number in range(TOTAL_ITERATIONS):
print("iteration #:", iteration_number)
#update discriminator "D_UPDATES_PER_G_UPDATE" times
for count in range(D_UPDATES_PER_G_UPDATE):
discriminator_loss, fake_X_Y, real_X_Y = discriminator_network.update(
NOISE_SIZE, BATCH_SIZE, X_train, X_Y_train, generator_network)
#update generator once
g_d_loss = g_d_network.update(NOISE_SIZE, BATCH_SIZE, X_train,
discriminator_network)
#save sampled fake and real images
utils.save_image(iteration_number, fake_X_Y, "fake",
"gan-output-" + str(run))
utils.save_image(iteration_number, real_X_Y, "real",
"gan-output-" + str(run))
def train(STEP_SIZE_CRITIC, STEP_SIZE_G_C, BATCH_SIZE, TOTAL_ITERATIONS,
NOISE_SIZE, C_UPDATES_PER_G_UPDATE, CLIP_THRESHOLD, run):
X_Y_train, X_train = utils.build_data()
critic_network = critic.critic_class(STATE_SHAPE, STEP_SIZE_CRITIC,
CLIP_THRESHOLD)
generator_network = generator.generator_class(STATE_SHAPE, NOISE_SIZE)
g_c_network = g_c.g_c_network(generator_network, critic_network,
STEP_SIZE_G_C)
for iteration_number in range(TOTAL_ITERATIONS):
print("iteration #:", iteration_number)
#update critic "C_UPDATES_PER_G_UPDATE" times
for count in range(C_UPDATES_PER_G_UPDATE):
critic_loss, fake_X_Y, real_X_Y = critic_network.update(
NOISE_SIZE, BATCH_SIZE, X_train, X_Y_train, generator_network)
#update generator once
g_c_loss = g_c_network.update(NOISE_SIZE, BATCH_SIZE, X_train,
critic_network)
#save sampled fake and real images
utils.save_image(iteration_number, fake_X_Y, "fake",
"wgan-output-" + str(run))
def main(run_id, data_path, score_as_pyfunc, score_as_tensorflow_lite):
print("Options:")
for k, v in locals().items():
print(f" {k}: {v}")
utils.dump(run_id)
data, _, _, _ = utils.build_data(data_path)
model_uri = f"runs:/{run_id}/keras-hd5-model"
predict_keras(model_uri, data)
if score_as_pyfunc:
predict_pyfunc(model_uri, data, "keras-hd5-model")
model_name = "tensorflow-model"
if artifact_exists(run_id, model_name):
predict_tensorflow_model(run_id, data)
else:
print(f"No model: {model_name}")
if score_as_tensorflow_lite:
model_name = "tensorflow-lite-model"
if artifact_exists(run_id, model_name):
predict_tensorflow_lite_model(run_id, data)
else:
print(f"No model: {model_name}")
model_name = "onnx-model"
if artifact_exists(run_id, model_name):
model_uri = f"runs:/{run_id}/{model_name}"
predict_onnx(model_uri, data)
predict_pyfunc(model_uri, data, "onnx-model")
else:
print(f"No model: {model_name}")
def build_and_train_model(n=1000, epochs=70, step_size=0.01):
print('\nGenerating training, validation and test sets of size {} each.'.format(n))
x_train, y_train = build_data(n)
x_validation, y_validation = build_data(n)
x_test, y_test = build_data(n)
print('Building the model\n')
model = build_model()
model.summary()
print('\nTraining the model on {} epochs'.format(epochs))
t = time()
model.fit(x_train, y_train, x_validation, y_validation, epochs=epochs, step_size=step_size)
t = int(time()- t)
print('\nTraining time : {0:0.0f} seconds ({1:0.3f} seconds per epoch)'.format(t, t/epochs))
print('\nTesting the trained model :')
te_predictions, te_loss = model.predict(x_test, y_test)
te_accuracy = (te_predictions == y_test).sum() / y_test.shape[1] / te_predictions.shape[0]
print('Test loss : {}'.format(te_loss.mean()))
print('Test accuracy : {}'.format(te_accuracy))
class TestMisLogin:
def setup_class(self):
self.driver = DriverUtils.get_mis_driver()
self.mis_login_proxy = MisLoginProxy()
@pytest.mark.parametrize(
("mis_username", "mis_password", "text"),
build_data(
r"F:\黑马\黑马就业班\UI自动化测试\课堂练习\day11\HM_TT_UI_TEST\data\mis_data\mis_login_data.json"
))
def test_mix_login(self, mis_username, mis_password, text):
self.mis_login_proxy.mis_login(mis_username, mis_password)
assert is_element_exist(self.driver, text)
def train(epochs, batch_size, autolog, log_as_onnx):
print("autolog:", autolog)
x_train, y_train, x_test, y_test = utils.build_data()
model = build_model()
print("model:", type(model))
model.compile(optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy'])
model.summary()
model.fit(x_train,
y_train,
epochs=epochs,
batch_size=batch_size,
verbose=0)
test_loss, test_acc = model.evaluate(x_test, y_test)
print("test_acc:", test_acc)
print("test_loss:", test_loss)
if not autolog:
mlflow.log_param("epochs", epochs)
mlflow.log_param("batch_size", batch_size)
mlflow.log_metric("test_acc", test_acc)
mlflow.log_metric("test_loss", test_loss)
mlflow.keras.log_model(model, "keras-model")
#mlflow.tensorflow.log_model(model, "tensorflow-model")
# write model as yaml file
with open("model.yaml", "w") as f:
f.write(model.to_yaml())
mlflow.log_artifact("model.yaml")
# write model summary
summary = []
model.summary(print_fn=summary.append)
summary = '\n'.join(summary)
with open("model_summary.txt", "w") as f:
f.write(summary)
mlflow.log_artifact("model_summary.txt")
# MLflow - log onnx model
if log_as_onnx:
import onnx_utils
onnx_utils.log_model(model, "onnx-model")
predictions = model.predict_classes(x_test)
print("predictions:", predictions)
def PLA_3_times_with_30_data(m, b, num, times):
# build 2D data
x, y = build_data(m, b, num)
#initial weight w = (0, 0, 0)
w = np.zeros([1, 3])
# count the iteration total numbers
iteration_count = 0
# initial the figure
plt_fig = plt_proc(x, num, title="HW1-1: PLA with 30 2D data samples")
# plot the sample line equation
plt_fig.add_line(w=None,
m=m,
b=b,
num=num,
iteration=None,
label=f"Benchmark",
txt="")
for i in range(times):
# run PLA algorithm
w_result, iteration = PLA(x, y, w, num)
# verify the line equation
verification(x, y, w_result, num, iteration, show=True)
# count the total number of iterations
iteration_count += iteration
# plot the line equation
plt_fig.add_line(w=w_result,
m=None,
b=None,
num=num,
iteration=iteration,
label=f"{i}",
txt=f", iteration = {iteration}")
print(f"Avg. Iteration = {iteration_count/3:.3f}")
# save and show the figure
plt_fig.save_and_show(itr_avg=iteration_count / 3,
filename='hw1-1.png',
avg_show=True)
def train(run, model_name, epochs, batch_size, mlflow_custom_log, log_as_onnx):
x_train, y_train, x_test, y_test = utils.build_data()
model = build_model()
model.compile(
optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy'])
model.summary()
model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size, verbose=0)
test_loss, test_acc = model.evaluate(x_test, y_test)
print("test_acc:", test_acc)
print("test_loss:", test_loss)
if mlflow_custom_log:
mlflow.log_param("epochs", epochs)
mlflow.log_param("batch_size", batch_size)
mlflow.log_metric("test_acc", test_acc)
mlflow.log_metric("test_loss", test_loss)
mlflow.keras.log_model(model, "keras-model", registered_model_name=model_name)
# write model summary
summary = []
model.summary(print_fn=summary.append)
summary = '\n'.join(summary)
with open("model_summary.txt", "w") as f:
f.write(summary)
mlflow.log_artifact("model_summary.txt")
else:
utils.register_model(run, model_name)
# write model as yaml file
with open("model.yaml", "w") as f:
f.write(model.to_yaml())
mlflow.log_artifact("model.yaml")
# MLflow - log onnx model
if log_as_onnx:
import onnx_utils
mname = f"{model_name}_onnx" if model_name else None
onnx_utils.log_model(model, "onnx-model", mname)
predictions = model.predict_classes(x_test)
print("predictions:", predictions)
class TestMp:
def setup_class(self):
self.driver = DriverUtils.get_mp_driver()
self.login_proxy = LoginProxy()
def teardown_class(self):
DriverUtils.quit_mp_driver()
#设置用例级别
@allure.severity(allure.severity_level.BLOCKER)
@pytest.mark.parametrize(
("username", "code", "text"),
build_data(
r"F:\黑马\黑马就业班\UI自动化测试\课堂练习\day11\HM_TT_UI_TEST\data\mp_data\mp_login_data.json"
))
def test_login(self, username, code, text):
self.login_proxy.login(username, code)
assert is_element_exist(self.driver, text)
class TestLogin(unittest.TestCase):
# 类级别的初始化的fixture
# a.打开浏览器并且打开测试网址
@classmethod
def setUpClass(cls):
# 创建的浏览器驱动对象
cls.driver = DriverUtils.get_driver()
# 创建首页业务层对象
cls.home_proxy = HomeProxy()
# 创建登陆业务层对象
cls.login_proxy = LoginProxy()
# 类级别的销毁的fixture
# e.关闭浏览器
@classmethod
def tearDownClass(cls):
DriverUtils.quit_driver()
# 方法级别的初始化fixture
# 每个方法在运行之前都会回到首页
def setUp(self):
time.sleep(2)
self.driver.get("http://localhost/")
# 3.定义测试方法
@parameterized.expand(build_data("../data/test_login_data.json"))
def test_login(self, username, password, code, expect, is_suc):
print("username={}, password={}, code={}, expect={}, is_suc={}".format(
username, password, code, expect, is_suc))
# b.在tpshop首页点击登陆的超链接
logging.info("----------------------->开始跳转登陆页面")
self.home_proxy.to_login_page()
# c.执行登陆操作
logging.info("----------------------->开始执行登陆操作")
self.login_proxy.test_login(username, password, code)
# 如果是反向的测试用例，获取是弹出提示信息
if is_suc:
# 如果是正向的测试用，获取是的页面的标题
time.sleep(3)
msg = self.driver.title
self.assertIn(expect, msg)
else:
msg = get_msg()
self.assertIn(expect, msg)
class TestPubAritcal:
# 2.定义初始化方法
def setup_class(self):
self.driver = DriverUtils.get_mp_driver()
#登陆
self.login = LoginProxy()
self.login.test_login("13911111111", "246810")
self.home_proxy = HomeProxy()
self.pub_ari_proxy = PubAriProxy()
# 3.定义测试方法
@pytest.mark.parametrize(
"ar_cont,ch_name",
build_data(
"C:\\Users\Administrator\Desktop\测试资料\项目实战\\autoToutiaoTest\data\\test_pub_artical_data.json"
))
def test_pub_artical(self, ar_cont, ch_name):
# 定义测试数据
ari_title = PUB_ARTICAL_TITLE
ari_content = ar_cont
option_name = ch_name
logging.info("发布文章信息为文章标题={},文章内容={},文章频道={}".format(
ari_title, ar_cont, ch_name))
# 调用业务层方法
logging.info("----->调用首页进入发布文章的业务方法")
self.home_proxy.to_pub_ar_pg()
logging.info("----->调用发布文章页面发布文章的业务方法")
self.pub_ari_proxy.test_pub_aritcal(ari_title, ari_content,
option_name)
# 执行断言
assert is_exists_element(self.driver, "新增文章成功")
# 4.定义销毁方法
def teardown_class(self):
time.sleep(2)
DriverUtils.quit_mp_driver()
class TestIHRMLogin(unittest.TestCase):
# 初始化
def setUp(self):
self.login_api = TestLoginApi()
def tearDown(self):
...
filename = app.BASE_DIR + "/data/login_data.json"
@parameterized.expand(build_data(filename))
# 编写第一个案例，测试登录成功
def test_login(self, name, jsonData, http_code, success, code, message):
# IHRM项目可以直接发送登录请求
headers = {"Content-Type": "application/json"} # 定义请求头
# 发送登录请求
response = self.login_api.login(jsonData, headers)
# 打印登录的结果
result = response.json()
logging.info("登录的结果为:{}".format(result))
# # 断言登录的结果
assert_common(http_code, success, code, message, response, self)
def main(args):
# fix random seed
random.seed(args.seed)
os.environ['PYTHONHASHSEED'] = str(args.seed)
np.random.seed(args.seed)
torch.manual_seed(args.seed)
torch.cuda.manual_seed(args.seed)
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
assert args.source not in args.target, 'Source domain can not be one of the target domains'
# create train configurations
config = utils.build_config(args)
# prepare data
dsets, dset_loaders = utils.build_data(config)
# set base network
net_config = config['encoder']
base_network = net_config["name"](**net_config["params"])
base_network = base_network.to(DEVICE)
print(base_network)
# set GNN classifier
classifier_gnn = graph_net.ClassifierGNN(in_features=base_network.bottleneck.out_features,
edge_features=config['edge_features'],
nclasses=base_network.fc.out_features,
device=DEVICE)
classifier_gnn = classifier_gnn.to(DEVICE)
print(classifier_gnn)
# train on source domain and compute domain inheritability
log_str = '==> Step 1: Pre-training on the source dataset ...'
utils.write_logs(config, log_str)
base_network, classifier_gnn = trainer.train_source(config, base_network, classifier_gnn, dset_loaders)
log_str = '==> Finished pre-training on source!\n'
utils.write_logs(config, log_str)
log_str = '==> Step 2: Curriculum learning ...'
utils.write_logs(config, log_str)
######## Stage 1: find the closest target domain ##########
temp_test_loaders = dict(dset_loaders['target_test'])
max_inherit_domain = trainer.select_closest_domain(config, base_network, classifier_gnn, temp_test_loaders)
# iterate over all domains
for _ in range(len(config['data']['target']['name'])):
log_str = '==> Starting the adaptation on {} ...'.format(max_inherit_domain)
utils.write_logs(config, log_str)
######## Stage 2: adapt to the chosen target domain having the maximum inheritance/similarity ##########
base_network, classifier_gnn = trainer.adapt_target(config, base_network, classifier_gnn,
dset_loaders, max_inherit_domain)
log_str = '==> Finishing the adaptation on {}!\n'.format(max_inherit_domain)
utils.write_logs(config, log_str)
######### Stage 3: obtain the target pseudo labels and upgrade source domain ##########
trainer.upgrade_source_domain(config, max_inherit_domain, dsets,
dset_loaders, base_network, classifier_gnn)
######### Sage 1: recompute target domain inheritability/similarity ###########
# remove already considered domain
del temp_test_loaders[max_inherit_domain]
# find the maximum inheritability/similarity domain
if len(temp_test_loaders.keys()) > 0:
max_inherit_domain = trainer.select_closest_domain(config, base_network,
classifier_gnn, temp_test_loaders)
######### Step 3: fine-tuning stage ###########
log_str = '==> Step 3: Fine-tuning on pseudo-source dataset ...'
utils.write_logs(config, log_str)
config['source_iters'] = config['finetune_iters']
base_network, classifier_gnn = trainer.train_source(config, base_network, classifier_gnn, dset_loaders)
log_str = 'Finished training and evaluation!'
utils.write_logs(config, log_str)
# save models
if args.save_models:
torch.save(base_network.cpu().state_dict(), os.path.join(config['output_path'], 'base_network.pth.tar'))
torch.save(classifier_gnn.cpu().state_dict(), os.path.join(config['output_path'], 'classifier_gnn.pth.tar'))
from argparse import ArgumentParser
import mlflow
import mlflow.onnx
import utils
import onnx_utils
print("MLflow Version:", mlflow.__version__)
print("Tracking URI:", mlflow.tracking.get_tracking_uri())
if __name__ == "__main__":
parser = ArgumentParser()
parser.add_argument("--model_uri", dest="model_uri", help="model_uri", default="../../data/train/wine-quality-white.csv")
args = parser.parse_args()
print("Arguments:")
for arg in vars(args):
print(f" {arg}: {getattr(args, arg)}")
_,_,data,_ = utils.build_data()
model = mlflow.onnx.load_model(args.model_uri)
print("model.type:", type(model))
predictions = onnx_utils.score_model(model, data)
print("predictions.type:",type(predictions))
print("predictions.shape:",predictions.shape)
print("predictions:",predictions)
if __name__ == "__main__":
parser = ArgumentParser()
parser.add_argument("--model_uri",
dest="model_uri",
help="model_uri",
required=True)
parser.add_argument("--data_path",
dest="data_path",
help="data_path",
default="../../data/wine-quality-white.csv")
args = parser.parse_args()
print("Arguments:")
for arg in vars(args):
print(f" {arg}: {getattr(args, arg)}")
X, y = utils.build_data(args.data_path)
print("\n=== mlflow.catboost.load_model")
model = mlflow.sklearn.load_model(args.model_uri)
print("model:", type(model))
predictions = model.predict(X)
print("predictions.type:", type(predictions))
print("predictions.shape:", predictions.shape)
print("predictions:", predictions)
print("\n=== mlflow.pyfunc.load_model")
model = mlflow.pyfunc.load_model(args.model_uri)
print("model:", type(model))
predictions = model.predict(X)
print("predictions.type:", type(predictions))
print("predictions.shape:", predictions.shape)
def main(args):
# fix random seed
random.seed(args.seed)
os.environ['PYTHONHASHSEED'] = str(args.seed)
np.random.seed(args.seed)
torch.manual_seed(args.seed)
torch.cuda.manual_seed(args.seed)
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
# create train configurations
args.use_cgct_mask = True # used in CGCT for pseudo label mask in target datasets
config = utils.build_config(args)
# prepare data
dsets, dset_loaders = utils.build_data(config)
# set base network
net_config = config['encoder']
base_network = net_config["name"](**net_config["params"])
base_network = base_network.to(DEVICE)
print(base_network)
# set GNN classifier
classifier_gnn = graph_net.ClassifierGNN(
in_features=base_network.bottleneck.out_features,
edge_features=config['edge_features'],
nclasses=base_network.fc.out_features,
device=DEVICE)
classifier_gnn = classifier_gnn.to(DEVICE)
print(classifier_gnn)
# train on source domain
log_str = '==> Step 1: Pre-training on the source dataset ...'
utils.write_logs(config, log_str)
base_network, classifier_gnn = trainer.train_source(
config, base_network, classifier_gnn, dset_loaders)
log_str = '==> Finished pre-training on source!\n'
utils.write_logs(config, log_str)
# create random layer and adversarial network
class_num = config['encoder']['params']['class_num']
random_layer = networks.RandomLayer([base_network.output_num(), class_num],
config['random_dim'], DEVICE)
adv_net = networks.AdversarialNetwork(config['random_dim'],
config['random_dim'],
config['ndomains'])
random_layer = random_layer.to(DEVICE)
adv_net = adv_net.to(DEVICE)
print(random_layer)
print(adv_net)
# run adaptation episodes
log_str = '==> Starting the adaptation'
utils.write_logs(config, log_str)
for curri_iter in range(len(config['data']['target']['name'])):
######## Step 1: train one adaptation episod on combined target domains ##########
target_train_datasets = preprocess.ConcatDataset(
dsets['target_train'].values())
dset_loaders['target_train'] = DataLoader(
dataset=target_train_datasets,
batch_size=config['data']['target']['batch_size'],
shuffle=True,
num_workers=config['num_workers'],
drop_last=True)
base_network, classifier_gnn = trainer.adapt_target_cgct(
config, base_network, classifier_gnn, dset_loaders, random_layer,
adv_net)
log_str = '==> Finishing {} adaptation episode!\n'.format(curri_iter)
utils.write_logs(config, log_str)
######### Step 2: obtain the target pseudo labels and upgrade target domains ##########
trainer.upgrade_target_domains(config, dsets, dset_loaders,
base_network, classifier_gnn,
curri_iter)
######### Step 3: fine-tuning stage ###########
log_str = '==> Step 3: Fine-tuning on pseudo-source dataset ...'
utils.write_logs(config, log_str)
config['source_iters'] = config['finetune_iters']
base_network, classifier_gnn = trainer.train_source(
config, base_network, classifier_gnn, dset_loaders)
log_str = 'Finished training and evaluation!'
utils.write_logs(config, log_str)
# save models
if args.save_models:
torch.save(base_network.cpu().state_dict(),
os.path.join(config['output_path'], 'base_network.pth.tar'))
torch.save(
classifier_gnn.cpu().state_dict(),
os.path.join(config['output_path'], 'classifier_gnn.pth.tar'))
# 导包
# =============================================================================
# split train and test
# =============================================================================
# Train/Test per doc
corpus_train, corpus_test = corpus_split(corpus, split=SPLIT)
# =============================================================================
# Build Tensor Data
# =============================================================================
# Create tensor data from corpus
print('\n---\nBuild Tensor data')
# Train datasets
print('\nBuild Train data:')
train_x, train_y = build_data(corpus_train,
char_to_n,
max_seq=MAX_SEQ,
stride=STRIDE)
if len(corpus_test):
print('\nBuild Test data:')
test_x, test_y = build_data(corpus_test,
char_to_n,
max_seq=MAX_SEQ,
stride=STRIDE)
else:
test_x, test_y = None, None
# =============================================================================
# Save proccess data
# =============================================================================
#For reproducibility
torch.set_grad_enabled(False)
torch.manual_seed(0)
np.random.seed(0)
rounds = 10
input_units = 2
hidden_units = 25
output_units = 2
epochs = 50
mini_batch_size = 5
X_train, y_train = build_data(1000) #(1000,2)
X_test, y_test = build_data(1000) #(1000,2)
print(
'Start training with parameters : {0} rounds, {1} epochs and {2} batch size'
.format(rounds, epochs, mini_batch_size))
result_rounds = [] #training_losses, training_acc, test_losses, test_acc
time1 = time.perf_counter()
for i in range(rounds):
print("Training round {0} : ".format(i + 1))
model = Sequential(Linear(input_units, hidden_units), ReLU(),
Linear(hidden_units, hidden_units), ReLU(),
Linear(hidden_units, hidden_units), ReLU(),
from utils import build_data, vectorization
from model import build_model
from keras.callbacks import ModelCheckpoint
import io
import os
if __name__ == "__main__":
text = io.open('Model_data/shakespear.txt',
encoding='utf-8').read().lower()
Tx = 40
chars = sorted(list(set(text)))
char_indices = dict((c, i) for i, c in enumerate(chars))
indices_char = dict((i, c) for i, c in enumerate(chars))
print("Creating training set...")
X, Y = build_data(text, Tx, stride=1)
print("Vectorizing training set...")
x, y = vectorization(X, Y, n_x=len(chars), char_indices=char_indices)
model = build_model(x, y)
filepath = os.path.join(os.getcwd(), "Model_checkpoints/model.h5")
checkpoint = ModelCheckpoint(filepath,
monitor='loss',
verbose=1,
save_best_only=True,
mode='min')
model.fit(x, y, batch_size=128, epochs=20, callbacks=[checkpoint])
def train(run, model_name, data_path, epochs, batch_size, mlflow_custom_log,
log_as_onnx, log_as_tensorflow_lite, log_as_tensorflow_js):
print("mlflow_custom_log:", mlflow_custom_log)
x_train, _, y_train, _ = utils.build_data(data_path)
ncols = x_train.shape[1]
def baseline_model():
model = Sequential()
model.add(
Dense(ncols,
input_dim=ncols,
kernel_initializer='normal',
activation='relu'))
model.add(Dense(1, kernel_initializer='normal'))
model.compile(loss='mean_squared_error', optimizer='adam')
return model
model = baseline_model()
if mlflow_custom_log:
print("Logging with mlflow.log")
mlflow.log_param("epochs", epochs)
mlflow.log_param("batch_size", batch_size)
mlflow.keras.log_model(model,
"tensorflow-model",
registered_model_name=model_name)
else:
utils.register_model(run, model_name)
# MLflow - log as ONNX model
if log_as_onnx:
import onnx_utils
mname = f"{model_name}_onnx" if model_name else None
onnx_utils.log_model(model, "onnx-model", model_name=mname)
# Save as TensorFlow Lite format
if log_as_tensorflow_lite:
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
path = "model.tflite"
with open(path, "wb") as f:
f.write(tflite_model)
mlflow.log_artifact(path, "tensorflow-lite-model")
# Save as TensorFlow.js format
if log_as_tensorflow_js:
import tensorflowjs as tfjs
path = "model.tfjs"
tfjs.converters.save_keras_model(model, path)
mlflow.log_artifact(path, "tensorflow-js-model")
# Evaluate model
estimator = KerasRegressor(build_fn=baseline_model,
epochs=epochs,
batch_size=batch_size,
verbose=0)
kfold = KFold(n_splits=10)
results = cross_val_score(estimator, x_train, y_train, cv=kfold)
print(
f"Baseline MSE: mean: {round(results.mean(),2)} std: {round(results.std(),2)}"
)
if mlflow_custom_log:
mlflow.log_metric("mse_mean", results.mean())
mlflow.log_metric("mse_std", results.std())
# Score
data = x_train
predictions = model.predict(data)
predictions = pd.DataFrame(data=predictions, columns=["prediction"])
print("predictions.shape:", predictions.shape)
print("predictions:", predictions)
import pandas as pd
import mlflow
import mlflow.pyfunc
import utils
print("MLflow Version:", mlflow.__version__)
print("Tracking URI:", mlflow.tracking.get_tracking_uri())
if __name__ == "__main__":
parser = ArgumentParser()
parser.add_argument("--model_uri",
dest="model_uri",
help="model_uri",
default="../../data/train/wine-quality-white.csv")
args = parser.parse_args()
print("Arguments:")
for arg in vars(args):
print(f" {arg}: {getattr(args, arg)}")
model = mlflow.pyfunc.load_model(args.model_uri)
print("model:", model)
_, _, ndarray, _ = utils.build_data()
data = pd.DataFrame(ndarray)
print("data.shape:", data.shape)
predictions = model.predict(data)
print("predictions.type:", type(predictions))
print("predictions.shape:", predictions.shape)
print("predictions:", predictions)
def pocket_vs_pla(m, b, num, threshold, continuous_threshold):
# build 2D data
x, y = build_data(m, b, num)
#initial weight w = (0, 0, 0)
w = np.zeros([1, 3])
# initial the figure
plt_fig = plt_proc(
x, num, title="HW1-2: Pocket v.s. PLA with 1000 2D data samples")
# plot the sample line equation
plt_fig.add_line(w=None,
m=m,
b=b,
num=num,
iteration=None,
label=f"Benchmark",
txt="")
# set the start time of PLA algorithm
PLA_start = time()
# run PLA algorithm
w_PLA, iteration_PLA = PLA(x, y, w, num)
# get the execution time of PLA
PLA_exe_time = time() - PLA_start
PLA_error_rate = verification(x, y, w_PLA, num, iteration=None, show=False)
# plot the PLA line equation
plt_fig.add_line(
w=w_PLA,
m=None,
b=None,
num=num,
iteration=iteration_PLA,
label=f"PLA",
txt=
f"\n error rate = {PLA_error_rate:.03f}, iteration = {iteration_PLA}, exec. time = {PLA_exe_time:.03f}"
)
# set the start time of PLA algorithm
Pocket_start = time()
# run Pocket algorithm
w_Pocket, iteration_Pocket = Pocket(x, y, w, num, threshold,
continuous_threshold)
# get the execution time of PLA
Pocket_exe_time = time() - Pocket_start
Pocket_error_rate = verification(x,
y,
w_Pocket,
num,
iteration_Pocket,
show=False)
# plot the Pocket line equation
plt_fig.add_line(
w=w_Pocket,
m=None,
b=None,
num=num,
iteration=iteration_Pocket,
label=f"Pocket",
txt=
f"\n error rate = {Pocket_error_rate:.03f}, iteration = {iteration_Pocket}, exec. time = {Pocket_exe_time:.03f}"
)
print(f"PLA execution time = {PLA_exe_time:.5f} seconds")
print(f"PLA Iteration = {iteration_PLA}")
print(f"PLA error rate = {PLA_error_rate}\n")
print(f"Pocket execution time = {Pocket_exe_time:.5f} seconds")
print(f"Pocket Iteration = {iteration_Pocket}")
print(f"Pocket error rate = {Pocket_error_rate:.03f}")
# save and show the figure
plt_fig.save_and_show(itr_avg=None, filename='hw1-2.png', avg_show=False)
def artifact_exists(run_id, path):
return len(client.list_artifacts(run_id, path)) > 0
if __name__ == "__main__":
parser = ArgumentParser()
parser.add_argument("--run_id", dest="run_id", help="run_id", required=True)
parser.add_argument("--data_path", dest="data_path", help="Data path", default="../../data/train/wine-quality-white.csv")
parser.add_argument("--score_as_pyfunc", dest="score_as_pyfunc", help="Score as PyFunc", default=False, action='store_true')
args = parser.parse_args()
print("Arguments:")
for arg in vars(args):
print(f" {arg}: {getattr(args, arg)}")
run_id = args.run_id
utils.dump(run_id)
data,_,_,_ = utils.build_data(args.data_path)
model_uri = f"runs:/{run_id}/keras-hd5-model"
predict_keras(model_uri, data)
if args.score_as_pyfunc:
predict_pyfunc(model_uri, data)
model_name = "onnx-model"
if artifact_exists(run_id, model_name):
model_uri = f"runs:/{run_id}/{model_name}"
predict_onnx(model_uri, data)
predict_pyfunc(model_uri, data)
else:
print(f"No model: {model_name}")
model_name = "tensorflow-model"
