def train()

in aiops/ContraAD/solver.py [0:0]

• 39 lines of code
• 6 McCabe index (conditional complexity)

    def train(self):
        time_now = time.time()
        path = self.model_save_path
        if not os.path.exists(path):
            os.makedirs(path)
        early_stopping = EarlyStopping(
            patience=5, verbose=True, dataset_name=self.data_path,win_size=self.win_size
        )
        train_steps = len(self.train_loader)

        for epoch in range(self.num_epochs):
            iter_count = 0

            epoch_time = time.time()
            self.model.train()
            for i, (input_data, labels) in enumerate(self.train_loader):
                # batch,win_size,channel
                iter_count += 1
                input_data = input_data#.to(self.device)
                z_score = torch.sum(normalize(input_data.detach()),dim=-1) # batch win_size
                intra = self.model(input_data)
                loss,_ = self.criterion(intra,z_score.detach())
                self.optimizer.zero_grad()
                if (i + 1) % 100 == 0:
                    speed = (time.time() - time_now) / iter_count
                    left_time = speed * ((self.num_epochs - epoch) * train_steps - i)
                    print(f"\tspeed: {speed:.4f}s/iter; left time: {left_time:.4f}s")
                    iter_count = 0
                    time_now = time.time()
                accelerator.backward(loss)
                self.optimizer.step()
            vali_loss1, vali_loss2 = self.vali(self.test_loader)
            early_stopping(vali_loss1, vali_loss2, self.model, path)
            if early_stopping.early_stop:
                print("stopped")
                break
            print(
                "Epoch: {0}, Cost time: {1:.3f}s Vali Loss: {2:.3f} ".format(
                    epoch + 1, time.time() - epoch_time,0.0
                )
            )

            adjust_learning_rate(self.optimizer, epoch + 1, self.lr)