Upload folder using huggingface_hub

s3dis-latent-inject-r-0.5/data.py.backup

@@ -0,0 +1,182 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Author: Yue Wang
+@Contact: yuewangx@mit.edu
+@File: data.py
+@Time: 2018/10/13 6:21 PM
+
+Modified by
+@Author: An Tao, Pengliang Ji, Ziyi Wu
+@Contact: ta19@mails.tsinghua.edu.cn, jpl1723@buaa.edu.cn, dazitu616@gmail.com
+@Time: 2022/7/30 7:49 PM
+"""
+
+
+import os
+import sys
+import glob
+import h5py
+import numpy as np
+import torch
+import json
+
+# import cv2
+import pickle
+from torch.utils.data import Dataset
+import codecs
+import pandas as pd
+from tqdm import tqdm 
+
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+from pointcept.datasets.precomputed_features import PrecomputedFeaturesDataset
+
+
+class GeomFeatDataset(Dataset):
+    def __init__(
+        self,
+        data_root="data/gf_scannet_ss_0.05",
+        split="train",
+        coord_only=False,
+        feature_to_file_mapping={},
+        num_point=4096,
+    ):
+        self.file_list = [
+            os.path.join(data_root, f)
+            for f in os.listdir(data_root)
+            if f.endswith(".asc")
+        ]
+        self.num_point = num_point
+        features_to_collect = [k for k in feature_to_file_mapping if k != "segment"]
+        if coord_only:
+            features_to_collect = ["coord"]
+  
+        pointcept_transforms = [
+            dict(
+                type="NanToNum",
+                nan=0.0,
+                posinf=1e6,
+                neginf=-1e6,
+            ),
+            dict(type="ToTensor"),
+            dict(
+                type="Collect",
+                keys=("coord", "segment"),
+                feat_keys=features_to_collect,
+            ),
+        ]
+
+        pointcept_style_dataset = PrecomputedFeaturesDataset(
+            split=split,
+            data_root=data_root,
+            transform=pointcept_transforms,
+            mapping=feature_to_file_mapping,
+        )
+
+        self.pointclouds = []
+        self.labels = []
+        self.names = []
+        self.blocks_per_scene = []  # Number of blocks per scene
+        self.samples = 0
+        self.num_features = None  # Store feature dimension
+
+        for idx in tqdm(range(len(pointcept_style_dataset)), desc=f"Processing {split}set"):
+            sample = pointcept_style_dataset[idx]
+            name = pointcept_style_dataset.get_data_name(idx)
+            feats = sample["feat"]  # shape (N, C), torch tensor
+            seg = sample["segment"]  # shape (N,) or (N, 1), torch tensor
+            feats_np = feats.cpu().numpy()  # (N, C)
+            seg_np = seg.cpu().numpy().reshape(-1, 1)  # (N,) or (N, 1)
+            
+            # Store feature dimension from first non-empty pointcloud
+            if self.num_features is None and feats_np.shape[0] > 0:
+                self.num_features = feats_np.shape[1]
+            
+            # Skip empty pointclouds
+            if feats_np.shape[0] == 0:
+                continue
+            
+            num_blocks = (feats_np.shape[0] + self.num_point - 1) // self.num_point  # Ceiling division
+            self.blocks_per_scene.append(num_blocks)
+            self.samples += num_blocks
+        
+            self.pointclouds.append(feats_np)
+            self.labels.append(seg_np)
+            self.names.append(name)
+        
+        # Ensure we have a feature dimension
+        if self.num_features is None:
+            raise ValueError("No valid pointclouds found in dataset!")
+
+    def __len__(self):
+        return self.samples
+
+    def __getitem__(self, idx):
+        # Find which scene this block belongs to using cumulative block counts
+        cum_blocks = np.cumsum([0] + self.blocks_per_scene)
+        scene_idx = np.searchsorted(cum_blocks, idx + 1, side="right") - 1
+        
+        # Ensure scene_idx is valid
+        scene_idx = max(0, min(scene_idx, len(self.pointclouds) - 1))
+        
+        # Calculate which block within this scene
+        block_within_scene = idx - cum_blocks[scene_idx]
+        
+        pointcloud = self.pointclouds[scene_idx]
+        labelcloud = self.labels[scene_idx]
+        name = self.names[scene_idx]
+        
+        num_points = self.num_point
+        total_points = pointcloud.shape[0]
+        num_features = self.num_features
+        
+        # Calculate the start and end indices for this block
+        block_start = block_within_scene * num_points
+        block_end = min(block_start + num_points, total_points)
+        
+        # Always create tensors of the same size
+        block_features = np.zeros((num_points, num_features), dtype=np.float32)
+        block_labels = np.full((num_points,), -1, dtype=np.int64)
+        
+        # Extract the block if we have valid data
+        if block_start < total_points and block_end > block_start:
+            actual_length = block_end - block_start
+            slc_feats = pointcloud[block_start:block_end]
+            slc_labels = labelcloud[block_start:block_end].reshape(-1)
+            
+            # Ensure shapes match
+            if slc_feats.shape[0] > 0:
+                block_features[:actual_length, :] = slc_feats
+                block_labels[:actual_length] = slc_labels
+
+        return (
+            torch.tensor(block_features, dtype=torch.float32),
+            torch.tensor(block_labels, dtype=torch.long),
+            name,
+        )
+
+
+
+
+if __name__ == "__main__":
+    FEATURE_TO_FILE_MAPPING = {
+        "coord": ["X_SS_SPATIAL_0.05", "Y_SS_SPATIAL_0.05", "Z_SS_SPATIAL_0.05"],
+        "segment": "segment_SS_SPATIAL_0.05",
+        "Anisotropy": "Anisotropy_(0.3)_SS_SPATIAL_0.05",
+        "Octree_normals" : ["Nx_SS_SPATIAL_0.05", "Ny_SS_SPATIAL_0.05", "Nz_SS_SPATIAL_0.05"],
+        "PCA1": "PCA1_(0.3)_SS_SPATIAL_0.05",
+        "PCA2": "PCA2_(0.3)_SS_SPATIAL_0.05",
+        "Roughness": "Roughness_(0.3)_SS_SPATIAL_0.05",
+        "Sphericity": "Sphericity_(0.3)_SS_SPATIAL_0.05",
+        "Verticality": "Verticality_(0.3)_SS_SPATIAL_0.05",
+    }
+    NUM_POINT = 4096
+
+    train_set = GeomFeatDataset(
+        data_root="../../data/gf_s3dis_ss_0.05",
+        split="train",
+        feature_to_file_mapping=FEATURE_TO_FILE_MAPPING,
+        num_point=NUM_POINT
+    )

s3dis-latent-inject-r-0.5/logs/events.out.tfevents.1762900875.eu-g4-010

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:302ec3b71305fa1f680e33e2f7162cacdc8af1e8e0d39ea5927fd8bb819a21b8
+size 14780

s3dis-latent-inject-r-0.5/main_semseg_gf_s3dis.py

@@ -0,0 +1,896 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Author: Ziyi Wu, Yingqi Wang
+@Contact: dazitu616@gmail.com, yingqi-w19@mails.tsinghua.edu.cn
+@File: main_semseg_scannet.py
+@Time: 2022/7/30 7:49 PM
+"""
+
+
+import argparse
+import os
+import random
+from tqdm import tqdm
+import numpy as np
+from pathlib import Path
+import time
+import pickle
+import torch
+import torch.nn as nn
+from torch.optim import SGD, Adam
+import torch.backends.cudnn as cudnn
+from torch.utils.data import DataLoader
+from torch.optim.lr_scheduler import CosineAnnealingLR, StepLR
+from torch_scatter import scatter_sum
+from tensorboardX import SummaryWriter
+from plyfile import PlyData, PlyElement
+import matplotlib.pyplot as plt
+import imageio
+from data import GeomFeatDataset
+from model import DGCNN, DGCNN_JAB
+from util import (
+    intersectionAndUnion,
+    IOStream,
+    str2bool,
+    get_lr,
+    adjust_lr,
+    weights_init,
+    bn_momentum_adjust,
+    cal_loss,
+)
+try:
+    from pointcept.utils.visualization import save_point_cloud, create_rotating_visualization
+except ImportError:
+    save_point_cloud = None
+    create_rotating_visualization = None
+
+def _init_(args):
+    if not os.path.exists("outputs"):
+        os.makedirs("outputs")
+    if not os.path.exists("outputs/" + args.exp_name):
+        os.makedirs("outputs/" + args.exp_name)
+    if not os.path.exists("outputs/" + args.exp_name + "/" + "models"):
+        os.makedirs("outputs/" + args.exp_name + "/" + "models")
+    os.system(
+        f"cp main_semseg_gf_s3dis.py outputs/{args.exp_name}/main_semseg_gf_s3dis.py"
+    )
+    os.system("cp model.py outputs" + "/" + args.exp_name + "/" + "model.py.backup")
+    os.system("cp util.py outputs" + "/" + args.exp_name + "/" + "util.py.backup")
+    os.system("cp data.py outputs" + "/" + args.exp_name + "/" + "data.py.backup")
+
+
+def parse_args():
+    parser = argparse.ArgumentParser("Train point cloud semantic segmentation")
+    parser.add_argument(
+        "--exp_name",
+        type=str,
+        default="exp",
+        metavar="N",
+        help="Name of the experiment",
+    )
+    parser.add_argument(
+        "--data_root",
+        type=str,
+        default="../../data/gf_s3dis_ss_0.05",
+        help="path to data",
+    )
+    parser.add_argument(
+        "--model_path", type=str, default="", help="pretrained model weight"
+    )
+    parser.add_argument(
+        "--split",
+        type=str,
+        default="val",
+        help="Split of data to evaluate on [default: val]",
+        choices=["val", "test"],
+    )
+    parser.add_argument(
+        "--in_channels", type=int, default=12, help="Dimension of embeddings"
+    )
+
+    # Dataset settings
+    parser.add_argument("--num_classes", type=int, default=13, help="Number of classes")
+    parser.add_argument(
+        "--class_names",
+        default=[
+            "ceiling",
+            "floor",
+            "wall",
+            "beam",
+            "column",
+            "window",
+            "door",
+            "table",
+            "chair",
+            "sofa",
+            "bookcase",
+            "board",
+            "clutter",
+        ],
+        help="Names of classes",
+    )
+    parser.add_argument(
+        "--feature_to_file_mapping",
+        default={
+            "coord": ["X_SS_SPATIAL_0.05", "Y_SS_SPATIAL_0.05", "Z_SS_SPATIAL_0.05"],
+            "segment": "segment_SS_SPATIAL_0.05",
+            "Anisotropy": "Anisotropy_(0.5)_SS_SPATIAL_0.05",
+            "Octree_normals" : ["Nx_SS_SPATIAL_0.05", "Ny_SS_SPATIAL_0.05", "Nz_SS_SPATIAL_0.05"],
+            "PCA1": "PCA1_(0.5)_SS_SPATIAL_0.05",
+            "PCA2": "PCA2_(0.5)_SS_SPATIAL_0.05",
+            "Roughness": "Roughness_(0.5)_SS_SPATIAL_0.05",
+            "Sphericity": "Sphericity_(0.5)_SS_SPATIAL_0.05",
+            "Verticality": "Verticality_(0.5)_SS_SPATIAL_0.05",
+        },
+        help="Feature to file mapping",
+    )
+    parser.add_argument(
+        "--ignore_index",
+        type=int,
+        default=-1,
+        help="Ignore label index for loss computation",
+    )
+    parser.add_argument(
+        "--coord_only", 
+        type=str2bool,
+        default=False,
+    )
+    parser.add_argument(
+        "--num_points",
+        type=int,
+        default=8192,
+        help="Ignore label index for loss computation",
+    )   
+    parser.add_argument("--dropout", type=float, default=0.5, help="dropout rate")
+    parser.add_argument(
+        "--emb_dims",
+        type=int,
+        default=1024,
+        metavar="N",
+        help="Dimension of embeddings",
+    )
+    parser.add_argument(
+        "--k", type=int, default=20, metavar="N", help="Num of nearest neighbors to use"
+    )
+    parser.add_argument(
+        "--batch_size",
+        type=int,
+        default=-1,
+        help="Batch Size during training [default: 6]",
+    )
+    parser.add_argument(
+        "--epoch", default=100, type=int, help="Epoch to run [default: 100]"
+    )
+    parser.add_argument(
+        "--learning_rate",
+        default=0.001,
+        type=float,
+        help="Initial learning rate [default: 0.001]",
+    )
+    parser.add_argument(
+        "--optimizer", type=str, default="Adam", help="Adam or SGD [default: Adam]"
+    )
+    parser.add_argument(
+        "--decay_rate", type=float, default=1e-4, help="weight decay [default: 1e-4]"
+    )
+    parser.add_argument(
+        "--lr_scheduler",
+        type=str,
+        default="cosine",
+        help="Learning rate scheduler [default: cosine decay]",
+    )
+    parser.add_argument(
+        "--step_size",
+        type=int,
+        default=10,
+        help="Decay step for lr decay [default: every 10 epochs]",
+    )
+    parser.add_argument(
+        "--lr_decay",
+        type=float,
+        default=0.7,
+        help="Decay rate for lr decay [default: 0.7]",
+    )
+    parser.add_argument(
+        "--eval",
+        type=int,
+        default=0,
+        help="whether to evaluate pretrained weight [default: False]",
+    )
+    parser.add_argument(
+        "--save_model_freq",
+        type=int,
+        default=1,
+        help="frequency of saving model checkpoints [default: 1], i.e. every epoch",
+    )
+    parser.add_argument(
+        "--seed", type=int, default=1, metavar="S", help="random seed [default: 1]"
+    )
+    parser.add_argument("--visu", type=str, default="", help="visualize the model")
+    parser.add_argument(
+        "--visu_format",
+        type=str,
+        default="ply",
+        help="file format of visualization [default: ply]",
+    )
+    parser.add_argument(
+        "--train_val",
+        type=str2bool,
+        default=False,
+        help="whether to train on both train set and val set [default: False]",
+    )
+    parser.add_argument(
+        "--jab",
+        type=str2bool,
+        default=False,
+        help="whether to use JAB module [default: False]",
+    )
+    parser.add_argument(
+        "--jab_out_channels",
+        type=int,
+        default=9,
+        help="number of output channels for JAB module [default: 9]",
+    )
+
+
+    return parser.parse_args()
+
+
+def train(args, io):
+    torch.cuda.empty_cache()
+    if args.batch_size == -1:
+        args.batch_size = 8
+    io.cprint(str(args))
+
+    root = args.data_root
+    NUM_CLASSES = args.num_classes  # scannet has 20 classes
+    NUM_POINT = args.num_points
+    BATCH_SIZE = args.batch_size
+
+    """MODEL LOADING"""
+    if args.jab:
+        classifier = DGCNN_JAB(
+            in_channels=args.in_channels,
+            out_channels=args.num_classes,
+            jab_out_channels=args.jab_out_channels,
+            k=args.k,
+            emb_dims=args.emb_dims,
+            dropout=args.dropout,
+        )
+    else:
+        classifier = DGCNN(
+            in_channels=args.in_channels,
+            out_channels=args.num_classes,
+            k=args.k,
+            emb_dims=args.emb_dims,
+            dropout=args.dropout,
+        )
+    criterion = cal_loss
+    # io.cprint(str(classifier))
+
+    if args.sync_bn:
+        io.cprint("Using Sync BN!")
+        from util import convert_to_syncbn
+
+        convert_to_syncbn(classifier)
+
+    classifier = nn.DataParallel(classifier.cuda()).cuda()
+    if args.sync_bn:
+        from sync_bn import patch_replication_callback
+
+        patch_replication_callback(classifier)
+
+    if args.optimizer.lower() == "Adam".lower():
+        optimizer = Adam(
+            classifier.parameters(), lr=args.learning_rate, weight_decay=args.decay_rate
+        )
+        io.cprint("Using Adam optimizer")
+    else:
+        optimizer = SGD(
+            classifier.parameters(),
+            lr=args.learning_rate,
+            momentum=0.9,
+            weight_decay=args.decay_rate,
+        )
+        io.cprint("Using SGD optimizer")
+
+    if args.lr_scheduler == "cosine":
+        lr_scheduler = CosineAnnealingLR(optimizer, T_max=args.epoch, eta_min=1e-5)
+        io.cprint("Using Cosine LR decay")
+    else:
+        lr_scheduler = StepLR(optimizer, step_size=args.step_size, gamma=args.lr_decay)
+        io.cprint("Using Step LR decay")
+
+    if args.model_path:
+        io.cprint("Using pretrained model {}".format(args.model_path))
+        checkpoint = torch.load(args.model_path, map_location="cpu")
+        try:
+            start_epoch = checkpoint["epoch"]
+            classifier.load_state_dict(checkpoint["state_dict"])
+            optimizer.load_state_dict(checkpoint["opt"])
+            lr_scheduler.load_state_dict(checkpoint["lr_scheduler"])
+        except KeyError:
+            try:
+                classifier.load_state_dict(checkpoint)
+            except KeyError:
+                classifier.module.load_state_dict(checkpoint)
+    else:
+        start_epoch = 0
+        classifier = classifier.apply(weights_init)
+
+    """DATA LOADING"""
+    io.cprint("Loading data")
+    train_set = GeomFeatDataset(
+        data_root=args.data_root,
+        split="train",
+        feature_to_file_mapping=args.feature_to_file_mapping,
+        coord_only=args.coord_only,
+        num_point=NUM_POINT,
+    )
+
+    train_loader = torch.utils.data.DataLoader(
+        train_set,
+        batch_size=args.batch_size,
+        shuffle=True,
+        num_workers=min(12, args.batch_size),
+        pin_memory=True,
+        drop_last=True,
+        worker_init_fn=lambda x: np.random.seed(x + int(time.time())),
+    )
+    weights = None
+    io.cprint("The number of training data is: %d" % len(train_set))
+
+    """CREATE DIR"""
+    start_datetime = time.strftime("%Y-%m-%d_%H:%M:%S", time.localtime())
+    logs_dir = "outputs/{}/".format(args.exp_name)
+
+    if not os.path.exists(logs_dir):
+        os.makedirs(logs_dir)
+    log_writer = SummaryWriter(os.path.join(logs_dir, "logs"))
+
+    MOMENTUM_ORIGINAL = 0.1
+    MOMENTUM_DECCAY = 0.5
+    MOMENTUM_DECCAY_STEP = args.step_size
+
+    global_epoch = 0
+    best_iou = 0
+    best_iou_epoch = -1
+
+    for epoch in range(start_epoch, args.epoch + 1):
+        """Train on chopped scenes"""
+        io.cprint("\n\n**** Epoch %d (%d/%s) ****" % (global_epoch, epoch, args.epoch))
+
+        # BN momentum decay
+        momentum = MOMENTUM_ORIGINAL * (
+            MOMENTUM_DECCAY ** (epoch // MOMENTUM_DECCAY_STEP)
+        )
+        if momentum < 0.01:
+            momentum = 0.01
+        io.cprint("BN momentum updated to: %.4f" % momentum)
+        classifier = classifier.apply(lambda x: bn_momentum_adjust(x, momentum))
+        classifier = classifier.train()
+
+        num_batches = len(train_loader)
+        total_correct = 0.0
+        total_seen = 0.0
+        loss_sum = 0.0
+        save_model = epoch % args.save_model_freq == 0
+        for i, data in tqdm(
+            enumerate(train_loader), total=len(train_loader), smoothing=0.9
+        ):
+            points, target = data
+            # TODO: data augmentation?
+            # TODO: seems no rotation aug in original paper/code!
+            # points = points.data.numpy()
+            # points[:,:, :3] = provider.rotate_point_cloud_z(points[:,:, :3])
+            # points = torch.Tensor(points)
+            points, target = points.float().cuda(), target.long().cuda()
+            points = points.transpose(2, 1)
+            optimizer.zero_grad()
+            seg_pred, trans_feat = classifier(points)
+            seg_pred = seg_pred.contiguous().view(-1, args.num_classes)
+            target = target.view(-1)
+            # TODO: loss weighting?
+            # TODO: seems no loss weighting in original paper/code!
+            loss = criterion(seg_pred, target, ignore_index=args.ignore_index)
+            loss.backward()
+            optimizer.step()
+            with torch.no_grad():
+                label = target.detach()
+                keep_index = torch.where(label != args.ignore_index)[0]
+                preds = seg_pred.argmax(1)
+                correct = (label[keep_index] == preds[keep_index]).sum(0).item()
+            total_correct += correct
+            total_seen += keep_index.shape[0]
+            loss_sum += loss.item()
+        mean_loss = loss_sum / num_batches
+        mean_acc = total_correct / float(total_seen)
+        lr = get_lr(optimizer)
+        io.cprint("Training mean loss: %.4f" % (mean_loss))
+        io.cprint("Training accuracy: %.4f" % (mean_acc))
+        io.cprint("Learning rate: %.6f" % (lr))
+        log_writer.add_scalar("train/loss", mean_loss, epoch)
+        log_writer.add_scalar("train/accuracy", mean_acc, epoch)
+        log_writer.add_scalar("train/lr", lr, epoch)
+
+        if save_model:
+            model_name = "model_{}.pth".format(epoch)
+            savepath = os.path.join(logs_dir, "models", model_name)
+            io.cprint("Saving at %s" % savepath)
+            state = {
+                "epoch": epoch,
+                # 'class_avg_iou': mIoU,
+                "state_dict": classifier.state_dict(),
+                "opt": optimizer.state_dict(),
+                "lr_scheduler": lr_scheduler.state_dict(),
+            }
+            torch.save(state, savepath)
+
+        global_epoch += 1
+        lr_scheduler.step()
+        torch.cuda.empty_cache()
+
+
+def test(args, io):
+    torch.cuda.empty_cache()
+
+    """LOG"""
+    if args.batch_size == -1:
+        args.batch_size = 8
+    io.cprint(str(args))
+
+    root = args.data_root
+    NUM_CLASSES = args.num_classes
+    NUM_POINT = args.num_points
+    if NUM_POINT != 4096:
+        io.cprint("Please check ZAHA num_points setting!")
+    BATCH_SIZE = args.batch_size
+
+    """MODEL LOADING"""
+    if args.jab:
+        classifier = DGCNN_JAB(
+            in_channels=args.in_channels,
+            out_channels=args.num_classes,
+            jab_out_channels=args.jab_out_channels,
+            k=args.k,
+            emb_dims=args.emb_dims,
+            dropout=args.dropout,
+        )
+    else:
+        classifier = DGCNN(
+            in_channels=args.in_channels,
+            out_channels=args.num_classes,
+            k=args.k,
+            emb_dims=args.emb_dims,
+            dropout=args.dropout,
+        )
+    classifier = nn.DataParallel(classifier.cuda()).cuda()
+    criterion = cal_loss
+
+    if args.model_path:
+        io.cprint("Loading pretrained model {}".format(args.model_path))
+        checkpoint = torch.load(args.model_path, map_location="cpu")
+        try:
+            classifier.load_state_dict(checkpoint["state_dict"])
+        except KeyError:
+            try:
+                classifier.load_state_dict(checkpoint)
+            except KeyError:
+                classifier.module.load_state_dict(checkpoint)
+    else:
+        io.cprint("No model_path specified, exiting.")
+        return
+
+    """DATA LOADING"""
+    io.cprint("Loading data")
+    test_set = GeomFeatDataset(
+        data_root=args.data_root,
+        split="val",
+        feature_to_file_mapping=args.feature_to_file_mapping,
+        coord_only=args.coord_only,
+        num_point=NUM_POINT,
+    )
+    test_loader = torch.utils.data.DataLoader(
+        test_set,
+        batch_size=BATCH_SIZE,
+        shuffle=False,
+        num_workers=min(12, BATCH_SIZE),
+        pin_memory=True,
+        drop_last=True,
+        worker_init_fn=lambda x: np.random.seed(x + int(time.time())),
+    )
+
+    io.cprint("The number of training data is: %d" % len(test_set))
+
+    classifier.eval()
+    total_correct = 0
+    total_seen = 0
+    loss_sum = 0.0
+
+    total_TP = np.zeros(NUM_CLASSES, dtype=np.float64)
+    total_FP = np.zeros(NUM_CLASSES, dtype=np.float64)
+    total_FN = np.zeros(NUM_CLASSES, dtype=np.float64)
+
+    # Visualization setup
+    vis_output_dir = os.path.join("outputs", args.exp_name, "visuals")
+    os.makedirs(vis_output_dir, exist_ok=True)
+    
+    # Scene collection for visualization
+    scene_coords = []
+    scene_preds = []
+    scene_targets = []
+    current_scene_name = None
+    scene_idx = 0
+
+    def save_scene_visualization(scene_name, coords, preds, targets, output_dir, class_names, num_classes):
+        """Save visualization for a complete scene"""
+        if len(coords) == 0:
+            return
+        
+        # Concatenate all blocks for this scene
+        coords_all = np.concatenate(coords, axis=0)  # (N, 3)
+        preds_all = np.concatenate(preds, axis=0)  # (N,)
+        targets_all = np.concatenate(targets, axis=0)  # (N,)
+        
+        # Filter out points with label -1
+        valid_mask = targets_all != -1
+        coords_all = coords_all[valid_mask]
+        preds_all = preds_all[valid_mask]
+        targets_all = targets_all[valid_mask]
+        
+        if len(coords_all) == 0:
+            return
+        
+        # Create colormap
+        cmap = plt.get_cmap("tab20", num_classes)
+        
+        # Save prediction visualization
+        pred_colors = np.array([cmap(pred)[:3] for pred in preds_all])
+        if save_point_cloud is not None:
+            save_point_cloud(
+                coords_all, 
+                pred_colors, 
+                file_path=os.path.join(output_dir, f"{scene_name}_pred.ply"),
+                logger=None
+            )
+        if create_rotating_visualization is not None:
+            try:
+                frames = create_rotating_visualization(coords_all, pred_colors, n_frames=60, width=1920, height=1080)
+                imageio.mimsave(os.path.join(output_dir, f"{scene_name}_pred.mp4"), frames, fps=15)
+            except Exception as e:
+                io.cprint(f"Warning: Could not create video for {scene_name}_pred: {e}")
+        
+        # Save ground truth visualization
+        gt_colors = np.array([cmap(target)[:3] for target in targets_all])
+        if save_point_cloud is not None:
+            save_point_cloud(
+                coords_all, 
+                gt_colors, 
+                file_path=os.path.join(output_dir, f"{scene_name}_gt.ply"),
+                logger=None
+            )
+        if create_rotating_visualization is not None:
+            try:
+                frames = create_rotating_visualization(coords_all, gt_colors, n_frames=60, width=1920, height=1080)
+                imageio.mimsave(os.path.join(output_dir, f"{scene_name}_gt.mp4"), frames, fps=15)
+            except Exception as e:
+                io.cprint(f"Warning: Could not create video for {scene_name}_gt: {e}")
+
+    with torch.no_grad():
+        for batch_idx, (points, target, name) in enumerate(tqdm(test_loader, total=len(test_loader), smoothing=0.9)):
+            # Extract scene names from batch (DataLoader returns list of strings)
+            if isinstance(name, (list, tuple)):
+                batch_scene_names = name
+            else:
+                batch_scene_names = [name]
+            
+            points, target = points.float().cuda(), target.long().cuda()
+            points_transposed = points.transpose(2, 1)
+
+            seg_pred, _ = classifier(points_transposed)
+            seg_pred = seg_pred.contiguous().view(-1, NUM_CLASSES)
+            target_flat = target.view(-1)
+
+            loss = criterion(seg_pred, target_flat, ignore_index=args.ignore_index)
+            loss_sum += loss.item()
+
+            keep_index = torch.where(target_flat != -1)[0]
+            preds = seg_pred.argmax(1)
+
+            correct = (target_flat[keep_index] == preds[keep_index]).sum().item()
+            total_correct += correct
+            total_seen += keep_index.shape[0]
+
+            for cls in range(NUM_CLASSES):
+                cls_mask = target_flat[keep_index] == cls
+                pred_mask = preds[keep_index] == cls
+
+                TP = (cls_mask & pred_mask).sum().item()
+                FP = ((~cls_mask) & pred_mask).sum().item()
+                FN = (cls_mask & (~pred_mask)).sum().item()
+
+                total_TP[cls] += TP
+                total_FP[cls] += FP
+                total_FN[cls] += FN
+            
+            # Collect points for visualization (extract coordinates from first 3 channels)
+            points_cpu = points.cpu().numpy()  # (B, N, C)
+            coords_batch = points_cpu[:, :, :3]  # (B, N, 3) - extract xyz coordinates
+            preds_batch = preds.cpu().numpy()  # (B*N,)
+            targets_batch = target_flat.cpu().numpy()  # (B*N,)
+            
+            # Reshape predictions and targets to match batch structure
+            B, N = points_cpu.shape[0], points_cpu.shape[1]
+            preds_batch = preds_batch.reshape(B, N)  # (B, N)
+            targets_batch = targets_batch.reshape(B, N)  # (B, N)
+            
+            # Process each sample in the batch separately, grouping by scene name
+            for b in range(B):
+                sample_scene_name = batch_scene_names[b] if b < len(batch_scene_names) else batch_scene_names[0]
+                
+                # Handle scene change - save previous scene if name changed
+                if current_scene_name is not None and sample_scene_name != current_scene_name:
+                    # Save previous scene
+                    if len(scene_coords) > 0:
+                        save_scene_visualization(
+                            current_scene_name, 
+                            scene_coords, 
+                            scene_preds, 
+                            scene_targets,
+                            vis_output_dir,
+                            args.class_names,
+                            NUM_CLASSES
+                        )
+                        io.cprint(f"Saved visualization for scene: {current_scene_name}")
+                    # Reset for new scene
+                    scene_coords = []
+                    scene_preds = []
+                    scene_targets = []
+                
+                # Update current scene name
+                current_scene_name = sample_scene_name
+                
+                # Collect this sample
+                scene_coords.append(coords_batch[b])  # (N, 3)
+                scene_preds.append(preds_batch[b])  # (N,)
+                scene_targets.append(targets_batch[b])  # (N,)
+        
+        # Save last scene
+        if len(scene_coords) > 0:
+            save_scene_visualization(
+                current_scene_name, 
+                scene_coords, 
+                scene_preds, 
+                scene_targets,
+                vis_output_dir,
+                args.class_names,
+                NUM_CLASSES
+            )
+            io.cprint(f"Saved visualization for scene: {current_scene_name}")
+
+    mean_loss = loss_sum / len(test_loader)
+
+    # OA
+    OA = total_correct / float(total_seen)
+
+    # Per-class metrics
+    precision_per_class = total_TP / np.maximum(total_TP + total_FP, 1)
+    recall_per_class = total_TP / np.maximum(total_TP + total_FN, 1)
+    iou_per_class = total_TP / np.maximum(total_TP + total_FP + total_FN, 1)
+    f1_per_class = (2 * precision_per_class * recall_per_class) / np.maximum(
+        precision_per_class + recall_per_class, 1e-8
+    )
+
+    # Means
+    μP = np.mean(precision_per_class)
+    μR = np.mean(recall_per_class)
+    μIoU = np.mean(iou_per_class)
+    μF1 = np.mean(f1_per_class)
+
+    # 输出
+    io.cprint("==== Evaluation Results ====")
+    io.cprint("Mean loss: %.4f" % mean_loss)
+    io.cprint("OA   : %.4f" % OA)
+    io.cprint("μP   : %.4f" % μP)
+    io.cprint("μIoU : %.4f" % μIoU)
+    io.cprint("μR   : %.4f" % μR)
+    io.cprint("μF1  : %.4f" % μF1)
+    io.cprint("============================")
+    for cls_name, p, r, iou, f1 in zip(
+        args.class_names,
+        precision_per_class,
+        recall_per_class,
+        iou_per_class,
+        f1_per_class,
+    ):
+        io.cprint(
+            "%-15s | P: %.4f | R: %.4f | IoU: %.4f | F1: %.4f"
+            % (cls_name, p, r, iou, f1)
+        )
+
+
+def set_seed(seed=42):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)  # if multiple GPUs
+
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+
+def validate(args, io):
+    torch.cuda.empty_cache()
+
+    """LOG"""
+    if args.batch_size == -1:
+        args.batch_size = 8
+    io.cprint(str(args))
+
+    root = args.data_root
+    NUM_CLASSES = args.num_classes 
+    NUM_POINT = args.num_points
+    if NUM_POINT != 4096:
+        io.cprint("Please check ZAHA num_points setting!")
+    BATCH_SIZE = args.batch_size
+
+    io.cprint("Loading data...")
+    test_set = GeomFeatDataset(
+        data_root=args.data_root,
+        split="val",
+        feature_to_file_mapping=args.feature_to_file_mapping,
+        coord_only=args.coord_only,
+        num_point=NUM_POINT,
+    )
+    test_loader = torch.utils.data.DataLoader(
+        test_set,
+        batch_size=BATCH_SIZE,
+        shuffle=False,
+        num_workers=min(12, BATCH_SIZE),
+        pin_memory=True,
+        drop_last=True,
+        worker_init_fn=lambda x: np.random.seed(x + int(time.time())),
+    )
+
+    io.cprint("The number of validation data is: %d" % len(test_set))
+
+    best_miou = -1
+    best_model = None
+
+    model_dir = Path(args.model_path)
+    for model_path in sorted(model_dir.glob("model_*.pth")):
+        model_path = str(model_path)
+        if not os.path.exists(model_path):
+            io.cprint(f"[Skip] {model_path} not found.")
+            continue
+
+        io.cprint(f"\nLoading pretrained model {model_path}")
+        if args.jab:
+            classifier = DGCNN_JAB(
+                in_channels=args.in_channels,
+                out_channels=args.num_classes,
+                jab_out_channels=args.jab_out_channels,
+                k=args.k,
+                emb_dims=args.emb_dims,
+                dropout=args.dropout,
+            )
+        else:
+            classifier = DGCNN(
+                in_channels=args.in_channels,
+                out_channels=args.num_classes,
+                k=args.k,
+                emb_dims=args.emb_dims,
+                dropout=args.dropout,
+            )
+
+        classifier = nn.DataParallel(classifier.cuda()).cuda()
+        criterion = cal_loss
+
+        checkpoint = torch.load(model_path, map_location="cpu")
+        try:
+            classifier.load_state_dict(checkpoint["state_dict"])
+        except KeyError:
+            try:
+                classifier.load_state_dict(checkpoint)
+            except KeyError:
+                classifier.module.load_state_dict(checkpoint)
+
+        classifier.eval()
+        total_correct = 0
+        total_seen = 0
+        loss_sum = 0.0
+
+        total_TP = np.zeros(NUM_CLASSES, dtype=np.float64)
+        total_FP = np.zeros(NUM_CLASSES, dtype=np.float64)
+        total_FN = np.zeros(NUM_CLASSES, dtype=np.float64)
+
+        with torch.no_grad():
+            for points, target, name in tqdm(
+                test_loader,
+                total=len(test_loader),
+                desc=f"Validating {model_path}",
+                smoothing=0.9,
+            ):
+                points, target = points.float().cuda(), target.long().cuda()
+                points = points.transpose(2, 1)
+
+                seg_pred, _ = classifier(points)
+                seg_pred = seg_pred.contiguous().view(-1, NUM_CLASSES)
+                target = target.view(-1)
+
+                loss = criterion(seg_pred, target)
+                loss_sum += loss.item()
+
+                keep_index = torch.where(target != 255)[0]
+                preds = seg_pred.argmax(1)
+
+                correct = (target[keep_index] == preds[keep_index]).sum().item()
+                total_correct += correct
+                total_seen += keep_index.shape[0]
+
+                for cls in range(NUM_CLASSES):
+                    cls_mask = target[keep_index] == cls
+                    pred_mask = preds[keep_index] == cls
+
+                    TP = (cls_mask & pred_mask).sum().item()
+                    FP = ((~cls_mask) & pred_mask).sum().item()
+                    FN = (cls_mask & (~pred_mask)).sum().item()
+
+                    total_TP[cls] += TP
+                    total_FP[cls] += FP
+                    total_FN[cls] += FN
+
+        # 计算指标
+        mean_loss = loss_sum / len(test_loader)
+        OA = total_correct / float(total_seen)
+
+        precision_per_class = total_TP / np.maximum(total_TP + total_FP, 1)
+        recall_per_class = total_TP / np.maximum(total_TP + total_FN, 1)
+        iou_per_class = total_TP / np.maximum(total_TP + total_FP + total_FN, 1)
+        f1_per_class = (2 * precision_per_class * recall_per_class) / np.maximum(
+            precision_per_class + recall_per_class, 1e-8
+        )
+
+        μIoU = np.mean(iou_per_class)
+
+        io.cprint(
+            f"{Path(model_path).stem} | μIoU: {μIoU:.4f} | OA: {OA:.4f} | Loss: {mean_loss:.4f}"
+        )
+
+        if μIoU > best_miou:
+            best_miou = μIoU
+            best_model = model_path
+
+        del classifier
+        torch.cuda.empty_cache()
+
+    io.cprint("\n==== Summary ====")
+    io.cprint(f"Best model: {best_model}")
+    io.cprint(f"Best μIoU : {best_miou:.4f}")
+    io.cprint("=================")
+
+
+if __name__ == "__main__":
+    args = parse_args()
+
+    # Setup logging and weights saving
+    _init_(args)
+    io = IOStream("outputs/" + args.exp_name + "/run.log")
+
+    set_seed(args.seed)
+    cudnn.benchmark = True
+    args.sync_bn = torch.cuda.device_count() > 1
+
+    # Dataset specific settings
+    io.cprint("Experiment on S3DIS dataset!")
+    assert args.num_classes == len(args.class_names)
+
+
+    if not args.eval:
+        train(args, io)
+    elif args.eval == 1:
+        validate(args, io)
+    else:
+        test(args, io)

