def __init__(self, opt):
BaseModel.__init__(self, opt)
self.loss_names = ['correctness','regularization']
self.visual_names = ['input_P1','input_P2', 'warp', 'flow_fields',
'masks']
self.model_names = ['G']
self.FloatTensor = torch.cuda.FloatTensor if len(self.gpu_ids)>0 \
else torch.FloatTensor
self.ByteTensor = torch.cuda.ByteTensor if len(self.gpu_ids)>0 \
else torch.ByteTensor
self.net_G = network.define_g(opt, structure_nc=opt.structure_nc, ngf=32, img_f=256,
encoder_layer=5, norm='instance', activation='LeakyReLU',
attn_layer=self.opt.attn_layer, use_spect=opt.use_spect_g,
)
self.L1loss = torch.nn.L1Loss()
self.flow2color = util.flow2color()
if self.isTrain:
self.Correctness = external_function.PerceptualCorrectness().to(opt.device)
self.Regularization = external_function.MultiAffineRegularizationLoss(kz_dic=opt.kernel_size).to(opt.device)
self.optimizer_G = torch.optim.Adam(itertools.chain(filter(lambda p: p.requires_grad, self.net_G.parameters())),
lr=opt.lr, betas=(0.0, 0.999))
self.optimizers.append(self.optimizer_G)
self.setup(opt)
def __init__(self, input_shape, output_shape, learning_rate):
BaseModel.__init__(self, input_shape, output_shape)
self.learning_rate = learning_rate
obs_input = Input(input_shape, name='observations')
conv_1 = Convolution2D(filters=32,
kernel_size=(8, 8),
strides=(4, 4),
padding='valid',
activation='relu')(obs_input)
conv_2 = Convolution2D(filters=64,
kernel_size=(4, 4),
strides=(2, 2),
padding='valid',
activation='relu')(conv_1)
conv_3 = Convolution2D(filters=64,
kernel_size=(3, 3),
strides=(1, 1),
padding='valid',
activation='relu')(conv_2)
conv_flattened = Flatten()(conv_3)
hidden = Dense(512, activation='linear')(conv_flattened)
output = Dense(output_shape)(hidden)
self.model = Model(input=obs_input, output=output)
# Compile model
optimizer = Adam(lr=self.learning_rate)
self.model.compile(optimizer=optimizer,
loss=tf.losses.huber_loss,
metrics=['acc'])
print(self.model.summary())
def train_model(
model: BaseModel,
dataset: Dict[str, np.ndarray],
test_split: Optional[float] = 0.1,
**kwargs
):
n = next(iter(dataset.values())).shape[0]
# shuffle dataset
shuffle_perm = np.random.permutation(n)
dataset = {k: v[shuffle_perm] for k, v in dataset.items()}
# train test split
if test_split is not None:
n_test = int(test_split * n)
dataset_test = {k: v[:n_test] for k, v in dataset.items()}
dataset_train = {k: v[n_test:] for k, v in dataset.items()}
else:
dataset_train = dataset_test = dataset
# train model
model.fit(dataset_train, **kwargs)
# test model
model.test(dataset_test)
def __init__(self, opt):
BaseModel.__init__(self, opt)
self.loss_names = ['mpjpe']
self.model_names = ['G']
self.FloatTensor = torch.cuda.FloatTensor if len(self.gpu_ids)>0 \
else torch.FloatTensor
self.ByteTensor = torch.cuda.ByteTensor if len(self.gpu_ids)>0 \
else torch.ByteTensor
self.net_G = network.define_g(opt, filename='generator', structure_nc=opt.structure_nc, channels=256, layers=4)
if len(opt.gpu_ids) > 1:
self.net_G = torch.nn.DataParallel(self.net_G, device_ids=self.gpu_ids)
self.convert2skeleton = openpose_utils.tensor2skeleton()
if self.isTrain:
self.L2loss = torch.nn.MSELoss()
self.optimizer_G = torch.optim.Adam(itertools.chain(
filter(lambda p: p.requires_grad, self.net_G.parameters())),
lr=opt.lr, betas=(0.0, 0.999))
self.optimizers.append(self.optimizer_G)
else:
self.L2loss = torch.nn.MSELoss()
util.mkdir(os.path.join(self.opt.results_dir))
self.setup(opt)
def __init__(self, feature_builder, num_clusters, n_init):
BaseModel.__init__(self, feature_builder)
self.le = LabelEncoder()
self.model = MiniBatchKMeans(n_clusters=num_clusters,
init='k-means++',
n_init=n_init,
init_size=1000,
batch_size=1000)
def __init__(self, env):
BaseModel.__init__(self, env)
nn.Module.__init__(self)
self.trainable = True
self.nn_model = True
self.fc1 = nn.Linear(self.n*3, self.n)
self.fc_pi = nn.Linear(self.n, self.n)
self.fc_v = nn.Linear(self.n, 1)
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_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']
# 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.isTrain:
self.model_names = ['G', 'D']
else: # during test time, only load G
self.model_names = ['G']
# define networks (both generator and discriminator)
# LGQ here I change the generator to my line encoding
#self.netG = networks.define_G(opt.input_nc, opt.output_nc, opt.ngf, opt.netG, opt.norm,
# not opt.no_dropout, opt.init_type, opt.init_gain, self.gpu_ids)
self.netG = fusion_nets3._2layerFusionNets_()
if self.isTrain:
# define loss functions
self.criterionGAN = networks.GANLoss(opt.gan_mode).to(self.device)
self.criterionL1 = torch.nn.L1Loss()
# LGQ add another loss for G
self.criterionMTL = MTL_loss()
# initialize optimizers; schedulers will be automatically created by function <BaseModel.setup>.
self.optimizer_G = torch.optim.Adam(self.netG.parameters(),
lr=opt.lr,
betas=(opt.beta1, 0.999))
self.optimizer_G_f = torch.optim.Adam(
self.netG.fusion_layer.parameters(),
lr=opt.lr,
betas=(opt.beta1, 0.999))
self.optimizer_G_1 = torch.optim.Adam(
self.netG.side_branch1.parameters(),
lr=opt.lr,
betas=(opt.beta1, 0.999))
self.optimizer_G_2 = torch.optim.Adam(
self.netG.side_branch2.parameters(),
lr=opt.lr,
betas=(opt.beta1, 0.999))
self.optimizer_G_3 = torch.optim.Adam(
self.netG.side_branch3.parameters(),
lr=opt.lr,
betas=(opt.beta1, 0.999))
self.optimizers.append(self.optimizer_G)
self.validation_init()
self.bw_cnt = 0
self.displayloss1 = 0
self.displayloss2 = 0
self.displayloss3 = 0
def __init__(self, opt):
"""Initial the pluralistic model"""
BaseModel.__init__(self, opt)
self.loss_names = ['app_gen','correctness_p', 'correctness_r','content_gen','style_gen',
'regularization_p', 'regularization_r',
'ad_gen','dis_img_gen',
'ad_gen_v', 'dis_img_gen_v']
self.visual_names = ['P_reference','BP_reference', 'P_frame_step','BP_frame_step','img_gen', 'flow_fields', 'masks']
self.model_names = ['G','D','D_V']
self.FloatTensor = torch.cuda.FloatTensor if len(self.gpu_ids)>0 \
else torch.FloatTensor
self.ByteTensor = torch.cuda.ByteTensor if len(self.gpu_ids)>0 \
else torch.ByteTensor
# define the Animation model
self.net_G = network.define_g(opt, image_nc=opt.image_nc, structure_nc=opt.structure_nc, ngf=64, img_f=512,
layers=opt.layers, num_blocks=2, use_spect=opt.use_spect_g, attn_layer=opt.attn_layer,
norm='instance', activation='LeakyReLU', extractor_kz=opt.kernel_size)
if len(opt.gpu_ids) > 1:
self.net_G = torch.nn.DataParallel(self.net_G, device_ids=self.gpu_ids)
self.flow2color = util.flow2color()
self.net_D = network.define_d(opt, ndf=32, img_f=128, layers=4, use_spect=opt.use_spect_d)
if len(opt.gpu_ids) > 1:
self.net_D = torch.nn.DataParallel(self.net_D, device_ids=self.gpu_ids)
input_nc = (opt.frames_D_V-1) * opt.image_nc
self.net_D_V = network.define_d(opt, input_nc=input_nc, ndf=32, img_f=128, layers=4, use_spect=opt.use_spect_d)
if len(opt.gpu_ids) > 1:
self.net_D_V = torch.nn.DataParallel(self.net_D_V, device_ids=self.gpu_ids)
if self.isTrain:
# define the loss functions
self.GANloss = external_function.AdversarialLoss(opt.gan_mode).to(opt.device)
self.L1loss = torch.nn.L1Loss()
self.L2loss = torch.nn.MSELoss()
self.Correctness = external_function.PerceptualCorrectness().to(opt.device)
self.Regularization = external_function.MultiAffineRegularizationLoss(kz_dic=opt.kernel_size).to(opt.device)
self.Vggloss = external_function.VGGLoss().to(opt.device)
# define the optimizer
self.optimizer_G = torch.optim.Adam(itertools.chain(
filter(lambda p: p.requires_grad, self.net_G.parameters())),
lr=opt.lr, betas=(0.0, 0.999))
self.optimizers.append(self.optimizer_G)
self.optimizer_D = torch.optim.Adam(itertools.chain(
filter(lambda p: p.requires_grad, self.net_D.parameters()),
filter(lambda p: p.requires_grad, self.net_D_V.parameters())),
lr=opt.lr*opt.ratio_g2d, betas=(0.0, 0.999))
self.optimizers.append(self.optimizer_D)
else:
self.results_dir_base = self.opt.results_dir
self.setup(opt)
def train(self):
# call parent function.
BaseModel.train(self)
#trains the k-nearest-neighbor model
self.model.fit(self.train_x, self.train_y)
# update the is_trained variable.
self.is_trained = True
def train(self):
# call parent function.
BaseModel.train(self)
#trains the support-vector-machine model
self.model.fit(self.train_x, self.train_y)
# update the is_trained variable.
self.is_trained = True
def __init__(self, data, normalize=False):
# call parent function.
BaseModel.__init__(self, data, normalize=normalize, **kwargs)
# placeholders specific to this class.
self.model = None
# Reference to the library used: https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html#sklearn.neighbors.KNeighborsClassifier
# Initlising the class
self.model = KNeighborsClassifier()
def __init__(self, data, normalize=False, **kwargs):
# call parent function.
BaseModel.__init__(self, data, normalize=normalize, **kwargs)
# placeholders specific to this class.
self.model = None
# Reference to the library used: https://scikit-learn.org/stable/modules/svm.html
# Initlising the class
self.model = svm.SVC()
def test(self):
# call parent function.
BaseModel.test(self)
# Using model built with training data, to predict the test data - using the predict method in
# sklearn.neighbors.KNeighborsClassifier
y_pred = self.model.predict(self.test_x)
self.test_predictions = pd.Series(data=y_pred, dtype="int64")
# assess the performance of the predictions.
self.assess_performance()
def __init__(self, tweet_id=None, author=None, text=None, timestamp=None):
"""
:type tweet_id: string
:type author: string
:type text: string
:type timestamp: string
"""
BaseModel.__init__(self, tweet_id)
self.author = author
self.text = text
self.timestamp = timestamp
def hyperparameter_tuning(self):
# Defines the parameter search space
param_space = {
'n_neighbors': (1, 100), # integer valued parameter
'weights': ['uniform', 'distance'], # categorical parameter
'metric': ['euclidean', 'manhattan',
'minkowski'] # categorical parameter
}
# Calls the parent function - finds the combination of parameters from the given param_space that
# yields the highest score - set to accuracy currently
BaseModel.hyperparameter_tuning(self, 'Grid', param_space)
def __init__(self, input_shape, output_shape, learning_rate):
BaseModel.__init__(self, input_shape, output_shape)
self.learning_rate = learning_rate
# input(f'Input shape: {input_shape}')
# obs_input = Input(input_shape, name='observations')
# normalized = Lambda(lambda x: x / 255.0)(obs_input)
# conv_1 = Convolution2D(16, 8, 8,
# subsample=(4, 4),
# activation='relu')(normalized)
# conv_2 = Convolution2D(32, 4, 4,
# subsample=(2, 2),
# activation='relu')(conv_1)
# conv_flattened = Flatten()(conv_2)
# hidden = Dense(256, activation='linear')(conv_flattened)
# output = Dense(output_shape)(hidden)
# # filtered_output = keras.layers.merge.Multiply()([output, actions_mask])
# self.model = Model(input=obs_input,
# output=output)
# # Compile model
# optimizer = RMSprop(learning_rate=self.learning_rate, epsilon=0.01)
# self.model.compile(optimizer=optimizer,
# loss='mse',
# metrics=['acc'])
# print(self.model.summary())
# self.model = Sequential()
# self.model.add(Dense(24, input_shape=input_shape, activation="relu"))
# self.model.add(Dense(24, activation="relu"))
# self.model.add(Dense(output_shape, activation="linear"))
# self.model.compile(loss="mse", optimizer=Adam(lr=self.learning_rate))
# print(self.model.summary())
# self.model = Sequential()
# self.model.add(Dense(24, input_shape=input_shape, activation="tanh"))
# self.model.add(Dense(48, activation="tanh"))
# self.model.add(Dense(output_shape, activation="linear"))
# self.model.compile(loss="mse", optimizer=Adam(
# learning_rate=self.learning_rate, decay=0.01))
# print(self.model.summary())
self.model = Sequential()
self.model.add(Dense(24, input_shape=input_shape, activation="relu"))
self.model.add(Dense(24, activation="relu"))
self.model.add(Dense(output_shape, activation="linear"))
self.model.compile(loss="mse", optimizer=Adam(lr=self.learning_rate))
print(self.model.summary())
def __init__(self, opt):
BaseModel.__init__(self, opt)
self.opt = opt
self.keys = ['head', 'body', 'leg']
self.mask_id = {
'head': [1, 2, 4, 13],
'body': [3, 5, 6, 7, 10, 11, 14, 15],
'leg': [8, 9, 12, 16, 17, 18, 19]
}
self.GPU = torch.device('cuda:0')
self.loss_names = ['correctness', 'regularization']
self.visual_names = [
'input_P1', 'input_P2', 'warp', 'flow_fields', 'masks',
'input_BP1', 'input_BP2'
]
self.model_names = ['G']
self.FloatTensor = torch.cuda.FloatTensor if len(self.gpu_ids)>0 \
else torch.FloatTensor
self.ByteTensor = torch.cuda.ByteTensor if len(self.gpu_ids)>0 \
else torch.ByteTensor
self.net_G = network.define_g(
opt,
structure_nc=opt.structure_nc,
ngf=32,
img_f=256,
layers=5,
norm='instance',
activation='LeakyReLU',
attn_layer=self.opt.attn_layer,
use_spect=opt.use_spect_g,
)
self.flow2color = util.flow2color()
if self.isTrain:
# define the loss functions
self.Correctness = external_function.PerceptualCorrectness().to(
opt.device)
self.Regularization = external_function.MultiAffineRegularizationLoss(
kz_dic=opt.kernel_size).to(opt.device)
# define the optimizer
self.optimizer_G = torch.optim.Adam(itertools.chain(
filter(lambda p: p.requires_grad, self.net_G.parameters())),
lr=opt.lr,
betas=(0.0, 0.999))
self.optimizers.append(self.optimizer_G)
# load the pretrained model and schedulers
self.setup(opt)
def __init__(self, sess, args):
BaseModel.__init__(self, sess, args)
self.args = args
if self.args.phase.find('train') >= 0:
self.is_train = True
else:
self.is_train = False
self.image_size = [
self.args.image_size, self.args.image_size, self.args.image_size
]
self.train_sampler = IntIntSimNetSampler(self.args, True)
self.validate_sampler = IntIntSimNetSampler(self.args, False)
self.build_network()
self.summary()
def __init__(self, comment_id=None, title=None, comment=None, status=None, likes=None, date=None):
"""
:type comment_id: string
:type title: string
:type comment: string
:type status: string
:type likes: int
:type date: string
"""
BaseModel.__init__(self, comment_id)
self.title = title
self.comment = comment
self.status = status
self.likes = likes
self.date = date
def __init__(self, sess, args):
BaseModel.__init__(self, sess, args)
# self.sess=sess
self.args = args
if args.phase == 'train':
self.is_train = True
else:
self.is_train = False
self.image_size = [
self.args.image_size, self.args.image_size, self.args.image_size
]
self.train_sampler = LabIntSimNetSampler(self.args, 'train')
self.validate_sampler = LabIntSimNetSampler(self.args, 'validate')
self.build_network()
self.summary()
def __init__(self, opt):
BaseModel.__init__(self, opt)
self.loss_names = ['app_gen', 'correctness_gen', 'content_gen', 'style_gen', 'regularization',
'ad_gen', 'dis_img_gen']
self.visual_names = ['input_P1','input_P2', 'img_gen', 'flow_fields', 'masks']
self.model_names = ['G','D']
self.keys = ['head','body','leg']
self.mask_id = {'head':[1,2,4,13],'body':[3,5,6,7,10,11,14,15],'leg':[8,9,12,16,17,18,19]}
self.GPU = torch.device('cuda:0')
self.FloatTensor = torch.cuda.FloatTensor if len(self.gpu_ids)>0 \
else torch.FloatTensor
# define the generator
self.net_G = network.define_g(opt, image_nc=opt.image_nc, structure_nc=opt.structure_nc, ngf=64, img_f=512,
layers=opt.layers, num_blocks=2, use_spect=opt.use_spect_g, attn_layer=opt.attn_layer,
norm='instance', activation='LeakyReLU', extractor_kz=opt.kernel_size)
# define the discriminator
if self.opt.dataset_mode == 'fashion':
self.net_D = network.define_d(opt, ndf=32, img_f=128, layers=4, use_spect=opt.use_spect_d)
elif self.opt.dataset_mode== 'market':
self.net_D = network.define_d(opt, ndf=32, img_f=128, layers=3, use_spect=opt.use_spect_d)
self.flow2color = util.flow2color()
if self.isTrain:
# define the loss functions
self.GANloss = external_function.AdversarialLoss(opt.gan_mode).to(opt.device)
self.L1loss = torch.nn.L1Loss()
self.Correctness = external_function.PerceptualCorrectness().to(opt.device)
self.Regularization = external_function.MultiAffineRegularizationLoss(kz_dic=opt.kernel_size).to(opt.device)
self.Vggloss = external_function.VGGLoss().to(opt.device)
# define the optimizer
self.optimizer_G = torch.optim.Adam(itertools.chain(
filter(lambda p: p.requires_grad, self.net_G.parameters())),
lr=opt.lr, betas=(0.0, 0.999))
self.optimizers.append(self.optimizer_G)
self.optimizer_D = torch.optim.Adam(itertools.chain(
filter(lambda p: p.requires_grad, self.net_D.parameters())),
lr=opt.lr*opt.ratio_g2d, betas=(0.0, 0.999))
self.optimizers.append(self.optimizer_D)
# load the pre-trained model and schedulers
self.setup(opt)
def get_a_page_of_link(cls, page, count_of_page):
"""
获取一页链接
:param page: 第几页
:param count_of_page: 每页记录数
:return:
"""
return BaseModel.get_one_page_of_table(cls.table_name, " group_status = 0 or group_status = 1", page, count_of_page)
def __init__(self,
depth=6,
n_device=1,
n_parallel_trees=1,
verbose=0,
column_sampling_rate=1.0,
bagging=0,
tree_method='auto'):
BaseModel.__init__(self)
self.verbose = verbose
self.n_device = n_device
self.column_sampling_rate = column_sampling_rate
self.bagging = bagging
self.n_parallel_trees = n_parallel_trees
self.tree_method = tree_method
self.objective = ""
self.num_class = 1
def __init__(self, sess, args):
BaseModel.__init__(self, sess, args)
# self.sess=sess
# self.args=args
self.minibatch_size = self.args.batch_size
self.image_size = [
self.args.image_size, self.args.image_size, self.args.image_size
]
if args.phase == 'train':
self.is_train = True
else:
self.is_train = False
self.train_sampler = Sampler(self.args, 'train')
self.validate_sampler = Sampler(self.args, 'validate')
self.logger = getLoggerV3('learn2reg', self.args.log_dir)
self.build_network()
self.summary()
def __init__(self, params):
BaseModel.__init__(self, params)
self.loss_names = [
'loss_identity', 'loss_cycle', 'loss_gan', 'loss_G', 'loss_D',
'loss_D_A', 'loss_D_B'
]
self.losses = self.make_loss_dict()
if self.params.isTrain:
self.model_names = ['G_A2B', 'G_B2A', 'D_A', 'D_B']
else:
self.model_names = ['G_A2B', 'G_B2A']
# define image pool
self.fake_pool_A = set_buffer_pool(self.params.pool_size)
self.fake_pool_B = set_buffer_pool(self.params.pool_size)
# define the nets
self.netG_A2B = G(self.params.input_nc,
self.params.output_nc).to(self.device)
self.netG_B2A = G(self.params.input_nc,
self.params.output_nc).to(self.device)
self.netD_A = D(self.params.input_nc).to(self.device)
self.netD_B = D(self.params.input_nc).to(self.device)
# define optimizer
self.optimizer_G = torch.optim.Adam(itertools.chain(self.netG_A2B.parameters(),\
self.netG_B2A.parameters()),lr=params.lr,betas=(params.beta1,0.999))
self.optimizer_D = torch.optim.Adam(itertools.chain(self.netD_A.parameters(),\
self.netD_B.parameters()),lr=params.lr, betas=(params.beta1,0.999))
self.optimizers = [self.optimizer_G, self.optimizer_D]
if self.params.isTrain:
self.schedulers = [
get_scheduler(optim, self.params) for optim in self.optimizers
]
# define loss function
self.criterion_identity = torch.nn.L1Loss()
self.criterion_cycle = torch.nn.L1Loss()
self.criterion_GAN = torch.nn.MSELoss()
#create target real and fake
self.target_real = torch.ones(self.params.batch_size,
requires_grad=False).to(
self.params.device)
self.target_fake = torch.zeros(self.params.batch_size,
requires_grad=False).to(
self.params.device)
#init net
self.init_weight_normal()
def get_a_page_of_link(cls, page, count_of_page):
"""
获取一页链接
:param page: 第几页
:param count_of_page: 每页记录数
:return:
"""
return BaseModel.get_one_page_of_table(
cls.table_name, " group_status = 0 or group_status = 1", page,
count_of_page)
def get_model_api():
model = BaseModel()
def model_api(image_storage):
image = image_to_np_array(image_storage)
output = model.predict(image)
image = draw_boxes(image, output, 0.8)
return image
return model_api
class WechatReplyModel(BaseModel):
table_name = "topic_wechat_reply"
db = BaseModel.get_db_lib()
@classmethod
def add_setting(cls, wechat_group_name, reply_content, status, reply_key):
"""
添加机器人绑定
:param wechat_group_name: 微信群昵称
:param reply_content: 自动回复内容
:param status: 回复状态
:param reply_key: 回复关键字
:return:
"""
sql = "insert into " + cls.table_name + "(wechat_group_name, reply_content, status, create_time, reply_key) values(%s, %s, %s, now(), %s);"
return cls.db.insert(
sql, [wechat_group_name, reply_content,
str(status), reply_key])
@classmethod
def update_setting(cls, wechat_group_name, reply_content, status, reply_id,
reply_key):
"""
修改自动回复配置
:param wechat_group_name: 微信群昵称
:param reply_content: 自动回复内容
:param reply_id: 主键id
:param status: 回复状态
:param reply_key: 回复关键字
:return:
"""
sql = "update " + cls.table_name + " set wechat_group_name = %s, reply_content = %s, status = %s, reply_key = %s where id = %s;"
return cls.db.update(sql, [
wechat_group_name, reply_content,
str(status), reply_key, reply_id
])
@classmethod
def remove_setting(cls, reply_id):
"""
删除配置
:param reply_id: 主键id
:return:
"""
sql = "update " + cls.table_name + " set status = 2 where id = %s;"
return cls.db.update(sql, [reply_id])
@classmethod
def get_replys(cls):
"""
获取自动回复配置
:return:
"""
sql = "select * from " + cls.table_name + " where status < 2 order by create_time;"
return cls.db.query_for_list(sql)
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_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']
# 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.isTrain:
self.model_names = ['G', 'D']
else: # during test time, only load G
self.model_names = ['G']
# define networks (both generator and discriminator)
self.netG = networks.define_G(opt.input_nc, opt.output_nc, opt.ngf,
opt.netG, opt.norm, not opt.no_dropout,
opt.init_type, opt.init_gain,
self.gpu_ids)
if self.isTrain: # define a discriminator; conditional GANs need to take both input and output images; Therefore, #channels for D is input_nc + output_nc
self.netD = networks.define_D(opt.input_nc + opt.output_nc,
opt.ndf, opt.netD, opt.n_layers_D,
opt.norm, opt.init_type,
opt.init_gain, self.gpu_ids)
if self.isTrain:
# define loss functions
self.criterionGAN = networks.GANLoss(opt.gan_mode).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.netG.parameters(),
lr=opt.lr,
betas=(opt.beta1, 0.999))
self.optimizer_D = torch.optim.Adam(self.netD.parameters(),
lr=opt.lr,
betas=(opt.beta1, 0.999))
self.optimizers.append(self.optimizer_G)
self.optimizers.append(self.optimizer_D)
def run_model_inference(image_list):
images_count = 0
prediction_dict = dict()
model = BaseModel()
session, image_string_input, model_input_image, model_output = model.create_session(
)
for image in tqdm(image_list):
image_id = os.path.basename(image)[:-4]
img_byte = image_feeder(image, new_width=1280, new_height=856)
with tf.Graph().as_default():
prediction = session.run([model_output],
feed_dict={image_string_input: img_byte})
pred_string = convert_predictions(prediction)
prediction_dict[image_id] = pred_string
images_count += 1
return prediction_dict
class ApplyFriendsModel(BaseModel):
table_name = 'card_apply_friends'
db = BaseModel.get_db_lib()
@classmethod
def apply_friend(cls, source_open_id, target_open_id, remarks):
"""
申请添加好友
:param source_open_id: 源用户openid
:param target_open_id: 目标用户openid
:param remarks: 备注信息
:return:
"""
create_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
sql = "insert into " + cls.table_name + "(source_open_id, target_open_id, create_time, remarks) values(%s, %s, %s, %s);"
try:
apply_id = cls.db.insert(
sql, [source_open_id, target_open_id, create_time, remarks])
# 通知对方和自己（小助手）
resource_message_dao.commit_apply.delay(source_open_id,
target_open_id, apply_id)
return apply_id
except IntegrityError:
return 0
@classmethod
def handle_apply(cls, apply_id, handle_status, target_open_id):
"""
标志申请已经处理
:param apply_id: 申请id
:param handle_status: 处理状态
:return:
"""
sql = "update " + cls.table_name + " set status = %s, handle_sign = null where id = %s AND target_open_id = %s;"
nums = cls.db.update(
sql, [str(handle_status),
str(apply_id), target_open_id])
# 通知对方已经处理
resource_message_dao.handle_apply.delay(apply_id, handle_status)
return nums
