def __init__(self, opt):
"""Initialize the pix2pix class.
Parameters:
opt (Option class)-- stores all the experiment flags; needs to be a subclass of BaseOptions
"""
BaseModel.__init__(self, opt)
# specify the training losses you want to print out. The training/test scripts will call <BaseModel.get_current_losses>
self.loss_names = ['G', 'G_GAN', 'G_L1', 'D_real', 'D_fake']
# specify the images you want to save/display. The training/test scripts will call <BaseModel.get_current_visuals>
# self.visual_names = ['real_A', 'fake_B', 'real_B']
self.visual_names = ['cloth_decoded', 'fakes_scaled', 'textures_unnormalized']
# specify the models you want to save to the disk. The training/test scripts will call <BaseModel.save_networks> and <BaseModel.load_networks>
if self.is_train:
self.model_names = ['G', 'D']
else: # during test time, only load G
self.model_names = ['G']
# define networks (both generator and discriminator)
self.net_G = define_G(opt.cloth_channels + 36, opt.texture_channels, 64, "unet_128", opt.norm, True, opt.init_type, opt.init_gain).to(self.device)
if self.is_train: # define a discriminator; conditional GANs need to take both input and output images; Therefore, #channels for D is input_nc + output_nc
self.net_D = define_D(opt.cloth_channels + 36 + opt.texture_channels, 64, opt.discriminator, opt.n_layers_D, opt.norm, opt.init_type, opt.init_gain).to(self.device)
if self.is_train:
# define loss functions
use_smooth = True if opt.gan_label_mode == "smooth" else False
self.criterionGAN = GANLoss(opt.gan_mode, smooth_labels=use_smooth).to(self.device)
self.criterionL1 = torch.nn.L1Loss()
# initialize optimizers; schedulers will be automatically created by function <BaseModel.setup>.
self.optimizer_G = torch.optim.Adam(self.net_G.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))
self.optimizer_D = torch.optim.Adam(self.net_D.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))
def __init__(self, dim_konf, dim_data, atype, region):
BaseModel.__init__(self, dim_konf, atype, region)
n_hidden = 32
self.features = \
torch.nn.Sequential(
torch.nn.Conv2d(1, n_hidden, kernel_size=(1, self.dim_konf + 4 + 4 + 4 + 2)),
torch.nn.LeakyReLU(),
torch.nn.Conv2d(n_hidden, n_hidden, kernel_size=(1, 1)),
torch.nn.LeakyReLU(),
torch.nn.Conv2d(n_hidden, n_hidden, kernel_size=(1, 1)),
torch.nn.LeakyReLU(),
torch.nn.MaxPool2d(kernel_size=(2, 1)),
torch.nn.Conv2d(n_hidden, n_hidden, kernel_size=(1, 1)),
torch.nn.LeakyReLU(),
torch.nn.MaxPool2d(kernel_size=(2, 1))
)
self.value = \
torch.nn.Sequential(
torch.nn.Linear(self.dim_cnn_features, 32),
torch.nn.ReLU(),
torch.nn.Linear(32, 32),
torch.nn.ReLU(),
torch.nn.Linear(32, 1)
)
def __init__(self, dim_data, atype, region, problem_name):
BaseModel.__init__(self, atype, region, problem_name)
self.konf_net = \
nn.Sequential(
torch.nn.Linear(self.n_konfs*self.dim_konf, self.n_hidden),
nn.ReLU(),
torch.nn.Linear(self.n_hidden, self.n_hidden),
nn.ReLU()
)
self.pose_net = \
nn.Sequential(
torch.nn.Linear(self.dim_pose_ids, self.n_hidden),
nn.ReLU(),
torch.nn.Linear(self.n_hidden, self.n_hidden),
nn.ReLU()
)
dim_actions = dim_data
self.action_net = \
nn.Sequential(
torch.nn.Linear(dim_actions, self.n_hidden),
nn.ReLU(),
torch.nn.Linear(self.n_hidden, self.n_hidden),
nn.ReLU()
)
dim_input = self.n_hidden * 3
self.output = \
nn.Sequential(
torch.nn.Linear(dim_input, self.n_hidden),
nn.ReLU(),
torch.nn.Linear(self.n_hidden, 1)
)
def predsFromModel(_modelName):
# Initialise nominal model
model = Model(len(test[0]), 1)
model.load_model(_modelName)
# Make a vector of outputs
_comp_preds = []
for (batchX, batchY) in next_batch(test, probs_test, batchSize):
if batchY.shape[0] < batchSize:
print('Batch size insufficient (%s), continuing...' %
batchY.shape[0])
continue
output = model.evaluate_total(batchX, debug=False)
_comp_preds.extend(output.T)
# Make a vector of outputs
_comp_preds_bkg = []
for (batchX, batchY) in next_batch(test_bkg, probs_test_bkg, batchSize):
if batchY.shape[0] < batchSize:
print('Batch size insufficient (%s), continuing...' %
batchY.shape[0])
continue
output = model.evaluate_total(batchX, debug=False)
_comp_preds_bkg.extend(output.T)
return _comp_preds, _comp_preds_bkg
def __init__(self, env, save_dirs, learning_rate=0.0001):
BaseModel.__init__(self,
input_shape=env.observation_space.shape,
num_actions=env.action_space.n,
save_dirs=save_dirs)
self.env = env
self.blueprint = {
'conv_layers': 3,
'filters': [32, 64, 64],
'kernel_sizes': [(8, 8), (4, 4), (3, 3)],
'strides': [(4, 4), (2, 2), (1, 1)],
'paddings': ['valid', 'valid', 'valid'],
'activations': ['relu', 'relu', 'relu'],
'dense_units': 512,
'dense_activation': 'relu'
}
self.local_model_save_path = os.path.join(self.save_path,
'local-wts.h5')
self.local_model = NeuralNet(input_shape=self.input_shape,
num_actions=self.num_actions,
learning_rate=learning_rate,
blueprint=self.blueprint).model
def __init__(self):
BaseModel.__init__(self)
self.dictionary = None
self.model = None
self.playlists = []
self.playlist_similarity = defaultdict(list)
self.pids = [] #All playlist id
def draw_model(self, model: models.BaseModel):
"""
Draws model
:param model: models.BaseModel
:return:
"""
model.render(self)
return self
def __init__(self, item):
BaseModel.__init__(self, item)
defs.StoppableThread.__init__(self)
self._scheduler = schedule.Scheduler()
job = self._scheduler.every(self.schedule['interval'])
job.unit = self.schedule['unit']
if len(self.schedule['at']) > 0:
job.at(self.schedule['at'][0])
job.do(self.run_job)
"""
class TestBaseModel(unittest.TestCase):
"""Test for BaseModel class
"""
def setUp(self):
"""sets up objects for testing later
"""
self.test_model1 = BaseModel()
self.test_model2 = BaseModel()
def test_basic_setup(self):
"""test for to_json method of BaseModel class
"""
self.assertTrue(hasattr(self.test_model1, "id"))
self.assertTrue(hasattr(self.test_model1, "__class__"))
self.assertTrue(hasattr(self.test_model1, "created_at"))
self.assertTrue(hasattr(self.test_model1, "updated_at"))
self.assertTrue(self.test_model1.id != self.test_model2.id)
m1c = self.test_model1.created_at
m2c = self.test_model2.created_at
self.assertTrue(m1c != m2c)
def test_types(self):
"""testing attributes to ensure proper typing
"""
self.assertTrue(type(self.test_model1.id) is str)
self.assertTrue(type(self.test_model1.__class__) is type)
m1c = self.test_model1.created_at
m2c = self.test_model2.created_at
m1u = self.test_model1.updated_at
m2u = self.test_model2.updated_at
self.assertTrue(type(m1c) is datetime.datetime)
self.assertTrue(type(m2c) is datetime.datetime)
self.assertTrue(type(m1u) is datetime.datetime)
self.assertTrue(type(m2u) is datetime.datetime)
def test_save(self):
"""testing whether save updates the updated_at attribute
"""
m1u = self.test_model1.updated_at
self.test_model1.save()
m1u_saved = self.test_model1.updated_at
self.assertFalse(m1u == m1u_saved)
def test_to_json(self):
"""tests to_json method with diffs in output & in-memory objects
"""
testmodelid = self.test_model1.id
jsondict = self.test_model1.to_json()
self.assertNotEqual(jsondict, self.test_model1.__dict__)
self.assertEqual(jsondict["id"], self.test_model1.__dict__["id"])
self.assertNotEqual(jsondict["created_at"],
self.test_model1.__dict__["created_at"])
self.assertNotEqual(type(jsondict["created_at"]),
type(self.test_model1.__dict__["created_at"]))
def states_get(state_id=None):
'''
Returns a list of all states, or specific state based on id
'''
list_of_dicts = []
for k, v in storage.all('State').items():
if state_id == BaseModel.to_dict(v)['id']:
return jsonify(BaseModel.to_dict(v))
list_of_dicts.append(BaseModel.to_dict(v))
if state_id:
abort(404)
return jsonify(list_of_dicts)
def cities_get(city_id=None):
'''
Returns a list of all cities, or specific city based on id
'''
list_of_dicts = []
for k, v in storage.all('City').items():
if city_id == BaseModel.to_dict(v)['id']:
return jsonify(BaseModel.to_dict(v))
list_of_dicts.append(BaseModel.to_dict(v))
if city_id:
abort(404)
return jsonify(list_of_dicts)
def modify_commandline_options(parser, is_train):
BaseModel.modify_commandline_options(parser, is_train)
parser.add_argument("--spatial_code_ch", default=8, type=int)
parser.add_argument("--global_code_ch", default=2048, type=int)
parser.add_argument("--lambda_R1", default=10.0, type=float)
parser.add_argument("--lambda_patch_R1", default=1.0, type=float)
parser.add_argument("--lambda_L1", default=1.0, type=float)
parser.add_argument("--lambda_GAN", default=1.0, type=float)
parser.add_argument("--lambda_PatchGAN", default=1.0, type=float)
parser.add_argument("--patch_min_scale", default=1 / 8, type=float)
parser.add_argument("--patch_max_scale", default=1 / 4, type=float)
parser.add_argument("--patch_num_crops", default=8, type=int)
parser.add_argument("--patch_use_aggregation",
type=util.str2bool, default=True)
return parser
def tp_xception_multi_period_score_fusion(dataset, config):
result = []
for i in range(iteration):
pre_list = []
y_test_list = []
for period in ['R1', 'R3', 'R4', 'R5', 'R6']:
model = BaseModel.Combined_Model(parallels=4, config=config)
model.load_weights('./{}_pdm_iteration-{}-{}.hdf5'.format(
dataset, i, period))
x_list = np.loadtxt('{}-{}_file_list.txt'.format(dataset, period))
img_x_list, shape_x, texture_x, vein_x, y_list = utils.data_loader_for_combined_model(
file_list=x_list,
dataset=dataset,
config=config,
isVenation=True)
img_x = np.array(img_x_list)
y = np.array(y_list)
id_map = np.loadtxt(dataset + '_id.txt')
for index, d in enumerate(y):
for label in id_map:
if d == label[0]:
y[index] = label[1]
y_one_hot = to_categorical(y)
test_index = np.load(
'{}_iteration_{}_img_{}_tp_xception_test_index.npy'.format(
dataset, i, period))
img_x_test = img_x[test_index]
shape_x_test = shape_x[test_index]
texture_x_test = texture_x[test_index]
vein_x_test = vein_x[test_index]
y_test = y_one_hot[test_index]
y_test_list.append(y_test)
x_test_list = create_input_list(shape_x_test,
texture_x_test,
vein_x_test,
img_x_test,
config,
isVenation=True)
pre = model.predict(x_test_list)
pre_list.append(pre)
pre_final_arr = np.array(pre_list)
pre_final = np.sum(pre_final_arr, axis=2)
pre_final_label = [np.argmax(d) for d in pre_final]
for i in range(1, len(y_test_list) + 1):
if y_test_list[i - 1] != y_test_list[i]:
print("The test label of different period should be the same")
return -1
y_test_label = [np.argmax(d) for d in y_test_list[0]]
performance = get_performance(pre_final_label, y_test_label)
result.append(performance)
plot_result(result)
def val(val_dataset: 'Single task_dataset',
model: BaseModel,
task_index,
visualizer=None) -> Tuple[MatrixItem, List]:
"""for validation on one task"""
logging.info(f"Validating task {task_index}")
start_time = time.time() # timer for validate a task
matrixItems = []
for i, data in enumerate(val_dataset): # inner loop within one epoch
model.set_data(PseudoData(opt, Bunch(**data["data"])))
model.test(visualizer)
# Add matrixItem result
matrixItems.append(model.get_matrix_item(task_index))
res = my_sum(matrixItems)
res = res / len(matrixItems)
logging.info(f"Validation Time Taken: {time.time() - start_time} sec")
return res, matrixItems
def cities_delete(city_id=None):
'''
Deletes a city object
Not accounting for DELETE request with no city_id
'''
for k, v in storage.all('City').items():
if city_id == BaseModel.to_dict(v)['id']:
storage.delete(v)
storage.save()
return jsonify({}), 200
abort(404)
def states_delete(state_id=None):
'''
Deletes a state object
Not accounting for DELETE request with no state_id
'''
for k, v in storage.all('State').items():
if state_id == BaseModel.to_dict(v)['id']:
storage.delete(v)
storage.save()
return jsonify({}), 200
abort(404)
class User(BaseModel):
# 自定义表名（如果不指定表名，默认为model类名的小写（user））
__tablename__ = 'users'
username = db.Column(db.String(120),
unique=True,
nullable=False,
doc="用户名",
comment="用户名")
password = db.Column(db.String(120),
nullable=False,
doc="密码",
comment="密码")
role = db.Column(db.Integer,
default=0,
doc="角色",
comment="角色, 0表示普通用户，1 表示admin")
email = db.Column(db.String(20), doc="邮箱", comment="邮箱")
address = db.Column(db.String(250), doc="地址", comment="地址")
phone = db.Column(db.String(20), doc="手机号", comment="手机号")
gender = db.Column(db.Integer, doc="性别", comment="性别, 0表示女性，1 表示男性")
tech = db.Column(db.String(250), doc="擅长领域", comment="擅长领域")
api = db.relationship("ApiModel", backref='api', lazy=True)
# 需要隐藏的字段
_hidden_fields = ["password"] + BaseModel.default_hidden_fields()
@staticmethod
def hash_password(password):
return pwd_context.encrypt(password)
def verify_password(self, password):
return pwd_context.verify(password, self.password)
def generate_auth_token(self, expiration=600):
s = Serializer(run_config.SECRET_KEY, expires_in=expiration)
return s.dumps({'id': self.id})
@staticmethod
def verify_auth_token(token):
s = Serializer(run_config.SECRET_KEY)
try:
data = s.loads(token)
except SignatureExpired:
return None # valid token, but expired
except BadSignature:
return None # invalid token
user = User.query.get(data['id'])
return user
def val(val_dataset: 'Single task_dataset',
model: BaseModel,
task_index,
visualizer=None) -> Tuple[MatrixItem, List]:
"""for validation on one task"""
logging.info(f"Validating task {task_index}")
start_time = time.time() # timer for validate a task
matrixItems = []
for i, data in enumerate(val_dataset): # inner loop within one epoch
image, target = data
# logging.debug(f'{image.shape},{target}')
image = image.to(opt.device, non_blocking=True)
target = target.to(opt.device, non_blocking=True)
model.set_data(PseudoData(opt, image, target))
model.test(visualizer)
# Add matrixItem result
matrixItems.append(model.get_matrix_item(task_index))
res = my_sum(matrixItems)
res = res / len(matrixItems)
logging.info(f"Validation Time Taken: {time.time() - start_time} sec")
return res, matrixItems
def analyze_trajectory(model, hold=0, log='y'):
if isinstance(model, basestring):
from models import BaseModel
m = BaseModel.load(model, initialize=False)
else:
m = model
from datatools import plot, plt
for var in m.results:
plt.figure()
res = m.results[var].matrix
plot(np.array([res[t].ravel() for t in range(res.shape[0])]),
hold=1,
xs=m.results[var].index,
log=log,
title=var)
if not hold:
plt.show()
def test(opt,
test_datasets,
model: BaseModel,
train_index,
task_index,
visualizer=None):
"""test the model on multi-task test_datasets, after training task indexed with <train_index>
Return
None
the global testMatrix will be updated
"""
print(
f'=============================After trained task {train_index - 1}========================================='
)
matrixItems = []
for test_index, test_dataset in enumerate(test_datasets):
matrixItem, _ = val(
test_dataset,
model,
test_index,
visualizer,
)
test_matrix[(train_index, test_index + 1)] = matrixItem
if test_index <= task_index:
matrixItems.append(model.get_matrix_item(task_index))
print(f'Test in task {test_index}, matrixItem=({matrixItem})')
if len(matrixItems):
res = my_sum(matrixItems)
res = res / len(matrixItems)
print(f'Average Accuracy is ({res})')
train_index += 1
return train_index
def xception_model_training_and_test(img_x_list, y_list, config):
x = np.array(img_x_list)
y = np.array(y_list)
dataset = config['dataset']
if dataset == 'soybean':
period = config['period']
else:
period = dataset
id_map = np.loadtxt(dataset + '_id.txt')
for index, d in enumerate(y):
for label in id_map:
if d == label[0]:
y[index] = label[1]
y_one_hot = to_categorical(y)
lr_adjust = ReduceLROnPlateau(monitor='val_loss',
factor=0.5,
patience=5,
min_lr=1e-6)
result = []
for i in range(iteration):
index = np.arange(len(y))
# print(index)
X_train_index, X_test_index, y_train_index, y_test_index = train_test_split(
index, y, test_size=0.3, random_state=i, shuffle=True, stratify=y)
print(len(X_train_index))
print(len(X_test_index))
np.save(
'{}_iteration_{}_img_{}_xception_train_index.npy'.format(
dataset, i, period), X_train_index)
np.save(
'{}_iteration_{}_img_{}_xception_test_index.npy'.format(
dataset, i, period), X_test_index)
X_train = x[X_train_index]
X_test = x[X_test_index]
y_train = y_one_hot[X_train_index]
y_test = y_one_hot[X_test_index]
save_best_weight = ModelCheckpoint(
'xception_img_{}_itreation-{}-{}.hdf5'.format(dataset, i, period),
monitor='val_loss',
verbose=1,
save_best_only=True,
mode='auto',
save_weights_only=True)
# you can change the parallels to create multi_gpu_model if you have more than one GPU available
model = BaseModel.Xception_Model(parallels=1, config=config)
# you should set a smaller batch_size if you GPU memory is limited
model.fit(X_train,
y_train,
batch_size=32,
epochs=100,
validation_split=0.1,
callbacks=[lr_adjust, save_best_weight])
K.clear_session()
model2 = BaseModel.Xception_Model(parallels=1, config=config)
model2.load_weights('xception_img_{}_itreation-{}-{}.hdf5'.format(
dataset, i, period))
score = model2.evaluate(X_test, y_test)
print(score)
pre_final = model2.predict(X_test, batch_size=128)
y_test_label = np.array([np.argmax(d) for d in y_test])
y_pre_label = np.array([np.argmax(d) for d in pre_final])
performance = get_performance(y_pre_label, y_test_label)
performance['test_loss'] = score[0]
performance['test_acc'] = score[1]
K.clear_session()
result.append(performance)
json_str = json.dumps(performance, indent=4)
with open(
'{}_xception-iteration-{}-{}-result.json'.format(
dataset, i, period), 'w') as json_file:
json_file.write(json_str)
plot_result(result)
def __init__(self):
BaseModel.__init__(self)
self.user_similarity = defaultdict(list) # {uid:{sim_id:similarity}}
def __init__(self): BaseModel.__init__(self) self.user_similarity = defaultdict(list) self.user_tag_distrib = defaultdict(dict)
def tp_xception_model_training_and_test(img_x_list, shape_x, texture_x, vein_x,
isVenation, y_list, config):
img_x = np.array(img_x_list)
shape_x = np.array(shape_x)
texture_x = np.array(texture_x)
if isVenation:
vein_x = np.array(vein_x)
y = np.array(y_list)
dataset = config['dataset']
id_map = np.loadtxt(dataset + '_id.txt')
for index, d in enumerate(y):
for label in id_map:
if d == label[0]:
y[index] = int(label[1])
y_one_hot = to_categorical(y)
result = []
lr_adjust = ReduceLROnPlateau(monitor='val_loss',
factor=0.5,
patience=5,
min_lr=1e-6)
dataset = config['dataset']
if dataset == 'soybean':
period = config['period']
else:
period = dataset
for i in range(iteration):
index = np.arange(len(y))
# print(index)
X_train_index, X_test_index, y_train, y_test = train_test_split(
index,
y_one_hot,
test_size=0.3,
random_state=i,
shuffle=True,
stratify=y_one_hot)
print(len(X_train_index))
print(len(X_test_index))
np.save(
'{}_iteration_{}_img_{}_tp_xception_train_index.npy'.format(
dataset, i, period), X_train_index)
np.save(
'{}_iteration_{}_img_{}_tp_xception_test_index.npy'.format(
dataset, i, period), X_test_index)
shape_x_train = shape_x[X_train_index]
texture_x_train = texture_x[X_train_index]
img_x_train = img_x[X_train_index]
shape_x_train_list = [
shape_x_train[:, i, :, :] for i in range(config["shape_views"])
]
texture_x_train_list = [
texture_x_train[:, i, :, :] for i in range(config["texture_views"])
]
if isVenation:
vein_x_train = vein_x[X_train_index]
vein_x_train[:, 0, :, 1] = (vein_x_train[:, 0, :, 1] - np.mean(
vein_x_train[:, 0, :, 1])) / np.std(vein_x_train[:, 0, :, 1])
vein_x_train[:, 1, :, 1] = (vein_x_train[:, 1, :, 1] - np.mean(
vein_x_train[:, 1, :, 1])) / np.std(vein_x_train[:, 1, :, 1])
vein_x_train_list = [
vein_x_train[:, i, :, :] for i in range(config["vein_views"])
]
x_train_list = []
for index, d in enumerate(texture_x_train_list):
texture_x_train_list[index] = np.reshape(
d, [d.shape[0], d.shape[1], d.shape[2], 1])
if isVenation:
for index, d in enumerate(vein_x_train_list):
vein_x_train_list[index] = np.reshape(
d, [d.shape[0], d.shape[1], d.shape[2], 1])
x_train_list.extend(shape_x_train_list)
x_train_list.extend(texture_x_train_list)
if isVenation:
x_train_list.extend(vein_x_train_list)
x_train_list.append(img_x_train)
y_train_label = [np.argmax(d) for d in y_train]
my_class_weights = list(
class_weight.compute_class_weight('balanced',
np.unique(y_train_label),
y_train_label))
class_weight_dict = dict(
zip([x for x in np.unique(y_train_label)], my_class_weights))
save_best_weight = ModelCheckpoint(
'./{}_pdm_iteration-{}-{}.hdf5'.format(dataset, i, period),
monitor='val_loss',
verbose=1,
save_best_only=True,
mode='auto',
save_weights_only=True)
model = BaseModel.Combined_Model(parallels=1, config=config)
lr_reduce = LearningRateScheduler(lr_reducer)
model.fit(x_train_list,
y_train,
batch_size=16,
epochs=100,
validation_split=0.1,
class_weight=class_weight_dict,
callbacks=[save_best_weight, lr_reduce, lr_adjust])
shape_x_test = shape_x[X_test_index]
texture_x_test = texture_x[X_test_index]
img_x_test = img_x[X_test_index]
shape_x_test_list = [
shape_x_test[:, i, :, :] for i in range(config["shape_views"])
]
texture_x_test_list = [
texture_x_test[:, i, :, :] for i in range(config["texture_views"])
]
if isVenation:
vein_x_test = vein_x[X_test_index]
vein_x_test[:, 0, :, 1] = (vein_x_test[:, 0, :, 1] - np.mean(
vein_x_train[:, 0, :, 1])) / np.std(vein_x_train[:, 0, :, 1])
vein_x_test[:, 1, :, 1] = (vein_x_test[:, 1, :, 1] - np.mean(
vein_x_train[:, 1, :, 1])) / np.std(vein_x_train[:, 1, :, 1])
vein_x_test_list = [
vein_x_test[:, i, :, :] for i in range(config["vein_views"])
]
x_test_list = []
for index, d in enumerate(texture_x_test_list):
texture_x_test_list[index] = np.reshape(
d, [d.shape[0], d.shape[1], d.shape[2], 1])
x_test_list.extend(shape_x_test_list)
x_test_list.extend(texture_x_test_list)
if isVenation:
for index, d in enumerate(vein_x_test_list):
vein_x_test_list[index] = np.reshape(
d, [d.shape[0], d.shape[1], d.shape[2], 1])
x_test_list.extend(vein_x_test_list)
x_test_list.append(img_x_test)
K.clear_session()
model2 = BaseModel.Combined_Model(parallels=1, config=config)
model2.load_weights('./{}_pdm_iteration-{}-{}.hdf5'.format(
dataset, i, period))
score = model2.evaluate(x_test_list, y_test, batch_size=128)
print(score)
y_test_label = np.array([np.argmax(d) for d in y_test])
y_pre = model2.predict(x_test_list)
y_pre_label = np.array([np.argmax(d) for d in y_pre])
performance = get_performance(y_pre_label, y_test_label)
performance['test_acc'] = score[1]
performance['test_loss'] = score[0]
result.append(performance)
K.clear_session()
print("precision_score: {}".format(performance['precision']))
print("recall_score: {}".format(performance['recall']))
print("f1_score: {}".format(performance['f1_score']))
json_str = json.dumps(performance, indent=4)
with open(
'./{}_pd-rgb-combined-iteration-{}-{}.json'.format(
dataset, i, period), 'w') as json_file:
json_file.write(json_str)
plot_result(result)
def run_movie(path,
destination='./Movie',
death=None,
dpi=150,
tsample=1,
imgformat='jpg',
maxpic=800,
noticks=False):
'''Creates a movie at destination. Images are stored at destination/img/'''
destination = Path(destination)
imgfolder = destination + Path('img')
imgfolder.mkdir()
from subprocess import call
import matplotlib.patches as mpatches
from matplotlib.collections import PatchCollection
from models import BaseModel
## Remove old figs
try:
call("rm -f {}.{}".format(imgfolder + '*', imgformat), shell=True)
except:
print(
"Your OS is not supported by my awesome movie plotter. Old figures not removed"
)
## Load in data
m = BaseModel.load(path, initialize=False)
var = m.variables.keys()[0]
traj = m.results[var]
prm = m.export_params()
colors = [
'b',
'g',
'r',
'y',
'k',
]
if 'death' in m.parameters[var]:
death = m.parameters[var]['death']
if death is None:
death = 0
#Size conversion (data to figure size)
def convert_dist(ax, pos):
if not hasattr(pos, '__iter__'):
pos = (0, pos)
tarea = (ax.transData.transform(
(area[2], area[3])) - ax.transData.transform((area[0], area[1])))
return (ax.transData.transform(pos) - ax.transData.transform(
(0, 0))) / tarea
graph = Graph(nx.from_numpy_matrix(m.data['community'].matrix))
## plot
alive = graph.nodes()[:]
for t in range(0, min(maxpic * tsample, traj.shape[0])):
if t % tsample != 0:
continue
plt.clf()
fig = plt.figure(edgecolor=[.4, .4, .4])
ax = fig.add_subplot(121)
dead = np.where(traj[t] < death)[0]
for d in dead:
if d in alive:
graph.remove_node(d)
alive.remove(d)
graph.plot(hold=1, newfig=0, node_size=traj[t][alive], edge_width=.1)
ax = fig.add_subplot(122)
plt.xlim(xmax=traj.index[-1])
plot(np.array([traj[t2].ravel() for t2 in range(t)]),
hold=1,
xs=traj.index[:t])
if noticks:
plt.xticks([])
plt.yticks([])
# save
ti = str(t / tsample + 100000)
plt.savefig(imgfolder + 'Fig_{}.{}'.format(ti[1:], imgformat),
dpi=dpi,
bbox_inches='tight')
print(t)
plt.close('all')
try:
call("ffmpeg -y -r 18 -i {}%05d.{} {}".format(
imgfolder + 'Fig_', imgformat, destination + 'movie.mp4'),
shell=True)
except:
pass
def __init__(self):
BaseModel.__init__(self)
self.item_similarity = {
} # {itemid:[(sim_item,similarity)]} sorted by similarity
def __init__(self): BaseModel.__init__(self) self.popular_list = []
def __init__(self):
BaseModel.__init__(self)
from werkzeug.exceptions import HTTPException
from models import BaseModel
from controllers import *
from responses import ISOAwareEncoder
##
# CONFIGURATION
##
# Defines and configures the web server,
# database connection, and data models.
##
app = Flask("letsschedit")
app.json_encoder = ISOAwareEncoder
db = BaseModel.get_database()
db.init(
env('DATABASE'),
user=env('DB_USERNAME'),
password=env('DB_PASSWORD')
)
@app.before_request
def _db_connect():
""" Ensures that whenever a HTTP request is comming in, a db connection is dispatched
from the pool. This is required as MySQL oftens kills idle connections, so we want
a hot new fresh one every time. """
db.connect()
import diagnostics
from models import BaseModel
mod = BaseModel()
print('instantiation successful')
a = 10**4
Ns = [5 * (10**5), a, 5 * a, 10 * a, 50 * a]
diagnostics.runtime_lineplot_N(mod, N_space=Ns, P=4)
print('ahuevooooooooo')
diagnostics.mse_lineplot_N(mod, N_space=Ns, P=4)
from models import BaseModel, TextContent, MessageContent, Photo, Role, User, UserRoles, MessageType, ConversationType, Conversation, Message, ConversationParty, Quotation, Company, database
try:
database.drop_tables(BaseModel.__subclasses__(), safe = True, cascade = True)
# database.create_tables(BaseModel.__subclasses__())
Photo.create_table()
Role.create_table()
User.create_table()
UserRoles.create_table()
MessageType.create_table()
ConversationType.create_table()
Quotation.create_table()
Company.create_table()
TextContent.create_table()
MessageContent.create_table()
Conversation.create_table()
Message.create_table()
ConversationParty.create_table()
database.create_foreign_key(Conversation, Conversation.last_message)
except Exception as e:
print('Error while creating schema %s' % e)
def __init__(self):
BaseModel.__init__(self)
self.item_similarity = {} # {itemid:[(sim_item,similarity)]} sorted by similarity
def __init__(self): BaseModel.__init__(self) self.user_similarity = defaultdict(dict) self.userCF = UserCF() self.userTag = UserTagCF() self.userLda = UserLDA()
def __init__(self): BaseModel.__init__(self)
def setUp(self):
"""sets up objects for testing later
"""
self.test_model1 = BaseModel()
self.test_model2 = BaseModel()
test_probabilitiesBkg = []
for b in bkg_test:
b = scaler.transform([b])
prob = classifier.predict_proba(b)[0][0]
b = b[0].flatten().tolist()
test_probabilitiesBkg.append(prob)
testDataBkg.append(b)
batchSize = 4
test = testDataSig
probs_test = test_probabilitiesSig
test_bkg = testDataBkg
probs_test_bkg = test_probabilitiesBkg
# Initialise model
model = Model(len(test[0]), 1)
model.load_model('approx1.pkl')
test = np.array(test)
probs_test = np.array(probs_test)
test_bkg = np.array(test_bkg)
probs_test_bkg = np.array(probs_test_bkg)
# Make a vector of outputs
comp_preds = []
comp_true = []
for (batchX, batchY) in next_batch(test, probs_test, batchSize):
if batchY.shape[0] < batchSize:
print('Batch size insufficient (%s), continuing...' % batchY.shape[0])
continue
#!/usr/bin/env python2.7
# -*- coding: utf-8 -*-
from sqlalchemy import Column, String, Text, Integer, DateTime
from models import BaseModel
__BASE_MODEL = BaseModel.get_base_model()
class Bangumi(__BASE_MODEL):
__tablename__ = 'bangumi'
cover = Column(Text, nullable=True)
favorites = Column(Integer, nullable=True)
is_finish = Column(Integer, nullable=True)
newest_ep_index = Column(String(16), nullable=True)
pub_time = Column(Integer, nullable=True)
season_id = Column(Integer, primary_key=True)
season_status = Column(Integer, nullable=True)
title = Column(String(64), nullable=True)
introduction = Column(String(512), nullable=True)
total_count = Column(Integer, nullable=True)
update_time = Column(Integer, nullable=True)
url = Column(Text, nullable=True)
week = Column(String(30), nullable=True)
tags = Column(Text, nullable=True)
actors = Column(Text, nullable=True)
createdAt = Column(DateTime, nullable=True)
updatedAt = Column(DateTime, nullable=True)
def __init__(self, data_dict):
def setUp(self):
"""
objects to be tested
"""
self.model1_test = BaseModel()
self.model2_test = BaseModel()
def __init__(self): BaseModel.__init__(self) self.dictionary = None self.model = None self.user_similarity = defaultdict(list)