s3dis-latent-inject-r-0.5/model.py.backup

@@ -0,0 +1,308 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Author: Yue Wang
+@Contact: yuewangx@mit.edu
+@File: model.py
+@Time: 2018/10/13 6:35 PM
+
+Modified by 
+@Author: An Tao, Ziyi Wu
+@Contact: ta19@mails.tsinghua.edu.cn, dazitu616@gmail.com
+@Time: 2022/7/30 7:49 PM
+"""
+
+
+import os
+import sys
+import copy
+import math
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.init as init
+import torch.nn.functional as F
+
+
+def knn(x, k):
+    inner = -2*torch.matmul(x.transpose(2, 1), x)
+    xx = torch.sum(x**2, dim=1, keepdim=True)
+    pairwise_distance = -xx - inner - xx.transpose(2, 1)
+ 
+    idx = pairwise_distance.topk(k=k, dim=-1)[1]   # (batch_size, num_points, k)
+    return idx
+
+
+def get_graph_feature(x, k=20, idx=None, dim9=False):
+    batch_size = x.size(0)
+    num_points = x.size(2)
+    x = x.view(batch_size, -1, num_points)
+    if idx is None:
+        if dim9 == False:
+            idx = knn(x, k=k)   # (batch_size, num_points, k)
+        else:
+            idx = knn(x[:, 6:], k=k)
+    device = torch.device('cuda')
+
+    idx_base = torch.arange(0, batch_size, device=device).view(-1, 1, 1)*num_points
+
+    idx = idx + idx_base
+
+    idx = idx.view(-1)
+ 
+    _, num_dims, _ = x.size()
+
+    x = x.transpose(2, 1).contiguous()   # (batch_size, num_points, num_dims)  -> (batch_size*num_points, num_dims) #   batch_size * num_points * k + range(0, batch_size*num_points)
+    feature = x.view(batch_size*num_points, -1)[idx, :]
+    feature = feature.view(batch_size, num_points, k, num_dims) 
+    x = x.view(batch_size, num_points, 1, num_dims).repeat(1, 1, k, 1)
+    
+    feature = torch.cat((feature-x, x), dim=3).permute(0, 3, 1, 2).contiguous()
+  
+    return feature      # (batch_size, 2*num_dims, num_points, k)
+
+
+class DGCNN(nn.Module):
+    def __init__(self, in_channels, out_channels, k=20, emb_dims=1024, dropout=0.5):
+        super(DGCNN, self).__init__()
+
+        self.k = k
+
+        self.bn1 = nn.BatchNorm2d(64)
+        self.bn2 = nn.BatchNorm2d(64)
+        self.bn3 = nn.BatchNorm2d(64)
+        self.bn4 = nn.BatchNorm2d(64)
+        self.bn5 = nn.BatchNorm2d(64)
+        self.bn6 = nn.BatchNorm1d(emb_dims)
+        self.bn7 = nn.BatchNorm1d(512)
+        self.bn8 = nn.BatchNorm1d(256)
+
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(in_channels * 2, 64, kernel_size=1, bias=False),
+            self.bn1,
+            nn.LeakyReLU(negative_slope=0.2),
+        )
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(64, 64, kernel_size=1, bias=False),
+            self.bn2,
+            nn.LeakyReLU(negative_slope=0.2),
+        )
+        self.conv3 = nn.Sequential(
+            nn.Conv2d(64 * 2, 64, kernel_size=1, bias=False),
+            self.bn3,
+            nn.LeakyReLU(negative_slope=0.2),
+        )
+        self.conv4 = nn.Sequential(
+            nn.Conv2d(64, 64, kernel_size=1, bias=False),
+            self.bn4,
+            nn.LeakyReLU(negative_slope=0.2),
+        )
+        self.conv5 = nn.Sequential(
+            nn.Conv2d(64 * 2, 64, kernel_size=1, bias=False),
+            self.bn5,
+            nn.LeakyReLU(negative_slope=0.2),
+        )
+        self.conv6 = nn.Sequential(
+            nn.Conv1d(192, emb_dims, kernel_size=1, bias=False),
+            self.bn6,
+            nn.LeakyReLU(negative_slope=0.2),
+        )
+        self.conv7 = nn.Sequential(
+            nn.Conv1d(1216, 512, kernel_size=1, bias=False),
+            self.bn7,
+            nn.LeakyReLU(negative_slope=0.2),
+        )
+        self.conv8 = nn.Sequential(
+            nn.Conv1d(512, 256, kernel_size=1, bias=False),
+            self.bn8,
+            nn.LeakyReLU(negative_slope=0.2),
+        )
+        self.dp1 = nn.Dropout(p=dropout)
+        self.conv9 = nn.Conv1d(256, out_channels, kernel_size=1, bias=False)
+
+
+    def forward(self, x):
+        bs = x.size(0)
+        npoint = x.size(2)
+
+        # (bs, 9, npoint) -> (bs, 9*2, npoint, k)
+        x = get_graph_feature(x, k=self.k, dim9=True)
+        # (bs, 9*2, npoint, k) -> (bs, 64, npoint, k)
+        x = self.conv1(x)
+        # (bs, 64, npoint, k) -> (bs, 64, npoint, k)
+        x = self.conv2(x)
+        # (bs, 64, npoint, k) -> (bs, 64, npoint)
+        x1 = x.max(dim=-1, keepdim=False)[0]
+
+        # (bs, 64, npoint) -> (bs, 64*2, npoint, k)
+        x = get_graph_feature(x1, k=self.k)
+        # (bs, 64*2, npoint, k) -> (bs, 64, npoint, k)
+        x = self.conv3(x)
+        # (bs, 64, npoint, k) -> (bs, 64, npoint, k)
+        x = self.conv4(x)
+        # (bs, 64, npoint, k) -> (bs, 64, npoint)
+        x2 = x.max(dim=-1, keepdim=False)[0]
+
+        # (bs, 64, npoint) -> (bs, 64*2, npoint, k)
+        x = get_graph_feature(x2, k=self.k)
+        # (bs, 64*2, npoint, k) -> (bs, 64, npoint, k)
+        x = self.conv5(x)
+        # (bs, 64, npoint, k) -> (bs, 64, npoint)
+        x3 = x.max(dim=-1, keepdim=False)[0]
+
+        x = torch.cat((x1, x2, x3), dim=1)      # (bs, 64*3, npoint)
+
+        # (bs, 64*3, npoint) -> (bs, emb_dims, npoint)
+        x = self.conv6(x)
+        # (bs, emb_dims, npoint) -> (bs, emb_dims, 1)
+        x = x.max(dim=-1, keepdim=True)[0]
+
+        x = x.repeat(1, 1, npoint)          # (bs, 1024, npoint)
+        x = torch.cat((x, x1, x2, x3), dim=1)   # (bs, 1024+64*3, npoint)
+
+        # (bs, 1024+64*3, npoint) -> (bs, 512, npoint)
+        x = self.conv7(x)
+        # (bs, 512, npoint) -> (bs, 256, npoint)
+        x = self.conv8(x)
+        x = self.dp1(x)
+        # (bs, 256, npoint) -> (bs, 13, npoint)
+        x = self.conv9(x)
+        # (bs, 13, npoint) -> (bs, npoint, 13)
+        x = x.transpose(2, 1).contiguous()
+
+        return x, None
+
+
+class JABModule(nn.Module):
+    # projects raw geometric features into a compact representation
+    def __init__(self, in_dim=9, out_dim=16):
+        super().__init__()
+        self.fc1 = nn.Linear(in_dim, out_dim)
+        self.bn1 = nn.BatchNorm1d(out_dim)
+
+
+    def forward(self, features):
+        # features: (B, F, N) with F = number of GFs per point
+        x = features.transpose(1, 2) # (B, N, F)
+        x = self.fc1(x) # (B, N, out_dim) # if some features are spatial we maybe need to transform them
+        x = x.transpose(1, 2) # (B, out_dim, N)
+        x = F.relu(self.bn1(x)) # batch norm over feature dimension
+        return x # (B, out_dim, N)
+    
+class DGCNN_JAB(nn.Module):
+    def __init__(self, in_channels, out_channels, jab_out_channels=9, k=20, emb_dims=1024, dropout=0.5):
+        super(DGCNN_JAB, self).__init__()
+
+        self.coord_channels = 3
+        self.k = k
+        self.jab_module = JABModule(in_dim=in_channels-self.coord_channels, out_dim=jab_out_channels)
+        
+
+        self.bn1 = nn.BatchNorm2d(64)
+        self.bn2 = nn.BatchNorm2d(64)
+        self.bn3 = nn.BatchNorm2d(64)
+        self.bn4 = nn.BatchNorm2d(64)
+        self.bn5 = nn.BatchNorm2d(64)
+        self.bn6 = nn.BatchNorm1d(emb_dims)
+        self.bn7 = nn.BatchNorm1d(512)
+        self.bn8 = nn.BatchNorm1d(256)
+
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(self.coord_channels * 2, 64, kernel_size=1, bias=False),
+            self.bn1,
+            nn.LeakyReLU(negative_slope=0.2),
+        )
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(64, 64, kernel_size=1, bias=False),
+            self.bn2,
+            nn.LeakyReLU(negative_slope=0.2),
+        )
+        self.conv3 = nn.Sequential(
+            nn.Conv2d((64 + jab_out_channels) * 2, 64, kernel_size=1, bias=False),
+            self.bn3,
+            nn.LeakyReLU(negative_slope=0.2),
+        )
+        self.conv4 = nn.Sequential(
+            nn.Conv2d(64, 64, kernel_size=1, bias=False),
+            self.bn4,
+            nn.LeakyReLU(negative_slope=0.2),
+        )
+        self.conv5 = nn.Sequential(
+            nn.Conv2d(64 * 2, 64, kernel_size=1, bias=False),
+            self.bn5,
+            nn.LeakyReLU(negative_slope=0.2),
+        )
+        self.conv6 = nn.Sequential(
+            nn.Conv1d(192 + jab_out_channels, emb_dims, kernel_size=1, bias=False),
+            self.bn6,
+            nn.LeakyReLU(negative_slope=0.2),
+        )
+        self.conv7 = nn.Sequential(
+            nn.Conv1d(1216 + jab_out_channels, 512, kernel_size=1, bias=False),
+            self.bn7,
+            nn.LeakyReLU(negative_slope=0.2),
+        )
+        self.conv8 = nn.Sequential(
+            nn.Conv1d(512, 256, kernel_size=1, bias=False),
+            self.bn8,
+            nn.LeakyReLU(negative_slope=0.2),
+        )
+        self.dp1 = nn.Dropout(p=dropout)
+        self.conv9 = nn.Conv1d(256, out_channels, kernel_size=1, bias=False)
+
+
+    def forward(self, x):
+        bs = x.size(0)
+        npoint = x.size(2)
+        gf = x[:,3:12,:]
+        x = x [:,0:3,:]
+
+        # (bs, 9, npoint) -> (bs, 9*2, npoint, k)
+        x = get_graph_feature(x, k=self.k, dim9=True)
+        # (bs, 9*2, npoint, k) -> (bs, 64, npoint, k)
+        x = self.conv1(x)
+        # (bs, 64, npoint, k) -> (bs, 64, npoint, k)
+        x = self.conv2(x)
+        # (bs, 64, npoint, k) -> (bs, 64, npoint)
+        x1 = x.max(dim=-1, keepdim=False)[0]
+
+        latent_gf = self.jab_module(gf) # (n, 16)
+        x1 = torch.cat([x1, latent_gf], dim=1) # (n, 64 + 16)
+
+        # (bs, 64, npoint) -> (bs, 64*2, npoint, k)
+        x = get_graph_feature(x1, k=self.k)
+        # (bs, 64*2, npoint, k) -> (bs, 64, npoint, k)
+        x = self.conv3(x)
+        # (bs, 64, npoint, k) -> (bs, 64, npoint, k)
+        x = self.conv4(x)
+        # (bs, 64, npoint, k) -> (bs, 64, npoint)
+        x2 = x.max(dim=-1, keepdim=False)[0]
+
+        # (bs, 64, npoint) -> (bs, 64*2, npoint, k)
+        x = get_graph_feature(x2, k=self.k)
+        # (bs, 64*2, npoint, k) -> (bs, 64, npoint, k)
+        x = self.conv5(x)
+        # (bs, 64, npoint, k) -> (bs, 64, npoint)
+        x3 = x.max(dim=-1, keepdim=False)[0]
+
+        x = torch.cat((x1, x2, x3), dim=1)      # (bs, 64*3, npoint)
+
+        # (bs, 64*3, npoint) -> (bs, emb_dims, npoint)
+        x = self.conv6(x)
+        # (bs, emb_dims, npoint) -> (bs, emb_dims, 1)
+        x = x.max(dim=-1, keepdim=True)[0]
+
+        x = x.repeat(1, 1, npoint)          # (bs, 1024, npoint)
+        x = torch.cat((x, x1, x2, x3), dim=1)   # (bs, 1024+64*3, npoint)
+
+        # (bs, 1024+64*3, npoint) -> (bs, 512, npoint)
+        x = self.conv7(x)
+        # (bs, 512, npoint) -> (bs, 256, npoint)
+        x = self.conv8(x)
+        x = self.dp1(x)
+        # (bs, 256, npoint) -> (bs, 13, npoint)
+        x = self.conv9(x)
+        # (bs, 13, npoint) -> (bs, npoint, 13)
+        x = x.transpose(2, 1).contiguous()
+
+        return x, None

s3dis-latent-inject-r-0.5/models/best.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36c39479ab2f2e37f5ace438f1019444b435c65a7dc358700105a233d30addff
+size 12039591

s3dis-latent-inject-r-0.5/models/last.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b580868ea38be75b729f161a36d51097509a60a5255bb63c4f1bc210e7489a0
+size 12039738

s3dis-latent-inject-r-0.5/run.log

@@ -0,0 +1,1279 @@
+Experiment on S3DIS dataset!
+Namespace(exp_name='s3dis-latent-inject-r-0.5', data_root='../../data/gf_s3dis_ss_0.05', model_path='', split='val', in_channels=12, num_classes=13, class_names=['ceiling', 'floor', 'wall', 'beam', 'column', 'window', 'door', 'table', 'chair', 'sofa', 'bookcase', 'board', 'clutter'], feature_to_file_mapping={'coord': ['X_SS_SPATIAL_0.05', 'Y_SS_SPATIAL_0.05', 'Z_SS_SPATIAL_0.05'], 'segment': 'segment_SS_SPATIAL_0.05', 'Anisotropy': 'Anisotropy_(0.5)_SS_SPATIAL_0.05', 'Octree_normals': ['Nx_SS_SPATIAL_0.05', 'Ny_SS_SPATIAL_0.05', 'Nz_SS_SPATIAL_0.05'], 'PCA1': 'PCA1_(0.5)_SS_SPATIAL_0.05', 'PCA2': 'PCA2_(0.5)_SS_SPATIAL_0.05', 'Roughness': 'Roughness_(0.5)_SS_SPATIAL_0.05', 'Sphericity': 'Sphericity_(0.5)_SS_SPATIAL_0.05', 'Verticality': 'Verticality_(0.5)_SS_SPATIAL_0.05'}, ignore_index=-1, coord_only=False, num_points=8192, dropout=0.5, emb_dims=1024, k=20, batch_size=8, epoch=100, learning_rate=0.001, optimizer='Adam', decay_rate=0.0001, lr_scheduler='cosine', step_size=10, lr_decay=0.7, eval=0, save_model_freq=1, seed=1, visu='', visu_format='ply', train_val=False, jab=True, jab_out_channels=9, sync_bn=False)
+Using Adam optimizer
+Using Cosine LR decay
+Loading data
+The number of training data is: 611
+
+
+**** Epoch 0 (0/100) ****
+BN momentum updated to: 0.1000
+Training mean loss: 1.7984
+Training accuracy: 0.4598
+Learning rate: 0.001000
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_0.pth
+
+
+**** Epoch 1 (1/100) ****
+BN momentum updated to: 0.1000
+Training mean loss: 1.2316
+Training accuracy: 0.6211
+Learning rate: 0.001000
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_1.pth
+
+
+**** Epoch 2 (2/100) ****
+BN momentum updated to: 0.1000
+Training mean loss: 1.1211
+Training accuracy: 0.6416
+Learning rate: 0.000999
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_2.pth
+
+
+**** Epoch 3 (3/100) ****
+BN momentum updated to: 0.1000
+Training mean loss: 0.9831
+Training accuracy: 0.6806
+Learning rate: 0.000998
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_3.pth
+
+
+**** Epoch 4 (4/100) ****
+BN momentum updated to: 0.1000
+Training mean loss: 0.8977
+Training accuracy: 0.6991
+Learning rate: 0.000996
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_4.pth
+
+
+**** Epoch 5 (5/100) ****
+BN momentum updated to: 0.1000
+Training mean loss: 0.8364
+Training accuracy: 0.7165
+Learning rate: 0.000994
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_5.pth
+
+
+**** Epoch 6 (6/100) ****
+BN momentum updated to: 0.1000
+Training mean loss: 0.8162
+Training accuracy: 0.7236
+Learning rate: 0.000991
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_6.pth
+
+
+**** Epoch 7 (7/100) ****
+BN momentum updated to: 0.1000
+Training mean loss: 0.7753
+Training accuracy: 0.7373
+Learning rate: 0.000988
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_7.pth
+
+
+**** Epoch 8 (8/100) ****
+BN momentum updated to: 0.1000
+Training mean loss: 0.7624
+Training accuracy: 0.7395
+Learning rate: 0.000984
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_8.pth
+
+
+**** Epoch 9 (9/100) ****
+BN momentum updated to: 0.1000
+Training mean loss: 0.7155
+Training accuracy: 0.7605
+Learning rate: 0.000980
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_9.pth
+
+
+**** Epoch 10 (10/100) ****
+BN momentum updated to: 0.0500
+Training mean loss: 0.6746
+Training accuracy: 0.7718
+Learning rate: 0.000976
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_10.pth
+
+
+**** Epoch 11 (11/100) ****
+BN momentum updated to: 0.0500
+Training mean loss: 0.6223
+Training accuracy: 0.7862
+Learning rate: 0.000971
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_11.pth
+
+
+**** Epoch 12 (12/100) ****
+BN momentum updated to: 0.0500
+Training mean loss: 0.5937
+Training accuracy: 0.7983
+Learning rate: 0.000965
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_12.pth
+
+
+**** Epoch 13 (13/100) ****
+BN momentum updated to: 0.0500
+Training mean loss: 0.5775
+Training accuracy: 0.7959
+Learning rate: 0.000959
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_13.pth
+
+
+**** Epoch 14 (14/100) ****
+BN momentum updated to: 0.0500
+Training mean loss: 0.5840
+Training accuracy: 0.8004
+Learning rate: 0.000953
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_14.pth
+
+
+**** Epoch 15 (15/100) ****
+BN momentum updated to: 0.0500
+Training mean loss: 0.5525
+Training accuracy: 0.8105
+Learning rate: 0.000946
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_15.pth
+
+
+**** Epoch 16 (16/100) ****
+BN momentum updated to: 0.0500
+Training mean loss: 0.5601
+Training accuracy: 0.8031
+Learning rate: 0.000939
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_16.pth
+
+
+**** Epoch 17 (17/100) ****
+BN momentum updated to: 0.0500
+Training mean loss: 0.5025
+Training accuracy: 0.8266
+Learning rate: 0.000931
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_17.pth
+
+
+**** Epoch 18 (18/100) ****
+BN momentum updated to: 0.0500
+Training mean loss: 0.4880
+Training accuracy: 0.8321
+Learning rate: 0.000923
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_18.pth
+
+
+**** Epoch 19 (19/100) ****
+BN momentum updated to: 0.0500
+Training mean loss: 0.4657
+Training accuracy: 0.8380
+Learning rate: 0.000914
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_19.pth
+
+
+**** Epoch 20 (20/100) ****
+BN momentum updated to: 0.0250
+Training mean loss: 0.4654
+Training accuracy: 0.8392
+Learning rate: 0.000905
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_20.pth
+
+
+**** Epoch 21 (21/100) ****
+BN momentum updated to: 0.0250
+Training mean loss: 0.4649
+Training accuracy: 0.8393
+Learning rate: 0.000896
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_21.pth
+
+
+**** Epoch 22 (22/100) ****
+BN momentum updated to: 0.0250
+Training mean loss: 0.4531
+Training accuracy: 0.8441
+Learning rate: 0.000886
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_22.pth
+
+
+**** Epoch 23 (23/100) ****
+BN momentum updated to: 0.0250
+Training mean loss: 0.4202
+Training accuracy: 0.8530
+Learning rate: 0.000876
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_23.pth
+
+
+**** Epoch 24 (24/100) ****
+BN momentum updated to: 0.0250
+Training mean loss: 0.4107
+Training accuracy: 0.8580
+Learning rate: 0.000866
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_24.pth
+
+
+**** Epoch 25 (25/100) ****
+BN momentum updated to: 0.0250
+Training mean loss: 0.4030
+Training accuracy: 0.8607
+Learning rate: 0.000855
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_25.pth
+
+
+**** Epoch 26 (26/100) ****
+BN momentum updated to: 0.0250
+Training mean loss: 0.4294
+Training accuracy: 0.8524
+Learning rate: 0.000844
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_26.pth
+
+
+**** Epoch 27 (27/100) ****
+BN momentum updated to: 0.0250
+Training mean loss: 0.4036
+Training accuracy: 0.8615
+Learning rate: 0.000832
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_27.pth
+
+
+**** Epoch 28 (28/100) ****
+BN momentum updated to: 0.0250
+Training mean loss: 0.3866
+Training accuracy: 0.8672
+Learning rate: 0.000821
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_28.pth
+
+
+**** Epoch 29 (29/100) ****
+BN momentum updated to: 0.0250
+Training mean loss: 0.3632
+Training accuracy: 0.8738
+Learning rate: 0.000808
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_29.pth
+
+
+**** Epoch 30 (30/100) ****
+BN momentum updated to: 0.0125
+Training mean loss: 0.3905
+Training accuracy: 0.8646
+Learning rate: 0.000796
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_30.pth
+
+
+**** Epoch 31 (31/100) ****
+BN momentum updated to: 0.0125
+Training mean loss: 0.3666
+Training accuracy: 0.8716
+Learning rate: 0.000783
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_31.pth
+
+
+**** Epoch 32 (32/100) ****
+BN momentum updated to: 0.0125
+Training mean loss: 0.3413
+Training accuracy: 0.8815
+Learning rate: 0.000770
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_32.pth
+
+
+**** Epoch 33 (33/100) ****
+BN momentum updated to: 0.0125
+Training mean loss: 0.3337
+Training accuracy: 0.8833
+Learning rate: 0.000757
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_33.pth
+
+
+**** Epoch 34 (34/100) ****
+BN momentum updated to: 0.0125
+Training mean loss: 0.3292
+Training accuracy: 0.8856
+Learning rate: 0.000743
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_34.pth
+
+
+**** Epoch 35 (35/100) ****
+BN momentum updated to: 0.0125
+Training mean loss: 0.3208
+Training accuracy: 0.8849
+Learning rate: 0.000730
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_35.pth
+
+
+**** Epoch 36 (36/100) ****
+BN momentum updated to: 0.0125
+Training mean loss: 0.3161
+Training accuracy: 0.8901
+Learning rate: 0.000716
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_36.pth
+
+
+**** Epoch 37 (37/100) ****
+BN momentum updated to: 0.0125
+Training mean loss: 0.2960
+Training accuracy: 0.8937
+Learning rate: 0.000702
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_37.pth
+
+
+**** Epoch 38 (38/100) ****
+BN momentum updated to: 0.0125
+Training mean loss: 0.3290
+Training accuracy: 0.8824
+Learning rate: 0.000687
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_38.pth
+
+
+**** Epoch 39 (39/100) ****
+BN momentum updated to: 0.0125
+Training mean loss: 0.3200
+Training accuracy: 0.8881
+Learning rate: 0.000673
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_39.pth
+
+
+**** Epoch 40 (40/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.3091
+Training accuracy: 0.8897
+Learning rate: 0.000658
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_40.pth
+
+
+**** Epoch 41 (41/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.3135
+Training accuracy: 0.8903
+Learning rate: 0.000643
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_41.pth
+
+
+**** Epoch 42 (42/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.2907
+Training accuracy: 0.8973
+Learning rate: 0.000628
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_42.pth
+
+
+**** Epoch 43 (43/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.2872
+Training accuracy: 0.8964
+Learning rate: 0.000613
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_43.pth
+
+
+**** Epoch 44 (44/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.2941
+Training accuracy: 0.8965
+Learning rate: 0.000598
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_44.pth
+
+
+**** Epoch 45 (45/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.3249
+Training accuracy: 0.8855
+Learning rate: 0.000582
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_45.pth
+
+
+**** Epoch 46 (46/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.3135
+Training accuracy: 0.8916
+Learning rate: 0.000567
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_46.pth
+
+
+**** Epoch 47 (47/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.2825
+Training accuracy: 0.9007
+Learning rate: 0.000552
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_47.pth
+
+
+**** Epoch 48 (48/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.3059
+Training accuracy: 0.8957
+Learning rate: 0.000536
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_48.pth
+
+
+**** Epoch 49 (49/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.2929
+Training accuracy: 0.8961
+Learning rate: 0.000521
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_49.pth
+
+
+**** Epoch 50 (50/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.2684
+Training accuracy: 0.9041
+Learning rate: 0.000505
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_50.pth
+
+
+**** Epoch 51 (51/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.2574
+Training accuracy: 0.9091
+Learning rate: 0.000489
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_51.pth
+
+
+**** Epoch 52 (52/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.2461
+Training accuracy: 0.9109
+Learning rate: 0.000474
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_52.pth
+
+
+**** Epoch 53 (53/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.2368
+Training accuracy: 0.9150
+Learning rate: 0.000458
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_53.pth
+
+
+**** Epoch 54 (54/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.2301
+Training accuracy: 0.9170
+Learning rate: 0.000443
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_54.pth
+
+
+**** Epoch 55 (55/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.2274
+Training accuracy: 0.9185
+Learning rate: 0.000428
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_55.pth
+
+
+**** Epoch 56 (56/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.2235
+Training accuracy: 0.9193
+Learning rate: 0.000412
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_56.pth
+
+
+**** Epoch 57 (57/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.2193
+Training accuracy: 0.9199
+Learning rate: 0.000397
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_57.pth
+
+
+**** Epoch 58 (58/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.2112
+Training accuracy: 0.9234
+Learning rate: 0.000382
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_58.pth
+
+
+**** Epoch 59 (59/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.2162
+Training accuracy: 0.9213
+Learning rate: 0.000367
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_59.pth
+
+
+**** Epoch 60 (60/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.2183
+Training accuracy: 0.9207
+Learning rate: 0.000352
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_60.pth
+
+
+**** Epoch 61 (61/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.2134
+Training accuracy: 0.9229
+Learning rate: 0.000337
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_61.pth
+
+
+**** Epoch 62 (62/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.2067
+Training accuracy: 0.9261
+Learning rate: 0.000323
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_62.pth
+
+
+**** Epoch 63 (63/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.2015
+Training accuracy: 0.9265
+Learning rate: 0.000308
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_63.pth
+
+
+**** Epoch 64 (64/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.2150
+Training accuracy: 0.9228
+Learning rate: 0.000294
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_64.pth
+
+
+**** Epoch 65 (65/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1995
+Training accuracy: 0.9273
+Learning rate: 0.000280
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_65.pth
+
+
+**** Epoch 66 (66/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1987
+Training accuracy: 0.9281
+Learning rate: 0.000267
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_66.pth
+
+
+**** Epoch 67 (67/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1989
+Training accuracy: 0.9271
+Learning rate: 0.000253
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_67.pth
+
+
+**** Epoch 68 (68/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1955
+Training accuracy: 0.9288
+Learning rate: 0.000240
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_68.pth
+
+
+**** Epoch 69 (69/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1919
+Training accuracy: 0.9302
+Learning rate: 0.000227
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_69.pth
+
+
+**** Epoch 70 (70/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1887
+Training accuracy: 0.9313
+Learning rate: 0.000214
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_70.pth
+
+
+**** Epoch 71 (71/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1882
+Training accuracy: 0.9312
+Learning rate: 0.000202
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_71.pth
+
+
+**** Epoch 72 (72/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1845
+Training accuracy: 0.9324
+Learning rate: 0.000189
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_72.pth
+
+
+**** Epoch 73 (73/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1866
+Training accuracy: 0.9320
+Learning rate: 0.000178
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_73.pth
+
+
+**** Epoch 74 (74/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1856
+Training accuracy: 0.9322
+Learning rate: 0.000166
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_74.pth
+
+
+**** Epoch 75 (75/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1737
+Training accuracy: 0.9362
+Learning rate: 0.000155
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_75.pth
+
+
+**** Epoch 76 (76/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1722
+Training accuracy: 0.9366
+Learning rate: 0.000144
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_76.pth
+
+
+**** Epoch 77 (77/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1752
+Training accuracy: 0.9357
+Learning rate: 0.000134
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_77.pth
+
+
+**** Epoch 78 (78/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1722
+Training accuracy: 0.9366
+Learning rate: 0.000124
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_78.pth
+
+
+**** Epoch 79 (79/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1679
+Training accuracy: 0.9385
+Learning rate: 0.000114
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_79.pth
+
+
+**** Epoch 80 (80/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1692
+Training accuracy: 0.9378
+Learning rate: 0.000105
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_80.pth
+
+
+**** Epoch 81 (81/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1652
+Training accuracy: 0.9396
+Learning rate: 0.000096
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_81.pth
+
+
+**** Epoch 82 (82/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1680
+Training accuracy: 0.9383
+Learning rate: 0.000087
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_82.pth
+
+
+**** Epoch 83 (83/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1619
+Training accuracy: 0.9407
+Learning rate: 0.000079
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_83.pth
+
+
+**** Epoch 84 (84/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1646
+Training accuracy: 0.9391
+Learning rate: 0.000071
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_84.pth
+
+
+**** Epoch 85 (85/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1564
+Training accuracy: 0.9425
+Learning rate: 0.000064
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_85.pth
+
+
+**** Epoch 86 (86/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1591
+Training accuracy: 0.9415
+Learning rate: 0.000057
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_86.pth
+
+
+**** Epoch 87 (87/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1604
+Training accuracy: 0.9412
+Learning rate: 0.000051
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_87.pth
+
+
+**** Epoch 88 (88/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1603
+Training accuracy: 0.9413
+Learning rate: 0.000045
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_88.pth
+
+
+**** Epoch 89 (89/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1559
+Training accuracy: 0.9420
+Learning rate: 0.000039
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_89.pth
+
+
+**** Epoch 90 (90/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1538
+Training accuracy: 0.9433
+Learning rate: 0.000034
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_90.pth
+
+
+**** Epoch 91 (91/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1561
+Training accuracy: 0.9428
+Learning rate: 0.000030
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_91.pth
+
+
+**** Epoch 92 (92/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1509
+Training accuracy: 0.9442
+Learning rate: 0.000026
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_92.pth
+
+
+**** Epoch 93 (93/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1526
+Training accuracy: 0.9440
+Learning rate: 0.000022
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_93.pth
+
+
+**** Epoch 94 (94/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1537
+Training accuracy: 0.9435
+Learning rate: 0.000019
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_94.pth
+
+
+**** Epoch 95 (95/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1546
+Training accuracy: 0.9433
+Learning rate: 0.000016
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_95.pth
+
+
+**** Epoch 96 (96/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1542
+Training accuracy: 0.9435
+Learning rate: 0.000014
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_96.pth
+
+
+**** Epoch 97 (97/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1550
+Training accuracy: 0.9434
+Learning rate: 0.000012
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_97.pth
+
+
+**** Epoch 98 (98/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1519
+Training accuracy: 0.9439
+Learning rate: 0.000011
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_98.pth
+
+
+**** Epoch 99 (99/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1536
+Training accuracy: 0.9433
+Learning rate: 0.000010
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_99.pth
+
+
+**** Epoch 100 (100/100) ****
+BN momentum updated to: 0.0100
+Training mean loss: 0.1586
+Training accuracy: 0.9421
+Learning rate: 0.000010
+Saving at outputs/s3dis-latent-inject-r-0.5/models/model_100.pth
+Experiment on S3DIS dataset!
+Namespace(exp_name='s3dis-latent-inject-r-0.5', data_root='../../data/gf_s3dis_ss_0.05', model_path='', split='val', in_channels=12, num_classes=13, class_names=['ceiling', 'floor', 'wall', 'beam', 'column', 'window', 'door', 'table', 'chair', 'sofa', 'bookcase', 'board', 'clutter'], feature_to_file_mapping={'coord': ['X_SS_SPATIAL_0.05', 'Y_SS_SPATIAL_0.05', 'Z_SS_SPATIAL_0.05'], 'segment': 'segment_SS_SPATIAL_0.05', 'Anisotropy': 'Anisotropy_(0.5)_SS_SPATIAL_0.05', 'Octree_normals': ['Nx_SS_SPATIAL_0.05', 'Ny_SS_SPATIAL_0.05', 'Nz_SS_SPATIAL_0.05'], 'PCA1': 'PCA1_(0.5)_SS_SPATIAL_0.05', 'PCA2': 'PCA2_(0.5)_SS_SPATIAL_0.05', 'Roughness': 'Roughness_(0.5)_SS_SPATIAL_0.05', 'Sphericity': 'Sphericity_(0.5)_SS_SPATIAL_0.05', 'Verticality': 'Verticality_(0.5)_SS_SPATIAL_0.05'}, ignore_index=-1, coord_only=False, num_points=8192, dropout=0.5, emb_dims=1024, k=20, batch_size=8, epoch=100, learning_rate=0.001, optimizer='Adam', decay_rate=0.0001, lr_scheduler='cosine', step_size=10, lr_decay=0.7, eval=0, save_model_freq=1, seed=1, visu='', visu_format='ply', train_val=False, jab=True, jab_out_channels=9, sync_bn=False)
+Using Adam optimizer
+Using Cosine LR decay
+Loading data
+Experiment on S3DIS dataset!
+Namespace(exp_name='s3dis-latent-inject-r-0.5', data_root='../../data/gf_s3dis_ss_0.05', model_path='outputs/s3dis-latent-inject-r-0.5/models/model_99.pth', split='val', in_channels=12, num_classes=13, class_names=['ceiling', 'floor', 'wall', 'beam', 'column', 'window', 'door', 'table', 'chair', 'sofa', 'bookcase', 'board', 'clutter'], feature_to_file_mapping={'coord': ['X_SS_SPATIAL_0.05', 'Y_SS_SPATIAL_0.05', 'Z_SS_SPATIAL_0.05'], 'segment': 'segment_SS_SPATIAL_0.05', 'Anisotropy': 'Anisotropy_(0.5)_SS_SPATIAL_0.05', 'Octree_normals': ['Nx_SS_SPATIAL_0.05', 'Ny_SS_SPATIAL_0.05', 'Nz_SS_SPATIAL_0.05'], 'PCA1': 'PCA1_(0.5)_SS_SPATIAL_0.05', 'PCA2': 'PCA2_(0.5)_SS_SPATIAL_0.05', 'Roughness': 'Roughness_(0.5)_SS_SPATIAL_0.05', 'Sphericity': 'Sphericity_(0.5)_SS_SPATIAL_0.05', 'Verticality': 'Verticality_(0.5)_SS_SPATIAL_0.05'}, ignore_index=-1, coord_only=False, num_points=8192, dropout=0.5, emb_dims=1024, k=20, batch_size=8, epoch=100, learning_rate=0.001, optimizer='Adam', decay_rate=0.0001, lr_scheduler='cosine', step_size=10, lr_decay=0.7, eval=2, save_model_freq=1, seed=1, visu='', visu_format='ply', train_val=False, jab=True, jab_out_channels=9, visualize=True, sync_bn=True)
+Please check ZAHA num_points setting!
+Loading pretrained model outputs/s3dis-latent-inject-r-0.5/models/model_99.pth
+Loading data
+The number of training data is: 245
+Visualization enabled. Output directory: outputs/s3dis-latent-inject-r-0.5/visuals
+==== Evaluation Results ====
+Mean loss: 0.7145
+OA   : 0.8266
+μP   : 0.6663
+μIoU : 0.4827
+μR   : 0.5861
+μF1  : 0.5937
+============================
+ceiling         | P: 0.9351 | R: 0.9646 | IoU: 0.9041 | F1: 0.9496
+floor           | P: 0.9857 | R: 0.9956 | IoU: 0.9814 | F1: 0.9906
+wall            | P: 0.8106 | R: 0.9318 | IoU: 0.7652 | F1: 0.8670
+beam            | P: 0.0028 | R: 0.0572 | IoU: 0.0027 | F1: 0.0053
+column          | P: 0.5625 | R: 0.3013 | IoU: 0.2441 | F1: 0.3924
+window          | P: 0.6722 | R: 0.1817 | IoU: 0.1669 | F1: 0.2861
+door            | P: 0.4760 | R: 0.7908 | IoU: 0.4228 | F1: 0.5943
+table           | P: 0.8628 | R: 0.8810 | IoU: 0.7728 | F1: 0.8718
+chair           | P: 0.6736 | R: 0.7175 | IoU: 0.5324 | F1: 0.6948
+sofa            | P: 0.6257 | R: 0.1436 | IoU: 0.1322 | F1: 0.2336
+bookcase        | P: 0.8736 | R: 0.6851 | IoU: 0.6233 | F1: 0.7680
+board           | P: 0.5347 | R: 0.4477 | IoU: 0.3222 | F1: 0.4873
+clutter         | P: 0.6469 | R: 0.5209 | IoU: 0.4056 | F1: 0.5771
+
+Generating visualizations for 10 samples...
+Saved visualizations for sample 0: outputs/s3dis-latent-inject-r-0.5/visuals/sample_000_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_000_pred.mp4
+Saved visualizations for sample 1: outputs/s3dis-latent-inject-r-0.5/visuals/sample_001_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_001_pred.mp4
+Saved visualizations for sample 2: outputs/s3dis-latent-inject-r-0.5/visuals/sample_002_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_002_pred.mp4
+Saved visualizations for sample 3: outputs/s3dis-latent-inject-r-0.5/visuals/sample_003_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_003_pred.mp4
+Saved visualizations for sample 4: outputs/s3dis-latent-inject-r-0.5/visuals/sample_004_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_004_pred.mp4
+Saved visualizations for sample 5: outputs/s3dis-latent-inject-r-0.5/visuals/sample_005_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_005_pred.mp4
+Saved visualizations for sample 6: outputs/s3dis-latent-inject-r-0.5/visuals/sample_006_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_006_pred.mp4
+Saved visualizations for sample 7: outputs/s3dis-latent-inject-r-0.5/visuals/sample_007_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_007_pred.mp4
+Saved visualizations for sample 8: outputs/s3dis-latent-inject-r-0.5/visuals/sample_008_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_008_pred.mp4
+Saved visualizations for sample 9: outputs/s3dis-latent-inject-r-0.5/visuals/sample_009_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_009_pred.mp4
+Visualization complete! Files saved to: outputs/s3dis-latent-inject-r-0.5/visuals
+Experiment on S3DIS dataset!
+Namespace(exp_name='s3dis-latent-inject-r-0.5', data_root='../../data/gf_s3dis_ss_0.05', model_path='outputs/s3dis-latent-inject-r-0.5/models/model_99.pth', split='val', in_channels=12, num_classes=13, class_names=['ceiling', 'floor', 'wall', 'beam', 'column', 'window', 'door', 'table', 'chair', 'sofa', 'bookcase', 'board', 'clutter'], feature_to_file_mapping={'coord': ['X_SS_SPATIAL_0.05', 'Y_SS_SPATIAL_0.05', 'Z_SS_SPATIAL_0.05'], 'segment': 'segment_SS_SPATIAL_0.05', 'Anisotropy': 'Anisotropy_(0.5)_SS_SPATIAL_0.05', 'Octree_normals': ['Nx_SS_SPATIAL_0.05', 'Ny_SS_SPATIAL_0.05', 'Nz_SS_SPATIAL_0.05'], 'PCA1': 'PCA1_(0.5)_SS_SPATIAL_0.05', 'PCA2': 'PCA2_(0.5)_SS_SPATIAL_0.05', 'Roughness': 'Roughness_(0.5)_SS_SPATIAL_0.05', 'Sphericity': 'Sphericity_(0.5)_SS_SPATIAL_0.05', 'Verticality': 'Verticality_(0.5)_SS_SPATIAL_0.05'}, ignore_index=-1, coord_only=False, num_points=8192, dropout=0.5, emb_dims=1024, k=20, batch_size=8, epoch=100, learning_rate=0.001, optimizer='Adam', decay_rate=0.0001, lr_scheduler='cosine', step_size=10, lr_decay=0.7, eval=2, save_model_freq=1, seed=1, visu='', visu_format='ply', train_val=False, jab=True, jab_out_channels=9, visualize=True, sync_bn=True)
+Please check ZAHA num_points setting!
+Loading pretrained model outputs/s3dis-latent-inject-r-0.5/models/model_99.pth
+Loading data
+The number of training data is: 245
+Visualization enabled. Output directory: outputs/s3dis-latent-inject-r-0.5/visuals
+==== Evaluation Results ====
+Mean loss: 0.7145
+OA   : 0.8266
+μP   : 0.6663
+μIoU : 0.4827
+μR   : 0.5861
+μF1  : 0.5937
+============================
+ceiling         | P: 0.9351 | R: 0.9646 | IoU: 0.9041 | F1: 0.9496
+floor           | P: 0.9857 | R: 0.9956 | IoU: 0.9814 | F1: 0.9906
+wall            | P: 0.8106 | R: 0.9318 | IoU: 0.7652 | F1: 0.8670
+beam            | P: 0.0028 | R: 0.0572 | IoU: 0.0027 | F1: 0.0053
+column          | P: 0.5625 | R: 0.3013 | IoU: 0.2441 | F1: 0.3924
+window          | P: 0.6722 | R: 0.1817 | IoU: 0.1669 | F1: 0.2861
+door            | P: 0.4760 | R: 0.7908 | IoU: 0.4228 | F1: 0.5943
+table           | P: 0.8628 | R: 0.8810 | IoU: 0.7728 | F1: 0.8718
+chair           | P: 0.6736 | R: 0.7175 | IoU: 0.5324 | F1: 0.6948
+sofa            | P: 0.6257 | R: 0.1436 | IoU: 0.1322 | F1: 0.2336
+bookcase        | P: 0.8736 | R: 0.6851 | IoU: 0.6233 | F1: 0.7680
+board           | P: 0.5347 | R: 0.4477 | IoU: 0.3222 | F1: 0.4873
+clutter         | P: 0.6469 | R: 0.5209 | IoU: 0.4056 | F1: 0.5771
+
+Generating visualizations for 10 scenes...
+Scene 1/10: sample_14 (12 points)
+Saved visualizations for sample_14: outputs/s3dis-latent-inject-r-0.5/visuals/sample_14_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_14_pred.mp4
+Scene 2/10: sample_24 (48 points)
+Saved visualizations for sample_24: outputs/s3dis-latent-inject-r-0.5/visuals/sample_24_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_24_pred.mp4
+Scene 3/10: sample_8 (12 points)
+Saved visualizations for sample_8: outputs/s3dis-latent-inject-r-0.5/visuals/sample_8_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_8_pred.mp4
+Scene 4/10: sample_19 (24 points)
+Saved visualizations for sample_19: outputs/s3dis-latent-inject-r-0.5/visuals/sample_19_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_19_pred.mp4
+Scene 5/10: sample_39 (12 points)
+Saved visualizations for sample_39: outputs/s3dis-latent-inject-r-0.5/visuals/sample_39_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_39_pred.mp4
+Scene 6/10: sample_53 (12 points)
+Saved visualizations for sample_53: outputs/s3dis-latent-inject-r-0.5/visuals/sample_53_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_53_pred.mp4
+Scene 7/10: sample_12 (12 points)
+Saved visualizations for sample_12: outputs/s3dis-latent-inject-r-0.5/visuals/sample_12_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_12_pred.mp4
+Scene 8/10: sample_5 (24 points)
+Saved visualizations for sample_5: outputs/s3dis-latent-inject-r-0.5/visuals/sample_5_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_5_pred.mp4
+Scene 9/10: sample_54 (12 points)
+Saved visualizations for sample_54: outputs/s3dis-latent-inject-r-0.5/visuals/sample_54_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_54_pred.mp4
+Scene 10/10: sample_41 (12 points)
+Saved visualizations for sample_41: outputs/s3dis-latent-inject-r-0.5/visuals/sample_41_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_41_pred.mp4
+Visualization complete! Files saved to: outputs/s3dis-latent-inject-r-0.5/visuals
+Experiment on S3DIS dataset!
+Namespace(exp_name='s3dis-latent-inject-r-0.5', data_root='../../data/gf_s3dis_ss_0.05', model_path='outputs/s3dis-latent-inject-r-0.5/models/model_99.pth', split='val', in_channels=12, num_classes=13, class_names=['ceiling', 'floor', 'wall', 'beam', 'column', 'window', 'door', 'table', 'chair', 'sofa', 'bookcase', 'board', 'clutter'], feature_to_file_mapping={'coord': ['X_SS_SPATIAL_0.05', 'Y_SS_SPATIAL_0.05', 'Z_SS_SPATIAL_0.05'], 'segment': 'segment_SS_SPATIAL_0.05', 'Anisotropy': 'Anisotropy_(0.5)_SS_SPATIAL_0.05', 'Octree_normals': ['Nx_SS_SPATIAL_0.05', 'Ny_SS_SPATIAL_0.05', 'Nz_SS_SPATIAL_0.05'], 'PCA1': 'PCA1_(0.5)_SS_SPATIAL_0.05', 'PCA2': 'PCA2_(0.5)_SS_SPATIAL_0.05', 'Roughness': 'Roughness_(0.5)_SS_SPATIAL_0.05', 'Sphericity': 'Sphericity_(0.5)_SS_SPATIAL_0.05', 'Verticality': 'Verticality_(0.5)_SS_SPATIAL_0.05'}, ignore_index=-1, coord_only=False, num_points=8192, dropout=0.5, emb_dims=1024, k=20, batch_size=8, epoch=100, learning_rate=0.001, optimizer='Adam', decay_rate=0.0001, lr_scheduler='cosine', step_size=10, lr_decay=0.7, eval=2, save_model_freq=1, seed=1, visu='', visu_format='ply', train_val=False, jab=True, jab_out_channels=9, visualize=True, sync_bn=True)
+Please check ZAHA num_points setting!
+Loading pretrained model outputs/s3dis-latent-inject-r-0.5/models/model_99.pth
+Loading data
+The number of training data is: 245
+Visualization enabled. Output directory: outputs/s3dis-latent-inject-r-0.5/visuals
+==== Evaluation Results ====
+Mean loss: 0.7175
+OA   : 0.8260
+μP   : 0.6643
+μIoU : 0.4823
+μR   : 0.5854
+μF1  : 0.5927
+============================
+ceiling         | P: 0.9364 | R: 0.9652 | IoU: 0.9058 | F1: 0.9506
+floor           | P: 0.9857 | R: 0.9954 | IoU: 0.9813 | F1: 0.9905
+wall            | P: 0.8067 | R: 0.9301 | IoU: 0.7606 | F1: 0.8640
+beam            | P: 0.0028 | R: 0.0572 | IoU: 0.0027 | F1: 0.0053
+column          | P: 0.5595 | R: 0.3013 | IoU: 0.2435 | F1: 0.3916
+window          | P: 0.6720 | R: 0.1817 | IoU: 0.1669 | F1: 0.2861
+door            | P: 0.4774 | R: 0.7915 | IoU: 0.4241 | F1: 0.5956
+table           | P: 0.8652 | R: 0.8779 | IoU: 0.7723 | F1: 0.8715
+chair           | P: 0.6736 | R: 0.7175 | IoU: 0.5324 | F1: 0.6948
+sofa            | P: 0.5830 | R: 0.1268 | IoU: 0.1163 | F1: 0.2083
+bookcase        | P: 0.8736 | R: 0.6852 | IoU: 0.6234 | F1: 0.7680
+board           | P: 0.5530 | R: 0.4595 | IoU: 0.3350 | F1: 0.5019
+clutter         | P: 0.6470 | R: 0.5209 | IoU: 0.4056 | F1: 0.5771
+
+Generating visualizations for 10 scenes...
+Scene 1/10: sample_0 (12 points)
+Saved visualizations for sample_0: outputs/s3dis-latent-inject-r-0.5/visuals/sample_0_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_0_pred.mp4
+Scene 2/10: sample_1 (60 points)
+Saved visualizations for sample_1: outputs/s3dis-latent-inject-r-0.5/visuals/sample_1_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_1_pred.mp4
+Scene 3/10: sample_2 (48 points)
+Saved visualizations for sample_2: outputs/s3dis-latent-inject-r-0.5/visuals/sample_2_pred.ply, outputs/s3dis-latent-inject-r-0.5/visuals/sample_2_pred.mp4
+Scene 4/10: sample_3 (24 points)
+Experiment on S3DIS dataset!
+Namespace(exp_name='s3dis-latent-inject-r-0.5', data_root='../../data/gf_s3dis_ss_0.05', model_path='outputs/s3dis-latent-inject-r-0.5/models/model_99.pth', split='val', in_channels=12, num_classes=13, class_names=['ceiling', 'floor', 'wall', 'beam', 'column', 'window', 'door', 'table', 'chair', 'sofa', 'bookcase', 'board', 'clutter'], feature_to_file_mapping={'coord': ['X_SS_SPATIAL_0.05', 'Y_SS_SPATIAL_0.05', 'Z_SS_SPATIAL_0.05'], 'segment': 'segment_SS_SPATIAL_0.05', 'Anisotropy': 'Anisotropy_(0.5)_SS_SPATIAL_0.05', 'Octree_normals': ['Nx_SS_SPATIAL_0.05', 'Ny_SS_SPATIAL_0.05', 'Nz_SS_SPATIAL_0.05'], 'PCA1': 'PCA1_(0.5)_SS_SPATIAL_0.05', 'PCA2': 'PCA2_(0.5)_SS_SPATIAL_0.05', 'Roughness': 'Roughness_(0.5)_SS_SPATIAL_0.05', 'Sphericity': 'Sphericity_(0.5)_SS_SPATIAL_0.05', 'Verticality': 'Verticality_(0.5)_SS_SPATIAL_0.05'}, ignore_index=-1, coord_only=False, num_points=8192, dropout=0.5, emb_dims=1024, k=20, batch_size=8, epoch=100, learning_rate=0.001, optimizer='Adam', decay_rate=0.0001, lr_scheduler='cosine', step_size=10, lr_decay=0.7, eval=2, save_model_freq=1, seed=1, visu='', visu_format='ply', train_val=False, jab=True, jab_out_channels=9, sync_bn=True)
+Please check ZAHA num_points setting!
+Loading pretrained model outputs/s3dis-latent-inject-r-0.5/models/model_99.pth
+Loading data
+The number of training data is: 245
+==== Evaluation Results ====
+Mean loss: 0.7145
+OA   : 0.8266
+μP   : 0.6663
+μIoU : 0.4827
+μR   : 0.5861
+μF1  : 0.5937
+============================
+ceiling         | P: 0.9351 | R: 0.9646 | IoU: 0.9041 | F1: 0.9496
+floor           | P: 0.9857 | R: 0.9956 | IoU: 0.9814 | F1: 0.9906
+wall            | P: 0.8106 | R: 0.9318 | IoU: 0.7652 | F1: 0.8670
+beam            | P: 0.0028 | R: 0.0572 | IoU: 0.0027 | F1: 0.0053
+column          | P: 0.5625 | R: 0.3013 | IoU: 0.2441 | F1: 0.3924
+window          | P: 0.6722 | R: 0.1817 | IoU: 0.1669 | F1: 0.2861
+door            | P: 0.4760 | R: 0.7908 | IoU: 0.4228 | F1: 0.5943
+table           | P: 0.8628 | R: 0.8810 | IoU: 0.7728 | F1: 0.8718
+chair           | P: 0.6736 | R: 0.7175 | IoU: 0.5324 | F1: 0.6948
+sofa            | P: 0.6257 | R: 0.1436 | IoU: 0.1322 | F1: 0.2336
+bookcase        | P: 0.8736 | R: 0.6852 | IoU: 0.6234 | F1: 0.7680
+board           | P: 0.5347 | R: 0.4477 | IoU: 0.3222 | F1: 0.4873
+clutter         | P: 0.6470 | R: 0.5209 | IoU: 0.4056 | F1: 0.5771
+Experiment on S3DIS dataset!
+Namespace(exp_name='s3dis-latent-inject-r-0.5', data_root='../../data/gf_s3dis_ss_0.05', model_path='outputs/s3dis-latent-inject-r-0.5/models/model_99.pth', split='val', in_channels=12, num_classes=13, class_names=['ceiling', 'floor', 'wall', 'beam', 'column', 'window', 'door', 'table', 'chair', 'sofa', 'bookcase', 'board', 'clutter'], feature_to_file_mapping={'coord': ['X_SS_SPATIAL_0.05', 'Y_SS_SPATIAL_0.05', 'Z_SS_SPATIAL_0.05'], 'segment': 'segment_SS_SPATIAL_0.05', 'Anisotropy': 'Anisotropy_(0.5)_SS_SPATIAL_0.05', 'Octree_normals': ['Nx_SS_SPATIAL_0.05', 'Ny_SS_SPATIAL_0.05', 'Nz_SS_SPATIAL_0.05'], 'PCA1': 'PCA1_(0.5)_SS_SPATIAL_0.05', 'PCA2': 'PCA2_(0.5)_SS_SPATIAL_0.05', 'Roughness': 'Roughness_(0.5)_SS_SPATIAL_0.05', 'Sphericity': 'Sphericity_(0.5)_SS_SPATIAL_0.05', 'Verticality': 'Verticality_(0.5)_SS_SPATIAL_0.05'}, ignore_index=-1, coord_only=False, num_points=8192, dropout=0.5, emb_dims=1024, k=20, batch_size=8, epoch=100, learning_rate=0.001, optimizer='Adam', decay_rate=0.0001, lr_scheduler='cosine', step_size=10, lr_decay=0.7, eval=2, save_model_freq=1, seed=1, visu='', visu_format='ply', train_val=False, jab=True, jab_out_channels=9, sync_bn=True)
+Please check ZAHA num_points setting!
+Loading pretrained model outputs/s3dis-latent-inject-r-0.5/models/model_99.pth
+Loading data
+The number of training data is: 245
+Experiment on S3DIS dataset!
+Namespace(exp_name='s3dis-latent-inject-r-0.5', data_root='../../data/gf_s3dis_ss_0.05', model_path='outputs/s3dis-latent-inject-r-0.5/models/model_99.pth', split='val', in_channels=12, num_classes=13, class_names=['ceiling', 'floor', 'wall', 'beam', 'column', 'window', 'door', 'table', 'chair', 'sofa', 'bookcase', 'board', 'clutter'], feature_to_file_mapping={'coord': ['X_SS_SPATIAL_0.05', 'Y_SS_SPATIAL_0.05', 'Z_SS_SPATIAL_0.05'], 'segment': 'segment_SS_SPATIAL_0.05', 'Anisotropy': 'Anisotropy_(0.5)_SS_SPATIAL_0.05', 'Octree_normals': ['Nx_SS_SPATIAL_0.05', 'Ny_SS_SPATIAL_0.05', 'Nz_SS_SPATIAL_0.05'], 'PCA1': 'PCA1_(0.5)_SS_SPATIAL_0.05', 'PCA2': 'PCA2_(0.5)_SS_SPATIAL_0.05', 'Roughness': 'Roughness_(0.5)_SS_SPATIAL_0.05', 'Sphericity': 'Sphericity_(0.5)_SS_SPATIAL_0.05', 'Verticality': 'Verticality_(0.5)_SS_SPATIAL_0.05'}, ignore_index=-1, coord_only=False, num_points=8192, dropout=0.5, emb_dims=1024, k=20, batch_size=8, epoch=100, learning_rate=0.001, optimizer='Adam', decay_rate=0.0001, lr_scheduler='cosine', step_size=10, lr_decay=0.7, eval=2, save_model_freq=1, seed=1, visu='', visu_format='ply', train_val=False, jab=True, jab_out_channels=9, sync_bn=True)
+Please check ZAHA num_points setting!
+Loading pretrained model outputs/s3dis-latent-inject-r-0.5/models/model_99.pth
+Loading data
+Experiment on S3DIS dataset!
+Namespace(exp_name='s3dis-latent-inject-r-0.5', data_root='../../data/gf_s3dis_ss_0.05', model_path='outputs/s3dis-latent-inject-r-0.5/models/model_99.pth', split='val', in_channels=12, num_classes=13, class_names=['ceiling', 'floor', 'wall', 'beam', 'column', 'window', 'door', 'table', 'chair', 'sofa', 'bookcase', 'board', 'clutter'], feature_to_file_mapping={'coord': ['X_SS_SPATIAL_0.05', 'Y_SS_SPATIAL_0.05', 'Z_SS_SPATIAL_0.05'], 'segment': 'segment_SS_SPATIAL_0.05', 'Anisotropy': 'Anisotropy_(0.5)_SS_SPATIAL_0.05', 'Octree_normals': ['Nx_SS_SPATIAL_0.05', 'Ny_SS_SPATIAL_0.05', 'Nz_SS_SPATIAL_0.05'], 'PCA1': 'PCA1_(0.5)_SS_SPATIAL_0.05', 'PCA2': 'PCA2_(0.5)_SS_SPATIAL_0.05', 'Roughness': 'Roughness_(0.5)_SS_SPATIAL_0.05', 'Sphericity': 'Sphericity_(0.5)_SS_SPATIAL_0.05', 'Verticality': 'Verticality_(0.5)_SS_SPATIAL_0.05'}, ignore_index=-1, coord_only=False, num_points=8192, dropout=0.5, emb_dims=1024, k=20, batch_size=8, epoch=100, learning_rate=0.001, optimizer='Adam', decay_rate=0.0001, lr_scheduler='cosine', step_size=10, lr_decay=0.7, eval=2, save_model_freq=1, seed=1, visu='', visu_format='ply', train_val=False, jab=True, jab_out_channels=9, sync_bn=True)
+Please check ZAHA num_points setting!
+Loading pretrained model outputs/s3dis-latent-inject-r-0.5/models/model_99.pth
+Loading data
+Experiment on S3DIS dataset!
+Namespace(exp_name='s3dis-latent-inject-r-0.5', data_root='../../data/gf_s3dis_ss_0.05', model_path='outputs/s3dis-latent-inject-r-0.5/models/model_99.pth', split='val', in_channels=12, num_classes=13, class_names=['ceiling', 'floor', 'wall', 'beam', 'column', 'window', 'door', 'table', 'chair', 'sofa', 'bookcase', 'board', 'clutter'], feature_to_file_mapping={'coord': ['X_SS_SPATIAL_0.05', 'Y_SS_SPATIAL_0.05', 'Z_SS_SPATIAL_0.05'], 'segment': 'segment_SS_SPATIAL_0.05', 'Anisotropy': 'Anisotropy_(0.5)_SS_SPATIAL_0.05', 'Octree_normals': ['Nx_SS_SPATIAL_0.05', 'Ny_SS_SPATIAL_0.05', 'Nz_SS_SPATIAL_0.05'], 'PCA1': 'PCA1_(0.5)_SS_SPATIAL_0.05', 'PCA2': 'PCA2_(0.5)_SS_SPATIAL_0.05', 'Roughness': 'Roughness_(0.5)_SS_SPATIAL_0.05', 'Sphericity': 'Sphericity_(0.5)_SS_SPATIAL_0.05', 'Verticality': 'Verticality_(0.5)_SS_SPATIAL_0.05'}, ignore_index=-1, coord_only=False, num_points=8192, dropout=0.5, emb_dims=1024, k=20, batch_size=8, epoch=100, learning_rate=0.001, optimizer='Adam', decay_rate=0.0001, lr_scheduler='cosine', step_size=10, lr_decay=0.7, eval=2, save_model_freq=1, seed=1, visu='', visu_format='ply', train_val=False, jab=True, jab_out_channels=9, sync_bn=True)
+Please check ZAHA num_points setting!
+Loading pretrained model outputs/s3dis-latent-inject-r-0.5/models/model_99.pth
+Loading data
+The number of training data is: 68
+Experiment on S3DIS dataset!
+Namespace(exp_name='s3dis-latent-inject-r-0.5', data_root='../../data/gf_s3dis_ss_0.05', model_path='outputs/s3dis-latent-inject-r-0.5/models/model_99.pth', split='val', in_channels=12, num_classes=13, class_names=['ceiling', 'floor', 'wall', 'beam', 'column', 'window', 'door', 'table', 'chair', 'sofa', 'bookcase', 'board', 'clutter'], feature_to_file_mapping={'coord': ['X_SS_SPATIAL_0.05', 'Y_SS_SPATIAL_0.05', 'Z_SS_SPATIAL_0.05'], 'segment': 'segment_SS_SPATIAL_0.05', 'Anisotropy': 'Anisotropy_(0.5)_SS_SPATIAL_0.05', 'Octree_normals': ['Nx_SS_SPATIAL_0.05', 'Ny_SS_SPATIAL_0.05', 'Nz_SS_SPATIAL_0.05'], 'PCA1': 'PCA1_(0.5)_SS_SPATIAL_0.05', 'PCA2': 'PCA2_(0.5)_SS_SPATIAL_0.05', 'Roughness': 'Roughness_(0.5)_SS_SPATIAL_0.05', 'Sphericity': 'Sphericity_(0.5)_SS_SPATIAL_0.05', 'Verticality': 'Verticality_(0.5)_SS_SPATIAL_0.05'}, ignore_index=-1, coord_only=False, num_points=8192, dropout=0.5, emb_dims=1024, k=20, batch_size=8, epoch=100, learning_rate=0.001, optimizer='Adam', decay_rate=0.0001, lr_scheduler='cosine', step_size=10, lr_decay=0.7, eval=2, save_model_freq=1, seed=1, visu='', visu_format='ply', train_val=False, jab=True, jab_out_channels=9, sync_bn=True)
+Please check ZAHA num_points setting!
+Loading pretrained model outputs/s3dis-latent-inject-r-0.5/models/model_99.pth
+Loading data
+The number of training data is: 280
+Experiment on S3DIS dataset!
+Namespace(exp_name='s3dis-latent-inject-r-0.5', data_root='../../data/gf_s3dis_ss_0.05', model_path='outputs/s3dis-latent-inject-r-0.5/models/model_99.pth', split='val', in_channels=12, num_classes=13, class_names=['ceiling', 'floor', 'wall', 'beam', 'column', 'window', 'door', 'table', 'chair', 'sofa', 'bookcase', 'board', 'clutter'], feature_to_file_mapping={'coord': ['X_SS_SPATIAL_0.05', 'Y_SS_SPATIAL_0.05', 'Z_SS_SPATIAL_0.05'], 'segment': 'segment_SS_SPATIAL_0.05', 'Anisotropy': 'Anisotropy_(0.5)_SS_SPATIAL_0.05', 'Octree_normals': ['Nx_SS_SPATIAL_0.05', 'Ny_SS_SPATIAL_0.05', 'Nz_SS_SPATIAL_0.05'], 'PCA1': 'PCA1_(0.5)_SS_SPATIAL_0.05', 'PCA2': 'PCA2_(0.5)_SS_SPATIAL_0.05', 'Roughness': 'Roughness_(0.5)_SS_SPATIAL_0.05', 'Sphericity': 'Sphericity_(0.5)_SS_SPATIAL_0.05', 'Verticality': 'Verticality_(0.5)_SS_SPATIAL_0.05'}, ignore_index=-1, coord_only=False, num_points=8192, dropout=0.5, emb_dims=1024, k=20, batch_size=8, epoch=100, learning_rate=0.001, optimizer='Adam', decay_rate=0.0001, lr_scheduler='cosine', step_size=10, lr_decay=0.7, eval=2, save_model_freq=1, seed=1, visu='', visu_format='ply', train_val=False, jab=True, jab_out_channels=9, sync_bn=True)
+Please check ZAHA num_points setting!
+Loading pretrained model outputs/s3dis-latent-inject-r-0.5/models/model_99.pth
+Loading data
+The number of training data is: 280
+Experiment on S3DIS dataset!
+Namespace(exp_name='s3dis-latent-inject-r-0.5', data_root='../../data/gf_s3dis_ss_0.05', model_path='outputs/s3dis-latent-inject-r-0.5/models/model_99.pth', split='val', in_channels=12, num_classes=13, class_names=['ceiling', 'floor', 'wall', 'beam', 'column', 'window', 'door', 'table', 'chair', 'sofa', 'bookcase', 'board', 'clutter'], feature_to_file_mapping={'coord': ['X_SS_SPATIAL_0.05', 'Y_SS_SPATIAL_0.05', 'Z_SS_SPATIAL_0.05'], 'segment': 'segment_SS_SPATIAL_0.05', 'Anisotropy': 'Anisotropy_(0.5)_SS_SPATIAL_0.05', 'Octree_normals': ['Nx_SS_SPATIAL_0.05', 'Ny_SS_SPATIAL_0.05', 'Nz_SS_SPATIAL_0.05'], 'PCA1': 'PCA1_(0.5)_SS_SPATIAL_0.05', 'PCA2': 'PCA2_(0.5)_SS_SPATIAL_0.05', 'Roughness': 'Roughness_(0.5)_SS_SPATIAL_0.05', 'Sphericity': 'Sphericity_(0.5)_SS_SPATIAL_0.05', 'Verticality': 'Verticality_(0.5)_SS_SPATIAL_0.05'}, ignore_index=-1, coord_only=False, num_points=8192, dropout=0.5, emb_dims=1024, k=20, batch_size=8, epoch=100, learning_rate=0.001, optimizer='Adam', decay_rate=0.0001, lr_scheduler='cosine', step_size=10, lr_decay=0.7, eval=2, save_model_freq=1, seed=1, visu='', visu_format='ply', train_val=False, jab=True, jab_out_channels=9, sync_bn=True)
+Please check ZAHA num_points setting!
+Loading pretrained model outputs/s3dis-latent-inject-r-0.5/models/model_99.pth
+Loading data
+The number of training data is: 280
+==== Evaluation Results ====
+Mean loss: 0.7040
+OA   : 0.6221
+μP   : 0.5337
+μIoU : 0.4054
+μR   : 0.5451
+μF1  : 0.5154
+============================
+ceiling         | P: 0.3978 | R: 0.9681 | IoU: 0.3927 | F1: 0.5639
+floor           | P: 0.9879 | R: 0.9952 | IoU: 0.9832 | F1: 0.9915
+wall            | P: 0.8084 | R: 0.8543 | IoU: 0.7105 | F1: 0.8307
+beam            | P: 0.0000 | R: 0.0000 | IoU: 0.0000 | F1: 0.0000
+column          | P: 0.5004 | R: 0.2549 | IoU: 0.2032 | F1: 0.3377
+window          | P: 0.0000 | R: 0.0000 | IoU: 0.0000 | F1: 0.0000
+door            | P: 0.4379 | R: 0.8058 | IoU: 0.3961 | F1: 0.5674
+table           | P: 0.8697 | R: 0.7983 | IoU: 0.7130 | F1: 0.8325
+chair           | P: 0.6403 | R: 0.7280 | IoU: 0.5166 | F1: 0.6813
+sofa            | P: 0.4287 | R: 0.2051 | IoU: 0.1611 | F1: 0.2774
+bookcase        | P: 0.8390 | R: 0.7293 | IoU: 0.6397 | F1: 0.7803
+board           | P: 0.4407 | R: 0.1879 | IoU: 0.1517 | F1: 0.2635
+clutter         | P: 0.5879 | R: 0.5597 | IoU: 0.4020 | F1: 0.5734
+Experiment on S3DIS dataset!
+Namespace(exp_name='s3dis-latent-inject-r-0.5', data_root='../../data/gf_s3dis_ss_0.05', model_path='outputs/s3dis-latent-inject-r-0.5/models/model_99.pth', split='val', in_channels=12, num_classes=13, class_names=['ceiling', 'floor', 'wall', 'beam', 'column', 'window', 'door', 'table', 'chair', 'sofa', 'bookcase', 'board', 'clutter'], feature_to_file_mapping={'coord': ['X_SS_SPATIAL_0.05', 'Y_SS_SPATIAL_0.05', 'Z_SS_SPATIAL_0.05'], 'segment': 'segment_SS_SPATIAL_0.05', 'Anisotropy': 'Anisotropy_(0.5)_SS_SPATIAL_0.05', 'Octree_normals': ['Nx_SS_SPATIAL_0.05', 'Ny_SS_SPATIAL_0.05', 'Nz_SS_SPATIAL_0.05'], 'PCA1': 'PCA1_(0.5)_SS_SPATIAL_0.05', 'PCA2': 'PCA2_(0.5)_SS_SPATIAL_0.05', 'Roughness': 'Roughness_(0.5)_SS_SPATIAL_0.05', 'Sphericity': 'Sphericity_(0.5)_SS_SPATIAL_0.05', 'Verticality': 'Verticality_(0.5)_SS_SPATIAL_0.05'}, ignore_index=-1, coord_only=False, num_points=8192, dropout=0.5, emb_dims=1024, k=20, batch_size=8, epoch=100, learning_rate=0.001, optimizer='Adam', decay_rate=0.0001, lr_scheduler='cosine', step_size=10, lr_decay=0.7, eval=2, save_model_freq=1, seed=1, visu='', visu_format='ply', train_val=False, jab=True, jab_out_channels=9, sync_bn=True)
+Please check ZAHA num_points setting!
+Loading pretrained model outputs/s3dis-latent-inject-r-0.5/models/model_99.pth
+Loading data
+The number of training data is: 280
+==== Evaluation Results ====
+Mean loss: 0.7040
+OA   : 0.8205
+μP   : 0.5768
+μIoU : 0.4458
+μR   : 0.5451
+μF1  : 0.5460
+============================
+ceiling         | P: 0.9372 | R: 0.9681 | IoU: 0.9092 | F1: 0.9524
+floor           | P: 0.9879 | R: 0.9952 | IoU: 0.9832 | F1: 0.9915
+wall            | P: 0.8084 | R: 0.8543 | IoU: 0.7105 | F1: 0.8307
+beam            | P: 0.0000 | R: 0.0000 | IoU: 0.0000 | F1: 0.0000
+column          | P: 0.5004 | R: 0.2549 | IoU: 0.2032 | F1: 0.3377
+window          | P: 0.0000 | R: 0.0000 | IoU: 0.0000 | F1: 0.0000
+door            | P: 0.4379 | R: 0.8058 | IoU: 0.3961 | F1: 0.5674
+table           | P: 0.8697 | R: 0.7983 | IoU: 0.7130 | F1: 0.8325
+chair           | P: 0.6403 | R: 0.7280 | IoU: 0.5166 | F1: 0.6813
+sofa            | P: 0.4287 | R: 0.2051 | IoU: 0.1611 | F1: 0.2774
+bookcase        | P: 0.8390 | R: 0.7293 | IoU: 0.6397 | F1: 0.7803
+board           | P: 0.4407 | R: 0.1879 | IoU: 0.1517 | F1: 0.2635
+clutter         | P: 0.6081 | R: 0.5597 | IoU: 0.4113 | F1: 0.5829
+Experiment on S3DIS dataset!
+Namespace(exp_name='s3dis-latent-inject-r-0.5', data_root='../../data/gf_s3dis_ss_0.05', model_path='outputs/s3dis-latent-inject-r-0.5/models/model_99.pth', split='val', in_channels=12, num_classes=13, class_names=['ceiling', 'floor', 'wall', 'beam', 'column', 'window', 'door', 'table', 'chair', 'sofa', 'bookcase', 'board', 'clutter'], feature_to_file_mapping={'coord': ['X_SS_SPATIAL_0.05', 'Y_SS_SPATIAL_0.05', 'Z_SS_SPATIAL_0.05'], 'segment': 'segment_SS_SPATIAL_0.05', 'Anisotropy': 'Anisotropy_(0.5)_SS_SPATIAL_0.05', 'Octree_normals': ['Nx_SS_SPATIAL_0.05', 'Ny_SS_SPATIAL_0.05', 'Nz_SS_SPATIAL_0.05'], 'PCA1': 'PCA1_(0.5)_SS_SPATIAL_0.05', 'PCA2': 'PCA2_(0.5)_SS_SPATIAL_0.05', 'Roughness': 'Roughness_(0.5)_SS_SPATIAL_0.05', 'Sphericity': 'Sphericity_(0.5)_SS_SPATIAL_0.05', 'Verticality': 'Verticality_(0.5)_SS_SPATIAL_0.05'}, ignore_index=-1, coord_only=False, num_points=8192, dropout=0.5, emb_dims=1024, k=20, batch_size=8, epoch=100, learning_rate=0.001, optimizer='Adam', decay_rate=0.0001, lr_scheduler='cosine', step_size=10, lr_decay=0.7, eval=2, save_model_freq=1, seed=1, visu='', visu_format='ply', train_val=False, jab=True, jab_out_channels=9, sync_bn=True)
+Please check ZAHA num_points setting!
+Loading pretrained model outputs/s3dis-latent-inject-r-0.5/models/model_99.pth
+Loading data
+The number of training data is: 280
+Saved visualization for scene: Area_5-office_18
+Saved visualization for scene: Area_5-office_30
+Saved visualization for scene: Area_5-office_7
+Saved visualization for scene: Area_5-office_15
+Saved visualization for scene: Area_5-storage_1
+Saved visualization for scene: Area_5-hallway_3
+Saved visualization for scene: Area_5-office_25
+Saved visualization for scene: Area_5-lobby_1
+Saved visualization for scene: Area_5-office_31
+Saved visualization for scene: Area_5-conferenceRoom_3
+Saved visualization for scene: Area_5-conferenceRoom_2
+Saved visualization for scene: Area_5-office_37
+Saved visualization for scene: Area_5-office_22
+Saved visualization for scene: Area_5-hallway_4
+Saved visualization for scene: Area_5-office_40
+Saved visualization for scene: Area_5-hallway_15
+Saved visualization for scene: Area_5-office_32
+Saved visualization for scene: Area_5-hallway_13
+Saved visualization for scene: Area_5-office_38
+Saved visualization for scene: Area_5-conferenceRoom_1
+Saved visualization for scene: Area_5-office_21
+Saved visualization for scene: Area_5-WC_1
+Saved visualization for scene: Area_5-office_24
+Saved visualization for scene: Area_5-office_4
+Saved visualization for scene: Area_5-office_27
+Saved visualization for scene: Area_5-hallway_7
+Saved visualization for scene: Area_5-office_41
+Saved visualization for scene: Area_5-storage_2
+Saved visualization for scene: Area_5-office_1
+Saved visualization for scene: Area_5-hallway_1
+Saved visualization for scene: Area_5-hallway_10
+Saved visualization for scene: Area_5-hallway_8
+Saved visualization for scene: Area_5-hallway_2
+Saved visualization for scene: Area_5-hallway_5
+==== Evaluation Results ====
+Mean loss: 0.7042
+OA   : 0.8205
+μP   : 0.5768
+μIoU : 0.4458
+μR   : 0.5451
+μF1  : 0.5459
+============================
+ceiling         | P: 0.9372 | R: 0.9681 | IoU: 0.9092 | F1: 0.9524
+floor           | P: 0.9879 | R: 0.9952 | IoU: 0.9832 | F1: 0.9915
+wall            | P: 0.8084 | R: 0.8543 | IoU: 0.7105 | F1: 0.8307
+beam            | P: 0.0000 | R: 0.0000 | IoU: 0.0000 | F1: 0.0000
+column          | P: 0.5004 | R: 0.2542 | IoU: 0.2027 | F1: 0.3371
+window          | P: 0.0000 | R: 0.0000 | IoU: 0.0000 | F1: 0.0000
+door            | P: 0.4377 | R: 0.8058 | IoU: 0.3959 | F1: 0.5672
+table           | P: 0.8698 | R: 0.7981 | IoU: 0.7129 | F1: 0.8324
+chair           | P: 0.6402 | R: 0.7279 | IoU: 0.5166 | F1: 0.6813
+sofa            | P: 0.4285 | R: 0.2049 | IoU: 0.1609 | F1: 0.2772
+bookcase        | P: 0.8390 | R: 0.7293 | IoU: 0.6397 | F1: 0.7803
+board           | P: 0.4410 | R: 0.1881 | IoU: 0.1519 | F1: 0.2637
+clutter         | P: 0.6081 | R: 0.5598 | IoU: 0.4114 | F1: 0.5830
+Experiment on S3DIS dataset!
+Namespace(exp_name='s3dis-latent-inject-r-0.5', data_root='../../data/gf_s3dis_ss_0.05', model_path='outputs/s3dis-latent-inject-r-0.5/models/model_99.pth', split='val', in_channels=12, num_classes=13, class_names=['ceiling', 'floor', 'wall', 'beam', 'column', 'window', 'door', 'table', 'chair', 'sofa', 'bookcase', 'board', 'clutter'], feature_to_file_mapping={'coord': ['X_SS_SPATIAL_0.05', 'Y_SS_SPATIAL_0.05', 'Z_SS_SPATIAL_0.05'], 'segment': 'segment_SS_SPATIAL_0.05', 'Anisotropy': 'Anisotropy_(0.5)_SS_SPATIAL_0.05', 'Octree_normals': ['Nx_SS_SPATIAL_0.05', 'Ny_SS_SPATIAL_0.05', 'Nz_SS_SPATIAL_0.05'], 'PCA1': 'PCA1_(0.5)_SS_SPATIAL_0.05', 'PCA2': 'PCA2_(0.5)_SS_SPATIAL_0.05', 'Roughness': 'Roughness_(0.5)_SS_SPATIAL_0.05', 'Sphericity': 'Sphericity_(0.5)_SS_SPATIAL_0.05', 'Verticality': 'Verticality_(0.5)_SS_SPATIAL_0.05'}, ignore_index=-1, coord_only=False, num_points=8192, dropout=0.5, emb_dims=1024, k=20, batch_size=8, epoch=100, learning_rate=0.001, optimizer='Adam', decay_rate=0.0001, lr_scheduler='cosine', step_size=10, lr_decay=0.7, eval=2, save_model_freq=1, seed=1, visu='', visu_format='ply', train_val=False, jab=True, jab_out_channels=9, sync_bn=True)
+Please check ZAHA num_points setting!
+Loading pretrained model outputs/s3dis-latent-inject-r-0.5/models/model_99.pth
+Loading data
+The number of training data is: 280
+Saved visualization for scene: Area_5-office_18
+Saved visualization for scene: Area_5-office_30
+Saved visualization for scene: Area_5-office_7
+Saved visualization for scene: Area_5-office_15
+Saved visualization for scene: Area_5-storage_1
+Saved visualization for scene: Area_5-hallway_3
+Saved visualization for scene: Area_5-office_25
+Saved visualization for scene: Area_5-lobby_1
+Saved visualization for scene: Area_5-office_31
+Saved visualization for scene: Area_5-conferenceRoom_3
+Saved visualization for scene: Area_5-conferenceRoom_2
+Saved visualization for scene: Area_5-office_37
+Saved visualization for scene: Area_5-office_22
+Saved visualization for scene: Area_5-hallway_4
+Saved visualization for scene: Area_5-office_40
+Saved visualization for scene: Area_5-hallway_15
+Saved visualization for scene: Area_5-office_32
+Saved visualization for scene: Area_5-hallway_13
+Saved visualization for scene: Area_5-office_38
+Saved visualization for scene: Area_5-conferenceRoom_1
+Saved visualization for scene: Area_5-office_21
+Saved visualization for scene: Area_5-WC_1
+Saved visualization for scene: Area_5-office_24
+Saved visualization for scene: Area_5-office_4
+Saved visualization for scene: Area_5-office_27
+Saved visualization for scene: Area_5-hallway_7
+Saved visualization for scene: Area_5-office_41
+Saved visualization for scene: Area_5-storage_2
+Saved visualization for scene: Area_5-office_1
+Saved visualization for scene: Area_5-hallway_1
+Saved visualization for scene: Area_5-hallway_10
+Saved visualization for scene: Area_5-hallway_8
+Saved visualization for scene: Area_5-hallway_2
+Saved visualization for scene: Area_5-hallway_5
+==== Evaluation Results ====
+Mean loss: 0.7041
+OA   : 0.8205
+μP   : 0.5768
+μIoU : 0.4458
+μR   : 0.5451
+μF1  : 0.5460
+============================
+ceiling         | P: 0.9372 | R: 0.9681 | IoU: 0.9092 | F1: 0.9524
+floor           | P: 0.9879 | R: 0.9952 | IoU: 0.9832 | F1: 0.9915
+wall            | P: 0.8084 | R: 0.8543 | IoU: 0.7105 | F1: 0.8307
+beam            | P: 0.0000 | R: 0.0000 | IoU: 0.0000 | F1: 0.0000
+column          | P: 0.5004 | R: 0.2549 | IoU: 0.2032 | F1: 0.3378
+window          | P: 0.0000 | R: 0.0000 | IoU: 0.0000 | F1: 0.0000
+door            | P: 0.4378 | R: 0.8057 | IoU: 0.3960 | F1: 0.5674
+table           | P: 0.8697 | R: 0.7983 | IoU: 0.7130 | F1: 0.8325
+chair           | P: 0.6402 | R: 0.7280 | IoU: 0.5166 | F1: 0.6813
+sofa            | P: 0.4287 | R: 0.2051 | IoU: 0.1611 | F1: 0.2774
+bookcase        | P: 0.8390 | R: 0.7292 | IoU: 0.6397 | F1: 0.7803
+board           | P: 0.4407 | R: 0.1879 | IoU: 0.1517 | F1: 0.2635
+clutter         | P: 0.6081 | R: 0.5597 | IoU: 0.4114 | F1: 0.5829
+Experiment on S3DIS dataset!
+Namespace(exp_name='s3dis-latent-inject-r-0.5', data_root='../../data/gf_s3dis_ss_0.05', model_path='outputs/s3dis-latent-inject-r-0.5/models/model_99.pth', split='val', in_channels=12, num_classes=13, class_names=['ceiling', 'floor', 'wall', 'beam', 'column', 'window', 'door', 'table', 'chair', 'sofa', 'bookcase', 'board', 'clutter'], feature_to_file_mapping={'coord': ['X_SS_SPATIAL_0.05', 'Y_SS_SPATIAL_0.05', 'Z_SS_SPATIAL_0.05'], 'segment': 'segment_SS_SPATIAL_0.05', 'Anisotropy': 'Anisotropy_(0.5)_SS_SPATIAL_0.05', 'Octree_normals': ['Nx_SS_SPATIAL_0.05', 'Ny_SS_SPATIAL_0.05', 'Nz_SS_SPATIAL_0.05'], 'PCA1': 'PCA1_(0.5)_SS_SPATIAL_0.05', 'PCA2': 'PCA2_(0.5)_SS_SPATIAL_0.05', 'Roughness': 'Roughness_(0.5)_SS_SPATIAL_0.05', 'Sphericity': 'Sphericity_(0.5)_SS_SPATIAL_0.05', 'Verticality': 'Verticality_(0.5)_SS_SPATIAL_0.05'}, ignore_index=-1, coord_only=False, num_points=8192, dropout=0.5, emb_dims=1024, k=20, batch_size=8, epoch=100, learning_rate=0.001, optimizer='Adam', decay_rate=0.0001, lr_scheduler='cosine', step_size=10, lr_decay=0.7, eval=2, save_model_freq=1, seed=1, visu='', visu_format='ply', train_val=False, jab=True, jab_out_channels=9, sync_bn=True)
+Please check ZAHA num_points setting!
+Loading pretrained model outputs/s3dis-latent-inject-r-0.5/models/model_99.pth
+Loading data
+The number of training data is: 280
+Saved visualization for scene: Area_5-office_18
+Saved visualization for scene: Area_5-office_6
+Saved visualization for scene: Area_5-office_30
+Saved visualization for scene: Area_5-office_19
+Saved visualization for scene: Area_5-office_7
+Saved visualization for scene: Area_5-office_36
+Saved visualization for scene: Area_5-office_15
+Saved visualization for scene: Area_5-office_23
+Saved visualization for scene: Area_5-storage_1
+Saved visualization for scene: Area_5-office_20
+Saved visualization for scene: Area_5-office_5
+Saved visualization for scene: Area_5-hallway_3
+Saved visualization for scene: Area_5-office_39
+Saved visualization for scene: Area_5-office_25
+Saved visualization for scene: Area_5-storage_4
+Saved visualization for scene: Area_5-pantry_1
+Saved visualization for scene: Area_5-lobby_1
+Saved visualization for scene: Area_5-hallway_6
+Saved visualization for scene: Area_5-office_31
+Saved visualization for scene: Area_5-office_29
+Saved visualization for scene: Area_5-conferenceRoom_3
+Saved visualization for scene: Area_5-office_17
+Saved visualization for scene: Area_5-conferenceRoom_2
+Saved visualization for scene: Area_5-office_37
+Saved visualization for scene: Area_5-office_22
+Saved visualization for scene: Area_5-office_12
+Saved visualization for scene: Area_5-hallway_4
+Saved visualization for scene: Area_5-office_8
+Saved visualization for scene: Area_5-office_40
+Saved visualization for scene: Area_5-office_34
+Saved visualization for scene: Area_5-hallway_15
+Saved visualization for scene: Area_5-WC_2
+Saved visualization for scene: Area_5-office_32
+Saved visualization for scene: Area_5-office_33
+Saved visualization for scene: Area_5-hallway_13
+Saved visualization for scene: Area_5-office_38
+Saved visualization for scene: Area_5-office_10
+Saved visualization for scene: Area_5-conferenceRoom_1
+Saved visualization for scene: Area_5-office_21
+Saved visualization for scene: Area_5-office_13
+Saved visualization for scene: Area_5-WC_1
+Saved visualization for scene: Area_5-office_14
+Saved visualization for scene: Area_5-office_24
+Saved visualization for scene: Area_5-office_9
+Saved visualization for scene: Area_5-office_4
+Saved visualization for scene: Area_5-hallway_11
+Saved visualization for scene: Area_5-office_3
+Saved visualization for scene: Area_5-office_27
+Saved visualization for scene: Area_5-hallway_9
+Saved visualization for scene: Area_5-hallway_7
+Saved visualization for scene: Area_5-office_35
+Saved visualization for scene: Area_5-office_41
+Saved visualization for scene: Area_5-office_2
+Saved visualization for scene: Area_5-office_16
+Saved visualization for scene: Area_5-storage_2
+Saved visualization for scene: Area_5-hallway_14
+Saved visualization for scene: Area_5-office_1
+Saved visualization for scene: Area_5-office_26
+Saved visualization for scene: Area_5-hallway_1
+Saved visualization for scene: Area_5-hallway_10
+Saved visualization for scene: Area_5-office_42
+Saved visualization for scene: Area_5-hallway_12
+Saved visualization for scene: Area_5-hallway_8
+Saved visualization for scene: Area_5-office_28
+Saved visualization for scene: Area_5-office_11
+Saved visualization for scene: Area_5-hallway_2
+Saved visualization for scene: Area_5-hallway_5
+==== Evaluation Results ====
+Mean loss: 0.7041
+OA   : 0.8205
+μP   : 0.5766
+μIoU : 0.4457
+μR   : 0.5451
+μF1  : 0.5459
+============================
+ceiling         | P: 0.9372 | R: 0.9681 | IoU: 0.9092 | F1: 0.9524
+floor           | P: 0.9879 | R: 0.9952 | IoU: 0.9832 | F1: 0.9915
+wall            | P: 0.8084 | R: 0.8543 | IoU: 0.7104 | F1: 0.8307
+beam            | P: 0.0000 | R: 0.0000 | IoU: 0.0000 | F1: 0.0000
+column          | P: 0.4994 | R: 0.2543 | IoU: 0.2026 | F1: 0.3370
+window          | P: 0.0000 | R: 0.0000 | IoU: 0.0000 | F1: 0.0000
+door            | P: 0.4378 | R: 0.8057 | IoU: 0.3960 | F1: 0.5674
+table           | P: 0.8697 | R: 0.7980 | IoU: 0.7128 | F1: 0.8323
+chair           | P: 0.6403 | R: 0.7280 | IoU: 0.5167 | F1: 0.6813
+sofa            | P: 0.4271 | R: 0.2051 | IoU: 0.1608 | F1: 0.2771
+bookcase        | P: 0.8390 | R: 0.7293 | IoU: 0.6398 | F1: 0.7803
+board           | P: 0.4409 | R: 0.1881 | IoU: 0.1519 | F1: 0.2637
+clutter         | P: 0.6081 | R: 0.5598 | IoU: 0.4114 | F1: 0.5829

s3dis-latent-inject-r-0.5/util.py.backup

@@ -0,0 +1,480 @@
+import os
+import glob
+import copy
+import random
+import pickle
+import numpy as np
+from plyfile import PlyData
+
+import torch
+from torch import nn
+from torch.nn.modules.conv import _ConvNd
+from torch.nn.modules.batchnorm import _BatchNorm
+import torch.nn.init as initer
+import torch.nn.functional as F
+
+
+class AverageMeter(object):
+    """Computes and stores the average and current value"""
+
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self.val = 0
+        self.avg = 0
+        self.sum = 0
+        self.count = 0
+
+    def update(self, val, n=1):
+        self.val = val
+        self.sum += val * n
+        self.count += n
+        self.avg = self.sum / self.count
+
+
+def set_seed(seed=1):
+    print('Using random seed', seed)
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+
+def str2bool(v):
+    return v.lower() in ("yes", "true", "t", "1")
+
+
+def get_lr(optimizer):
+    return optimizer.param_groups[0]['lr']
+
+
+def adjust_lr(optimizer, new_lr):
+    for param_group in optimizer.param_groups:
+        param_group['lr'] = new_lr
+
+
+def weights_init(m):
+    classname = m.__class__.__name__
+    if classname.find('Conv2d') != -1:
+        nn.init.xavier_normal_(m.weight.data)
+        try:
+            nn.init.constant_(m.bias.data, 0.0)
+        except AttributeError:
+            pass
+    elif classname.find('Linear') != -1:
+        nn.init.xavier_normal_(m.weight.data)
+        try:
+            nn.init.constant_(m.bias.data, 0.0)
+        except AttributeError:
+            pass
+
+
+def bn_momentum_adjust(m, momentum):
+    if isinstance(m, nn.BatchNorm2d) or \
+            isinstance(m, nn.BatchNorm1d):
+        m.momentum = momentum
+
+
+def intersectionAndUnion(output, target, K, ignore_index=255):
+    # 'K' classes, output and target sizes are N or N * L or N * H * W, each value in range 0 to K - 1.
+    assert (output.ndim in [1, 2, 3])
+    assert output.shape == target.shape
+    output = output.reshape(output.size).copy()
+    target = target.reshape(target.size)
+    output[np.where(target == ignore_index)[0]] = 255
+    target[np.where(target == ignore_index)[0]] = 255
+    intersection = output[np.where(output == target)[0]]
+    area_intersection, _ = np.histogram(intersection, bins=np.arange(K+1))
+    area_output, _ = np.histogram(output, bins=np.arange(K+1))
+    area_target, _ = np.histogram(target, bins=np.arange(K+1))
+    area_union = area_output + area_target - area_intersection
+    return area_intersection, area_union, area_target
+
+
+def calc_victim_value(class_value, label, victim_class):
+    values = []
+    for lbl in victim_class:
+        if label is None or (label == lbl).any():
+            values.append(class_value[lbl])
+    return np.mean(values)
+
+
+def check_makedirs(dir_name):
+    if not os.path.exists(dir_name):
+        os.makedirs(dir_name)
+
+
+def init_weights(model, conv='kaiming', batchnorm='normal', linear='kaiming', lstm='kaiming'):
+    """
+    :param model: Pytorch Model which is nn.Module
+    :param conv:  'kaiming' or 'xavier'
+    :param batchnorm: 'normal' or 'constant'
+    :param linear: 'kaiming' or 'xavier'
+    :param lstm: 'kaiming' or 'xavier'
+    """
+    for m in model.modules():
+        if isinstance(m, (_ConvNd)):
+            if conv == 'kaiming':
+                initer.kaiming_normal_(m.weight)
+            elif conv == 'xavier':
+                initer.xavier_normal_(m.weight)
+            else:
+                raise ValueError("init type of conv error.\n")
+            if m.bias is not None:
+                initer.constant_(m.bias, 0)
+
+        elif isinstance(m, _BatchNorm):
+            if batchnorm == 'normal':
+                initer.normal_(m.weight, 1.0, 0.02)
+            elif batchnorm == 'constant':
+                initer.constant_(m.weight, 1.0)
+            else:
+                raise ValueError("init type of batchnorm error.\n")
+            initer.constant_(m.bias, 0.0)
+
+        elif isinstance(m, nn.Linear):
+            if linear == 'kaiming':
+                initer.kaiming_normal_(m.weight)
+            elif linear == 'xavier':
+                initer.xavier_normal_(m.weight)
+            else:
+                raise ValueError("init type of linear error.\n")
+            if m.bias is not None:
+                initer.constant_(m.bias, 0)
+
+        elif isinstance(m, nn.LSTM):
+            for name, param in m.named_parameters():
+                if 'weight' in name:
+                    if lstm == 'kaiming':
+                        initer.kaiming_normal_(param)
+                    elif lstm == 'xavier':
+                        initer.xavier_normal_(param)
+                    else:
+                        raise ValueError("init type of lstm error.\n")
+                elif 'bias' in name:
+                    initer.constant_(param, 0)
+
+
+def convert_to_syncbn(model):
+    def recursive_set(cur_module, name, module):
+        if len(name.split('.')) > 1:
+            recursive_set(
+                getattr(cur_module, name[:name.find('.')]), name[name.find('.')+1:], module)
+        else:
+            setattr(cur_module, name, module)
+    from sync_bn import SynchronizedBatchNorm1d, SynchronizedBatchNorm2d, \
+        SynchronizedBatchNorm3d
+    for name, m in model.named_modules():
+        if isinstance(m, nn.BatchNorm1d):
+            recursive_set(model, name, SynchronizedBatchNorm1d(
+                m.num_features, m.eps, m.momentum, m.affine))
+        elif isinstance(m, nn.BatchNorm2d):
+            recursive_set(model, name, SynchronizedBatchNorm2d(
+                m.num_features, m.eps, m.momentum, m.affine))
+        elif isinstance(m, nn.BatchNorm3d):
+            recursive_set(model, name, SynchronizedBatchNorm3d(
+                m.num_features, m.eps, m.momentum, m.affine))
+
+
+def lbl2rgb(label, names):
+    """Convert label to rgb colors.
+    label: [N]
+    """
+    from config import NAME2COLOR
+    if len(names) == 13:
+        colors = NAME2COLOR['S3DIS']
+    else:
+        colors = NAME2COLOR['ScanNet']
+    rgb = np.zeros((label.shape[0], 3))
+    uni_lbl = np.unique(label).astype(np.uint8)
+    for lbl in uni_lbl:
+        mask = (label == lbl)
+        rgb[mask] = np.tile(np.array(
+            colors[names[lbl]])[None, :], (mask.sum(), 1))
+    return rgb
+
+
+def convert2vis(xyz, label, names):
+    """Assign color to each point according to label."""
+    rgb = lbl2rgb(label, names) * 255.
+    data = np.concatenate([xyz, rgb], axis=1)
+    return data
+
+
+def proc_pert(points, gt, pred, folder,
+              names, part=False, ignore_label=255):
+    """Process and save files for visulization in perturbation attack."""
+    check_makedirs(folder)
+    lbl2cls = {i: names[i] for i in range(len(names))}
+
+    np.savetxt(os.path.join(folder, 'all_points.txt'), points, delimiter=';')
+    gt_seg = convert2vis(points[gt != ignore_label, :3],
+                         gt[gt != ignore_label], names)
+    pred_seg = convert2vis(points[gt != ignore_label, :3],
+                           pred[gt != ignore_label], names)
+    np.savetxt(os.path.join(folder, 'gt.txt'),
+               gt_seg, delimiter=';')
+    np.savetxt(os.path.join(folder, 'pred.txt'),
+               pred_seg, delimiter=';')
+    if part:
+        uni_lbl = np.unique(gt[gt != ignore_label]).astype(np.uint8)
+        for lbl in uni_lbl:
+            lbl = int(lbl)
+            mask = (gt == lbl)
+            sel_points = points[mask]
+            mask = (gt[gt != ignore_label] == lbl)
+            sel_seg = pred_seg[mask]
+            np.savetxt(
+                os.path.join(folder, '{}_{}_points.txt'.format(
+                    lbl, lbl2cls[lbl])),
+                sel_points, delimiter=';')
+            np.savetxt(
+                os.path.join(folder, '{}_{}_pred.txt'.format(
+                    lbl, lbl2cls[lbl])),
+                sel_seg, delimiter=';')
+
+
+def proc_add(points, noise, gt, pred, noise_pred, folder,
+             names, part=False, ignore_label=255):
+    """Process and save files for visulization in adding attack."""
+    check_makedirs(folder)
+    lbl2cls = {i: names[i] for i in range(len(names))}
+
+    np.savetxt(os.path.join(folder, 'all_points.txt'), points, delimiter=';')
+    np.savetxt(os.path.join(folder, 'noise_points.txt'), noise, delimiter=';')
+    gt_seg = convert2vis(points[gt != ignore_label, :3],
+                         gt[gt != ignore_label], names)
+    pred_seg = convert2vis(points[gt != ignore_label, :3],
+                           pred[gt != ignore_label], names)
+    noise_seg = convert2vis(noise[:, :3], noise_pred, names)
+    np.savetxt(os.path.join(folder, 'gt.txt'),
+               gt_seg, delimiter=';')
+    np.savetxt(os.path.join(folder, 'pred.txt'),
+               pred_seg, delimiter=';')
+    np.savetxt(os.path.join(folder, 'noise_pred.txt'),
+               noise_seg, delimiter=';')
+    if part:
+        uni_lbl = np.unique(gt[gt != ignore_label]).astype(np.uint8)
+        for lbl in uni_lbl:
+            lbl = int(lbl)
+            mask = (gt == lbl)
+            sel_points = points[mask]
+            mask = (gt[gt != ignore_label] == lbl)
+            sel_seg = pred_seg[mask]
+            np.savetxt(
+                os.path.join(folder, '{}_{}_points.txt'.format(
+                    lbl, lbl2cls[lbl])),
+                sel_points, delimiter=';')
+            np.savetxt(
+                os.path.join(folder, '{}_{}_pred.txt'.format(
+                    lbl, lbl2cls[lbl])),
+                sel_seg, delimiter=';')
+
+
+def save_vis(pred_root, save_root, data_root):
+    from config import CLASS_NAMES
+    if 'S3DIS' in data_root:  # save Area5 data
+        names = CLASS_NAMES['S3DIS']['other']
+        gt_save = load_pickle(
+            os.path.join(pred_root, 'gt_5.pickle'))['gt']
+        pred_save = load_pickle(
+            os.path.join(pred_root, 'pred_5.pickle'))['pred']
+        assert len(gt_save) == len(pred_save)
+        all_rooms = sorted(os.listdir(data_root))
+        all_rooms = [
+            room for room in all_rooms if 'Area_5' in room
+        ]
+        assert len(gt_save) == len(all_rooms)
+        check_makedirs(save_root)
+        for i, room in enumerate(all_rooms):
+            points = np.load(os.path.join(data_root, room))[:, :6]
+            folder = os.path.join(save_root, room[:-4])
+            check_makedirs(folder)
+            proc_pert(points, gt_save[i], pred_save[i],
+                      folder, names, part=True)
+    elif 'ScanNet' in data_root:  # save val set data
+        names = CLASS_NAMES['ScanNet']['other']
+        gt_save = load_pickle(
+            os.path.join(pred_root, 'gt_val.pickle'))['gt']
+        pred_save = load_pickle(
+            os.path.join(pred_root, 'pred_val.pickle'))['pred']
+        assert len(gt_save) == len(pred_save)
+        data_file = os.path.join(
+            data_root, 'scannet_val_rgb21c_pointid.pickle')
+        file_pickle = open(data_file, 'rb')
+        xyz_all = pickle.load(file_pickle)
+        file_pickle.close()
+        assert len(xyz_all) == len(gt_save)
+        with open(os.path.join(
+                data_root, 'meta_data/scannetv2_val.txt')) as fl:
+            scene_id = fl.read().splitlines()
+        assert len(scene_id) == len(gt_save)
+        check_makedirs(save_root)
+        for i in range(len(gt_save)):
+            points = xyz_all[i][:, :6]
+            folder = os.path.join(save_root, scene_id[i])
+            check_makedirs(folder)
+            proc_pert(points, gt_save[i], pred_save[i],
+                      folder, names, part=True)
+
+
+def save_vis_mink(pred_root, save_root, data_root):
+    from config import CLASS_NAMES
+
+    def load_data(file_name):
+        plydata = PlyData.read(file_name)
+        data = plydata.elements[0].data
+        coords = np.array([data['x'], data['y'], data['z']],
+                          dtype=np.float32).T
+        colors = np.array([data['red'], data['green'],
+                           data['blue']], dtype=np.float32).T
+        return np.concatenate([coords, colors], axis=1)
+
+    if 'S3DIS' in data_root:  # save Area5 data
+        names = CLASS_NAMES['S3DIS']['mink']
+        gt_save = load_pickle(
+            os.path.join(pred_root, 'gt_5.pickle'))['gt']
+        pred_save = load_pickle(
+            os.path.join(pred_root, 'pred_5.pickle'))['pred']
+        assert len(gt_save) == len(pred_save)
+        data_root = os.path.join(data_root, 'Area_5')
+        all_rooms = sorted(os.listdir(data_root))
+        assert len(all_rooms) == len(gt_save)
+        check_makedirs(save_root)
+
+        for i, room in enumerate(all_rooms):
+            data = os.path.join(data_root, room)
+            points = load_data(data)
+            folder = os.path.join(
+                save_root, 'Area_5_{}'.format(room[:-4]))
+            check_makedirs(folder)
+            proc_pert(points, gt_save[i], pred_save[i],
+                      folder, names, part=True)
+    elif 'ScanNet' in data_root:  # save val set
+        names = CLASS_NAMES['ScanNet']['mink']
+        gt_save = load_pickle(
+            os.path.join(pred_root, 'gt_val.pickle'))['gt']
+        pred_save = load_pickle(
+            os.path.join(pred_root, 'pred_val.pickle'))['pred']
+        assert len(gt_save) == len(pred_save)
+        data_root = os.path.join(data_root, 'train')
+        with open(os.path.join(
+                data_root, 'scannetv2_val.txt'), 'r') as f:
+            all_rooms = f.readlines()
+        all_rooms = [room[:-1] for room in all_rooms]
+        assert len(all_rooms) == len(gt_save)
+        check_makedirs(save_root)
+
+        for i, room in enumerate(all_rooms):
+            data = os.path.join(data_root, room)
+            points = load_data(data)
+            folder = os.path.join(save_root, room[:-4])
+            check_makedirs(folder)
+            proc_pert(points, gt_save[i], pred_save[i],
+                      folder, names, part=True)
+
+
+def save_vis_from_pickle(pkl_root, save_root=None, room_idx=52,
+                         room_name='scene0354_00'):
+    names = [
+        'wall', 'floor', 'cabinet', 'bed', 'chair', 'sofa', 'table',
+        'door', 'window', 'bookshelf', 'picture', 'counter', 'desk',
+        'curtain', 'refrigerator', 'showercurtain', 'toilet', 'sink',
+        'bathtub', 'otherfurniture'
+    ]
+    data = load_pickle(pkl_root)
+    points = data['data'][room_idx]
+    pred = data['pred'][room_idx]
+    gt = data['gt'][room_idx]
+    if save_root is None:
+        save_root = os.path.dirname(pkl_root)
+    save_folder = os.path.join(save_root, room_name)
+    proc_pert(points, gt, pred, save_folder, names, part=True)
+
+
+def save_pickle(filename, dict_data):
+    with open(filename, 'wb') as handle:
+        pickle.dump(dict_data, handle,
+                    protocol=pickle.HIGHEST_PROTOCOL)
+
+
+def load_pickle(filename):
+    with open(filename, 'rb') as f:
+        data = pickle.load(f)
+    return data
+
+
+def load_s3dis_instance(folder, name2cls, load_name=['chair']):
+    """Load S3DIS room in a Inst Seg format.
+    Get each instance separately.
+
+    If load_name is None or [], return all instances.
+    Returns a list of [np.array of [N, 6], label]
+    """
+    cls2name = {name2cls[name]: name for name in name2cls.keys()}
+    anno_path = os.path.join(folder, 'Annotations')
+    points_list = []
+    labels_list = []
+    idx = 0
+    files = glob.glob(os.path.join(anno_path, '*.txt'))
+    files.sort()
+
+    for f in files:
+        cls = os.path.basename(f).split('_')[0]
+        if cls not in name2cls.keys():
+            cls = 'clutter'
+        points = np.loadtxt(f)  # [N, 6]
+        num = points.shape[0]
+        points_list.append(points)
+        labels_list.append((idx, idx + num, name2cls[cls]))
+        idx += num
+
+    # normalize points coords by minus min
+    data = np.concatenate(points_list, 0)
+    xyz_min = np.amin(data, axis=0)[0:3]
+    data[:, 0:3] -= xyz_min
+
+    # rearrange to separate instances
+    if load_name is None or not load_name:
+        load_name = list(name2cls.keys())
+    instances = [
+        [data[pair[0]:pair[1]], pair[2]] for pair in labels_list if
+        cls2name[pair[2]] in load_name
+    ]
+    return instances
+
+
+def cal_loss(pred, gold, smoothing=False, ignore_index=255):
+    ''' Calculate cross entropy loss, apply label smoothing if needed. '''
+
+    gold = gold.contiguous().view(-1)
+
+    if smoothing:
+        eps = 0.2
+        n_class = pred.size(1)
+
+        one_hot = torch.zeros_like(pred).scatter(1, gold.view(-1, 1), 1)
+        one_hot = one_hot * (1 - eps) + (1 - one_hot) * eps / (n_class - 1)
+        log_prb = F.log_softmax(pred, dim=1)
+
+        loss = -(one_hot * log_prb).sum(dim=1).mean()
+    else:
+        loss = F.cross_entropy(
+            pred, gold, reduction='mean',
+            ignore_index=ignore_index)
+
+    return loss
+
+
+class IOStream():
+    def __init__(self, path):
+        self.f = open(path, 'a')
+
+    def cprint(self, text):
+        print(text)
+        self.f.write(text+'\n')
+        self.f.flush()
+
+    def close(self):
+        self.f.close()