def __init__(self, config, src_vocab_size, tgt_vocab_size, use_cuda, pretrain=None, score_fn=None): super(seq2seq, self).__init__() if pretrain is not None: # hint: 会自动冻结 src_embedding = nn.Embedding.from_pretrained(pretrain['src_emb']) tgt_embedding = nn.Embedding.from_pretrained(pretrain['tgt_emb']) ''' def normal2(A): return A / np.sqrt(np.sum(A ** 2)) # for i in range(len(pretrain['tgt_emb'])): # pretrain['tgt_emb'][i] = normal2(pretrain['tgt_emb'][i]) mat = np.zeros(45*45).reshape(45, 45) for i in range(45): for j in range(45): _ = normal2(pretrain['tgt_emb'][i].numpy().copy()) __ = normal2(pretrain['tgt_emb'][j].numpy().copy()) mat[i][j] = _.dot(__) print(mat) print() ''' else: src_embedding = None tgt_embedding = None self.encoder = models.rnn_encoder(config, src_vocab_size, embedding=src_embedding, tgt_embedding=tgt_embedding) if config.shared_vocab == False: self.decoder = models.rnn_decoder(config, tgt_vocab_size, embedding=tgt_embedding, score_fn=score_fn) else: self.decoder = models.rnn_decoder(config, tgt_vocab_size, embedding=self.encoder.embedding, score_fn=score_fn) self.use_cuda = use_cuda self.src_vocab_size = src_vocab_size self.tgt_vocab_size = tgt_vocab_size self.config = config if config.score == 'margin': # print("using margin loss") self.criterion = models.margin_criterion(tgt_vocab_size, use_cuda, config) elif config.score == 'hybrid': self.criterion = {} self.criterion['softmax'] = models.criterion(tgt_vocab_size, use_cuda, config) self.criterion['margin'] = models.margin_criterion(tgt_vocab_size, use_cuda, config) elif config.score == 'softmax': self.criterion = models.criterion(tgt_vocab_size, use_cuda, config) else: print('no such score function') os.abort() self.log_softmax = nn.LogSoftmax(dim=1)
def __init__(self, opt): super(seq2seq, self).__init__() self.opt = opt self.encoder = models.rnn_encoder(opt) self.decoder = models.rnn_decoder(opt) self.criterion = models.criterion(opt.use_cuda) self.log_softmax = nn.LogSoftmax(dim=1)
def __init__(self, config, src_vocab, tgt_vocab, use_cuda, bmodel, pretrain=None, score_fn=None): super(seq2seq, self).__init__() if pretrain is not None: self.slot_embedding = nn.Embedding.from_pretrained( pretrain['slot'], freeze=False) else: self.slot_embedding = None if bert: self.src_embedding = bmodel self.dsep_id = src_vocab['-'] self.ssep_id = src_vocab[','] self.vsep_id = src_vocab[';'] src_vocab_size = len(src_vocab) tgt_vocab_size = len(tgt_vocab) self.encoder = models.rnn_encoder( config, ) # tgt_vocab_size,False, embedding=slot_embedding) self.decoder = models.rnn_decoder(config, src_vocab_size, tgt_vocab_size, slot_embedding=self.slot_embedding, value_embedding=self.slot_embedding, score_fn=score_fn) self.use_cuda = use_cuda self.config = config self.criterion = models.criterion(tgt_vocab_size, use_cuda)
def validate(model, val_loader, timestamps): predictions = [] total_loss = [] running_loss = 0.0 with torch.no_grad(): for step, (data, target) in enumerate(val_loader): data = data.to(device) target = target.to(device) prediction = model(data.float()) loss = torch.sqrt( models.criterion(prediction.squeeze(1), target.float())) print("Step [{:4d}/{}] -> Date: {}/{}, Target: {}, Prediction: {}".\ format(step+1, len(val_loader), timestamps[step].month, timestamps[step].year,\ target.item(), prediction.item())) predictions.append(float(prediction.item())) total_loss.append(loss.item()) running_loss += loss.item() print(LINESPLIT) print("Average Validation Loss: {}".format(running_loss / len(total_loss))) return (predictions, total_loss)
def __init__(self, config, input_emb_size, mix_speech_len, tgt_vocab_size, use_cuda, pretrain=None, score_fn=''): super(seq2seq, self).__init__() if pretrain is not None: src_embedding = pretrain['src_emb'] tgt_embedding = pretrain['tgt_emb'] else: src_embedding = None tgt_embedding = None self.encoder = models.rnn_encoder(config, input_emb_size, None, embedding=src_embedding) if config.shared_vocab == False: self.decoder = models.rnn_decoder(config, tgt_vocab_size, embedding=tgt_embedding, score_fn=score_fn) else: self.decoder = models.rnn_decoder(config, tgt_vocab_size, embedding=self.encoder.embedding, score_fn=score_fn) self.use_cuda = use_cuda self.tgt_vocab_size = tgt_vocab_size self.config = config self.criterion = models.criterion(tgt_vocab_size, use_cuda,config.loss) self.loss_for_ss = nn.MSELoss() self.log_softmax = nn.LogSoftmax() self.wav_loss = models.WaveLoss(dBscale=1, nfft=config.FRAME_LENGTH, hop_size=config.FRAME_SHIFT) speech_fre = input_emb_size num_labels = tgt_vocab_size if config.use_tas: self.ss_model = models.ConvTasNet() else: self.ss_model = models.SS(config, speech_fre, mix_speech_len, num_labels)
def __init__(self, config, vocab, use_cuda, pretrain=None): super(bow2seq, self).__init__() self.vocab = vocab self.vocab_size = vocab.voc_size if pretrain is not None: self.embedding = pretrain['emb'] else: self.embedding = nn.Embedding(self.vocab_size, config.emb_size) # self.encoder = models.GCN_Encoder(config, self.vocab_size, embedding=self.embedding) self.bert_encoder = models.bert.BERT(config.head_num, config.emb_size, config.dropout, config.emb_size, self.vocab_size, config.num_layers, config.max_sentence_len, word_emb=self.embedding) self.decoder = models.rnn_decoder(config, self.vocab_size, embedding=self.embedding) self.proj = nn.Linear(config.emb_size, config.decoder_hidden_size) self.state_wc = nn.Linear( config.decoder_hidden_size, config.decoder_hidden_size * config.num_layers) self.state_wh = nn.Linear( config.decoder_hidden_size, config.decoder_hidden_size * config.num_layers) self.tanh = nn.Tanh() self.config = config self.criterion = models.criterion(self.vocab_size, use_cuda) self.log_softmax = nn.LogSoftmax()
def __init__(self, config, src_vocab_size, tgt_vocab_size, use_cuda, pretrain=None, score_fn=None): super(seq2seq, self).__init__() if pretrain is not None: src_embedding = pretrain['src_emb'] tgt_embedding = pretrain['tgt_emb'] else: src_embedding = None tgt_embedding = None self.encoder = models.rnn_encoder(config, src_vocab_size, embedding=src_embedding) if config.shared_vocab == False: self.decoder = models.rnn_decoder(config, tgt_vocab_size, embedding=tgt_embedding, score_fn=score_fn) else: self.decoder = models.rnn_decoder(config, tgt_vocab_size, embedding=self.encoder.embedding, score_fn=score_fn) self.use_cuda = use_cuda self.src_vocab_size = src_vocab_size self.tgt_vocab_size = tgt_vocab_size self.config = config self.criterion = models.criterion(tgt_vocab_size, use_cuda) self.log_softmax = nn.LogSoftmax()
def __init__(self, config, vocab, use_cuda, pretrain=None): super(hierarchical_attention, self).__init__() self.vocab = vocab self.vocab_size = vocab.voc_size if pretrain is not None: self.embedding = pretrain['emb'] else: self.embedding = nn.Embedding(self.vocab_size, config.emb_size) self.word_encoder = Encoder(config.emb_size, config.emb_size, config.num_layers, config.dropout, config.bidirec) self.word_attentive_pool = attentive_pooling(config.emb_size * 2) self.sentence_encoder = Encoder(config.emb_size * 2, config.emb_size * 2, config.num_layers, config.dropout, config.bidirec) self.sentence_attentive_pool = attentive_pooling( config.decoder_hidden_size) self.decoder = models.rnn_decoder(config, self.vocab_size, embedding=self.embedding) self.w_context = nn.Linear(config.decoder_hidden_size * 2, config.decoder_hidden_size, bias=False) self.state_wc = nn.Linear( config.decoder_hidden_size, config.decoder_hidden_size * config.num_layers) self.state_wh = nn.Linear( config.decoder_hidden_size, config.decoder_hidden_size * config.num_layers) self.tanh = nn.Tanh() self.config = config self.criterion = models.criterion(self.vocab_size, use_cuda) self.log_softmax = nn.LogSoftmax()
def __init__(self, config, src_vocab_size, tgt_vocab_size, use_cuda, w2v=None, score_fn=None, weight=0.0, pretrain_updates=0, extend_vocab_size=0, device_ids=None): super(ae, self).__init__() if w2v is not None: src_embedding = w2v['src_emb'] tgt_embedding = w2v['tgt_emb'] else: src_embedding = None tgt_embedding = None self.encoder_s2s = models.gated_rnn_encoder(config, src_vocab_size, embedding=src_embedding) if config.shared_vocab == False: self.decoder = models.rnn_decoder(config, tgt_vocab_size, embedding=tgt_embedding, score_fn=score_fn) else: self.decoder = models.rnn_decoder( config, tgt_vocab_size, embedding=self.encoder_s2s.embedding, score_fn=score_fn) self.encoder_ae = models.rnn_encoder(config, src_vocab_size, embedding=self.decoder.embedding) self.use_cuda = use_cuda self.src_vocab_size = src_vocab_size self.tgt_vocab_size = tgt_vocab_size self.config = config self.weight = weight self.pretrain_updates = pretrain_updates if 'emb' in score_fn: self.criterion = models.criterion_emb(config.hidden_size, tgt_vocab_size, use_cuda) else: self.criterion = models.criterion(tgt_vocab_size, use_cuda) self.log_softmax = nn.LogSoftmax() if score_fn.startswith('dis'): self.discriminator = nn.Linear( config.num_layers * config.hidden_size * 2, 1) self.sigmoid = nn.Sigmoid() if score_fn.endswith('map'): self.h_map = nn.Linear(config.hidden_size, config.hidden_size) self.c_map = nn.Linear(config.hidden_size, config.hidden_size) self.score_fn = score_fn
def __init__(self, config, src_vocab_size, tgt_vocab_size, use_cuda, w2v=None, score_fn=None, weight=0.0, pretrain_updates=0, extend_vocab_size=0, device_ids=None): super(seq2seq, self).__init__() if w2v is not None: src_embedding = w2v['src_emb'] tgt_embedding = w2v['tgt_emb'] else: src_embedding = None tgt_embedding = None if 'copy' in score_fn: build_encoder = models.copy_rnn_encoder build_decoder = models.copy_rnn_decoder else: build_encoder = models.rnn_encoder build_decoder = models.rnn_decoder self.encoder = build_encoder(config, src_vocab_size, embedding=src_embedding) if config.shared_vocab == False: self.decoder = build_decoder(config, tgt_vocab_size, embedding=tgt_embedding, score_fn=score_fn, extend_vocab_size=extend_vocab_size) else: self.decoder = build_decoder(config, tgt_vocab_size, embedding=self.encoder.embedding, score_fn=score_fn, extend_vocab_size=extend_vocab_size) #if len(device_ids) > 0: # self.encoder = nn.DataParallel(self.encoder, device_ids=device_ids, dim=1) # self.decoder = nn.DataParallel(self.decoder, device_ids=device_ids, dim=1) self.use_cuda = use_cuda self.src_vocab_size = src_vocab_size self.tgt_vocab_size = tgt_vocab_size self.config = config self.weight = weight if 'emb' in score_fn: self.criterion = models.criterion_emb(config.hidden_size, tgt_vocab_size, use_cuda) elif 'copy' in score_fn: self.criterion = models.copy_criterion(use_cuda) else: self.criterion = models.criterion(tgt_vocab_size, use_cuda) self.log_softmax = nn.LogSoftmax()
def __init__(self, config, vocab, use_cuda, use_content=False, pretrain=None): super(seq2seq, self).__init__() self.vocab = vocab self.vocab_size = vocab.voc_size if pretrain is not None: self.embedding = pretrain['emb'] else: self.embedding = nn.Embedding(self.vocab_size, config.emb_size) if config.emb_file is not None: print(len(vocab._word2id)) print('Loading embedding file: %s' % config.emb_file) embeddings = np.random.randn(self.vocab_size, config.emb_size) * 0.01 pre_trained = 0 i = 0 #small = open('data/music/small_embedding.txt', 'w') count = 0 #with open('data/music/small_embedding.txt', 'w') as small: for line in open(config.emb_file, 'r', encoding='utf-8').readlines(): count += 1 if count % 100000 == 0: print(count) sp = line.split() if (len(sp) == config.emb_size + 1) and sp[0] in set( vocab._id2word): pre_trained += 1 embeddings[vocab._word2id[sp[0]]] = [ float(x) for x in sp[1:] ] #small.write(line) else: i += 1 #print(sp[0]) #small.close() print("Number of len(sp)!=301 :", i) print('Pre-trained: %d (%.2f%%)' % (pre_trained, pre_trained * 100.0 / len(vocab._word2id))) self.embedding.weight.data.copy_(torch.FloatTensor(embeddings)) self.encoder = models.rnn_encoder(config, self.vocab_size, embedding=self.embedding) self.decoder = models.rnn_decoder(config, self.vocab_size, embedding=self.embedding) self.config = config self.use_content = use_content self.criterion = models.criterion(self.vocab_size, use_cuda) self.log_softmax = nn.LogSoftmax() self.tanh = nn.Tanh()
def __init__(self, config, input_emb_size, mix_speech_len, tgt_vocab_size, use_cuda, pretrain=None, score_fn=''): super(seq2seq, self).__init__() if pretrain is not None: src_embedding = pretrain['src_emb'] tgt_embedding = pretrain['tgt_emb'] else: src_embedding = None tgt_embedding = None # self.encoder = models.rnn_encoder(config, input_emb_size, None, embedding=src_embedding) if config.is_two_channel: self.encoder = models.TransEncoder(config, 2 * input_emb_size) else: self.encoder = models.TransEncoder(config, input_emb_size) self.decoder = models.TransDecoder(config, sos_id=0, eos_id=tgt_vocab_size - 1, n_tgt_vocab=tgt_vocab_size) # if config.shared_vocab == False: # self.decoder = models.rnn_decoder(config, tgt_vocab_size, embedding=tgt_embedding, score_fn=score_fn) # else: # self.decoder = models.rnn_decoder(config, tgt_vocab_size, embedding=self.encoder.embedding, # score_fn=score_fn) self.use_cuda = use_cuda self.tgt_vocab_size = tgt_vocab_size self.config = config self.criterion = models.criterion(tgt_vocab_size, use_cuda, config.loss) self.loss_for_ss = nn.MSELoss() self.log_softmax = nn.LogSoftmax() self.wav_loss = models.WaveLoss(dBscale=1, nfft=config.FRAME_LENGTH, hop_size=config.FRAME_SHIFT) speech_fre = input_emb_size num_labels = tgt_vocab_size if config.is_two_channel: self.separation_linear_real = nn.Linear(self.encoder.d_model, 2 * speech_fre) self.separation_linear_imag = nn.Linear(self.encoder.d_model, 2 * speech_fre) else: self.separation_linear = nn.Linear(self.encoder.d_model, 2 * speech_fre) self.speech_fre = speech_fre self.dropout_layer = nn.Dropout(config.linear_dropout)
def __init__(self, config, vocab, use_cuda, use_copy, use_bert, word_level_model, graph_model, pretrain=None): super(graph2seq, self).__init__() self.word_level_model = word_level_model self.vocab = vocab self.vocab_size = vocab.voc_size if pretrain is not None: self.embedding = pretrain['emb'] else: self.embedding = nn.Embedding(self.vocab_size, config.emb_size) # self.encoder = models.GCN_Encoder(config, self.vocab_size, embedding=self.embedding) self.use_copy = use_copy self.use_bert = use_bert if use_bert: self.bert_encoder = models.bert.BERT( config.head_num, config.decoder_hidden_size, config.dropout, config.decoder_hidden_size, self.vocab_size, config.num_layers, config.max_sentence_len) self.encoder = models.Memory_Network(config, self.vocab_size, word_level_model, graph_model, embedding=self.embedding) if use_copy: self.decoder = models.pointer_decoder(config, self.vocab_size, embedding=self.embedding) else: self.decoder = models.rnn_decoder(config, self.vocab_size, embedding=self.embedding, gru=False) self.state_wc = nn.Linear( config.decoder_hidden_size, config.decoder_hidden_size * config.num_layers) self.state_wh = nn.Linear( config.decoder_hidden_size, config.decoder_hidden_size * config.num_layers) self.tanh = nn.Tanh() self.config = config self.criterion = models.criterion(self.vocab_size, use_cuda) self.log_softmax = nn.LogSoftmax()
def train(model, train_loader, optim, sch, num_epochs): avg_loss = [] for epoch in range(num_epochs): if epoch == MAX_EPOCHS: print(LINESPLIT) print("Maximum allowed training epochs({}) reached".format(epoch)) total_steps = len(train_loader) running_loss = 0.0 for step, (feats, sns) in enumerate(train_loader): feats = feats.to(device) sns = sns.to(device) optim.zero_grad() outputs = model(feats.float()) loss = torch.sqrt( models.criterion(outputs.squeeze(1), sns.float()) + eps) loss.backward() optim.step() running_loss += loss.item() avg_loss.append(running_loss / total_steps) sch.step(running_loss / total_steps) if (epoch + 1) % SAVE_FREQ == 0: torch.save( model.state_dict(), "{}_{}_{}.pth".format(modelfolder, model.__class__.__name__, epoch + 1)) print(LINESPLIT) print("Model checkpoint saved as _{}_{}.pth".format( model.__class__.__name__, epoch + 1)) print(LINESPLIT) if (epoch + 1) % PRINT_FREQ == 0: print("Epoch [{:4d}/{}] -> Loss: {:.4f}".format( epoch + 1, num_epochs, running_loss / total_steps)) running_loss = 0.0 return avg_loss
def __init__(self, config, input_emb_size, mix_speech_len, tgt_vocab_size, use_cuda, pretrain=None, score_fn=None): super(seq2seq, self).__init__() if pretrain is not None: src_embedding = pretrain['src_emb'] tgt_embedding = pretrain['tgt_emb'] else: src_embedding = None tgt_embedding = None self.encoder = models.rnn_encoder(config, input_emb_size, None, embedding=src_embedding) if config.shared_vocab == False: self.decoder = models.rnn_decoder(config, tgt_vocab_size, embedding=tgt_embedding, score_fn=score_fn) else: self.decoder = models.rnn_decoder(config, tgt_vocab_size, embedding=self.encoder.embedding, score_fn=score_fn) self.use_cuda = use_cuda self.tgt_vocab_size = tgt_vocab_size self.config = config self.criterion = models.criterion(tgt_vocab_size, use_cuda) self.loss_for_ss = nn.MSELoss() self.log_softmax = nn.LogSoftmax() speech_fre = input_emb_size num_labels = tgt_vocab_size self.ss_model = models.SS(config, speech_fre, mix_speech_len, num_labels)
def __init__(self, config, vocab, use_cuda, use_content=False, pretrain=None): super(seq2seq, self).__init__() self.vocab = vocab self.vocab_size = vocab.voc_size if pretrain is not None: self.embedding = pretrain['emb'] else: self.embedding = nn.Embedding(self.vocab_size, config.emb_size) self.encoder = models.rnn_encoder(config, self.vocab_size, embedding=self.embedding) self.decoder = models.rnn_decoder(config, self.vocab_size, embedding=self.embedding) self.config = config self.use_content = use_content self.criterion = models.criterion(self.vocab_size, use_cuda) self.log_softmax = nn.LogSoftmax() self.tanh = nn.Tanh()
def __init__(self, config, input_emb_size, mix_speech_len, tgt_vocab_size, use_cuda, pretrain=None, score_fn=''): super(seq2seq_music, self).__init__() if pretrain is not None: src_embedding = pretrain['src_emb'] tgt_embedding = pretrain['tgt_emb'] else: src_embedding = None tgt_embedding = None self.use_cuda = use_cuda self.tgt_vocab_size = tgt_vocab_size self.config = config self.criterion = models.criterion(tgt_vocab_size, use_cuda,config.loss) self.loss_for_ss = nn.MSELoss() self.log_softmax = nn.LogSoftmax() self.wav_loss = models.WaveLoss(dBscale=1, nfft=config.FRAME_LENGTH, hop_size=config.FRAME_SHIFT) speech_fre = input_emb_size num_labels = tgt_vocab_size if config.use_tas: if self.config.use_dprnn: self.ss_model = models.FaSNet_base(config) self.spk_lstm = nn.LSTMCell(self.ss_model.B + self.ss_model.N, self.ss_model.B) # LSTM over the speakers' step. else: self.ss_model = models.ConvTasNet_music(config) if self.config.two_stage: self.second_ss_model = models.ConvTasNet_2nd(config) for p in self.encoder.parameters(): p.requires_grad = False for p in self.decoder.parameters(): p.requires_grad = False for p in self.ss_model.parameters(): p.requires_grad = False self.spk_lstm = nn.LSTMCell(self.ss_model.B + self.ss_model.N, self.ss_model.B) # LSTM over the speakers' step. else: # self.ss_model = models.SS_att(config, speech_fre, mix_speech_len, num_labels) self.ss_model = models.SS(config, speech_fre, mix_speech_len, num_labels)
def __init__(self, config, input_emb_size, mix_speech_len, tgt_vocab_size, use_cuda, pretrain=None, score_fn=''): super(seq2seq, self).__init__() if pretrain is not None: src_embedding = pretrain['src_emb'] tgt_embedding = pretrain['tgt_emb'] else: src_embedding = None tgt_embedding = None # self.encoder = models.rnn_encoder(config, input_emb_size, None, embedding=src_embedding) self.encoder = models.TransEncoder(config, input_emb_size) self.decoder = models.TransDecoder(config, sos_id=0, eos_id=tgt_vocab_size - 1, n_tgt_vocab=tgt_vocab_size) # if config.shared_vocab == False: # self.decoder = models.rnn_decoder(config, tgt_vocab_size, embedding=tgt_embedding, score_fn=score_fn) # else: # self.decoder = models.rnn_decoder(config, tgt_vocab_size, embedding=self.encoder.embedding, # score_fn=score_fn) self.use_cuda = use_cuda self.tgt_vocab_size = tgt_vocab_size self.config = config self.criterion = models.criterion(tgt_vocab_size, use_cuda, config.loss) self.loss_for_ss = nn.MSELoss() self.log_softmax = nn.LogSoftmax() self.wav_loss = models.WaveLoss(dBscale=1, nfft=config.FRAME_LENGTH, hop_size=config.FRAME_SHIFT) speech_fre = input_emb_size num_labels = tgt_vocab_size if config.use_tas: if self.config.use_dprnn: self.ss_model = models.FaSNet_base(config) if self.config.two_stage: self.second_ss_model = models.FaSNet_base_2nd(config) for p in self.encoder.parameters(): p.requires_grad = False for p in self.decoder.parameters(): p.requires_grad = False for p in self.ss_model.parameters(): p.requires_grad = False else: self.ss_model = models.ConvTasNet(config) if self.config.two_stage: self.second_ss_model = models.ConvTasNet_2nd(config) for p in self.encoder.parameters(): p.requires_grad = False for p in self.decoder.parameters(): p.requires_grad = False for p in self.ss_model.parameters(): p.requires_grad = False else: # self.ss_model = models.SS_att(config, speech_fre, mix_speech_len, num_labels) self.ss_model = models.SS(config, speech_fre, mix_speech_len, num_labels)
def main(args): os.makedirs(args.checkpoint_dir, exist_ok=True) dataset, collate_fn, batch_frontend = build_dataset(args) model = build_model(args) data_loader = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size, num_workers=args.num_workers, collate_fn=collate_fn, shuffle=True) optimizer = torch.optim.Adam(model.parameters(), lr=args.learning_rate) loss_scale_consistency = args.gamma_regularization loss_scale_entropy = args.gamma_regularization start = time.time() iteration = 0 for epoch in range(args.num_epochs): model.train() total_loss = 0 for i, (frames_paths, frames, flow_paths, flow) in enumerate(data_loader): learning_rate = (args.learning_rate * (iteration / args.warmup_steps) if iteration < args.warmup_steps else args.learning_rate) * (args.decay_rate**int( iteration / args.decay_steps)) loss_scale_consistency = args.loss_scale_consistency * ( args.gamma_regularization**int(iteration / args.decay_steps)) loss_scale_entropy = args.loss_scale_entropy * ( args.gamma_regularization**int(iteration / args.decay_steps)) optimizer.param_groups[0]['lr'] = learning_rate breakpoint() flow = sample_frames_flow(flow) flow = batch_frontend(flow.to(args.device)) recon_combined, recons, masks, slots, attn = model(flow) loss = models.criterion( recon_combined, masks, flow, loss_scale_reconstruction=args.loss_scale_reconstruction, loss_scale_consistency=loss_scale_consistency, loss_scale_entropy=loss_scale_entropy) loss_item = float(loss) total_loss += loss_item optimizer.zero_grad() loss.backward() optimizer.step() print('Epoch:', epoch, '#', iteration, '|', i, '/', len(data_loader), 'Loss:', loss_item) iteration += 1 total_loss /= len(data_loader) print('Epoch:', epoch, 'Loss:', total_loss, 'Time:', datetime.timedelta(seconds=time.time() - start)) if not epoch % args.checkpoint_epoch_interval: model_state_dict = model.module.state_dict() if isinstance( model, nn.DataParallel) else model.state_dict() torch.save( dict(model_state_dict=model_state_dict), os.path.join(args.checkpoint_dir, args.checkpoint_pattern.format(epoch=epoch)))
from django.test import TestCase dataset = get_dataset() testdata=[] for item in dataset: if(item[0]==(4,2018,2)): for items in item: testdata.append(items) testdata.remove((4,2018,2)) #获取最佳聚类数 maxk = 9 #所测试的最大聚类数 WSSarray = [] # 对聚类数为1,2,...maxk,分别存储其误差值,WSSarray的长度为maxk for i in range(1,maxk+1): cluster, belong = Clustering(testdata, i) WSS = criterion(testdata,cluster,belong) WSSarray.append(WSS) # print("不同聚类数对应的误差值所组成的数组为:",WSS) # 输出误差数组 WSSDelta = list(np.ones(maxk)) # 获得误差数组的增量差,选择增量差最大的点对应的聚类数作为合适的聚类数 WSSDelta[0] = 0 maxDelta = -1 indexDelta = 0 for i in range(1,maxk): WSSDelta[i] = WSSarray[i-1] - WSSarray[i] if WSSDelta[i]>maxDelta: maxDelta = WSSDelta[i] indexDelta = i+1 # 较好的聚类数 # print("最大的误差差值为:",maxDelta) # 输出最大误差 # print("误差差值对应的数组为:",SSEDelta) # 输出误差差值 #print(WSSDelta)