def tf_encode(container):
"""
LSB matching algorithm (+-1 embedding)
:param container: tf tensor shape (batch_size, width, height, chan)
:param information: array with int bits
:param stego: name of image with hidden message
"""
with tf.variable_scope('Stego'):
n, width, height, chan = tuple(map(int, container._shape))
information = BaseStego.get_information(n, 50)
# logger.debug('Information to hide', information)
mask = np.zeros(list(container.get_shape()))
print('Num of images: %s' % n)
for img_idx in range(n):
print(img_idx)
for i, bit in enumerate(information[img_idx]):
ind, jnd = i // width, i - width * (i // width)
if tf.to_int32(container[img_idx, ind, jnd, 0]) % 2 != bit:
if np.random.randint(0, 2) == 0:
# tf.assign_sub(container[img_idx, ind, jnd, 0], 1)
mask[img_idx, ind, jnd, 0] += 1
else:
# tf.assign_add(container[img_idx, ind, jnd, 0], 1)
mask[img_idx, ind, jnd, 0] -= 1
logger.debug('Finish encoding')
return tf.add(container, mask)
def block(blockhash):
log_ip(request, inspect.stack()[0][3])
try:
block = Block.from_json(get_block_from_db(blockhash)).object()
except Exception as e:
logger.debug("BLOCK/blockhash: " + str(e))
return template("error.html")
return template("block.html", block=block)
def execute_script(self, file_name):
logger.debug("Executing script: " + file_name)
print("Executing script: " + file_name)
with open(file_name) as script:
for line in script:
print("\t\t" + line.strip())
args = line.split()
self.command_handler("server", args, admin=True)
def get(self, request):
snippet_qs = Snippet.objects.order_by('-update_dt')
snippet_list = []
for snippet in snippet_qs:
snippet_list.append(snippet.to_simple_dict())
logger.debug('query snippets|%s', len(snippet_list))
return SuccessResponse(snippet_list)
def reprocess_api(self):
logger.debug('Reprocess dataset: %s' % self.dataset_id)
self.database \
.mongodb_dataset \
.update({'_id': self.dataset['_id']}, \
{'$set': {'status': AnnotationServer.STATUS_PROCESSING}})
self.do_process_dataset()
return AnnotationServer.response_success(result='Processing dataset')
def delete_module(module_path):
""" Delete Module after it has been processed """
try:
del sys.modules[module_path]
except Exception as exc:
logger.debug('Could not delete: {}'.format(module_path))
else:
logger.debug('Deleted Module: {}'.format(module_path))
def get(self, request, id):
try:
snippet = Snippet.objects.get(id=id)
except Snippet.DoesNotExist:
logger.warning('snippet not exist|%d', id)
return ObjectNotExistResponse()
logger.debug('query snippet|%d', id)
return SuccessResponse(snippet.to_dict())
def _bookable_offers(query):
beginning_date_is_in_the_future = (Stock.beginningDatetime > datetime.utcnow())
no_beginning_date = Stock.beginningDatetime == None
query = query.filter(beginning_date_is_in_the_future | no_beginning_date)
logger.debug(lambda: '(reco) offers in the future .count ' + str(query.count()))
query = _filter_bookable_offers_for_discovery(query)
logger.debug(lambda: '(reco) bookable .count ' + str(query.count()))
return query
def dump(cls):
if not cls.no_dump_mode:
if logger is not None:
logger.debug('Dumping save to disk')
p = xdrlib.Packer()
p.pack_array(cls.data, p.pack_int)
b = p.get_buffer()
with open(cls.path, 'wb') as file:
file.write(b)
def __send_order(self, socket, order):
socket.send(order.to_json())
ret = socket.recv()
data = json.loads(ret.decode('utf-8'))
if 0 != data['code']:
logger.debug(order.to_json())
logger.debug(data['msg'])
else:
pass
def get_thing_type_and_extra_data_from_titelive_type(titelive_type):
if titelive_type == 'A':
return None, None
elif titelive_type == 'BD':
return str(ThingType.LIVRE_EDITION), BookFormat.BANDE_DESSINEE.value
elif titelive_type == 'BL':
return str(ThingType.LIVRE_EDITION), BookFormat.BEAUX_LIVRES.value
elif titelive_type == 'C':
return None, None
elif titelive_type == 'CA':
return None, None
elif titelive_type == 'CB':
return None, None
elif titelive_type == 'CD':
return None, None
elif titelive_type == 'CL':
return None, None
elif titelive_type == 'DV':
return None, None
elif titelive_type == 'EB':
return None, None
elif titelive_type == 'K7':
return None, None
elif titelive_type == 'LA':
return None, None
elif titelive_type == 'LC':
return str(ThingType.LIVRE_EDITION), BookFormat.LIVRE_CASSETTE.value
elif titelive_type == 'LD':
return str(ThingType.LIVRE_EDITION), BookFormat.LIVRE_AUDIO.value
elif titelive_type == 'LE':
return None, None
elif titelive_type == 'LR':
return None, None
elif titelive_type == 'LT':
return None, None
elif titelive_type == 'LV':
return None, None
elif titelive_type == 'M':
return str(ThingType.LIVRE_EDITION), BookFormat.MOYEN_FORMAT.value
elif titelive_type == 'O':
return None, None
elif titelive_type == 'P':
return str(ThingType.LIVRE_EDITION), BookFormat.POCHE.value
elif titelive_type == 'PC':
return None, None
elif titelive_type == 'PS':
return None, None
elif titelive_type == 'R':
return str(ThingType.LIVRE_EDITION), BookFormat.REVUE.value
elif titelive_type == 'T' \
or titelive_type == 'TL':
return str(ThingType.LIVRE_EDITION), None
elif titelive_type == 'TR':
return None, None
else:
logger.debug(" WARNING: Unknown titelive_type: " + titelive_type)
return None, None
def manager_meta_job(group_id):
"""
添加, 删除, 修改job
该方法中使用了scheduler, 不能被序列化, 只能放到该类中
"""
logger.debug("starting manager_meta_job...")
subject_dao = SubjectManualInfo()
jobs = subject_dao.read_jobs(group_id)
# 遍历, 处理Job
for job in jobs:
process_status = job['process_status']
group_id = job['group_id']
subject_id = job['subject_id']
subject_name = job['subject_name']
monitor_type = job['monitor_type']
begin_time = job['begin_time']
end_time = job['end_time']
exec_type = job['exec_type']
exec_week = job['exec_week']
exec_time = job['exec_time']
cluster_type = job['cluster_type']
logger.debug('{subject_id: %s, process_status: %s}.' % (subject_id, process_status))
job_id = str(subject_id)
if process_status == 3: # delete job
try:
scheduler.remove_job(job_id)
except Exception, e:
logger.error('remove error, job not exists. {job_id: %s}' % (job_id,))
if process_status == 1 or process_status == 2: # add job
args = (group_id, subject_id, subject_name, monitor_type, begin_time, end_time, exec_time, cluster_type)
if exec_type == 0: # 一次数
args += ('cluster_result', )
run_date = datetime.strptime(exec_time, '%Y-%m-%d %H:%M')
scheduler.add_job(cluster_job, trigger='date', run_date=run_date,
id=job_id, args=args, replace_existing=True)
elif exec_type == 1: # 天
args += ('cluster_result', )
dt = datetime.strptime(exec_time, '%H:%M')
scheduler.add_job(cluster_job, trigger='cron', hour=dt.hour, minute=dt.minute,
id=job_id, args=args, replace_existing=True)
elif exec_type == 2: # 周
args += ('cluster_result_week', )
dt = datetime.strptime(exec_time, '%H:%M')
scheduler.add_job(cluster_job, trigger='cron', hour=dt.hour, minute=dt.minute,
day_of_week=exec_week,
id=job_id, args=args, replace_existing=True)
elif exec_type == 3: # 月
args += 'cluster_result_month',
dt = datetime.strptime(exec_time, '%d %H:%M')
scheduler.add_job(cluster_job, trigger='cron', day=dt.day, hour=dt.hour, minute=dt.minute,
id=job_id, args=args, replace_existing=True)
def register_api(self):
logger.debug(self.request.json)
face = self.request.json.get('face')
client_id = self.request.json.get('client_socket_id')
send_at = self.request.json.get('sent_at')
logger.debug('POST /register name: %s, client: %s, timestamp: %s' %
(face, client_id, send_at))
self.register_queue.put((face, client_id, send_at))
return DemoRegisterServer.response_success('Registering')
def _create_voting_table(self):
"""Filling table with assignment scores.
Create table which represents paired label assignments, i.e. each
cell comprises score for corresponding label assignment"""
size = max(len(np.unique(self.gt_labels_subset)),
len(np.unique(self.predicted_labels)))
self._voting_table = np.zeros((size, size))
for idx_gt, gt_label in enumerate(np.unique(self.gt_labels_subset)):
self._gt_label2index[gt_label] = idx_gt
self._gt_index2label[idx_gt] = gt_label
if len(self._gt_label2index) < size:
for idx_gt in range(len(np.unique(self.gt_labels_subset)), size):
gt_label = idx_gt
while gt_label in self._gt_label2index:
gt_label += 1
self._gt_label2index[gt_label] = idx_gt
self._gt_index2label[idx_gt] = gt_label
for idx_pr, pr_label in enumerate(np.unique(self.predicted_labels)):
self._pr_label2index[pr_label] = idx_pr
self._pr_index2label[idx_pr] = pr_label
if len(self._pr_label2index) < size:
for idx_pr in range(len(np.unique(self.predicted_labels)), size):
pr_label = idx_pr
while pr_label in self._pr_label2index:
pr_label += 1
self._pr_label2index[pr_label] = idx_pr
self._pr_index2label[idx_pr] = pr_label
for idx_gt, gt_label in enumerate(np.unique(self.gt_labels_subset)):
if gt_label in list(self.exclude.keys()):
continue
gt_mask = self.gt_labels_subset == gt_label
for idx_pr, pr_label in enumerate(np.unique(
self.predicted_labels)):
if pr_label in list(self.exclude.values()):
continue
self._voting_table[idx_gt, idx_pr] = \
np.sum(self.predicted_labels[gt_mask] == pr_label, dtype=float)
for key, val in self.exclude.items():
# works only if one pair in exclude
assert len(self.exclude) == 1
try:
self._voting_table[
self._gt_label2index[key],
self._pr_label2index[val[0]]] = size * np.max(
self._voting_table)
except KeyError:
logger.debug('No background!')
self._voting_table[self._gt_label2index[key],
-1] = size * np.max(self._voting_table)
self._pr_index2label[size - 1] = val[0]
self._pr_label2index[val[0]] = size - 1
def add_altitude_callback(self, callback: Callable):
logger.debug('Altitude callback')
if self.vessel_name is not '?':
altitude_stream = self.client.add_stream(
getattr, self.client.space_center.active_vessel.flight(),
'mean_altitude')
altitude_stream.rate = 10
altitude_stream.add_callback(callback)
altitude_stream.start()
def get_phone_number_by_user_name(self, user_name):
# TODO: Mocked because it's difficult to pull this from slack
# TODO: Update test if we pull this from slack later
team = Team()
for member in team.members:
logger.debug(member)
logger.debug("{0}, {1}".format(member["user_name"], user_name))
if member["user_name"] == user_name:
return member["name"], member["phone_number"]
def channel_from_phone_number(self, phone_number):
"""
Fetches a clients channel (i.e. itemId) from Unomi based on phone number
"""
profile = self.profile_search(phone_number)
logger.debug("PROFILE: {0}".format(profile))
if profile:
return profile["itemId"]
else:
return channel_token(phone_number)
def pages(self) -> int:
logger.debug(
f"Find total pages using `{BooksPageLocators.TOTAL_PAGES}`")
total_pages = self.soup.select_one(
BooksPageLocators.TOTAL_PAGES).string
pattern = r"Page [0-9]+ of ([0-9]+)"
match = re.search(pattern, total_pages)
page_count = int(match.group(1))
logger.info(f"Total number of pages: `{page_count}`.")
return page_count
def disable(self):
"""Assign diasble status E (boolean) on the selected channel.
:return: True if successful or False otherwise.
"""
self.select()
logger.debug("Disabled Device : {} , Channel : {}".format(
self.device, self.id))
return bitlib.BL_Enable(0)
def find_nearest_api(self):
image_id = self.request.json.get('image_id')
logger.debug('FindNearest, image_id: %s' % image_id)
try:
result = self.database.nearest_image_ids_for_image_id(image_id)
logger.debug(result)
return self.response_success(result=result)
except Exception as e:
logger.error(e, exec_info=True)
return self.response_error('Find nearest failed')
def price(self) -> (str, float):
logger.debug("Finding book price...")
locator = BookLocators.PRICE
elem = self.parent.select_one(locator).string
pattern = r"(.)([0-9]+\.[0-9]{2})"
match = re.search(pattern, elem)
Price = namedtuple("Price", ["currency", "number"])
price_instance = Price(match.group(1), float(match.group(2)))
logger.debug(f"Price found: `{price_instance.currency}`, `{price_instance.number}`.")
return price_instance
def __init__(self, server):
self.server = server
self.inactive_time_start = datetime.datetime.now()
self.inactive_time = 0
self.inactive_timer = False
self.time_interval = 6
self.last_wave = 0
threading.Thread.__init__(self)
logger.debug("Mapper for " + server.name + " initialised")
def request_task(peers, url, data):
for peer in peers:
try:
requests.post(get_peer_url(peer) + url,
data=data,
timeout=(5, 1))
except Exception as e:
logger.debug(
"Server: Requests: Error while sending data in process" +
str(peer))
def department_or_national_offers(query, departement_codes):
if '00' in departement_codes:
return query
query = query.filter(
Venue.departementCode.in_(departement_codes) | (Offer.isNational == True)
)
logger.debug(lambda: '(reco) departement .count ' + str(query.count()))
return query
def read_contract_output(self, contract_address: str) -> Optional[str]:
if contract_address.lower() == 'self':
contract_address = Wallet.gen_public_key(int(self.current_contract_priv_key))
if not is_valid_contract_address(contract_address):
raise Exception(f"Contract Address {contract_address} is invalid contract address")
_, co, _ = get_cc_co_cp_by_contract_address(contract_address)
co = str(co)
co = co.replace("'", "\\'") if co != '' else None
logger.debug(f"Read output of contract {contract_address}: {co}")
return co
def __init__(self, name):
self.sqlite_db_file = name + "_db" + ".sqlite"
if not path.exists(self.sqlite_db_file):
self.build_schema()
self.conn = sqlite3.connect(self.sqlite_db_file,
check_same_thread=False)
self.cur = self.conn.cursor()
logger.debug("Database for " + name + " initialised")
def mining_thread_task():
while True:
if not miner.is_mining() and not consts.NO_MINING:
try:
miner.start_mining(BLOCKCHAIN.mempool, BLOCKCHAIN.active_chain,
MY_WALLET)
except Exception as e:
miner.stop_mining()
logger.debug(f"Miner: Error while mining: {type(e)}({str(e)})")
time.sleep(consts.MINING_INTERVAL_THRESHOLD // 2)
def send(self, params=None, data=None, **kwargs):
response = self.session.request(method=self.method,
url=self.url,
params=params,
data=data,
**kwargs)
response.encoding = 'utf-8'
logger.debug('{0} {1}'.format(self.method, self.url))
logger.debug('请求成功: {0}\n{1}'.format(response, response.text))
return response
def execute_cleaners(df):
cleaners = dynamic_loading.objects_from_modules(DATA_CLEANERS_DIR, 'clean')
rows_count = len(df)
for clean_func in cleaners:
df = clean_func(df)
logger.debug('Row count is {} '
'({} Cleaned {} rows)'.format(len(df),
clean_func.__module__,
rows_count - len(df)))
rows_count = len(df)
return df
def train(self, counter=1, gen_dirs=()):
if self.conf.need_to_load:
self.load(self.conf.checkpoint_dir, step=counter)
data = self.data
logger.info('Total amount of images: %s' % len(data))
# np.random.shuffle(data)
tf.initialize_all_variables().run()
# counter = 1
start_time = time.time()
batch_idxs = min(len(data), self.conf.train_size) / self.conf.batch_size
stego_accuracy = 0
accuracies = []
accuracies_steps = []
logger.debug('Starting updating')
for epoch in range(self.conf.epoch):
losses = []
np.random.shuffle(data)
logger.info('Starting epoch %s' % epoch)
for idx in range(0, int(batch_idxs)):
batch_files = data[idx * self.conf.batch_size:(idx + 1) * self.conf.batch_size]
batch = [get_image(batch_file, self.conf.image_size)
for batch_file in batch_files]
batch_images = np.array(batch).astype(np.float32)
batch_targets = self.get_targets(batch_files)
self.sess.run(self.optimize, feed_dict={self.images: batch_images, self.target: batch_targets})
loss = self.loss.eval({self.images: batch_images, self.target: batch_targets})
losses.append(loss)
# logger.debug("[ITERATION] Epoch [%2d], iteration [%4d/%4d] time: %4.4f, Loss: %8f, accuracy: %8f" %
# (epoch, idx, batch_idxs, time.time() - start_time, loss, stego_accuracy))
counter += 1
if counter % 300 == 0:
logger.info('------')
stego_accuracy = self.accuracy(n_files=-1, test_dir=self.test_dir)
logger.info('[TEST] Epoch {:2d} accuracy: {:3.1f}%'.format(epoch + 1, 100 * stego_accuracy))
for gen_dir in gen_dirs:
gen_accuracy = self.accuracy(n_files=-1, test_dir=gen_dir)
logger.info('[GEN_TEST] Folder {}, accuracy: {:3.1f}%'.format(gen_dir, 100 * gen_accuracy))
def update_domains(update_all=False):
logger.debug('start to update domains')
try:
update_butian_src_domains(update_all)
except RequestException:
logger.error('update failed with bad network, please retry')
except JSONDecodeError:
logger.error('update failed with json decode error, please retry')
except Exception:
logger.error('unexpect error occured, please retry')
logger.debug('finish update domains')
def action_record(self):
if self.player.record_position:
logger.debug(
'stop recording player position, it will be saved to "record.npy"'
)
self.player.stop_recording_position()
np.save('records.npy',
self.player.position_records[:self.player.last_index])
else:
logger.debug('start recording player position')
self.player.start_recording_position()
def getAppData(key):
logger.info("Hitting URL %s", request.url)
error, response = None, None
response = AppDataCore.getAppDataForKey(key)
if response == None:
error = "Invalid data requested"
logger.debug("Error: %s", error)
logger.debug("Response: %s", response)
return jsonify(response=response, error=error)
def getProfileInfo(profileName):
logger.info("Hitting URL %s", request.url)
error, response = None, None
appData = AppDataCore.getAppData()
response = appData["profile"].get(profileName, None)
if response == None:
error = "Profile %s does not exist." % (profileName)
logger.debug("Error: %s", error)
logger.debug("Response: %s", response)
return jsonify(response=response, error=error)
def readfile():
logger.info("Hitting URL %s", request.url)
rawContent = None
filePath = request.args.get("file_path")
error, response = FileIO.readFile(filePath)
if error:
response = None
logger.debug("Error: %s", error)
logger.debug("Response: %s", response)
return jsonify(response=response, error=error)
def _validateInput(self, inputParams):
if not util.isEmail(inputParams.get('username')):
logger.debug('Invalid email address:' + inputParams.get('username'))
self._sendError(self.USERNAME_ERRORCODE, 'Invalid email address')
return False
if not util.isPassword(inputParams.get('password')):
logger.debug('Invalid password:'******'password'))
self._sendError(self.PASSWORD_ERRORCODE, 'Invalid password')
return False
return True
def load(self, checkpoint_dir, step):
model_dir = "%s_%s" % (self.conf.model_name, self.conf.batch_size)
checkpoint_dir = os.path.join(checkpoint_dir, model_dir)
try:
ckpt_name = "%s_%s.ckpt-%s" % (self.conf.model_name, step, step)
logger.info("[LOADING] step: %s, name: %s" % (step, ckpt_name))
self.saver.restore(self.sess, os.path.join(checkpoint_dir, ckpt_name))
except Exception as e:
logger.debug(e)
ckpt_name = "StegoDCGAN-%s" % (step)
logger.info("[LOADING] step: %s, name: %s" % (step, ckpt_name))
self.saver.restore(self.sess, os.path.join(checkpoint_dir, ckpt_name))
def register_dev(imei, platform, dev_type):
string = imei + platform + dev_type
did = uuid.uuid3(uuid.NAMESPACE_DNS, str(string)).hex
logger.debug('register device info:')
logger.debug('\timei: %s, platform: %s, dev_type: %s, did: %s' % (imei, platform, dev_type, did))
try:
with db_session:
dev = Device.get(did=did)
if not dev:
mast_secret = uuid.uuid4().hex
dev = Device(did=did, platform=platform, dev_type=dev_type, mast_secret=mast_secret)
return SuccessPage(dev.to_dict())
except Exception, e:
logger.error(e)
return ErrorPage(ErrNo.INTERNAL_SERVER_ERROR)
def addProfile(profile):
logger.info("Hitting URL %s", request.url)
error, response = None, None
action = request.form.get("action")
if action == "add":
error, response = TagCore.addProfile(profile)
elif action == "delete":
error, response = TagCore.removeProfile(profile)
if error:
response = None
logger.debug("Error: %s", error)
logger.debug("Response: %s", response)
return jsonify(response=response, error=error)
def run(self, stop_on_failure=False):
fail_cnt = 0
metadata = None
getter = self.iter_get()
try:
while True:
try:
# Some getters require metadata from the last response to figure out the
# pagination of the next one
data_str = getter.send(metadata)
logger.debug('Got: %s' % data_str)
logger.info('Got records')
data = self.parse(data_str)
logger.debug('Parsed into: %s' % str(data))
metadata, records = self.normalize(data)
logger.debug('Normalized: \nMetadata: %s \nRecords: %s' % \
(str(metadata), str(records)))
logger.info('Normalized %d records' % len(records))
logger.info('Storing')
self.store(metadata, records)
except Exception, e:
if isinstance(e, StopIteration):
raise
if stop_on_failure or fail_cnt > 100:
raise
else:
fail_cnt += 1
sys.stderr.write("Failed: %s" % str(e))
continue
except StopIteration:
pass
def main():
logger.info('Started.')
gmail = build('gmail', 'v1', http=make_google())
gmail_send = gmail.users().messages().send
email_messages = {}
with open(CONFIG_FILE, 'r') as file:
users = json.load(file)
logger.debug('User loaded')
for endpoint in ENDPOINTS:
logger.info('Processing endpoint: %s', endpoint.name)
endpoint.request()
if not make_cache(endpoint.name, endpoint._text):
logger.debug('Content is same with cached. Skipping.')
continue
for user in users:
logger.debug('Processing user: %s', user['name'])
if user['name'] in endpoint:
logger.debug('User in endpoint.')
message = make_message('match', regexp=user['name'],
name=endpoint.name, url=endpoint.url)
email_messages.setdefault(user['email'], []).append(message)
logger.info('Done fetching endpoints. Now drafting email.')
queue = []
for recepient, messages in email_messages.items():
message_text = make_message('frame', matches='\n'.join(messages))
message = MIMEText(message_text)
message['to'] = recepient
# message['from'] = sender
message['subject'] = MAIL_SUBJECT
# The byte/str drama, you know.
raw = base64.b64encode(message.as_string().encode())
queue.append({'raw': raw.decode()})
logger.info('%d email(s) have been drafted. Sending.', len(queue))
consume_message_queue(gmail_send, queue)
logger.info('Done.')
def train(self):
if self.conf.need_to_load:
self.load(self.conf.checkpoint_dir)
data = glob(os.path.join(self.conf.data, "*.%s" % self.conf.img_format))
logger.info('Total amount of images: %s' % len(data))
# np.random.shuffle(data)
d_fr_optim = tf.train.AdamOptimizer(self.conf.learning_rate, beta1=self.conf.beta1)
d_fr_optim = d_fr_optim.minimize(self.d_fr_loss, var_list=self.d_fr_vars)
d_s_n_optim = tf.train.AdamOptimizer(self.conf.learning_rate, beta1=self.conf.beta1)
d_s_n_optim = d_s_n_optim.minimize(self.d_stego_loss_total, var_list=self.d_s_n_vars)
g_optim_fake = tf.train.AdamOptimizer(self.conf.learning_rate, beta1=self.conf.beta1)
g_optim_fake = g_optim_fake.minimize(self.g_loss, var_list=self.g_vars)
# g_optim_stego = tf.train.AdamOptimizer(0.000005, beta1=0.9)
# g_optim_stego = g_optim_stego.minimize(self.g_loss_stego, var_list=self.g_vars)
merged = tf.merge_all_summaries()
train_writer = tf.train.SummaryWriter('./logs_sgan', self.sess.graph)
tf.initialize_all_variables().run()
sample_z = np.random.uniform(-1, 1, size=(self.sample_size, self.z_dim))
sample_files = data[0:self.sample_size]
sample = [get_image(sample_file, self.image_size, need_transform=True) for sample_file in sample_files]
sample_images = np.array(sample).astype(np.float32)
counter = 1
start_time = time.time()
batch_idxs = min(len(data), self.conf.train_size) / self.conf.batch_size
logger.debug('Starting updating')
for epoch in range(self.conf.epoch):
stego_losses, fake_real_losses, generator_losses = [], [], []
logger.info('Starting epoch %s' % epoch)
for idx in range(0, int(batch_idxs)):
batch_files = data[idx * self.conf.batch_size:(idx + 1) * self.conf.batch_size]
batch = [get_image(batch_file, self.image_size, need_transform=True) for batch_file in batch_files]
batch_images = np.array(batch).astype(np.float32)
batch_z = np.random.uniform(-1, 1, [self.conf.batch_size, self.z_dim]).astype(np.float32)
self.sess.run(d_fr_optim, feed_dict={self.images: batch_images, self.z: batch_z})
self.sess.run(d_s_n_optim, feed_dict={self.images: batch_images, self.z: batch_z})
self.sess.run(g_optim_fake, feed_dict={self.z: batch_z})
self.sess.run(g_optim_fake, feed_dict={self.z: batch_z})
# # if epoch > 5:
# self.sess.run(g_optim_stego, feed_dict={self.z: batch_z})
# errD_fake = self.d_loss_fake.eval({self.z: batch_z})
# errD_real = self.d_loss_real.eval({self.images: batch_images})
#
# errD_stego = self.d_loss_stego.eval({self.z: batch_z})
# errD_n_stego = self.d_loss_nonstego.eval({self.z: batch_z})
#
# errG = self.g_loss.eval({self.z: batch_z})
#
# fake_real_losses.append(errD_fake + errD_stego)
# stego_losses.append(errD_stego + errD_n_stego)
# generator_losses.append(errG)
#
logger.debug("[ITERATION] Epoch [%2d], iteration [%4d/%4d] time: %4.4f" %
(epoch, idx, batch_idxs, time.time() - start_time))
# logger.debug('[LOSS] Real/Fake: %.8f' % (errD_fake + errD_real))
# logger.debug('[LOSS] Stego/Non-Stego: %.8f' % (errD_stego + errD_n_stego))
# logger.debug('[LOSS] Generator: %.8f' % errG)
counter += 1
if np.mod(counter, 1000) == 0:
self.save(self.conf.checkpoint_dir, counter)
if np.mod(counter, 300) == 0:
logger.info('Save samples')
samples, d_loss, g_loss = self.sess.run(
[self.sampler, self.d_fr_loss, self.g_loss_fake,
],
feed_dict={self.z: sample_z, self.images: sample_images}
)
save_images_to_one(samples, [8, 8], './samples/train_%s_%s.png' % (epoch, idx))
