def save_excitation_force(result, filename):
"""
Saves the excitation forces to a file in tec format
Args:
result: object, the hydrodynamic coefficients cases
filename: The path to the file where to save
"""
signature = __name__ + '.save_excitation_force(result, filename)'
logger = logging.getLogger(__name__)
utility.log_entrance(logger, signature,
{"result": str(result),
'filename': str(filename)})
utility.mkdir_p(os.path.abspath(os.path.dirname(filename)))
with open(filename, 'w') as inp:
inp.write('VARIABLES="w (rad/s)"\n')
for k in range(result.n_integration):
s = '"abs(F\t' + str(result.idx_force[k, 1]) + '\t' + str(result.idx_force[k, 2])
s += ')" "angle(F\t' + str(result.idx_force[k, 1]) + '\t' + str(result.idx_force[k, 2]) + ')"\n'
inp.write(s)
for j in range(result.n_beta):
s = 'Zone t="Diffraction force - beta = ' + str(result.beta[j]*180./(4.*np.arctan(1.0)))
s += ' deg",I= ' + str(result.n_w) + ',F=POINT\n'
inp.write(s)
for i in range(result.n_w):
s = str(result.w[i]) + '\t'
for k in range(result.n_integration):
temp = result.diffraction_force[i, j, k] + result.froudkrylov_force[i, j, k]
s += str(np.abs(temp)) + '\t'
s += str(np.arctan2(np.imag(temp), np.real(temp))) + '\t'
inp.write(s + '\n')
utility.log_and_print(logger, utility.get_abs(filename) + ' contains the excitation forces in tec format.')
utility.log_exit(logger, signature, [None])
def test(args, testloader, enc, dec, disc_l, disc_v, epoch, use_cuda):
global best_acc
batch_time = AverageMeter()
data_time = AverageMeter()
top1 = AverageMeter()
# switch to evaluate mode
enc.eval()
dec.eval()
disc_l.eval()
disc_v.eval()
end = time.time()
batch = args.batch
isize = args.isize
csize = args.cropsize
exp = args.exp_name
for batch_idx, (inputs, targets) in enumerate(testloader):
# measure data loading time
data_time.update(time.time() - end)
if use_cuda:
inputs, targets = inputs.cuda(), targets.cuda()
with torch.no_grad():
inputs, targets = torch.autograd.Variable(
inputs), torch.autograd.Variable(targets)
# compute output
recon = dec(enc(inputs), args)
scores = torch.mean(torch.pow((inputs - recon), 2), dim=[1, 2, 3])
prec1 = roc_auc_score(targets.cpu().detach().numpy(),
-scores.cpu().detach().numpy())
top1.update(prec1, inputs.size(0))
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
print(top1.avg)
recon = recon.cpu().data
recon = recon / 2 + 0.5
inputs = inputs.cpu().data
inputs = inputs / 2 + 0.5
if not os.path.exists('./result'):
os.mkdir('./result')
if not os.path.isdir(os.path.join("result", exp, "test_real")):
utility.mkdir_p(os.path.join("result", exp, "test_real"))
if not os.path.isdir(os.path.join("result", exp, "test_fake")):
utility.mkdir_p(os.path.join("result", exp, "test_fake"))
t_fake_name = 'fake' + exp + '_' + str(epoch) + '.png'
t_real_name = 'real' + exp + '_' + str(epoch) + '.png'
save_image(recon, os.path.join(".", "result", exp, "test_fake",
t_fake_name))
save_image(inputs,
os.path.join(".", "result", exp, "test_real", t_real_name))
return top1.avg
def save_radiation_coefficients(result, filename):
"""
Saves the radiation coefficient to a file in tec format
Args:
result: object, the hydrodynamic coefficients cases
filename: The path to the file where to save
"""
utility.mkdir_p(os.path.abspath(os.path.dirname(filename)))
with open(filename, 'w') as inp:
inp.write('VARIABLES="w (rad/s)"\n')
for k in range(result.n_integration):
s = '"A\t' + str(result.idx_force[k, 1]) + '\t' + str(result.idx_force[k, 2])
s = s + '" "B\t' + str(result.idx_force[k, 1]) + '\t' + str(result.idx_force[k, 2]) + '"\n'
inp.write(s)
for j in range(result.n_radiation):
s = 'Zone t="Motion of body\t' + str(result.idx_radiation[j, 1])
s += '\tin DoF\t' + str(result.idx_radiation[j, 2]) + '",I=\t' + str(result.n_w) + ',F=POINT\n'
inp.write(s)
for i in range(result.n_w):
s = str(result.w[i]) + '\t'
for k in range(result.n_integration):
s += str(result.added_mass[i, j, k]) + '\t' + str(result.radiation_damping[i, j, k]) + '\t'
inp.write(s + '\n')
def save_irf(irf, filename):
"""
Saves the irf to a file in the tec format
Args:
irf: object, the irf
filename: string, The path to the file where to save the irf
"""
signature = __name__ + '.save_irf(irf, filename)'
logger = logging.getLogger(__name__)
utility.log_entrance(logger, signature,
{"irf": str(irf),
'filename': str(filename)})
utility.mkdir_p(os.path.abspath(os.path.dirname(filename)))
with open(filename, 'w') as inp:
inp.write('VARIABLES="Time (s)"\n')
for k in range(irf.n_integration):
inp.write('"AddedMass '+ str(k+1) + '" "IRF ' + str(k+1) +'"\n')
for j in range(irf.n_radiation):
inp.write('Zone t="DoF ' + str(j+1) + '",I=\t' + str(irf.n_time) + ',F=POINT\n')
for i in range(irf.n_time):
inp.write(' ' + str(irf.time[i]) + ' ')
s = ''
for k in range(irf.n_integration):
s += ' ' + str(irf.added_mass[j, k]) + ' ' + ' ' + str(irf.k[i, j, k]) + ' '
inp.write(s + '\n')
utility.log_and_print(logger, utility.get_abs(filename) + ' contains the irf in tec format.')
utility.log_exit(logger, signature, [None])
def save_stifness(result, filename):
"""
Saves the radiation coefficient to a file in tec format
Args:
result: object, the hydrodynamic coefficients cases
filename: The path to the file where to save
"""
signature = __name__ + '.save_stifness(result, filename)'
logger = logging.getLogger(__name__)
utility.log_entrance(logger, signature, {
"result": str(result),
'filename': str(filename)
})
utility.mkdir_p(os.path.abspath(os.path.dirname(filename)))
with open(filename, 'w') as inp:
for i in range(len(result[:, :])):
for j in range(len(result[:, :])):
if j == len(result[:, :]) - 1:
inp.write(" % E\n" % result[i, j])
else:
inp.write(" % E " % result[i, j])
utility.log_and_print(
logger,
utility.get_abs(filename) + ' contains the hydrostatic stifness.')
utility.log_exit(logger, signature, [None])
def save_irf(irf, filename):
"""
Saves the irf to a file in the tec format
Args:
irf: object, the irf
filename: string, The path to the file where to save the irf
"""
signature = __name__ + '.save_irf(irf, filename)'
logger = logging.getLogger(__name__)
utility.log_entrance(logger, signature, {
"irf": str(irf),
'filename': str(filename)
})
utility.mkdir_p(os.path.abspath(os.path.dirname(filename)))
with open(filename, 'w') as inp:
inp.write('VARIABLES="Time (s)"\n')
for k in range(irf.n_integration):
inp.write('"AddedMass ' + str(k + 1) + '" "IRF ' + str(k + 1) +
'"\n')
for j in range(irf.n_radiation):
inp.write('Zone t="DoF ' + str(j + 1) + '",I=\t' +
str(irf.n_time) + ',F=POINT\n')
for i in range(irf.n_time):
inp.write(' ' + str(irf.time[i]) + ' ')
s = ''
for k in range(irf.n_integration):
s += ' ' + str(irf.added_mass[j, k]) + ' ' + ' ' + str(
irf.k[i, j, k]) + ' '
inp.write(s + '\n')
utility.log_and_print(
logger,
utility.get_abs(filename) + ' contains the irf in tec format.')
utility.log_exit(logger, signature, [None])
def save_excitation_force(result, filename):
"""
Saves the excitation forces to a file in tec format
Args:
result: object, the hydrodynamic coefficients cases
filename: The path to the file where to save
"""
utility.mkdir_p(os.path.abspath(os.path.dirname(filename)))
with open(filename, 'w') as inp:
inp.write('VARIABLES="w (rad/s)"\n')
for k in range(result.n_integration):
s = '"abs(F\t' + str(result.idx_force[k, 1]) + '\t' + str(result.idx_force[k, 2])
s += ')" "angle(F\t' + str(result.idx_force[k, 1]) + '\t' + str(result.idx_force[k, 2]) + ')"\n'
inp.write(s)
for j in range(result.n_beta):
s = 'Zone t="Diffraction force - beta = ' + str(result.beta[j]*180./(4.*np.arctan(1.0)))
s += ' deg",I=' + str(result.n_w) + ',F=POINT\n'
inp.write(s)
for i in range(result.n_w):
s = str(result.w[i]) + '\t'
for k in range(result.n_integration):
temp = result.diffraction_force[i, j, k] + result.froudkrylov_force[i, j, k]
s += str(np.abs(temp)) + '\t'
s += str(np.arctan2(np.imag(temp), np.real(temp))) + '\t'
inp.write(s + '\n')
def write_fk_force_tec(int_case, fk_force, w, beta, filename):
"""
Writes the froude krylov forces to .tec format
Args:
int_case: 1D array, the integration cases
fk_forces: 3D array, the froudkrylov forces
w: 1D array, represents the wave frequencies omega
beta: 1D array, represents the wave directions beta
filename: string, the path to the file where to save the forces
"""
utility.mkdir_p(os.path.abspath(os.path.dirname(filename)))
n_integration = len(int_case)
n_beta = len(beta)
n_w = len(w)
with open(filename, 'w') as inp:
inp.write('VARIABLES="w (rad/s)"\n')
for k in range(n_integration):
s = '"abs(F\t' + str(int_case[k].body +
1) + '\t' + str(k + 1) + ')" "angle(F\t'
s += str(int_case[k].body + 1) + '\t' + str(k + 1) + ')"\n'
inp.write(s)
for c in range(n_beta):
inp.write('Zone t="FKforce - beta =\t' +
str(beta[c] * 180. / np.pi) + '",I=\t' + str(n_w) +
',F=POINT\n')
for i in range(n_w):
s = str(w[i]) + '\t'
for k in range(n_integration):
val = str(
np.arctan2(np.imag(fk_force[i, c, k]),
np.real(fk_force[i, c, k])))
s += str(np.abs(fk_force[i, c, k])) + '\t' + val + '\t'
inp.write(s)
inp.write('\n')
def write_mesh_tec(mesh, mesh_tec_file):
"""
Export the mesh to tec file
Args:
mesh: object, the mesh
mesh_tec_file: string, the path to the mesh tec file to save
"""
utility.mkdir_p(os.path.abspath(os.path.dirname(mesh_tec_file)))
with open(mesh_tec_file, 'w') as inp:
inp.write('VARIABLES="X" "Y" "Z" "NX" "NY" "NZ" "A"\n')
inp.write('ZONE N=\t' + str(mesh.n_points) + '\t, E=\t' +
str(mesh.n_panels) + '\t, F=FEPOINT,ET=QUADRILATERAL\n')
for i in range(mesh.n_points):
s = str(mesh.x[0, i]) + '\t' + str(mesh.x[1, i]) + '\t' + str(
mesh.x[2, i]) + '\t0.\t0.\t0.\t0.\n'
inp.write(s)
for i in range(mesh.n_panels):
s = str(mesh.p[0, i] +
1) + '\t' + str(mesh.p[1, i] + 1) + '\t' + str(
mesh.p[2, i] + 1) + '\t' + str(mesh.p[3, i] + 1) + '\n'
inp.write(s)
inp.write('ZONE t="normales", F=POINT, I=\t' + str(mesh.n_panels) +
'\n')
for i in range(mesh.n_panels):
s = str(mesh.xm[0, i]) + '\t' + str(mesh.xm[1, i]) + '\t' + str(
mesh.xm[2, i]) + '\t'
s += str(mesh.n[0, i]) + '\t' + str(mesh.n[1, i]) + '\t' + str(
mesh.n[2, i]) + '\t'
s += str(mesh.a[i]) + '\n'
inp.write(s)
def write_fk_force_tec(int_case, fk_force, w, beta, filename):
"""
Writes the froude krylov forces to .tec format
Args:
int_case: 1D array, the integration cases
fk_forces: 3D array, the froudkrylov forces
w: 1D array, represents the wave frequencies omega
beta: 1D array, represents the wave directions beta
filename: string, the path to the file where to save the forces
"""
utility.mkdir_p(os.path.abspath(os.path.dirname(filename)))
n_integration = len(int_case)
n_beta = len(beta)
n_w = len(w)
with open(filename, 'w') as inp:
inp.write('VARIABLES="w (rad/s)"\n')
for k in range(n_integration):
s = '"abs(F\t' + str(int_case[k].body + 1) + '\t' + str(k+1) + ')" "angle(F\t'
s += str(int_case[k].body + 1) + '\t' + str(k+1) + ')"\n'
inp.write(s)
for c in range(n_beta):
inp.write('Zone t="FKforce - beta =\t' + str(beta[c]*180./np.pi) + '",I=\t' + str(n_w) + ',F=POINT\n')
for i in range(n_w):
s = str(w[i]) + '\t'
for k in range(n_integration):
val = str(np.arctan2(np.imag(fk_force[i, c, k]), np.real(fk_force[i, c, k])))
s += str(np.abs(fk_force[i, c, k])) + '\t' + val + '\t'
inp.write(s)
inp.write('\n')
def write_mesh_tec(mesh, mesh_tec_file):
"""
Export the mesh to tec file
Args:
mesh: object, the mesh
mesh_tec_file: string, the path to the mesh tec file to save
"""
utility.mkdir_p(os.path.abspath(os.path.dirname(mesh_tec_file)))
with open(mesh_tec_file, 'w') as inp:
inp.write('VARIABLES="X" "Y" "Z" "NX" "NY" "NZ" "A"\n')
inp.write('ZONE N=\t' + str(mesh.n_points) + '\t, E=\t' + str(mesh.n_panels) + '\t, F=FEPOINT,ET=QUADRILATERAL\n')
for i in range(mesh.n_points):
s = str(mesh.x[0, i]) + '\t' + str(mesh.x[1, i]) + '\t' + str(mesh.x[2, i]) + '\t0.\t0.\t0.\t0.\n'
inp.write(s)
for i in range(mesh.n_panels):
s = str(mesh.p[0, i] + 1) + '\t' + str(mesh.p[1, i] + 1) + '\t' + str(mesh.p[2, i] + 1) + '\t' + str(mesh.p[3, i] + 1) + '\n'
inp.write(s)
inp.write('ZONE t="normales", F=POINT, I=\t' + str(mesh.n_panels) + '\n')
for i in range(mesh.n_panels):
s = str(mesh.xm[0, i]) + '\t' + str(mesh.xm[1, i]) + '\t' + str(mesh.xm[2, i]) + '\t'
s += str(mesh.n[0, i]) + '\t' + str(mesh.n[1, i]) + '\t' + str(mesh.n[2, i]) + '\t'
s += str(mesh.a[i]) + '\n'
inp.write(s)
def save_radiation_coefficients(result, filename):
"""
Saves the radiation coefficient to a file in tec format
Args:
result: object, the hydrodynamic coefficients cases
filename: The path to the file where to save
"""
signature = __name__ + '.save_radiation_coefficients(result, filename)'
logger = logging.getLogger(__name__)
utility.log_entrance(logger, signature,
{"result": str(result),
'filename': str(filename)})
utility.mkdir_p(os.path.abspath(os.path.dirname(filename)))
with open(filename, 'w') as inp:
inp.write('VARIABLES="w (rad/s)"\n')
for k in range(result.n_integration):
s = '"A\t' + str(result.idx_force[k, 1]) + '\t' + str(result.idx_force[k, 2])
s = s + '" "B\t' + str(result.idx_force[k, 1]) + '\t' + str(result.idx_force[k, 2]) + '"\n'
inp.write(s)
for j in range(result.n_radiation):
s = 'Zone t="Motion of body\t' + str(result.idx_radiation[j, 1])
s += '\tin DoF\t' + str(result.idx_radiation[j, 2]) + '",I=\t' + str(result.n_w) + ',F=POINT\n'
inp.write(s)
for i in range(result.n_w):
s = str(result.w[i]) + '\t'
for k in range(result.n_integration):
s += str(result.added_mass[i, j, k]) + '\t' + str(result.radiation_damping[i, j, k]) + '\t'
inp.write(s + '\n')
utility.log_and_print(logger, utility.get_abs(filename) + ' contains the radiation coefficients in tec format.')
utility.log_exit(logger, signature, [None])
def _autosave(self, autosave_dir, sim_data):
utility.mkdir_p(autosave_dir)
#filename
temp = ['%s',self.__class__.__name__]+list(map(lambda x: str(x), time.localtime()[0:6]))
file_name = os.path.join(autosave_dir, "-".join(temp)+'.csv')
#make and save dataframe
str_formatted_data = sim_data.to_csv()#file_name%'all_sim_traces')
#also save all model info to txt file
with open(file_name%'simulation_autosave', "w") as f:
with utility.stdout_redirected(f):
self.printVarsHelper()
print '--------------------'
print str_formatted_data
def save_image(self):
self.last_save_was_series = False
mkdir_p(self.save_directory())
write_image(self.filename() + '.tif',
self.image,
metadata=self.metadata)
self.save.setChecked(False)
if self.include_incrementing_image_num.isChecked():
increment_textbox(self.include_incrementing_image_num)
elif self.include_incrementing_dir_num.isChecked():
increment_textbox(self.include_incrementing_dir_num)
zero_textbox(self.include_incrementing_image_num)
def save_wave_elevation(w, etai, etap, eta, x, y, filename):
"""
Save the wave elevation to a file in tec format
Args:
w: float, the wave frequency
etai: 2D array, a wave elevation variable
eta: 2D array, a wave elevation variable
etap: 2D array, a wave elevation variable
x: 1D array, a wave elevation variable
y: 1D array, a wave elevation variable
filename: string, the path to the file where to save
"""
signature = __name__ + '.save_wave_elevation(w, etai, etap, eta, x, y, filename)'
logger = logging.getLogger(__name__)
utility.log_entrance(logger, signature,
{"w": w,
"etai": etai,
"etap": etap,
"eta": eta,
"x": x,
"y": y,
"filename": filename})
nx = len(x)
ny = len(y)
utility.mkdir_p(os.path.abspath(os.path.dirname(filename)))
with open(filename, 'w') as inp:
s = 'VARIABLES="X" "Y" "etaI_C" "etaI_S" "etaP_C" "etaC_S" '
s += '"etaI_C+etaP_C" "etaI_S+etaI_P" "|etaP|" "|etaI+etaP|"\n'
inp.write(s)
s = 'ZONE t="Wave frequency - w = '
s += str(w)+ '",N=\t'+ str(nx*ny) + ', E=\t' + str((nx-1)*(nx-1)) + '\t , F=FEPOINT,ET=QUADRILATERAL\n'
inp.write(s)
for i in range(nx):
for j in range(ny):
s = str(x[i]) + '\t' + str(y[j]) + '\t' + str(np.real(etai[i, j])) + '\t'
s += str(np.imag(etai[i,j])) + '\t' + str(np.real(etap[i, j])) + '\t'
s += str(np.imag(etap[i,j])) + '\t' + str(np.real(etai[i,j]+etap[i,j])) + '\t'
s += str(np.imag(etai[i,j]+etap[i,j])) + '\t' + str(np.abs(etap[i,j])) + '\t'
s += str(np.abs(eta[i,j])) + '\n'
inp.write(s)
for i in range(nx-1):
for j in range(ny-1):
s = str(j+1+i*ny) + '\t' + str(j+1+(i+1)*ny) + '\t' + str(j+2+ i*ny) + '\n'
inp.write(s)
utility.log_and_print(logger, utility.get_abs(filename) + ' contains the wave elevation in tec format.')
utility.log_exit(logger, signature, [None])
def train_options():
parser=argparse.ArgumentParser()
# Datasets
parser.add_argument('--exp_name' , default='first_ex',type=str)
parser.add_argument('--dataroot', default='./data', type=str)
parser.add_argument('--normal_class', default='1', type=str)
parser.add_argument('--abnormal_class', default='1', type=str)
parser.add_argument('--datasource' , default='./data',type=str)
parser.add_argument('--isize', default='28', type=int)
parser.add_argument('--cropsize', default='28', type=int)
parser.add_argument('--protocol', default ='1', type = int)
parser.add_argument('-j', '--workers', default=4, type=int, metavar='N',
help='number of data loading workers (default: 4)')
parser.add_argument('--latent', default = 16, type = int)
# Optimization options
parser.add_argument('--epochs', default=100, type=int, metavar='N',
help='number of total epochs to run')
parser.add_argument('--start-epoch', default=0, type=int, metavar='N',
help='manual epoch number (useful on restarts)')
parser.add_argument('--batch', default=128, type=int, metavar='N',
help='batchsize')
parser.add_argument('--lr', '--learning-rate', default=0.001, type=float,
metavar='LR', help='initial learning rate')
parser.add_argument('--momentum', default=0.9, type=float, metavar='M',
help='momentum')
parser.add_argument('--weight-decay', '--wd', default=5e-4, type=float,
metavar='W', help='weight decay (default: 1e-4)')
parser.add_argument('--manualSeed', type=int, help='manual seed')
# Checkpoints
parser.add_argument('-c', '--checkpoint', default='checkpoint', type=str, metavar='PATH',
help='path to save checkpoint (default: checkpoint)')
parser.add_argument('--resume', default='', type=str, metavar='PATH',
help='path to latest checkpoint (default: none)')
# Architecture
# Miscs
#Device options
parser.add_argument('--gpu-id', default='0', type=str,
help='id(s) for CUDA_VISIBLE_DEVICES')
args = parser.parse_args()
if not os.path.isdir(args.checkpoint):
utility.mkdir_p(args.checkpoint)
with open(os.path.join(args.checkpoint,'configuration.json'), 'w') as f:
json.dump(args.__dict__, f, indent=2)
return args
def plot(history_model):
plt.plot(history_model.history['val_loss'],
'g',
label='Network 1 Val Loss')
plt.plot(history_model.history['loss'], 'r', label='Network Loss')
plt.plot(history_model.history['val_acc'], 'b-', label='Network 1 Val acc')
plt.plot(history_model.history['acc'], 'y-', label='Network acc')
plt.xlabel('Epochs')
plt.ylabel('acc/loss')
plt.legend()
out_path = path.join(RESULT_PATH, 'figures')
if not path.exists(out_path):
util.mkdir_p(out_path)
plt.savefig(path.join(out_path, 'comparison_of_networks_acc.png'))
def preprocess(custom_config):
"""
Configure and then run the preprocessor
Args:
custom_config, dict The custom configuration dictionary
"""
if not custom_config:
custom_config = {}
hdf5_file = utility.get_setting(settings.HDF5_FILE, custom_config,
'HDF5_FILE')
nemoh_cal = utility.get_setting(settings.NEMOH_CALCULATIONS_FILE,
custom_config, 'NEMOH_CALCULATIONS_FILE')
input_file = utility.get_setting(settings.NEMOH_INPUT_FILE, custom_config,
'NEMOH_INPUT_FILE')
utility.validate_string(hdf5_file, 'HDF5_FILE')
if not nemoh_cal and not input_file:
utility.validate_file(hdf5_file, 'HDF5_FILE')
utility.mkdir_p(os.path.abspath(os.path.dirname(hdf5_file)))
with h5py.File(hdf5_file, "a") as hdf5_db:
if nemoh_cal:
utility.convert_calculations(nemoh_cal, hdf5_db)
if input_file:
utility.convert_input(input_file, hdf5_db)
remove_irregular_frequencies = utility.get_setting(
settings.REMOVE_IRREGULAR_FREQUENCIES, custom_config,
'REMOVE_IRREGULAR_FREQUENCIES')
if remove_irregular_frequencies is not None:
dset = utility.require_dataset(
hdf5_db,
structure.H5_SOLVER_REMOVE_IRREGULAR_FREQUENCIES, (1, ),
dtype='i')
utility.set_hdf5_attributes(
dset, structure.H5_SOLVER_REMOVE_IRREGULAR_FREQUENCIES_ATTR)
dset[:] = int(remove_irregular_frequencies)
else:
settings.REMOVE_IRREGULAR_FREQUENCIES = hdf5_db.get(
structure.H5_SOLVER_REMOVE_IRREGULAR_FREQUENCIES)[0]
run(hdf5_db, custom_config)
def plot(history_model):
plt.figure()
plt.plot(history_model.history['val_main_output_loss'],
'g--',
label='Val Main output Loss')
plt.plot(history_model.history['main_output_loss'],
'r',
label='Main output Loss')
plt.plot(history_model.history['val_aux_output_loss'],
'b--',
label='Val AUX output Loss')
plt.plot(history_model.history['aux_output_loss'],
'y',
label='Aux Loss')
plt.xlabel('Epochs')
plt.ylabel('loss')
plt.legend()
out_path = path.join(RESULT_PATH, 'figures')
if not path.exists(out_path):
util.mkdir_p(out_path)
plt.savefig(path.join(out_path, 'cnn_comparison_of_networks_loss.png'))
plt.figure()
plt.plot(history_model.history['val_main_output_acc'],
'g--',
label='Network 1 Val Main output acc')
plt.plot(history_model.history['main_output_acc'],
'r',
label='Main output acc')
plt.plot(history_model.history['val_aux_output_acc'],
'b--',
label='Val Aux acc')
plt.plot(history_model.history['aux_output_acc'],
'y',
label='Aux acc')
plt.xlabel('Epochs')
plt.ylabel('acc')
plt.legend()
plt.savefig(path.join(out_path, 'cnn_comparison_of_networks_acc.png'))
def save_radiation_coefficients(result, filename):
"""
Saves the radiation coefficient to a file in tec format
Args:
result: object, the hydrodynamic coefficients cases
filename: The path to the file where to save
"""
signature = __name__ + '.save_radiation_coefficients(result, filename)'
logger = logging.getLogger(__name__)
utility.log_entrance(logger, signature, {
"result": str(result),
'filename': str(filename)
})
utility.mkdir_p(os.path.abspath(os.path.dirname(filename)))
with open(filename, 'w') as inp:
inp.write('VARIABLES="w (rad/s)"\n')
for k in range(result.n_integration):
s = '"A\t' + str(result.idx_force[k, 1]) + '\t' + str(
result.idx_force[k, 2])
s = s + '" "B\t' + str(result.idx_force[k, 1]) + '\t' + str(
result.idx_force[k, 2]) + '"\n'
inp.write(s)
for j in range(result.n_radiation):
s = 'Zone t="Motion of body\t' + str(result.idx_radiation[j, 1])
s += '\tin DoF\t' + str(
result.idx_radiation[j, 2]) + '",I=\t' + str(
result.n_w) + ',F=POINT\n'
inp.write(s)
for i in range(result.n_w):
s = str(result.w[i]) + '\t'
for k in range(result.n_integration):
s += str(result.added_mass[i, j, k]) + '\t' + str(
result.radiation_damping[i, j, k]) + '\t'
inp.write(s + '\n')
utility.log_and_print(
logger,
utility.get_abs(filename) +
' contains the radiation coefficients in tec format.')
utility.log_exit(logger, signature, [None])
def save_excitation_force(result, filename):
"""
Saves the excitation forces to a file in tec format
Args:
result: object, the hydrodynamic coefficients cases
filename: The path to the file where to save
"""
signature = __name__ + '.save_excitation_force(result, filename)'
logger = logging.getLogger(__name__)
utility.log_entrance(logger, signature, {
"result": str(result),
'filename': str(filename)
})
utility.mkdir_p(os.path.abspath(os.path.dirname(filename)))
with open(filename, 'w') as inp:
inp.write('VARIABLES="w (rad/s)"\n')
for k in range(result.n_integration):
s = '"abs(F\t' + str(result.idx_force[k, 1]) + '\t' + str(
result.idx_force[k, 2])
s += ')" "angle(F\t' + str(result.idx_force[k, 1]) + '\t' + str(
result.idx_force[k, 2]) + ')"\n'
inp.write(s)
for j in range(result.n_beta):
s = 'Zone t="Diffraction force - beta = ' + str(
result.beta[j] * 180. / (4. * np.arctan(1.0)))
s += ' deg",I=' + str(result.n_w) + ',F=POINT\n'
inp.write(s)
for i in range(result.n_w):
s = str(result.w[i]) + '\t'
for k in range(result.n_integration):
temp = result.diffraction_force[
i, j, k] + result.froudkrylov_force[i, j, k]
s += str(np.abs(temp)) + '\t'
s += str(np.arctan2(np.imag(temp), np.real(temp))) + '\t'
inp.write(s + '\n')
utility.log_and_print(
logger,
utility.get_abs(filename) +
' contains the excitation forces in tec format.')
utility.log_exit(logger, signature, [None])
def save_irf(irf, filename):
"""
Saves the irf to a file in the tec format
Args:
irf: object, the irf
filename: string, The path to the file where to save the irf
"""
utility.mkdir_p(os.path.abspath(os.path.dirname(filename)))
with open(filename, 'w') as inp:
inp.write('VARIABLES="Time (s)"\n')
for k in range(irf.n_integration):
inp.write('"AddedMass '+ str(k+1) + '" "IRF ' + str(k+1) +'"\n')
for j in range(irf.n_radiation):
inp.write('Zone t="DoF ' + str(j+1) + '",I=\t' + str(irf.n_time) + ',F=POINT\n')
for i in range(irf.n_time):
inp.write(' ' + str(irf.time[i]) + ' ')
s = ''
for k in range(irf.n_integration):
s += ' ' + str(irf.added_mass[j, k]) + ' ' + ' ' + str(irf.k[i, j, k]) + ' '
inp.write(s + '\n')
def save_hydroinfo(cg, cf, disVol, Warea, filename):
"""
Saves the radiation coefficient to a file in tec format
Args:
result: object, the hydrodynamic coefficients cases
filename: The path to the file where to save
cb[0] = cf[0] + cg[0]
cb[1] = cf[1] + cg[1]
cb[2] = cf[2]
"""
signature = __name__ + '.save_hydroinfo(result, filename)'
logger = logging.getLogger(__name__)
utility.log_entrance(
logger, signature, {
"cg": str(cg),
"cf": str(cf),
"disVol": str(disVol),
"Warea": str(Warea),
'filename': str(filename)
})
utility.mkdir_p(os.path.abspath(os.path.dirname(filename)))
with open(filename, 'w') as inp:
# print "XF = %(cb) 7.3f - XG = %(cg) 7.3f" % {"cb":cb(1), "cg":cb(1)}
inp.write("XB = %7.3f - XG = %7.3f\n" % (cf[0] + cg[0], cg[0]))
inp.write("YB = %7.3f - YG = %7.3f\n" % (cf[1] + cg[1], cg[1]))
inp.write("ZB = %7.3f - ZG = %7.3f\n" % (cf[2], cg[2]))
inp.write("Displacement = %E\n" % disVol)
inp.write("Waterplane area = %E" % Warea)
# inp.write(str(result[i,:])
# tmpFmt = "%5.3f"*len(result[i,:])+"\n"
# print(tmpFmt % result[i,:])
utility.log_and_print(
logger,
utility.get_abs(filename) + ' contains the hydrostatic information.')
utility.log_exit(logger, signature, [None])
def preprocess(custom_config):
"""
Configure and then run the preprocessor
Args:
custom_config, dict The custom configuration dictionary
"""
if not custom_config:
custom_config = {}
hdf5_file = utility.get_setting(settings.HDF5_FILE, custom_config, 'HDF5_FILE')
nemoh_cal = utility.get_setting(settings.NEMOH_CALCULATIONS_FILE, custom_config, 'NEMOH_CALCULATIONS_FILE')
input_file = utility.get_setting(settings.NEMOH_INPUT_FILE, custom_config, 'NEMOH_INPUT_FILE')
utility.validate_string(hdf5_file, 'HDF5_FILE')
if not nemoh_cal and not input_file:
utility.validate_file(hdf5_file, 'HDF5_FILE')
utility.mkdir_p(os.path.abspath(os.path.dirname(hdf5_file)))
with h5py.File(hdf5_file, "a") as hdf5_db:
if nemoh_cal:
utility.convert_calculations(nemoh_cal, hdf5_db)
if input_file:
utility.convert_input(input_file, hdf5_db)
remove_irregular_frequencies = utility.get_setting(settings.REMOVE_IRREGULAR_FREQUENCIES, custom_config,
'REMOVE_IRREGULAR_FREQUENCIES')
if remove_irregular_frequencies is not None:
dset = utility.require_dataset(hdf5_db, structure.H5_SOLVER_REMOVE_IRREGULAR_FREQUENCIES, (1, ), dtype='i')
utility.set_hdf5_attributes(dset, structure.H5_SOLVER_REMOVE_IRREGULAR_FREQUENCIES_ATTR)
dset[:] = int(remove_irregular_frequencies)
else:
settings.REMOVE_IRREGULAR_FREQUENCIES = hdf5_db.get(structure.H5_SOLVER_REMOVE_IRREGULAR_FREQUENCIES)[0]
run(hdf5_db, custom_config)
def save_wave_elevation(w, etai, etap, eta, x, y, filename):
"""
Save the wave elevation to a file in tec format
Args:
w: float, the wave frequency
etai: 2D array, a wave elevation variable
eta: 2D array, a wave elevation variable
etap: 2D array, a wave elevation variable
x: 1D array, a wave elevation variable
y: 1D array, a wave elevation variable
filename: string, the path to the file where to save
"""
nx = len(x)
ny = len(y)
utility.mkdir_p(os.path.abspath(os.path.dirname(filename)))
with open(filename, 'w') as inp:
s = 'VARIABLES="X" "Y" "etaI_C" "etaI_S" "etaP_C" "etaC_S" '
s += '"etaI_C+etaP_C" "etaI_S+etaI_P" "|etaP|" "|etaI+etaP|"\n'
inp.write(s)
s = 'ZONE t="Wave frequency - w = '
s += str(w)+ '",N=\t'+ str(nx*ny) + ', E=\t' + str((nx-1)*(nx-1)) + '\t , F=FEPOINT,ET=QUADRILATERAL\n'
inp.write(s)
for i in range(nx):
for j in range(ny):
s = str(x[i]) + '\t' + str(y[j]) + '\t' + str(np.real(etai[i, j])) + '\t'
s += str(np.imag(etai[i,j])) + '\t' + str(np.real(etap[i, j])) + '\t'
s += str(np.imag(etap[i,j])) + '\t' + str(np.real(etai[i,j]+etap[i,j])) + '\t'
s += str(np.imag(etai[i,j]+etap[i,j])) + '\t' + str(np.abs(etap[i,j])) + '\t'
s += str(np.abs(eta[i,j])) + '\n'
inp.write(s)
for i in range(nx-1):
for j in range(ny-1):
s = str(j+1+i*ny) + '\t' + str(j+1+(i+1)*ny) + '\t' + str(j+2+ i*ny) + '\n'
inp.write(s)
def train(args, trainloader, enc, dec, disc_l, disc_v, optimizer_en,
optimizer_de, optimizer_dl, optimizer_dv, criterion_ae, criterion_ce,
Tensor, epoch, use_cuda):
enc.train()
dec.train()
disc_l.train()
disc_v.train()
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
isize = args.isize
csize = args.cropsize
batch = args.batch
latent = args.latent
exp = args.exp_name
end = time.time()
bat = 0
for batch_idx, (inputs, targets) in tqdm(enumerate(trainloader)):
data_time.update(time.time() - end)
if use_cuda:
inputs, targets = inputs.cuda(), targets.cuda()
inputs, targets = torch.autograd.Variable(
inputs), torch.autograd.Variable(targets)
u = np.random.uniform(-1, 1, (batch, latent, 1, 1))
l2 = torch.from_numpy(u).float().cuda()
l2 = torch.tanh(l2)
dec_l2 = dec(l2, args)
n = torch.normal(0, 0.2, size=(batch, 3, csize, csize)).cuda()
inputs_noise = inputs + n
l1 = enc(inputs_noise)
#Discriminator update
logits_Dl_l1 = disc_l(l1)
logits_Dl_l2 = disc_l(l2)
dl_logits_DL_l1 = Variable(Tensor(logits_Dl_l1.shape[0], 1).fill_(0.0),
requires_grad=False)
dl_logits_DL_l2 = Variable(Tensor(logits_Dl_l2.shape[0], 1).fill_(1.0),
requires_grad=False)
loss_dl_1 = criterion_ce(logits_Dl_l1, dl_logits_DL_l1)
loss_dl_2 = criterion_ce(logits_Dl_l2, dl_logits_DL_l2)
loss_dl = loss_dl_1 + loss_dl_2
# visual Discriminator l1 = real l2 = random
logits_Dv_X = disc_v(inputs)
logits_Dv_l2 = disc_v(dec(l2, args))
dv_logits_Dv_X = Variable(Tensor(logits_Dv_X.shape[0], 1).fill_(1.0),
requires_grad=False)
dv_logits_Dv_l2 = Variable(Tensor(logits_Dv_l2.shape[0], 1).fill_(0.0),
requires_grad=False)
optimizer_dl.zero_grad()
optimizer_dv.zero_grad()
loss_dv_1 = criterion_ce(logits_Dv_X, dv_logits_Dv_X)
loss_dv_2 = criterion_ce(logits_Dv_l2, dv_logits_Dv_l2)
loss_dv = loss_dv_1 + loss_dv_2
loss_second = loss_dv + loss_dl
loss_second.backward(retain_graph=True)
optimizer_dv.step()
optimizer_dl.step()
###### update ae
Xh = dec(l1, args)
loss_mse = criterion_ae(Xh, inputs) #errR
logits_Dl_l1 = disc_l(l1)
#logits_Dl_l2=disc_l(l2)
ones_logits_Dl_l1 = Variable(Tensor(logits_Dl_l1.shape[0],
1).fill_(1.0),
requires_grad=False)
# zeros_logits_Dl_l2 = Variable(Tensor(logits_Dl_l2.shape[0], 1).fill_(0.0), requires_grad=False)
loss_AE_l = criterion_ce(logits_Dl_l1, ones_logits_Dl_l1)
logits_Dv_l1_mine = disc_v(dec(l2, args))
# logits_Dv_l2_mine = disc_v(inputs)
ones_logits_Dv_l1_mine = Variable(Tensor(logits_Dv_l1_mine.shape[0],
1).fill_(1.0),
requires_grad=False)
# zeros_logits_Dv_l2_mine = Variable(Tensor(logits_Dv_l2_mine.shape[0], 1).fill_(0.0), requires_grad=False)
loss_ae_v = criterion_ce(logits_Dv_l1_mine, ones_logits_Dv_l1_mine)
optimizer_en.zero_grad()
optimizer_de.zero_grad()
loss_ae_all = 10.0 * loss_mse + loss_ae_v + loss_AE_l
loss_ae_all.backward()
optimizer_en.step()
optimizer_de.step()
losses.update(loss_ae_all.item(), inputs.size(0))
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
bat += batch_idx
if epoch % 5 == 0:
recon = dec(enc(inputs), args)
recon = recon.cpu().data
recon = recon / 2 + 0.5
inputs_noise = inputs_noise.cpu().data
inputs_noise = inputs_noise / 2 + 0.5
inputs = inputs.cpu().data
inputs = inputs / 2 + 0.5
if not os.path.exists('./result'):
os.mkdir('./result')
if not os.path.isdir(os.path.join("result", exp, "real")):
utility.mkdir_p(os.path.join("result", exp, "real"))
if not os.path.isdir(os.path.join("result", exp, "fake")):
utility.mkdir_p(os.path.join("result", exp, "fake"))
if not os.path.isdir(os.path.join("result", exp, "real_noise")):
utility.mkdir_p(os.path.join("result", exp, "real_noise"))
fake_name = 'fake' + exp + '_' + str(epoch) + '.png'
real_name = 'real' + exp + '_' + str(epoch) + '.png'
real_noise_name = 'real' + exp + '_' + str(epoch) + '.png'
save_image(recon, os.path.join(".", "result", exp, "fake", fake_name))
save_image(inputs, os.path.join(".", "result", exp, "real", real_name))
save_image(
inputs_noise,
os.path.join(".", "result", exp, "real_noise", real_noise_name))
return losses.avg
def save_metadata(self):
mkdir_p(self.save_directory())
open(self.metadata_filename, 'w').write(yaml.dump(self.metadata))
def timerEvent(self, event):
#obtain most recent image
frame_number = self.camera.get_frame_number()
self.image = self.camera.get_image()
self.roi_shape = np.shape(self.image)
#show most recent image
self.showImage()
#show info about this image
def set_imageinfo():
maxval = self.image.max()
height = len(self.image)
width = np.size(self.image) / height
portion = round(
np.sum(self.image == maxval) / (1.0 * np.size(self.image)), 3)
if self.divide_background.isChecked():
is_autoscaled = ", Contrast Autoscaled"
else:
is_autoscaled = ""
self.imageinfo.setText(
'Camera Controller Version 0.0.1, Image Size: {}x{}, Max pixel value: {}, Fraction at max: {}, Frame number in buffer: {}{}'
.format(width, height, maxval, portion, frame_number,
is_autoscaled))
set_imageinfo()
if self.timeseries_slow.isChecked():
if (textbox_int(self.include_incrementing_image_num) *
textbox_float(self.interval) *
60) <= time.time() - self.slowseries_start:
self.save_image()
if textbox_int(self.include_incrementing_image_num) >= textbox_int(
self.numOfFrames2):
self.timeseries_slow.setChecked(False)
self.next_directory()
#check if a time series to save has been finished collecting:
if self.timeseries.isChecked():
if self.camera.finished_live_sequence():
time.sleep(0.1)
set_imageinfo()
self.freeze.toggle()
mkdir_p(self.save_directory())
write_timeseries(self.filename(),
range(1, 1 + textbox_int(self.numOfFrames)),
self.metadata, self)
increment_textbox(self.include_incrementing_image_num)
self.next_directory()
self.timeseries.setChecked(False)
self.livebutton.setChecked(True)
self.live()
#for back-saving the contents of the rolling buffer
if self.save_buffer.isChecked():
self.freeze.setChecked(True)
self.live() #this processes that the freeze button was checked
time.sleep(0.1)
set_imageinfo()
mkdir_p(self.save_directory())
lastframe = self.camera.get_frame_number()
imagenums = []
for i in range(lastframe + 2,
textbox_int(self.buffersize) + 1) + range(
1, lastframe + 2):
#chonological
imagenums.append(i)
write_timeseries(self.filename(), imagenums, self.metadata, self)
self.next_directory()
self.save_buffer.setChecked(False)
self.livebutton.setChecked(True)
self.live()
def train(args, trainloader,enc,dec,optimizer_en, optimizer_de,
criterion_ae, criterion_ce, Tensor, epoch, use_cuda):
enc.train()
dec.train()
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
isize=args.isize
csize=args.cropsize
batch = args.batch
latent = args.latent
exp = args.exp_name
end=time.time()
bat=0
for batch_idx, (inputs, targets) in tqdm(enumerate(trainloader)):
data_time.update(time.time()-end)
if use_cuda:
inputs, targets = inputs.cuda(), targets.cuda()
inputs, targets = torch.autograd.Variable(inputs), torch.autograd.Variable(targets)
u = np.random.uniform(-1,1, (batch, latent,1,1))
l2 = torch.from_numpy(u).float().cuda()
l2 = torch.tanh(l2)
dec_l2 = dec(l2,args)
n= torch.normal(0,0.2,size=(batch, 3, csize , csize)).cuda()
inputs_noise = inputs + n
l1 = enc(inputs_noise)
###### update ae
Xh = dec(l1,args)
loss_mse = criterion_ae(Xh,inputs) #errR
optimizer_en.zero_grad()
optimizer_de.zero_grad()
loss_ae_all = loss_mse
loss_ae_all.backward()
optimizer_en.step()
optimizer_de.step()
losses.update(loss_ae_all.item(), inputs.size(0))
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
bat+=batch_idx
if epoch % 5 ==0:
recon=dec(enc(inputs),args)
recon=recon.cpu().data
recon=recon/2 +0.5
inputs_noise=inputs_noise.cpu().data
inputs_noise=inputs_noise/2+0.5
inputs=inputs.cpu().data
inputs=inputs/2+0.5
if not os.path.exists('./result'):
os.mkdir('./result')
if not os.path.isdir(os.path.join("result",exp,"real")):
utility.mkdir_p(os.path.join("result",exp,"real"))
if not os.path.isdir(os.path.join("result",exp,"fake")):
utility.mkdir_p(os.path.join("result",exp,"fake"))
if not os.path.isdir(os.path.join("result",exp,"real_noise")):
utility.mkdir_p(os.path.join("result",exp,"real_noise"))
fake_name = 'fake'+exp+'_'+str(epoch)+'.png'
real_name = 'real'+exp+'_'+str(epoch)+'.png'
real_noise_name = 'real'+exp+'_'+str(epoch)+'.png'
save_image(recon, os.path.join(".", "result",exp,"fake",fake_name))
save_image(inputs, os.path.join(".", "result",exp,"real",real_name))
save_image(inputs_noise, os.path.join(".", "result",exp,"real_noise",real_noise_name))
return losses.avg
def saveImageOrYaml(self, img, series = False, slowseries = False):
'''
For saving images and metadata to locations on hard disk. Autogenerates a suggested file name
based on the user's input in the "Saving" tab. User may also type in a
different name at this point. User will be asked to change name if the file
already exists.
Is not allowed to overwrite any files.
'''
# img is true if saving an image, false if saving a yaml file
if img and series and self.numberincrement.isChecked(): #include number
self.keynumber.setText(str(0).zfill(4))
self.createFilename()
#Write yaml file
if img and self.saveMetaYes.checkState():
self.saveImageOrYaml(False)
savingcheck = QtGui.QInputDialog()
#get correct filename for yamls
if img:
fname = self.filename
else:
tempname = self.filename
filetype = tempname.split('.')[-1]
n_filetype = filetype.__len__()
fname = tempname[:-n_filetype] +'yaml'
#grab image for saving
selectedFrame = self.im
usersfilename = fname
if series == False:
numOfFrames = 1
else:
#TODO: implement numOfFrames2
numOfFrames = int(str(self.numOfFrames.text()))
for i in range(1,numOfFrames+1):
if series == True:
#get each image
selectedFrame = frameToArray(i)
selectedFrame = toimage(selectedFrame) #PIL image
usersfilename = self.filename
#TODO: move overwriting check elsewhere
'''#don't overwrite files
if os.path.isfile(str(usersfilename)):
directorywarning = QtGui.QMessageBox()
directorywarning.setWindowTitle('Filename Error')
directorywarning.setText('Overwriting data not allowed. Choose a different name or delete the item with the same name.')
ret = directorywarning.exec_()
self.saveImageOrYaml(img) #cycle back to try again
else:'''
#check if directory exists, and make it, save, or warn
directory, filename = os.path.split(str(usersfilename))
mkdir_p(directory)
if os.path.isdir(directory):
if img:#save image
if usersfilename[-4:]== '.tif':
selectedFrame.save(str(usersfilename), autoscale=False)
else:
selectedFrame.save(str(usersfilename), autoscale=False)
else:#write yaml
data = self.createYaml()
with open(str(usersfilename), 'w') as outfile:
outfile.write( yaml.dump(data, default_flow_style=True) )
#saving was successful, advance the incrementers if they are being used
#numbered file, increment if checked and if saving an image
if img and self.numberincrement.isChecked(): #include number
int(self.keynumber.text()) + 1
self.keynumber.setText(str((int(self.keynumber.text())+ 1)).zfill(4))
self.createFilename()
if not slowseries:
if series == False or i == numOfFrames:
#only increment the directory if done with this series
#numbered directory, increment if checked
if img and self.numberincrementdir.isChecked():
int(self.keynumberdir.text())+1
#automatically sets first image number back to zero
self.keynumber.setText(str(int(0)).zfill(4))
self.keynumberdir.setText(str((int(self.keynumberdir.text())+ 1)).zfill(2))
self.createFilename()
if slowseries:
if self.lastimageflag == True:
self.livebutton.toggle()
#only increment the directory if done with the series
if img and self.numberincrementdir.isChecked():
int(self.keynumberdir.text())+1
#automatically sets first image number back to zero
self.keynumber.setText(str(int(0)).zfill(4))
self.keynumberdir.setText(str((int(self.keynumberdir.text())+ 1)).zfill(2))
self.createFilename()
else:
directorywarning = QtGui.QMessageBox()
directorywarning.setWindowTitle('Filename Error')
directorywarning.setText('The directory you chose does not exist. This software will only create the directory for you if the path exists all the way up to the final subdirectory. Create the necessary path structure on your computer or save to an already existing location. Image NOT saved.')
ret = directorywarning.exec_()
self.saveImageOrYaml(img)
self.save.setChecked(False)
def save_wave_elevation(w, etai, etap, eta, x, y, filename):
"""
Save the wave elevation to a file in tec format
Args:
w: float, the wave frequency
etai: 2D array, a wave elevation variable
eta: 2D array, a wave elevation variable
etap: 2D array, a wave elevation variable
x: 1D array, a wave elevation variable
y: 1D array, a wave elevation variable
filename: string, the path to the file where to save
"""
signature = __name__ + '.save_wave_elevation(w, etai, etap, eta, x, y, filename)'
logger = logging.getLogger(__name__)
utility.log_entrance(
logger, signature, {
"w": w,
"etai": etai,
"etap": etap,
"eta": eta,
"x": x,
"y": y,
"filename": filename
})
nx = len(x)
ny = len(y)
utility.mkdir_p(os.path.abspath(os.path.dirname(filename)))
with open(filename, 'w') as inp:
s = 'VARIABLES="X" "Y" "etaI_C" "etaI_S" "etaP_C" "etaC_S" '
s += '"etaI_C+etaP_C" "etaI_S+etaI_P" "|etaP|" "|etaI+etaP|"\n'
inp.write(s)
s = 'ZONE t="Wave frequency - w = '
s += str(w) + '",N=\t' + str(nx * ny) + ', E=\t' + str(
(nx - 1) * (nx - 1)) + '\t , F=FEPOINT,ET=QUADRILATERAL\n'
inp.write(s)
for i in range(nx):
for j in range(ny):
s = str(x[i]) + '\t' + str(y[j]) + '\t' + str(
np.real(etai[i, j])) + '\t'
s += str(np.imag(etai[i, j])) + '\t' + str(np.real(
etap[i, j])) + '\t'
s += str(np.imag(etap[i, j])) + '\t' + str(
np.real(etai[i, j] + etap[i, j])) + '\t'
s += str(np.imag(etai[i, j] + etap[i, j])) + '\t' + str(
np.abs(etap[i, j])) + '\t'
s += str(np.abs(eta[i, j])) + '\n'
inp.write(s)
for i in range(nx - 1):
for j in range(ny - 1):
s = str(j + 1 + i * ny) + '\t' + str(
j + 1 + (i + 1) * ny) + '\t' + str(j + 2 + i * ny) + '\n'
inp.write(s)
utility.log_and_print(
logger,
utility.get_abs(filename) +
' contains the wave elevation in tec format.')
utility.log_exit(logger, signature, [None])
def train(args, trainloader, enc, dec, cl, disc_l, disc_v, l2_int,
optimizer_en, optimizer_de, optimizer_c, optimizer_dl, optimizer_dv,
optimizer_l2, criterion_ae, criterion_ce, Tensor, epoch, use_cuda):
enc.train()
dec.train()
cl.train()
disc_l.train()
disc_v.train()
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
isize = args.isize
csize = args.cropsize
batch = args.batch
latent = args.latent
exp = args.exp_name
end = time.time()
bat = 0
for batch_idx, (inputs, targets) in tqdm(enumerate(trainloader)):
data_time.update(time.time() - end)
if use_cuda:
inputs, targets = inputs.cuda(), targets.cuda()
inputs, targets = torch.autograd.Variable(
inputs), torch.autograd.Variable(targets)
#무작위 latent space 생성
#l2 = 무작위 latent vector l1 = 노이즈 추가된 이미지의 latent vector
u = np.random.uniform(-1, 1, (batch, latent, 1, 1))
l2 = torch.from_numpy(u).float().cuda()
l2 = torch.tanh(l2)
dec_l2 = dec(l2, args)
#가우시안 분포로 노이즈 만들기
n = torch.normal(0, 0.2, size=(batch, 3, csize, csize)).cuda()
inputs_noise = inputs + n
#노이즈가 추가된 이미지 생성
l1 = enc(inputs)
#latent discriminator optimizer 초기화 후
# classifier update
#노이즈가 추가된 이미지 classifier
logits_C_l1 = cl(dec(l1, args))
#무작위로 생성된 이미지 classifier
logits_C_l2 = cl(dec(l2, args))
#classifier에 대한 label 생성 l1 = 1, l2 = 0
valid_logits_C_l1 = Variable(Tensor(logits_C_l1.shape[0],
1).fill_(1.0),
requires_grad=False)
fake_logits_C_l2 = Variable(Tensor(logits_C_l2.shape[0], 1).fill_(0.0),
requires_grad=False)
#바이너리 크로스 엔트로피 로스 계산 classifier
loss_cl_l1 = criterion_ce(logits_C_l1, valid_logits_C_l1)
loss_cl_l2 = criterion_ce(logits_C_l2, fake_logits_C_l2)
loss_cl = loss_cl_l1 + loss_cl_l2
#classifier optimizer 초기화 후 역전파, 업데이트
optimizer_c.zero_grad()
loss_cl.backward(retain_graph=True)
optimizer_c.step()
#Discriminator update
#latent discriminator 통과
logits_Dl_l1 = disc_l(l1)
logits_Dl_l2 = disc_l(l2)
# latent D 에 대한 label 생성 l1 = 0, l2 = 1
dl_logits_DL_l1 = Variable(Tensor(logits_Dl_l1.shape[0], 1).fill_(0.0),
requires_grad=False)
dl_logits_DL_l2 = Variable(Tensor(logits_Dl_l2.shape[0], 1).fill_(1.0),
requires_grad=False)
# 정답지에 대한 결과
loss_dl_1 = criterion_ce(logits_Dl_l1, dl_logits_DL_l1)
loss_dl_2 = criterion_ce(logits_Dl_l2, dl_logits_DL_l2)
loss_dl = loss_dl_1 + loss_dl_2
#역전파 및 업데이트
# visual Discriminator l1 = real l2 = random
logits_Dv_X = disc_v(inputs)
logits_Dv_l2 = disc_v(dec(l2, args))
# visual Discriminator 에 대한 label
dv_logits_Dv_X = Variable(Tensor(logits_Dv_X.shape[0], 1).fill_(1.0),
requires_grad=False)
dv_logits_Dv_l2 = Variable(Tensor(logits_Dv_l2.shape[0], 1).fill_(0.0),
requires_grad=False)
optimizer_dl.zero_grad()
optimizer_dv.zero_grad()
# loss값 계산
loss_dv_1 = criterion_ce(logits_Dv_X, dv_logits_Dv_X)
loss_dv_2 = criterion_ce(logits_Dv_l2, dv_logits_Dv_l2)
loss_dv = loss_dv_1 + loss_dv_2
#초기화, 역전파, 업데이트
loss_second = loss_dv + loss_dl
loss_second.backward(retain_graph=True)
optimizer_dv.step()
optimizer_dl.step()
for i in range(5):
logits_C_l2_mine = cl(dec(l2, args))
zeros_logits_C_l2_mine = Variable(Tensor(logits_C_l2_mine.shape[0],
1).fill_(1.0),
requires_grad=False)
loss_C_l2_mine = criterion_ce(logits_C_l2_mine,
zeros_logits_C_l2_mine)
optimizer_l2.zero_grad()
loss_C_l2_mine.backward()
optimizer_l2.step()
u = u - 2.0 * batch / l2.shape[0] * l2_int.numpy()
l2 = torch.from_numpy(u).float().cuda()
l2 = torch.tanh(l2)
###### update ae
# 노이즈 추가된 재생성된 이미지
Xh = dec(l1, args)
# 위 값 vs 입력된 이미지 reconstruction error계산
loss_mse = criterion_ae(Xh, inputs) #errR
#l1에 대해 label생성 및 latent loss계산
logits_Dl_l1 = disc_l(l1)
#logits_Dl_l2=disc_l(l2)
ones_logits_Dl_l1 = Variable(Tensor(logits_Dl_l1.shape[0],
1).fill_(1.0),
requires_grad=False)
# zeros_logits_Dl_l2 = Variable(Tensor(logits_Dl_l2.shape[0], 1).fill_(0.0), requires_grad=False)
loss_AE_l = criterion_ce(logits_Dl_l1, ones_logits_Dl_l1)
logits_Dv_l1_mine = disc_v(dec(l2, args))
# logits_Dv_l2_mine = disc_v(inputs)
ones_logits_Dv_l1_mine = Variable(Tensor(logits_Dv_l1_mine.shape[0],
1).fill_(1.0),
requires_grad=False)
# zeros_logits_Dv_l2_mine = Variable(Tensor(logits_Dv_l2_mine.shape[0], 1).fill_(0.0), requires_grad=False)
loss_ae_v = criterion_ce(logits_Dv_l1_mine, ones_logits_Dv_l1_mine)
optimizer_en.zero_grad()
optimizer_de.zero_grad()
loss_ae_all = 10.0 * loss_mse + loss_ae_v + loss_AE_l
loss_ae_all.backward()
optimizer_en.step()
optimizer_de.step()
losses.update(loss_ae_all.item(), inputs.size(0))
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
bat += batch_idx
#그림 저장
if epoch % 5 == 0:
recon = dec(enc(inputs), args)
recon = recon.cpu().data
recon = recon / 2 + 0.5
inputs_noise = inputs_noise.cpu().data
inputs_noise = inputs_noise / 2 + 0.5
inputs = inputs.cpu().data
inputs = inputs / 2 + 0.5
if not os.path.exists('./result'):
os.mkdir('./result')
if not os.path.isdir(os.path.join("result", exp, "real")):
utility.mkdir_p(os.path.join("result", exp, "real"))
if not os.path.isdir(os.path.join("result", exp, "fake")):
utility.mkdir_p(os.path.join("result", exp, "fake"))
if not os.path.isdir(os.path.join("result", exp, "real_noise")):
utility.mkdir_p(os.path.join("result", exp, "real_noise"))
fake_name = 'fake' + exp + '_' + str(epoch) + '.png'
real_name = 'real' + exp + '_' + str(epoch) + '.png'
real_noise_name = 'real' + exp + '_' + str(epoch) + '.png'
save_image(recon, os.path.join(".", "result", exp, "fake", fake_name))
save_image(inputs, os.path.join(".", "result", exp, "real", real_name))
save_image(
inputs_noise,
os.path.join(".", "result", exp, "real_noise", real_noise_name))
return losses.avg
