def gen_pic(ckpt, epoch):
device = torch.device('cuda')
model = AutoEncoder().to(device)
model.load_state_dict(torch.load(ckpt))
model.eval()
sample = torch.randn(64, 20).to(device)
sample = model.decoder(sample).cpu()
save_image(sample.view(64, 1, 28, 28),
'results/sample_e{:02}.png'.format(epoch))
def decode(model_name, encoding, decoder_name):
"""Synthesize audio from an array of embeddings.
Args:
encodings: Numpy array with shape [batch_size, time, dim].
save_paths: Iterable of output file names.
checkpoint_path: Location of the pretrained model. [model.ckpt-200000]
samples_per_save: Save files after every amount of generated samples.
"""
decoder_path = './decoding/'
model_path = './restore/'
# Create directory for encoding
if os.path.exists(decoder_path) is False:
os.makedirs(decoder_path)
net = AutoEncoder()
net = load_model(net,model_path,model_name)
cuda_available = torch.cuda.is_available()
if cuda_available is True:
net = net.cuda()
net.eval()
# Load Encoding
encoding_ndarray = np.load(encoding)
encoding = torch.from_numpy(encoding_ndarray).float()
encoding = Variable(encoding, volatile=True)
generated_spec = net.decoder(encoding)
generated_spec = generated_spec.data.cpu().numpy()
generated_spec = np.squeeze(generated_spec)
dec_name = decoder_path + decoder_name
np.save(dec_name , generated_spec)
video = np.array(
[cv2.resize(frame.reshape(540, 720), (512, 512)) for frame in video])
video = video.reshape((-1, 1, 512, 512))
trainloader = torch.utils.data.DataLoader(video,
batch_size=32,
shuffle=True,
pin_memory=True)
print("数据集准备完毕")
from model import AutoEncoder, BAN_decoder, Sine_decoder
autoencoder = AutoEncoder().cuda()
sin_decoder = Sine_decoder().cuda()
ban_decoder = BAN_decoder().cuda()
autoencoder.decoder = ban_decoder
criterion = nn.MSELoss().cuda()
optimizer = optim.Adam(autoencoder.parameters(), lr=0.001)
print("开始训练 training GeneralConv...")
stime = time.time()
for epoch in range(20):
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
optimizer.zero_grad()
Tensordata = data.float().cuda()
_, output = autoencoder(Tensordata)
loss = criterion(output, Tensordata)
loss.backward()
optimizer.step()