add experiments

fxia22 · fxia22 · commit 146ca4b84f63 · 2017-06-11T16:42:24.000-07:00
diff --git a/dataset_metallic_glass.py b/dataset_metallic_glass.py
@@ -80,12 +80,13 @@ def __getitem__(self, index):
         point_set = point_set/dist
 
 
-        choice = np.random.choice(len(seg), self.npoints, replace=True)
+        #choice = np.random.choice(len(seg), self.npoints, replace=True)
         #resample
-        point_set = point_set[choice, :]
-        point_set = point_set + 1e-5 * np.random.rand(*point_set.shape)
+        #point_set = point_set[choice, :]
+        #point_set = point_set + 1e-5 * np.random.rand(*point_set.shape)
+        #print(point_set.shape)
 
-        seg = seg[choice]
+        #seg = seg[choice]
         point_set = torch.from_numpy(point_set.astype(np.float32))
         seg = torch.from_numpy(seg.astype(np.int64))
         cls = torch.from_numpy(np.array([cls]).astype(np.int64))
@@ -98,14 +99,105 @@ def __len__(self):
         return len(self.datapath)
 
 
+class PartDatasetSVM(data.Dataset):
+    def __init__(self, root, npoints = 2048, classification = False, class_choice = None, train = True):
+        self.npoints = npoints
+        self.root = root
+        self.catfile = os.path.join(self.root, 'synsetoffset2category.txt')
+        self.cat = {}
+
+        self.classification = classification
+
+        with open(self.catfile, 'r') as f:
+            for line in f:
+                ls = line.strip().split()
+                #print(ls)
+                self.cat[ls[0]] = ls[1]
+        #print(self.cat)
+        if not class_choice is None:
+            self.cat = {k:v for k,v in self.cat.items() if k in class_choice}
+
+        self.meta = {}
+        for item in self.cat:
+            #print('category', item)
+            self.meta[item] = []
+            dir_point = os.path.join(self.root, self.cat[item])
+            #dir_point = os.path.join(self.root, self.cat[item], 'points')
+            #dir_seg = os.path.join(self.root, self.cat[item], 'points_label')
+            #print(dir_point, dir_seg)
+            fns = sorted(os.listdir(dir_point))
+            if train:
+                fns = fns[:int(len(fns) * 0.9)]
+            else:
+                fns = fns[int(len(fns) * 0.9):]
+
+            #print(os.path.basename(fns))
+            for fn in fns:
+                token = (os.path.splitext(os.path.basename(fn))[0])
+                pth = os.path.join(dir_point, token + '.npy')
+                self.meta[item].append((pth, pth))
+
+        self.datapath = []
+        for item in self.cat:
+            for fn in self.meta[item]:
+                self.datapath.append((item, fn[0], fn[1]))
+
+        self.classes = dict(zip(self.cat, range(len(self.cat))))
+        print(self.classes)
+        self.num_seg_classes = 0
+
+
+    def __getitem__(self, index):
+        fn = self.datapath[index]
+        cls = self.classes[self.datapath[index][0]]
+        cluster_data = np.load(fn[1])
+        #print (cluster_data.dtype)
+        point_set = cluster_data['delta']
+        seg = cluster_data['type_j']
+        #print(point_set.shape, seg.shape)
+
+        #point_set = point_set - np.expand_dims(np.mean(point_set, axis = 0), 0)
+        dist = np.max(np.sqrt(np.sum(point_set ** 2, axis = 1)),0)
+        dist = np.expand_dims(np.expand_dims(dist, 0), 1)
+        point_set = point_set/dist
+        
+        
+
+        dist = np.sum(point_set**2,1)
+        bins = np.arange(0,1 + 1e-4,1/30.0)
+        feat1 = np.histogram(dist[seg == 1], bins, density = True)[0]
+        feat2 = np.histogram(dist[seg == 2], bins, density = True)[0]
+        
+        feat = np.concatenate([feat1, feat2])
+        
+        #from IPython import embed; embed()
+
+        #choice = np.random.choice(len(seg), self.npoints, replace=True)
+        #resample
+        #point_set = point_set[choice, :]
+        #point_set = point_set + 1e-5 * np.random.rand(*point_set.shape)
+        #print(point_set.shape)
+
+        #seg = seg[choice]
+        #point_set = torch.from_numpy(point_set.astype(np.float32))
+        #seg = torch.from_numpy(seg.astype(np.int64))
+        #cls = torch.from_numpy(np.array([cls]).astype(np.int64))
+        
+        return feat, cls
+
+    def __len__(self):
+        return len(self.datapath)    
+    
+    
+    
 if __name__ == '__main__':
     print('test')
-    d = PartDataset(root = 'shapenetcore_partanno_segmentation_benchmark_v0', class_choice = ['Chair'])
+    d = PartDataset(root = 'mg', classification = True)
     print(len(d))
     ps, seg = d[0]
     print(ps.size(), ps.type(), seg.size(),seg.type())
 
-    d = PartDataset(root = 'shapenetcore_partanno_segmentation_benchmark_v0', classification = True)
+    d = PartDatasetSVM(root = 'mg', classification = True)
     print(len(d))
     ps, cls = d[0]
-    print(ps.size(), ps.type(), cls.size(),cls.type())
+    print(ps.shape, ps.dtype, cls)
diff --git a/svm.py b/svm.py
@@ -0,0 +1,58 @@
+from dataset_metallic_glass import PartDataset, PartDatasetSVM
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.autograd import Variable
+import torch.optim as optim
+
+
+d = PartDatasetSVM(root = 'mg', classification = False)
+dt = PartDatasetSVM(root = 'mg', classification = False, train = False)
+
+
+l = len(d)
+print(len(d.classes), l)
+
+
+lt = len(dt)
+print(lt)
+
+train_set = []
+train_label = []
+for i in range(l):
+    idx = i
+    sample, label = d[idx]
+    train_set.append(sample)
+    train_label.append(label)
+    if i%100 == 0:
+        print i
+    
+test_set = []
+test_label = [] 
+for i in range(lt):
+    idx = i
+    sample, label = dt[idx]
+    test_set.append(sample)
+    test_label.append(label)
+    if i%100 == 0:
+        print i
+        
+        
+train_set = np.array(train_set)
+train_label = np.array(train_label)
+test_set = np.array(test_set)
+test_label = np.array(test_label)
+
+print(train_set.shape, train_label.shape)
+
+from sklearn.svm import SVC
+clf = SVC()
+
+clf.fit(train_set, train_label)
+
+accuracy = np.sum(clf.predict(train_set) == train_label)/float(l)
+print(accuracy)
+
+accuracy_test = np.sum(clf.predict(test_set) == test_label)/float(lt)
+print(accuracy_test)
diff --git a/train_MG2.py b/train_MG2.py
@@ -226,5 +226,5 @@ def split_ps_reuse(point_set, level, pos, tree, cutdim):
     print('batch: %d, loss: %f, correct %d/%d' %( it, np.mean(losses), correct, bt))
 
     if it % 1000 == 0:
-        torch.save(net.state_dict(), 'mg2_model_cuda_%d.pth' % (it))
+        torch.save(net.state_dict(), 'mg2_model_cuda_new_%d.pth' % (it))
 
