code
stringlengths
17
6.64M
class BallQuery(Function): @staticmethod def forward(ctx, radius, nsample, xyz, new_xyz): '\n\n Parameters\n ----------\n radius : float\n radius of the balls\n nsample : int\n maximum number of features in the balls\n xyz : torch.Tensor\n (B, N, 3) xyz coordinates of the features\n new_xyz : torch.Tensor\n (B, npoint, 3) centers of the ball query\n\n Returns\n -------\n torch.Tensor\n (B, npoint, nsample) tensor with the indicies of the features that form the query balls\n ' output = _ext.ball_query(new_xyz, xyz, radius, nsample) ctx.mark_non_differentiable(output) return output @staticmethod def backward(ctx, grad_out): return ()
class QueryAndGroup(nn.Module): '\n Groups with a ball query of radius\n\n Parameters\n ---------\n radius : float32\n Radius of ball\n nsample : int32\n Maximum number of features to gather in the ball\n ' def __init__(self, radius, nsample, use_xyz=True): super(QueryAndGroup, self).__init__() (self.radius, self.nsample, self.use_xyz) = (radius, nsample, use_xyz) def forward(self, xyz, new_xyz, features=None): '\n Parameters\n ----------\n xyz : torch.Tensor\n xyz coordinates of the features (B, N, 3)\n new_xyz : torch.Tensor\n centriods (B, npoint, 3)\n features : torch.Tensor\n Descriptors of the features (B, C, N)\n\n Returns\n -------\n new_features : torch.Tensor\n (B, 3 + C, npoint, nsample) tensor\n ' idx = ball_query(self.radius, self.nsample, xyz, new_xyz) xyz_trans = xyz.transpose(1, 2).contiguous() grouped_xyz = grouping_operation(xyz_trans, idx) grouped_xyz -= new_xyz.transpose(1, 2).unsqueeze((- 1)) if (features is not None): grouped_features = grouping_operation(features, idx) if self.use_xyz: new_features = torch.cat([grouped_xyz, grouped_features], dim=1) else: new_features = grouped_features else: assert self.use_xyz, 'Cannot have not features and not use xyz as a feature!' new_features = grouped_xyz return new_features
class GroupAll(nn.Module): '\n Groups all features\n\n Parameters\n ---------\n ' def __init__(self, use_xyz=True): super(GroupAll, self).__init__() self.use_xyz = use_xyz def forward(self, xyz, new_xyz, features=None): '\n Parameters\n ----------\n xyz : torch.Tensor\n xyz coordinates of the features (B, N, 3)\n new_xyz : torch.Tensor\n Ignored\n features : torch.Tensor\n Descriptors of the features (B, C, N)\n\n Returns\n -------\n new_features : torch.Tensor\n (B, C + 3, 1, N) tensor\n ' grouped_xyz = xyz.transpose(1, 2).unsqueeze(2) if (features is not None): grouped_features = features.unsqueeze(2) if self.use_xyz: new_features = torch.cat([grouped_xyz, grouped_features], dim=1) else: new_features = grouped_features else: new_features = grouped_xyz return new_features
class HiddenPrints(): def __enter__(self): self._original_stdout = sys.stdout sys.stdout = open(os.devnull, 'w') def __exit__(self, exc_type, exc_val, exc_tb): sys.stdout.close() sys.stdout = self._original_stdout
def multiprocess(func): p = Pool(80) p.map(func, idx_list) p.close() p.join()
def pds(idx): if 1: print(os.path.join(save_path_list[idx], ('%d.npy' % num_point)), ' is preparing.') ms_set = pymeshlab.MeshSet() ms_set.load_new_mesh(os.path.join(os.path.join(path_list[idx], 'scaled_model.off'))) ms_set.generate_sampling_poisson_disk(samplenum=int((num_point / (1 - 0.006))), exactnumflag=True) pc = np.array(ms_set.current_mesh().vertex_matrix()) if (not os.path.exists(save_path_list[idx])): os.makedirs(save_path_list[idx]) np.save(os.path.join(save_path_list[idx], ('%d.npy' % num_point)), pc.astype(np.float32)) print(os.path.join(save_path_list[idx], ('%d.npy' % num_point)), ' is prepared.') del pc, ms_set else: print('skip ', os.path.join(save_path_list[idx], ('%d.npy' % num_point)))
class HiddenPrints(): def __enter__(self): self._original_stdout = sys.stdout sys.stdout = open(os.devnull, 'w') def __exit__(self, exc_type, exc_val, exc_tb): sys.stdout.close() sys.stdout = self._original_stdout
def multiprocess(func): p = Pool(20) p.map(func, idx_list) p.close() p.join()
def sample(idx): mesh = trimesh.load(os.path.join(path_list[idx], 'scaled_model.off')) points = mesh.sample(int(num_sample)) if (not os.path.exists(save_path_list[idx])): os.makedirs(os.path.join(save_path_list[idx])) np.save(os.path.join(save_path_list[idx], 'points.npy'), points.astype(np.float32)) print(os.path.join(save_path_list[idx], 'points.npy'))
class HiddenPrints(): def __enter__(self): self._original_stdout = sys.stdout sys.stdout = open(os.devnull, 'w') def __exit__(self, exc_type, exc_val, exc_tb): sys.stdout.close() sys.stdout = self._original_stdout
def multiprocess(func): p = Pool(20) p.map(func, idx_list) p.close() p.join()
def sample(idx): if 1: boundary_points_list = [] df_list = [] closest_points_list = [] for i in range(3): ratio = ratio_list[i] std = std_list[i] mesh = trimesh.load(os.path.join(path_list[idx], 'scaled_model.off')) points = mesh.sample(int((num_sample * ratio))) noise = (np.random.randn(*points.shape) * std) boundary_points = (points + noise) (df, fi, bc) = pcu.closest_points_on_mesh(boundary_points, mesh.vertices, mesh.faces) closest_points = pcu.interpolate_barycentric_coords(mesh.faces, fi, bc, mesh.vertices) boundary_points_list.append(boundary_points) df_list.append(df) closest_points_list.append(closest_points) boundary_points_list = np.concatenate(boundary_points_list, axis=0) df_list = np.concatenate(df_list, axis=0) closest_points_list = np.concatenate(closest_points_list, axis=0) if (not os.path.exists(save_path_list[idx])): os.makedirs(os.path.join(save_path_list[idx])) np.savez(os.path.join(save_path_list[idx], 'sample_gauss.npz'), points=boundary_points_list.astype(np.float32), df=df_list.astype(np.float32), closest_points=closest_points_list.astype(np.float32)) print(os.path.join(save_path_list[idx], 'sample_gauss.npz'))
def as_mesh(scene_or_mesh): '\n Convert a possible scene to a mesh.\n\n If conversion occurs, the returned mesh has only vertex and face data.\n Suggested by https://github.com/mikedh/trimesh/issues/507\n ' if isinstance(scene_or_mesh, trimesh.Scene): if (len(scene_or_mesh.geometry) == 0): mesh = None else: mesh = trimesh.util.concatenate(tuple((trimesh.Trimesh(vertices=g.vertices, faces=g.faces) for g in scene_or_mesh.geometry.values()))) else: assert isinstance(scene_or_mesh, trimesh.Trimesh) mesh = scene_or_mesh return mesh
def scalled_off(idx): input = trimesh.load(os.path.join(base_path_1[idx], 'isosurf.obj')) mesh = as_mesh(input) total_size = (mesh.bounds[1] - mesh.bounds[0]).max() centers = ((mesh.bounds[1] + mesh.bounds[0]) / 2) mesh.apply_translation((- centers)) mesh.apply_scale((1 / total_size)) if (not os.path.exists(save_path_1[idx])): os.makedirs(save_path_1[idx]) mesh.export(os.path.join(save_path_1[idx], 'scaled_model.off')) print(os.path.join(save_path_1[idx], 'scaled_model.off'))
def multiprocess(func): p = Pool(16) p.map(func, idx_list) p.close() p.join()
def split(x): return x.lower().split()
def length(sequence): used = tf.sign(tf.reduce_max(tf.abs(sequence), reduction_indices=2)) length = tf.reduce_sum(used, reduction_indices=1) length = tf.cast(length, tf.int32) return length
def cost(output, target): cross_entropy = (target * tf.log(output)) cross_entropy = (- tf.reduce_sum(cross_entropy, reduction_indices=2)) mask = tf.sign(tf.reduce_max(tf.abs(target), reduction_indices=2)) cross_entropy *= mask cross_entropy = tf.reduce_sum(cross_entropy, reduction_indices=1) cross_entropy /= tf.reduce_sum(mask, reduction_indices=1) return tf.reduce_mean(cross_entropy, name='loss')
def activate(outputs, weight_shape, bias_shape, activation=tf.nn.softmax): dim_str = {3: 'ijk,kl->ijl', 2: 'ij,jk->ik'} weights = tf.get_variable('weights', shape=weight_shape, initializer=tf.random_normal_initializer()) biases = tf.get_variable('biases', shape=bias_shape, initializer=tf.constant_initializer(0.0)) if (outputs.get_shape().ndims == 2): result = activation((tf.matmul(outputs, weights) + biases)) else: result = activation((tf.reshape(tf.matmul(tf.reshape(outputs, [(- 1), weight_shape[0]]), weights), [(- 1), outputs.get_shape().as_list()[1], weight_shape[1]]) + biases)) return result
def rmse_loss(outputs, targets): return tf.sqrt(tf.reduce_mean(tf.square(tf.sub(targets, outputs))))
def pad(x, max_length, pad_constant=(- 1)): x = list(x) for i in range(len(x)): x[i] += ([pad_constant] * (max_length - len(x[i]))) x[i] = np.array(x[i]) return x
def get_batch_pos(obj, size=5): idx = np.random.choice(range(len(obj.sent)), size=size, replace=False) p = pad(obj.pos[idx], obj.max_length, (- 1)) s = pad(obj.sent[idx], obj.max_length, (obj.vec.shape[0] - 1)) c = pad(obj.chun[idx], obj.max_length, (- 1)) return (s, p, c)
def get_batch_sent(obj, size=5): idx = np.random.choice(range(len(obj.sent1)), size=size, replace=False) s1 = pad(obj.sent1[idx], obj.max_length, (obj.vec.shape[0] - 1)) s2 = pad(obj.sent2[idx], obj.max_length, (obj.vec.shape[0] - 1)) r = obj.rel[idx] e = obj.ent[idx] return (s1, s2, r.values, e.values)
class JMT(): def __init__(self, dim, reg_lambda, lr=0.01): self.dim = dim self.reg_lambda = reg_lambda self.lr = lr def load_data(self): data = np.load('data/data.npz')['data'].item() self.sent = data['word_level']['sent'].values self.pos = data['word_level']['pos'] self.i2p = data['word_level']['i2p'] self.i2c = data['word_level']['i2c'] self.chun = data['word_level']['chunk'] self.sent1 = data['sent_level']['sent1'] self.sent2 = data['sent_level']['sent2'] self.i2e = data['sent_level']['i2e'] self.rel = data['sent_level']['rel'] self.ent = data['sent_level']['entailment'] self.w2i = data['w2i'] self.vec = np.array((data['vec'] + [([0] * 300)])) self.max_length = max([len(i) for i in self.sent]) print('***Data loaded***') def build_model(self): ' Builds the whole computational graph ' def sentence_op(inputs, t_pos, t_chunk): with tf.variable_scope('pos'): embeddings = tf.constant(self.vec, dtype=tf.float32) embeds = tf.nn.embedding_lookup(embeddings, inputs) fw_lstm = MyLSTM(self.dim, state_is_tuple=True) bw_lstm = MyLSTM(self.dim, state_is_tuple=True) (outputs, _) = tf.nn.bidirectional_dynamic_rnn(cell_fw=fw_lstm, cell_bw=bw_lstm, inputs=embeds, sequence_length=length(embeds), dtype=tf.float32) concat_outputs = tf.concat(2, outputs) y_pos = activate(concat_outputs, [(self.dim * 2), len(self.i2p)], [len(self.i2p)]) t_pos_sparse = tf.one_hot(indices=t_pos, depth=len(self.i2p), axis=(- 1)) loss = cost(y_pos, t_pos_sparse) loss += tf.reduce_sum([(self.reg_lambda * tf.nn.l2_loss(x)) for x in tf.trainable_variables()]) optimize_op = tf.train.AdagradOptimizer(self.lr).minimize(loss) with tf.variable_scope('chunk'): inputs1 = tf.concat(2, [embeds, concat_outputs, y_pos]) fw_lstm = MyLSTM(self.dim, state_is_tuple=True) bw_lstm = MyLSTM(self.dim, state_is_tuple=True) (outputs1, _) = tf.nn.bidirectional_dynamic_rnn(cell_fw=fw_lstm, cell_bw=bw_lstm, inputs=inputs1, sequence_length=length(embeds), dtype=tf.float32) concat_outputs1 = tf.concat(2, outputs1) y_chunk = activate(concat_outputs1, [(self.dim * 2), len(self.i2c)], [len(self.i2c)]) t_chunk_sparse = tf.one_hot(indices=t_chunk, depth=len(self.i2c), axis=(- 1)) loss1 = cost(y_chunk, t_chunk_sparse) loss1 += tf.reduce_sum([(self.reg_lambda * tf.nn.l2_loss(x)) for x in tf.trainable_variables()]) optimize_op1 = tf.train.AdagradOptimizer(self.lr).minimize(loss1) with tf.variable_scope('relatedness'): with tf.variable_scope('layer_1'): inputs2 = tf.concat(2, [embeds, concat_outputs1, y_pos, y_chunk]) fw_lstm = MyLSTM(self.dim, state_is_tuple=True) bw_lstm = MyLSTM(self.dim, state_is_tuple=True) (outputs2, _) = tf.nn.bidirectional_dynamic_rnn(cell_fw=fw_lstm, cell_bw=bw_lstm, inputs=inputs2, sequence_length=length(embeds), dtype=tf.float32) concat_outputs2 = tf.concat(2, outputs2) with tf.variable_scope('layer_2'): inputs3 = tf.concat(2, [embeds, concat_outputs2, y_pos, y_chunk]) fw_lstm1 = MyLSTM(self.dim, state_is_tuple=True) bw_lstm1 = MyLSTM(self.dim, state_is_tuple=True) (outputs3, _) = tf.nn.bidirectional_dynamic_rnn(cell_fw=fw_lstm1, cell_bw=bw_lstm1, inputs=inputs3, sequence_length=length(embeds), dtype=tf.float32) concat_outputs3 = tf.concat(2, outputs3) s = tf.reduce_max(concat_outputs3, reduction_indices=1) with tf.variable_scope('layer_3'): inputs4 = tf.concat(2, [embeds, concat_outputs3, y_pos, y_chunk]) fw_lstm2 = MyLSTM(self.dim, state_is_tuple=True) bw_lstm2 = MyLSTM(self.dim, state_is_tuple=True) (outputs4, _) = tf.nn.bidirectional_dynamic_rnn(cell_fw=fw_lstm2, cell_bw=bw_lstm2, inputs=inputs4, sequence_length=length(embeds), dtype=tf.float32) concat_outputs4 = tf.concat(2, outputs3) s1 = tf.reduce_max(concat_outputs4, reduction_indices=1) return (s, s1, optimize_op, optimize_op1, loss, loss1, y_pos, y_chunk) with tf.variable_scope('sentence') as scope: self.inp = tf.placeholder(shape=[None, self.max_length], dtype=tf.int32, name='input') self.t_p = tf.placeholder(shape=[None, self.max_length], dtype=tf.int32, name='t_pos') self.t_c = tf.placeholder(shape=[None, self.max_length], dtype=tf.int32, name='t_chunk') (s11, s12, self.optimize_op, self.optimize_op1, self.loss, self.loss1, self.y_pos, self.y_chunk) = sentence_op(self.inp, self.t_p, self.t_c) scope.reuse_variables() self.inp1 = tf.placeholder(shape=[None, self.max_length], dtype=tf.int32, name='input1') (s21, s22) = sentence_op(self.inp1, self.t_p, self.t_c)[:2] d = tf.concat(1, [tf.abs(tf.sub(s11, s21)), tf.mul(s11, s21)]) d1 = tf.concat(1, [tf.sub(s12, s22), tf.mul(s12, s22)]) with tf.variable_scope('relation'): self.y_rel = tf.squeeze(activate(d, [(self.dim * 4), 1], [1], activation=tf.nn.relu)) self.t_rel = tf.placeholder(shape=[None], dtype=tf.float32) self.loss2 = rmse_loss(self.y_rel, self.t_rel) self.loss2 += tf.reduce_sum([(self.reg_lambda * tf.nn.l2_loss(x)) for x in tf.trainable_variables()]) self.optimize_op2 = tf.train.AdagradOptimizer(self.lr).minimize(self.loss2) with tf.variable_scope('entailment'): self.t_ent = tf.placeholder(shape=[None], dtype=tf.int32) t_ent_sparse = tf.one_hot(indices=self.t_ent, depth=3, axis=(- 1)) self.y_ent = activate(d1, [(self.dim * 4), 3], [3]) self.loss3 = (- tf.reduce_mean((t_ent_sparse * tf.log(self.y_ent)))) self.loss3 += tf.reduce_sum([(self.reg_lambda * tf.nn.l2_loss(x)) for x in tf.trainable_variables()]) self.optimize_op3 = tf.train.AdagradOptimizer(self.lr).minimize(self.loss3) print('***Model built***') def get_predictions(self, graph, task_desc): resp = dict() saver = tf.train.Saver() with tf.Session(graph=graph) as sess: saver = tf.train.import_meta_graph('saves/model.ckpt.meta') saver.restore(sess, tf.train.latest_checkpoint('./saves')) if ('pos' in task_desc): inp = task_desc['pos'].lower().split() inputs = [([self.w2i[i] for i in inp] + ([(self.vec.shape[0] - 1)] * (self.max_length - len(inp))))] preds = sess.run(self.y_pos, {self.inp: inputs})[0] preds = np.argmax(preds, axis=(- 1))[:len(inp)] preds = [self.i2p[i] for i in preds] resp['pos'] = preds if ('chunk' in task_desc): inp = task_desc['chunk'].lower().split() inputs = [([self.w2i[i] for i in inp] + ([(self.vec.shape[0] - 1)] * (self.max_length - len(inp))))] preds = sess.run(self.y_chunk, {self.inp: inputs})[0] preds = np.argmax(preds, axis=(- 1))[:len(inp)] preds = [self.i2c[i] for i in preds] resp['chunk'] = preds if ('relatedness' in task_desc): inp1 = task_desc['relatedness'][0].lower().split() inputs1 = [([self.w2i[i] for i in inp1] + ([(self.vec.shape[0] - 1)] * (self.max_length - len(inp1))))] inp2 = task_desc['relatedness'][1].lower().split() inputs2 = [([self.w2i[i] for i in inp2] + ([(self.vec.shape[0] - 1)] * (self.max_length - len(inp2))))] preds = sess.run(self.y_rel, {self.inp: inputs1, self.inp1: inputs2}) resp['relatedness'] = preds if ('entailment' in task_desc): inp1 = task_desc['entailment'][0].lower().split() inputs1 = [([self.w2i[i] for i in inp1] + ([(self.vec.shape[0] - 1)] * (self.max_length - len(inp1))))] inp2 = task_desc['entailment'][1].lower().split() inputs2 = [([self.w2i[i] for i in inp2] + ([(self.vec.shape[0] - 1)] * (self.max_length - len(inp2))))] preds = sess.run(self.y_ent, {self.inp: inputs1, self.inp1: inputs2})[0] resp['entailment'] = self.i2e[np.argmax(preds)] return resp def train_model(self, graph, train_desc, resume=False): saver = tf.train.Saver() batch_size = train_desc['batch_size'] with tf.Session(graph=graph) as sess: if resume: saver = tf.train.import_meta_graph('saves/model.ckpt.meta') saver.restore(sess, tf.train.latest_checkpoint('./saves')) print('training resumed') else: sess.run(tf.global_variables_initializer()) if ('pos' in train_desc): print('***Training POS layer***') for i in range(train_desc['pos']): (a, b, c) = get_batch_pos(self, batch_size) (_, l) = sess.run([self.optimize_op, self.loss], {self.inp: a, self.t_p: b}) if ((i % 50) == 0): print(l) saver.save(sess, 'saves/model.ckpt') if ('chunk' in train_desc): print('***Training chunk layer***') for i in range(train_desc['chunk']): (a, b, c) = get_batch_pos(self, batch_size) (_, l1) = sess.run([self.optimize_op1, self.loss1], {self.inp: a, self.t_p: b, self.t_c: c}) if ((i % 50) == 0): print(l1) saver.save(sess, 'saves/model.ckpt') if ('relatedness' in train_desc): print('***Training semantic relatedness***') for i in range(train_desc['relatedness']): (a, b, c, _) = get_batch_sent(self, batch_size) (_, l2) = sess.run([self.optimize_op2, self.loss2], {self.inp: a, self.inp1: b, self.t_rel: c}) if ((i % 50) == 0): print(l2) saver.save(sess, 'saves/model.ckpt') if ('entailment' in train_desc): print('***Training semantic entailment***') for i in range(train_desc['entailment']): (a, b, _, c) = get_batch_sent(self, batch_size) (_, l3) = sess.run([self.optimize_op3, self.loss3], {self.inp: a, self.inp1: b, self.t_ent: c}) if ((i % 50) == 0): print(l3) saver.save(sess, 'saves/model.ckpt')
class MyLSTM(tf.nn.rnn_cell.BasicLSTMCell): def __call__(self, inputs, state, scope=None): 'LSTM as mentioned in paper.' with vs.variable_scope((scope or 'basic_lstm_cell')): if self._state_is_tuple: (c, h) = state else: (c, h) = array_ops.split(value=state, num_or_size_splits=2, split_dim=1) g = tf.concat(1, [inputs, h]) concat = linear([g], (4 * self._num_units), True, scope=scope) (i, j, f, o) = array_ops.split(value=concat, num_split=4, split_dim=1) new_c = ((c * sigmoid((f + self._forget_bias))) + (sigmoid(i) * self._activation(j))) new_h = (self._activation(new_c) * sigmoid(o)) if self._state_is_tuple: new_state = LSTMStateTuple(new_c, new_h) else: new_state = array_ops.concat_v2([new_c, new_h], 1) return (new_h, new_state)
class Net(torch.nn.Module): def __init__(self): super(Net, self).__init__() self.lin0 = nn.Linear(3, nf[0]) self.resnet_block11 = HarmonicResNetBlock(nf[0], nf[0], max_order, n_rings, prev_order=0) self.resnet_block12 = HarmonicResNetBlock(nf[0], nf[0], max_order, n_rings) self.pool = ParallelTransportPool(1, scale1_transform) self.resnet_block21 = HarmonicResNetBlock(nf[0], nf[1], max_order, n_rings) self.resnet_block22 = HarmonicResNetBlock(nf[1], nf[1], max_order, n_rings) self.resnet_block31 = HarmonicResNetBlock(nf[1], nf[1], max_order, n_rings) self.resnet_block32 = HarmonicResNetBlock(nf[1], nf[1], max_order, n_rings) self.unpool = ParallelTransportUnpool(1) self.resnet_block41 = HarmonicResNetBlock((nf[1] + nf[0]), nf[0], max_order, n_rings) self.resnet_block42 = HarmonicResNetBlock(nf[0], nf[0], max_order, n_rings, last_layer=True) self.lin3 = nn.Linear(nf[0], 256) self.lin4 = nn.Linear(256, num_nodes) def forward(self, data): x = data.pos x = F.relu(self.lin0(x)) x = torch.stack((x, torch.zeros_like(x)), dim=(- 1)).unsqueeze(1) data_scale0 = scale0_transform(data) attributes = (data_scale0.edge_index, data_scale0.precomp, data_scale0.connection) x = self.resnet_block11(x, *attributes) x_prepool = self.resnet_block12(x, *attributes) (x, data, data_pooled) = self.pool(x_prepool, data) attributes_pooled = (data_pooled.edge_index, data_pooled.precomp, data_pooled.connection) x = self.resnet_block21(x, *attributes_pooled) x = self.resnet_block22(x, *attributes_pooled) x = self.resnet_block31(x, *attributes_pooled) x = self.resnet_block32(x, *attributes_pooled) x = self.unpool(x, data) x = torch.cat((x, x_prepool), dim=2) x = self.resnet_block41(x, *attributes) x = self.resnet_block42(x, *attributes) x = magnitudes(x, keepdim=False) x = x.sum(dim=1) x = F.relu(self.lin3(x)) x = F.dropout(x, training=self.training) x = self.lin4(x) return F.log_softmax(x, dim=1)
def train(epoch): model.train() if (epoch == 60): for param_group in optimizer.param_groups: param_group['lr'] = 0.001 for data in progressbar.progressbar(train_loader): data = data.to(device) optimizer.zero_grad() F.nll_loss(model(data), target).backward() optimizer.step()
def test(): model.eval() correct = 0 for (i, data) in progressbar.progressbar(enumerate(test_loader)): pred = model(data.to(device)).max(1)[1] correct += pred.eq(target).sum().item() return (correct / (len(test_dataset) * num_nodes))
class FAUST(InMemoryDataset): 'The FAUST humans dataset from the `"FAUST: Dataset and Evaluation for\n 3D Mesh Registration"\n <http://files.is.tue.mpg.de/black/papers/FAUST2014.pdf>`_ paper,\n containing 100 watertight meshes representing 10 different poses for 10\n different subjects.\n\n .. note::\n\n Data objects hold mesh faces instead of edge indices.\n To convert the mesh to a graph, use the\n :obj:`torch_geometric.transforms.FaceToEdge` as :obj:`pre_transform`.\n To convert the mesh to a point cloud, use the\n :obj:`torch_geometric.transforms.SamplePoints` as :obj:`transform` to\n sample a fixed number of points on the mesh faces according to their\n face area.\n\n Args:\n root (string): Root directory where the dataset should be saved.\n train (bool, optional): If :obj:`True`, loads the training dataset,\n otherwise the test dataset. (default: :obj:`True`)\n transform (callable, optional): A function/transform that takes in an\n :obj:`torch_geometric.data.Data` object and returns a transformed\n version. The data object will be transformed before every access.\n (default: :obj:`None`)\n pre_transform (callable, optional): A function/transform that takes in\n an :obj:`torch_geometric.data.Data` object and returns a\n transformed version. The data object will be transformed before\n being saved to disk. (default: :obj:`None`)\n pre_filter (callable, optional): A function that takes in an\n :obj:`torch_geometric.data.Data` object and returns a boolean\n value, indicating whether the data object should be included in the\n final dataset. (default: :obj:`None`)\n ' url = 'http://faust.is.tue.mpg.de/' def __init__(self, root, train=True, transform=None, pre_transform=None, pre_filter=None): super(FAUST, self).__init__(root, transform, pre_transform, pre_filter) path = (self.processed_paths[0] if train else self.processed_paths[1]) (self.data, self.slices) = torch.load(path) @property def raw_file_names(self): return 'faust.zip' @property def processed_file_names(self): return ['training.pt', 'test.pt'] def download(self): raise RuntimeError('Dataset not found. Please download {} from {} and move it to {}'.format(self.raw_file_names, self.url, self.raw_dir)) def process(self): extract_zip(self.raw_paths[0], self.raw_dir, log=False) path = osp.join(self.raw_dir, 'meshes') path = osp.join(path, 'tr_reg_{0:03d}.ply') data_list = [] for i in progressbar.progressbar(range(100)): data = read_ply(path.format(i)) if ((self.pre_filter is not None) and (not self.pre_filter(data))): continue if (self.pre_transform is not None): data = self.pre_transform(data) data_list.append(data) torch.save(self.collate(data_list[:80]), self.processed_paths[0]) torch.save(self.collate(data_list[80:]), self.processed_paths[1]) shutil.rmtree(osp.join(self.raw_dir, 'meshes')) shutil.rmtree(osp.join(self.raw_dir, 'segs'))
class FAUSTRemeshed(InMemoryDataset): 'The remeshed FAUST humans dataset from the paper `Multi-directional\n Geodesic Neural Networks via Equivariant Convolution`\n containing 100 watertight meshes representing 10 different poses for 10\n different subjects.\n\n .. note::\n\n Data objects hold mesh faces instead of edge indices.\n To convert the mesh to a graph, use the\n :obj:`torch_geometric.transforms.FaceToEdge` as :obj:`pre_transform`.\n To convert the mesh to a point cloud, use the\n :obj:`torch_geometric.transforms.SamplePoints` as :obj:`transform` to\n sample a fixed number of points on the mesh faces according to their\n face area.\n\n Args:\n root (string): Root directory where the dataset should be saved.\n train (bool, optional): If :obj:`True`, loads the training dataset,\n otherwise the test dataset. (default: :obj:`True`)\n transform (callable, optional): A function/transform that takes in an\n :obj:`torch_geometric.data.Data` object and returns a transformed\n version. The data object will be transformed before every access.\n (default: :obj:`None`)\n pre_transform (callable, optional): A function/transform that takes in\n an :obj:`torch_geometric.data.Data` object and returns a\n transformed version. The data object will be transformed before\n being saved to disk. (default: :obj:`None`)\n pre_filter (callable, optional): A function that takes in an\n :obj:`torch_geometric.data.Data` object and returns a boolean\n value, indicating whether the data object should be included in the\n final dataset. (default: :obj:`None`)\n ' url = 'https://surfdrive.surf.nl/files/index.php/s/KLSxAN0QEsfJuBV' def __init__(self, root, train=True, transform=None, pre_transform=None, pre_filter=None): super(FAUSTRemeshed, self).__init__(root, transform, pre_transform, pre_filter) path = (self.processed_paths[0] if train else self.processed_paths[(- 1)]) (self.data, self.slices) = torch.load(path) @property def raw_file_names(self): return 'FAUST_remeshed.zip' @property def processed_file_names(self): return ['training.pt', 'test.pt'] def download(self): raise RuntimeError('Dataset not found. Please download {} from {} and move it to {}'.format(self.raw_file_names, self.url, self.raw_dir)) def process(self): extract_zip(self.raw_paths[0], self.raw_dir, log=False) path = osp.join(self.raw_dir, 'shapes') path = osp.join(path, 'tr_reg_{0:03d}.ply') data_list = [] file_idx = 0 for i in progressbar.progressbar(range(100)): data = read_ply(path.format(i)) if ((self.pre_filter is not None) and (not self.pre_filter(data))): continue if (self.pre_transform is not None): data = self.pre_transform(data) data_list.append(data) if ((i == 79) or (i == 99)): torch.save(self.collate(data_list), self.processed_paths[file_idx]) data_list = [] file_idx += 1 shutil.rmtree(osp.join(self.raw_dir, 'shapes'))
class ShapeSeg(InMemoryDataset): 'The Shape Segmentation dataset proposed by Maron et al. in\n "Convolutional neural networks on surfaces via seamless toric covers"\n <https://dl.acm.org/citation.cfm?id=3073616>`_ ,\n containing meshes from Adobe, SCAPE, FAUST, and MIT for training\n and SHREC shapes for testing.\n\n .. note::\n\n Data objects hold mesh faces instead of edge indices.\n To convert the mesh to a graph, use the\n :obj:`torch_geometric.transforms.FaceToEdge` as :obj:`pre_transform`.\n To convert the mesh to a point cloud, use the\n :obj:`torch_geometric.transforms.SamplePoints` as :obj:`transform` to\n sample a fixed number of points on the mesh faces according to their\n face area.\n\n Args:\n root (string): Root directory where the dataset should be saved.\n train (bool, optional): If :obj:`True`, loads the training dataset,\n otherwise the test dataset. (default: :obj:`True`)\n transform (callable, optional): A function/transform that takes in an\n :obj:`torch_geometric.data.Data` object and returns a transformed\n version. The data object will be transformed before every access.\n (default: :obj:`None`)\n pre_transform (callable, optional): A function/transform that takes in\n an :obj:`torch_geometric.data.Data` object and returns a\n transformed version. The data object will be transformed before\n being saved to disk. (default: :obj:`None`)\n pre_filter (callable, optional): A function that takes in an\n :obj:`torch_geometric.data.Data` object and returns a boolean\n value, indicating whether the data object should be included in the\n final dataset. (default: :obj:`None`)\n ' mit_folders = {'crane': 18, 'squat1': 25, 'jumping': 15, 'squat2': 25, 'bouncing': 18, 'march1': 25, 'handstand': 18, 'march2': 25} url = 'https://surfdrive.surf.nl/files/index.php/s/L68uSYpHtfO6dLa' def __init__(self, root, train=True, transform=None, pre_transform=None, pre_filter=None): super(ShapeSeg, self).__init__(root, transform, pre_transform, pre_filter) path = (self.processed_paths[0] if train else self.processed_paths[1]) (self.data, self.slices) = torch.load(path) @property def raw_file_names(self): return ['shapeseg.zip'] @property def processed_file_names(self): return ['training.pt', 'test.pt'] def download(self): raise RuntimeError('Dataset not found. Please download {} from {} and move it to {}'.format(self.raw_file_names, self.url, self.raw_dir)) def process(self): print('Extracting zip...') extract_zip(self.raw_paths[0], self.raw_dir, log=False) shapeseg_path = osp.join(self.raw_dir, 'ShapeSeg') data_list = [] print('Processing Adobe') adobe_path = osp.join(shapeseg_path, 'Adobe', 'raw') extract_zip(osp.join(adobe_path, 'adobe.zip'), adobe_path) adobe_meshes = osp.join(adobe_path, 'meshes') adobe_meshes = osp.join(adobe_meshes, '{}.ply') adobe_segs = osp.join(adobe_path, 'segs', '{}.pt') for i in progressbar.progressbar(range(41)): data = read_ply(adobe_meshes.format(i)) if ((self.pre_filter is not None) and (not self.pre_filter(data))): continue if (self.pre_transform is not None): data = self.pre_transform(data) data.y = torch.load(adobe_segs.format(i)) if hasattr(data, 'sample_idx'): data.y = data.y[data.sample_idx] data_list.append(data) torch.save(self.collate(data_list), osp.join(shapeseg_path, 'adobe.pt')) print('Processing FAUST') faust_path = osp.join(shapeseg_path, 'FAUST', 'raw') extract_zip(osp.join(faust_path, 'faust.zip'), faust_path) faust_meshes = osp.join(faust_path, 'meshes') faust_meshes = osp.join(faust_meshes, 'tr_reg_{0:03d}.ply') faust_segs = torch.load(osp.join(faust_path, 'segs', 'faust_seg.pt')) for i in progressbar.progressbar(range(100)): data = read_ply(faust_meshes.format(i)) if ((self.pre_filter is not None) and (not self.pre_filter(data))): continue if (self.pre_transform is not None): data = self.pre_transform(data) data.y = faust_segs if hasattr(data, 'sample_idx'): data.y = data.y[data.sample_idx] data_list.append(data) torch.save(self.collate(data_list), osp.join(shapeseg_path, 'faust.pt')) print('Processing MIT') mit_path = osp.join(shapeseg_path, 'MIT', 'raw') extract_zip(osp.join(mit_path, 'mit.zip'), mit_path) mit_meshes = osp.join(mit_path, 'meshes') mit_seg = osp.join(mit_path, 'segs') for filename in progressbar.progressbar(osls(mit_meshes)): data = read_obj(osp.join(mit_meshes, filename)) seg_path = osp.join(mit_seg, filename.replace('.obj', '.eseg')) segs = torch.from_numpy(np.loadtxt(seg_path)).long() data.y = edge_to_vertex_labels(data.face, segs, data.num_nodes) if ((self.pre_filter is not None) and (not self.pre_filter(data))): continue if (self.pre_transform is not None): data = self.pre_transform(data) data_list.append(data) torch.save(self.collate(data_list), osp.join(shapeseg_path, 'mit.pt')) print('Processing SCAPE') scape_path = osp.join(shapeseg_path, 'SCAPE', 'raw') extract_zip(osp.join(scape_path, 'scape.zip'), scape_path) scape_meshes = osp.join(scape_path, 'meshes') scape_meshes = osp.join(scape_meshes, '{}.ply') scape_segs = torch.load(osp.join(scape_path, 'segs', 'scape_seg.pt')) for i in progressbar.progressbar(range(71)): data = read_ply(scape_meshes.format(i)) if ((self.pre_filter is not None) and (not self.pre_filter(data))): continue if (self.pre_transform is not None): data = self.pre_transform(data) data.y = scape_segs if hasattr(data, 'sample_idx'): data.y = data.y[data.sample_idx] data_list.append(data) torch.save(self.collate(data_list), osp.join(shapeseg_path, 'scape.pt')) torch.save(self.collate(data_list), self.processed_paths[0]) data_list = [] print('Processing SHREC') shrec_path = osp.join(shapeseg_path, 'SHREC', 'raw') extract_zip(osp.join(shrec_path, 'shrec.zip'), shrec_path) shrec_meshes = osp.join(shrec_path, 'meshes') shrec_meshes = osp.join(shrec_meshes, '{}.ply') shrec_segs = osp.join(shrec_path, 'segs', '{}.pt') for i in progressbar.progressbar(range(18)): data = read_ply(shrec_meshes.format(i)) if ((self.pre_filter is not None) and (not self.pre_filter(data))): continue if (self.pre_transform is not None): data = self.pre_transform(data) data.y = torch.load(shrec_segs.format(i)) if hasattr(data, 'sample_idx'): data.y = data.y[data.sample_idx] data_list.append(data) torch.save(self.collate(data_list), self.processed_paths[1]) shutil.rmtree(osp.join(self.raw_dir, 'ShapeSeg'))
class Shrec16(InMemoryDataset): 'The shrec classification dataset.\n\n This is the remeshed version from MeshCNN.\n\n .. note::\n\n Data objects hold mesh faces instead of edge indices.\n To convert the mesh to a graph, use the\n :obj:`torch_geometric.transforms.FaceToEdge` as :obj:`pre_transform`.\n To convert the mesh to a point cloud, use the\n :obj:`torch_geometric.transforms.SamplePoints` as :obj:`transform` to\n sample a fixed number of points on the mesh faces according to their\n face area.\n\n Args:\n root (string): Root directory where the dataset should be saved.\n train (bool, optional): If :obj:`True`, loads the training dataset,\n otherwise the test dataset. (default: :obj:`True`)\n transform (callable, optional): A function/transform that takes in an\n :obj:`torch_geometric.data.Data` object and returns a transformed\n version. The data object will be transformed before every access.\n (default: :obj:`None`)\n pre_transform (callable, optional): A function/transform that takes in\n an :obj:`torch_geometric.data.Data` object and returns a\n transformed version. The data object will be transformed before\n being saved to disk. (default: :obj:`None`)\n pre_filter (callable, optional): A function that takes in an\n :obj:`torch_geometric.data.Data` object and returns a boolean\n value, indicating whether the data object should be included in the\n final dataset. (default: :obj:`None`)\n ' url = 'https://surfdrive.surf.nl/files/index.php/s/ifhelkX4cd7ky8W' class_names = ['alien', 'ants', 'armadillo', 'bird1', 'bird2', 'camel', 'cat', 'centaur', 'dinosaur', 'dino_ske', 'dog1', 'dog2', 'flamingo', 'glasses', 'gorilla', 'hand', 'horse', 'lamp', 'laptop', 'man', 'myScissor', 'octopus', 'pliers', 'rabbit', 'santa', 'shark', 'snake', 'spiders', 'two_balls', 'woman'] def __init__(self, root, train=True, transform=None, pre_transform=None, pre_filter=None, split10=True): self.split10 = split10 super(Shrec16, self).__init__(root, transform, pre_transform, pre_filter) path = (self.processed_paths[0] if train else self.processed_paths[1]) (self.data, self.slices) = torch.load(path) @property def raw_file_names(self): return ['shrec_16.zip'] @property def processed_file_names(self): return ['training.pt', 'test.pt'] @property def num_classes(self): return len(self.class_names) def download(self): raise RuntimeError('Dataset not found. Please download {} from {} and move it to {}'.format(self.raw_file_names, self.url, self.raw_dir)) def process(self): print('Extracting zip...') extract_zip(self.raw_paths[0], self.raw_dir, log=False) training_list = [] test_list = [] print('Processing Shrec...') raw_path = osp.join(self.raw_dir, 'shrec_16') for (class_idx, class_name) in enumerate(self.class_names): train_meshes = osp.join(raw_path, class_name, 'train') mesh_files = osls(train_meshes) idx = (np.random.permutation(len(mesh_files))[:10] if self.split10 else np.arange(len(mesh_files))) for (file_i, filename) in progressbar.progressbar(enumerate(mesh_files)): if (file_i not in idx): continue data = read_obj(osp.join(train_meshes, filename)) data.y = class_idx if ((self.pre_filter is not None) and (not self.pre_filter(data))): continue if (self.pre_transform is not None): data = self.pre_transform(data) training_list.append(data) test_meshes = osp.join(raw_path, class_name, 'test') for filename in progressbar.progressbar(osls(test_meshes)): data = read_obj(osp.join(test_meshes, filename)) data.y = class_idx if ((self.pre_filter is not None) and (not self.pre_filter(data))): continue if (self.pre_transform is not None): data = self.pre_transform(data) test_list.append(data) torch.save(self.collate(training_list), self.processed_paths[0]) torch.save(self.collate(test_list), self.processed_paths[1]) shutil.rmtree(osp.join(self.raw_dir, 'shrec_16'))
class ComplexLin(nn.Module): 'A linear layer applied to complex feature vectors\n The result is a linear combination of the complex input features\n\n Args:\n in_channels (int): number of input features\n out_channels (int): number of output features\n ' def __init__(self, in_channels, out_channels): super(ComplexLin, self).__init__() self.in_channels = in_channels self.out_channels = out_channels self.lin = nn.Linear(in_channels, out_channels) def forward(self, x): x = x.permute(0, 1, 3, 2) sh = x.size() x = self.lin(x.reshape((- 1), self.in_channels)) return x.reshape(sh[0], sh[1], sh[2], self.out_channels).permute(0, 1, 3, 2)
class ComplexNonLin(nn.Module): 'Adds a learned bias and applies the nonlinearity\n given by fnc to the radial component of complex features\n\n Args:\n num_features (int): number of input features\n fnc (torch.nn.Module): non-linearity function\n ' def __init__(self, in_channels, fnc=F.relu): super(ComplexNonLin, self).__init__() self.fnc = fnc self.bias = nn.Parameter(torch.Tensor(in_channels)) zeros(self.bias) def forward(self, x): magnitude = magnitudes(x) rb = (magnitude + self.bias.unsqueeze((- 1))) c = torch.div(self.fnc(rb), magnitude) return (c * x)
class HarmonicResNetBlock(torch.nn.Module): '\n ResNet block with convolutions, linearities, and non-linearities\n as described in Harmonic Surface Networks\n\n Args:\n in_channels (int): number of input features\n out_channels (int): number of output features\n prev_order (int, optional): the maximum rotation order of the previous layer,\n should be set to 0 if this is the first layer (default: :obj:`1`)\n max_order (int, optionatl): the maximum rotation order of this convolution\n will convolve with every rotation order up to and including `max_order`,\n (default: :obj:`1`)\n n_rings (int, optional): the number of rings in the radial profile (default: :obj:`2`)\n offset (bool, optional): if set to :obj:`False`, does not learn an offset parameter,\n this is practical in the last layer of a network (default: :obj:`True`)\n separate_streams (bool, optional): if set to :obj:`True`, learns a radial profile\n for each convolution connecting streams, instead of only an m=0 and m=1 convolution\n (default: :obj:`True`)\n last_layer (bool, optional): if set to :obj:`True`, does not learn a phase offset\n for the last harmonic conv. (default :obj:`False`)\n ' def __init__(self, in_channels, out_channels, max_order=1, n_rings=2, prev_order=1, offset=True, separate_streams=True, last_layer=False): super(HarmonicResNetBlock, self).__init__() self.prev_order = prev_order self.conv1 = HarmonicConv(in_channels, out_channels, max_order, n_rings, prev_order, offset, separate_streams) self.nonlin1 = ComplexNonLin(out_channels, F.relu) self.conv2 = HarmonicConv(out_channels, out_channels, max_order, n_rings, max_order, (offset and (not last_layer)), separate_streams) self.project_residuals = (in_channels != out_channels) if self.project_residuals: self.lin = ComplexLin(in_channels, out_channels) self.nonlin2 = ComplexNonLin(out_channels, F.relu) def forward(self, x, edge_index, precomp, connection=None): if (self.prev_order == 0): x_conv = self.nonlin1(self.conv1(x, edge_index, precomp)) else: x_conv = self.nonlin1(self.conv1(x, edge_index, precomp, connection)) x_conv = self.conv2(x_conv, edge_index, precomp, connection) x = (self.lin(x) if self.project_residuals else x) x_conv = (x_conv + x) return self.nonlin2(x_conv)
class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.conv1 = HarmonicConv(1, nf[0], max_order, n_rings, prev_order=0) self.nonlin1 = ComplexNonLin(nf[0]) self.conv2 = HarmonicConv(nf[0], nf[0], max_order, n_rings) self.bn1 = nn.BatchNorm1d(((max_order + 1) * nf[0]), eps=0.001, momentum=0.01) self.pool1 = ParallelTransportPool(1, scale1_transform) self.conv3 = HarmonicConv(nf[0], nf[1], max_order, n_rings) self.nonlin3 = ComplexNonLin(nf[1]) self.conv4 = HarmonicConv(nf[1], nf[1], max_order, n_rings) self.bn2 = nn.BatchNorm1d(((max_order + 1) * nf[1]), eps=0.001, momentum=0.01) self.pool2 = ParallelTransportPool(2, scale2_transform) self.conv5 = HarmonicConv(nf[1], nf[2], max_order, n_rings) self.nonlin5 = ComplexNonLin(nf[2]) self.conv6 = HarmonicConv(nf[2], nf[2], max_order, n_rings) self.bn3 = nn.BatchNorm1d(((max_order + 1) * nf[2]), eps=0.001, momentum=0.01) self.conv7 = HarmonicConv(nf[2], 10, max_order, n_rings, offset=False) self.bias = nn.Parameter(torch.Tensor(10)) zeros(self.bias) def forward(self, data): x = torch.stack((data.x, torch.zeros_like(data.x)), dim=(- 1)).unsqueeze(1) batch_size = data.num_graphs n_nodes = x.size(0) data_scale0 = scale0_transform(data) attributes = (data_scale0.edge_index, data_scale0.precomp, data_scale0.connection) x = self.conv1(x, attributes[0], attributes[1]) x = self.nonlin1(x) x = self.conv2(x, *attributes) x = c_batch_norm(x, batch_size, self.bn1, F.relu) (x, data, data_pooled) = self.pool1(x, data) attributes_pooled = (data_pooled.edge_index, data_pooled.precomp, data_pooled.connection) x = self.conv3(x, *attributes_pooled) x = self.nonlin3(x) x = self.conv4(x, *attributes_pooled) x = c_batch_norm(x, batch_size, self.bn2, F.relu) (x, data, data_pooled) = self.pool2(x, data) attributes_pooled = (data_pooled.edge_index, data_pooled.precomp, data_pooled.connection) x = self.conv5(x, *attributes_pooled) x = self.nonlin5(x) x = self.conv6(x, *attributes_pooled) x = c_batch_norm(x, batch_size, self.bn3, F.relu) x = self.conv7(x, *attributes_pooled) x = magnitudes(x, keepdim=False) x = x.sum(dim=1) x = global_mean_pool(x, data.batch) x = (x + self.bias) return F.log_softmax(x, dim=1)
def train(epoch): model.train() for param_group in optimizer.param_groups: param_group['lr'] = (param_group['lr'] * np.power(0.1, (epoch / 50))) for data in train_loader: optimizer.zero_grad() F.nll_loss(model(data.to(device)), data.y).backward() optimizer.step()
def test(): model.eval() correct = 0 for data in progressbar.progressbar(test_loader): data = data.to(device) pred = model(data).max(1)[1] correct += pred.eq(data.y).sum().item() return (correct / len(test_dataset))
class Net(torch.nn.Module): def __init__(self): super(Net, self).__init__() self.lin0 = nn.Linear(3, nf[0]) self.resnet_block11 = HarmonicResNetBlock(nf[0], nf[0], max_order, n_rings, prev_order=0) self.pool = ParallelTransportPool(1, scale1_transform) self.resnet_block21 = HarmonicResNetBlock(nf[0], nf[1], max_order, n_rings) self.conv_final = HarmonicConv(nf[1], n_classes, max_order, n_rings, offset=False) self.bias = nn.Parameter(torch.Tensor(n_classes)) zeros(self.bias) def forward(self, data): x = data.pos x = F.relu(self.lin0(x)) x = torch.stack((x, torch.zeros_like(x)), dim=(- 1)).unsqueeze(1) data_scale0 = scale0_transform(data) attributes = (data_scale0.edge_index, data_scale0.precomp, data_scale0.connection) x = self.resnet_block11(x, *attributes) (x, data, data_pooled) = self.pool(x, data) attributes_pooled = (data_pooled.edge_index, data_pooled.precomp, data_pooled.connection) x = self.resnet_block21(x, *attributes_pooled) x = self.conv_final(x, *attributes_pooled) x = magnitudes(x, keepdim=False) x = x.sum(dim=1) x = torch.mean(x, dim=0, keepdim=True) x = (x + self.bias) return F.log_softmax(x, dim=1)
def train(epoch): model.train() if (epoch > 30): for param_group in optimizer.param_groups: param_group['lr'] = 0.001 for data in train_loader: optimizer.zero_grad() F.nll_loss(model(data.to(device)), data.y).backward() optimizer.step()
def test(): model.eval() correct = 0 total_num = 0 for (i, data) in enumerate(test_loader): pred = model(data.to(device)).max(1)[1] correct += pred.eq(data.y).sum().item() total_num += 1 return (correct / total_num)
class Net(torch.nn.Module): def __init__(self): super(Net, self).__init__() self.lin0 = nn.Linear(3, nf[0]) self.resnet_block11 = HarmonicResNetBlock(nf[0], nf[0], max_order, n_rings, prev_order=0) self.resnet_block12 = HarmonicResNetBlock(nf[0], nf[0], max_order, n_rings) self.pool = ParallelTransportPool(1, scale1_transform) self.resnet_block21 = HarmonicResNetBlock(nf[0], nf[1], max_order, n_rings) self.resnet_block22 = HarmonicResNetBlock(nf[1], nf[1], max_order, n_rings) self.resnet_block31 = HarmonicResNetBlock(nf[1], nf[1], max_order, n_rings) self.resnet_block32 = HarmonicResNetBlock(nf[1], nf[1], max_order, n_rings) self.unpool = ParallelTransportUnpool(from_lvl=1) self.resnet_block41 = HarmonicResNetBlock((nf[1] + nf[0]), nf[0], max_order, n_rings) self.resnet_block42 = HarmonicResNetBlock(nf[0], nf[0], max_order, n_rings) self.conv_final = HarmonicConv(nf[0], n_classes, max_order, n_rings, offset=False) self.bias = nn.Parameter(torch.Tensor(n_classes)) zeros(self.bias) def forward(self, data): x = data.pos x = F.relu(self.lin0(x)) x = torch.stack((x, torch.zeros_like(x)), dim=(- 1)).unsqueeze(1) data_scale0 = scale0_transform(data) attributes = (data_scale0.edge_index, data_scale0.precomp, data_scale0.connection) x = self.resnet_block11(x, *attributes) x_prepool = self.resnet_block12(x, *attributes) (x, data, data_pooled) = self.pool(x_prepool, data) attributes_pooled = (data_pooled.edge_index, data_pooled.precomp, data_pooled.connection) x = self.resnet_block21(x, *attributes_pooled) x = self.resnet_block22(x, *attributes_pooled) x = self.resnet_block31(x, *attributes_pooled) x = self.resnet_block32(x, *attributes_pooled) x = self.unpool(x, data) x = torch.cat((x, x_prepool), dim=2) x = self.resnet_block41(x, *attributes) x = self.resnet_block42(x, *attributes) x = self.conv_final(x, *attributes) x = magnitudes(x, keepdim=False) x = x.sum(dim=1) x = (x + self.bias) return F.log_softmax(x, dim=1)
def train(epoch): model.train() if (epoch > 20): for param_group in optimizer.param_groups: param_group['lr'] = 0.001 for data in progressbar.progressbar(train_loader): optimizer.zero_grad() F.nll_loss(model(data.to(device)), data.y).backward() optimizer.step()
def test(): model.eval() correct = 0 total_num = 0 for (i, data) in enumerate(test_loader): pred = model(data.to(device)).max(1)[1] correct += pred.eq(data.y).sum().item() total_num += data.y.size(0) return (correct / total_num)
class MultiscaleRadiusGraph(object): 'Creates a radius graph for multiple pooling levels.\n The nodes and adjacency matrix for each pooling level can be accessed by masking\n tensors with values for nodes and edges with data.node_mask and data.edge_mask, respectively.\n\n Edges can belong to multiple levels,\n therefore we store the membership of an edge for a certain level with a bitmask:\n - The bit at position 2 * n corresponds to the edges used for pooling to level n\n - The bit at position 2 * n + 1 corresponds to the edges used for convolution in level n\n\n To find out if an edge belongs to a level, use a bitwise AND:\n `edge_mask & (0b1 << lvl) > 0`\n\n Args:\n ratios (list): the ratios for downsampling at each pooling layer.\n radii (list): the radius of the kernel support for each scale.\n max_neighbours (int, optional): the maximum number of neighbors per vertex,\n important to set higher than the expected number of neighbors.\n sample_n (int, optional): if provided, constructs a graph for only sample_n vertices.\n loop (bool, optional): If :obj:`True`, the graph will contain\n self-loops. (default: :obj:`False`)\n flow (string, optional): The flow direction when using in combination\n with message passing (:obj:`"source_to_target"` or\n :obj:`"target_to_source"`). (default: :obj:`"source_to_target"`)\n cache_file (string, optional): if set, cache the precomputation\n in the given file and reuse for every following shape.\n ' def __init__(self, ratios, radii, max_neighbours=512, sample_n=None, loop=False, flow='source_to_target', cache_file=None): assert (len(ratios) == len(radii)) self.ratios = ratios self.radii = radii self.max_neighbours = max_neighbours self.sample_n = sample_n self.loop = loop self.flow = flow self.get_cache = ((cache_file is not None) and osp.exists(cache_file)) self.save_cache = ((cache_file is not None) and (not self.get_cache)) self.cache_file = cache_file if self.get_cache: (self.edge_index, self.node_mask, self.edge_mask) = torch.load(cache_file) def __call__(self, data): if self.get_cache: (data.edge_index, data.node_mask, data.edge_mask) = (self.edge_index, self.node_mask, self.edge_mask) return data data.edge_attr = None batch = (data.batch if ('batch' in data) else None) pos = data.pos edge_index = torch.LongTensor() edge_mask = torch.LongTensor() node_mask = torch.zeros(data.num_nodes) if ((self.sample_n is not None) and (not (self.sample_n > data.pos.size(0)))): sample_idx = fps(pos, batch, ratio=(self.sample_n / data.pos.size(0))).sort()[0] else: sample_idx = torch.arange(data.num_nodes) data.sample_idx = sample_idx original_idx = torch.arange(sample_idx.size(0)) pos = pos[sample_idx] batch = (batch[sample_idx] if (batch is not None) else None) for (i, r) in enumerate(self.ratios): if (r == 1): pool_idx = original_idx else: pool_idx = fps(pos, batch, r).sort()[0] (pos_vh, face_vh) = (data.pos.cpu().numpy(), data.face.cpu().numpy().T) (idx_vh, labels_vh) = (sample_idx[pool_idx].cpu().numpy(), np.arange(pool_idx.size(0))) pool_neigh = torch.from_numpy(vh.nearest(pos_vh, face_vh, idx_vh, labels_vh)).round().long().clamp(0, (pool_idx.size(0) - 1)).view((- 1)) edge_index = torch.cat((edge_index, torch.stack((original_idx[pool_idx][pool_neigh][sample_idx], original_idx), dim=0)), dim=1) edge_mask = torch.cat((edge_mask, (torch.ones(sample_idx.size(0)) * (1 << (i * 2))).long())) (sample_idx, original_idx, pos, batch) = (sample_idx[pool_idx], original_idx[pool_idx], pos[pool_idx], (batch[pool_idx] if (batch is not None) else None)) node_mask[sample_idx] = i radius_edges = radius(pos, pos, self.radii[i], batch, batch, self.max_neighbours) radius_edges = original_idx[radius_edges] edge_index = torch.cat((edge_index, radius_edges), dim=1) edge_mask = torch.cat((edge_mask, (torch.ones(radius_edges.size(1)) * (1 << ((i * 2) + 1))).long())) (edge_index, edge_mask) = coalesce(edge_index, edge_mask, data.num_nodes, data.num_nodes, 'add') data.edge_index = edge_index data.node_mask = node_mask data.edge_mask = edge_mask if self.save_cache: with open(self.cache_file, 'wb') as f: torch.save((edge_index, node_mask, edge_mask), f) self.save_cache = False self.get_cache = True (self.edge_index, self.node_mask, self.edge_mask) = (edge_index, node_mask, edge_mask) return data def __repr__(self): return '{}(radii={}, ratios={}, sample_n={})'.format(self.__class__.__name__, self.radii, self.ratios, self.sample_n)
class NormalizeArea(object): 'Centers shapes and normalizes their surface area.\n ' def __init__(self): return def __call__(self, data): data.pos = (data.pos - ((torch.max(data.pos, dim=0)[0] + torch.min(data.pos, dim=0)[0]) / 2)) (pos_vh, face_vh) = (data.pos.cpu().numpy(), data.face.cpu().numpy().T) area = (1 / np.sqrt(vh.surface_area(pos_vh, face_vh))) data.pos = (data.pos * area) return data def __repr__(self): return '{}()'.format(self.__class__.__name__)
class Subsample(object): 'Samples only the positions and descriptors that are set in data.sample_idx.\n ' def __init__(self): return def __call__(self, data): assert hasattr(data, 'sample_idx') sample_idx = data.sample_idx data.pos = data.pos[sample_idx] if hasattr(data, 'node_mask'): data.node_mask = data.node_mask[sample_idx] if hasattr(data, 'desc'): data.desc = data.desc[sample_idx] return data def __repr__(self): return '{}()'.format(self.__class__.__name__)
def write_ply(file, data, pred, features): ' \n Creates a ply file with the mesh,\n given predictions on each vertex and features from inside the network\n Can be used to visualize features in other software\n\n :param file: file name to write to\n :param data: mesh object with positions and faces in `pos` and `face`\n :param pred: predictions for each vertex, size [n_vert]\n :param features: complex features for each vertex, size [n_vert, 2]\n ' with open(file, 'w') as f: f.write(((((((((((('ply\n' + 'format ascii 1.0\n') + 'element vertex {}\n'.format(data.pos.size(0))) + 'property float x\n') + 'property float y\n') + 'property float z\n') + 'property float fx\n') + 'property float fy\n') + 'property float seg\n') + 'element face {}\n'.format(data.face.size(1))) + 'property list uchar uint vertex_indices\n') + 'end_header\n')) for i in range(data.pos.size(0)): f.write('{:1.6f} {:1.6f} {:1.6f} {:1.6f} {:1.6f} {}\n'.format(data.pos[(i, 0)], data.pos[(i, 1)], data.pos[(i, 2)], features[(i, 0)], features[(i, 1)], pred[i])) for face in data.face.transpose(0, 1): f.write('3 {} {} {}\n'.format(face[0], face[1], face[2])) return
class CMakeExtension(Extension): def __init__(self, name, sourcedir=''): Extension.__init__(self, name, sources=[]) self.sourcedir = os.path.abspath(sourcedir)
class CMakeBuild(build_ext): def run(self): try: out = subprocess.check_output(['cmake', '--version']) except OSError: raise RuntimeError(('CMake must be installed to build the following extensions: ' + ', '.join((e.name for e in self.extensions)))) if (platform.system() == 'Windows'): cmake_version = LooseVersion(re.search('version\\s*([\\d.]+)', out.decode()).group(1)) if (cmake_version < '3.1.0'): raise RuntimeError('CMake >= 3.1.0 is required on Windows') for ext in self.extensions: self.build_extension(ext) def build_extension(self, ext): extdir = os.path.abspath(os.path.dirname(self.get_ext_fullpath(ext.name))) cmake_args = [('-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' + extdir), ('-DPYTHON_EXECUTABLE=' + sys.executable)] cfg = ('Debug' if self.debug else 'Release') build_args = ['--config', cfg] if (platform.system() == 'Windows'): cmake_args += ['-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{}={}'.format(cfg.upper(), extdir)] if (sys.maxsize > (2 ** 32)): cmake_args += ['-A', 'x64'] build_args += ['--', '/m'] else: cmake_args += [('-DCMAKE_BUILD_TYPE=' + cfg)] build_args += ['--', '-j2'] env = os.environ.copy() env['CXXFLAGS'] = '{} -DVERSION_INFO=\\"{}\\"'.format(env.get('CXXFLAGS', ''), self.distribution.get_version()) if (not os.path.exists(self.build_temp)): os.makedirs(self.build_temp) subprocess.check_call((['cmake', ext.sourcedir] + cmake_args), cwd=self.build_temp, env=env) subprocess.check_call((['cmake', '--build', '.'] + build_args), cwd=self.build_temp)
def evaluate(j, e, solver, scores1, scores2, data_loader, logdir, reference_point, split, result_dict): '\n Do one forward pass through the dataloader and log the scores.\n ' assert (split in ['train', 'val', 'test']) mode = 'pf' if (mode == 'pf'): assert (len(scores1) == len(scores2) <= 3), 'Cannot generate cirlce points for more than 3 dimensions.' n_test_rays = 25 test_rays = utils.circle_points(n_test_rays, dim=len(scores1)) elif (mode == 'mcr'): test_rays = np.ones((1, len(scores1))) test_rays /= test_rays.sum(axis=1).reshape(1, 1) else: raise ValueError() print(test_rays[0]) score_values1 = np.array([]) score_values2 = np.array([]) for (k, batch) in enumerate(data_loader): print(f'eval batch {(k + 1)} of {len(data_loader)}') batch = utils.dict_to_cuda(batch) s1 = [] s2 = [] for l in solver.eval_step(batch, test_rays): batch.update(l) s1.append([s(**batch) for s in scores1]) s2.append([s(**batch) for s in scores2]) if (score_values1.size == 0): score_values1 = np.array(s1) score_values2 = np.array(s2) else: score_values1 += np.array(s1) score_values2 += np.array(s2) score_values1 /= len(data_loader) score_values2 /= len(data_loader) hv = HyperVolume(reference_point) if (mode == 'pf'): pareto_front = utils.ParetoFront([s.__class__.__name__ for s in scores1], logdir, '{}_{:03d}'.format(split, e)) pareto_front.append(score_values1) pareto_front.plot() volume = hv.compute(score_values1) else: volume = (- 1) result = {'scores_loss': score_values1.tolist(), 'scores_mcr': score_values2.tolist(), 'hv': volume, 'task': j, 'max_epoch_so_far': (- 1), 'max_volume_so_far': (- 1), 'training_time_so_far': (- 1)} result.update(solver.log()) result_dict[f'start_{j}'][f'epoch_{e}'] = result with open((pathlib.Path(logdir) / f'{split}_results.json'), 'w') as file: json.dump(result_dict, file) return result_dict
def eval(settings): '\n The full evaluation loop. Generate scores for all checkpoints found in the directory specified above.\n\n Uses the same ArgumentParser as main.py to determine the method and dataset.\n ' settings['batch_size'] = 2048 print('start evaluation with settings', settings) logdir = os.path.join(settings['logdir'], settings['method'], settings['dataset'], utils.get_runname(settings)) pathlib.Path(logdir).mkdir(parents=True, exist_ok=True) train_set = utils.dataset_from_name(split='train', **settings) val_set = utils.dataset_from_name(split='val', **settings) test_set = utils.dataset_from_name(split='test', **settings) train_loader = data.DataLoader(train_set, settings['batch_size'], shuffle=True, num_workers=settings['num_workers']) val_loader = data.DataLoader(val_set, settings['batch_size'], shuffle=True, num_workers=settings['num_workers']) test_loader = data.DataLoader(test_set, settings['batch_size'], settings['num_workers']) objectives = from_name(settings.pop('objectives'), val_set.task_names()) scores1 = from_objectives(objectives) scores2 = [mcr(o.label_name, o.logits_name) for o in objectives] solver = solver_from_name(objectives=objectives, **settings) train_results = dict(settings=settings, num_parameters=utils.num_parameters(solver.model_params())) val_results = dict(settings=settings, num_parameters=utils.num_parameters(solver.model_params())) test_results = dict(settings=settings, num_parameters=utils.num_parameters(solver.model_params())) task_ids = (settings['task_ids'] if (settings['method'] == 'SingleTask') else [0]) for j in task_ids: if (settings['method'] == 'SingleTask'): checkpoints = pathlib.Path(CHECKPOINT_DIR).glob(f'**/*_{j:03d}/*/c_*.pth') else: checkpoints = pathlib.Path(CHECKPOINT_DIR).glob('**/c_*.pth') train_results[f'start_{j}'] = {} val_results[f'start_{j}'] = {} test_results[f'start_{j}'] = {} for c in sorted(checkpoints): print('checkpoint', c) (_, e) = c.stem.replace('c_', '').split('-') j = int(j) e = int(e) solver.model.load_state_dict(torch.load(c)) val_results = evaluate(j, e, solver, scores1, scores2, val_loader, logdir, reference_point=settings['reference_point'], split='val', result_dict=val_results) test_results = evaluate(j, e, solver, scores1, scores2, test_loader, logdir, reference_point=settings['reference_point'], split='test', result_dict=test_results)
class HyperVolume(): '\n Hypervolume computation based on variant 3 of the algorithm in the paper:\n C. M. Fonseca, L. Paquete, and M. Lopez-Ibanez. An improved dimension-sweep\n algorithm for the hypervolume indicator. In IEEE Congress on Evolutionary\n Computation, pages 1157-1163, Vancouver, Canada, July 2006.\n\n Minimization is implicitly assumed here!\n\n ' def __init__(self, referencePoint): 'Constructor.' self.referencePoint = referencePoint self.list = [] def compute(self, front): 'Returns the hypervolume that is dominated by a non-dominated front.\n\n Before the HV computation, front and reference point are translated, so\n that the reference point is [0, ..., 0].\n\n ' def weaklyDominates(point, other): for i in range(len(point)): if (point[i] > other[i]): return False return True relevantPoints = [] referencePoint = self.referencePoint dimensions = len(referencePoint) for point in front: if weaklyDominates(point, referencePoint): relevantPoints.append(point) if any(referencePoint): for j in range(len(relevantPoints)): relevantPoints[j] = [(relevantPoints[j][i] - referencePoint[i]) for i in range(dimensions)] self.preProcess(relevantPoints) bounds = ([(- 1e+308)] * dimensions) hyperVolume = self.hvRecursive((dimensions - 1), len(relevantPoints), bounds) return hyperVolume def hvRecursive(self, dimIndex, length, bounds): 'Recursive call to hypervolume calculation.\n\n In contrast to the paper, the code assumes that the reference point\n is [0, ..., 0]. This allows the avoidance of a few operations.\n\n ' hvol = 0.0 sentinel = self.list.sentinel if (length == 0): return hvol elif (dimIndex == 0): return (- sentinel.next[0].cargo[0]) elif (dimIndex == 1): q = sentinel.next[1] h = q.cargo[0] p = q.next[1] while (p is not sentinel): pCargo = p.cargo hvol += (h * (q.cargo[1] - pCargo[1])) if (pCargo[0] < h): h = pCargo[0] q = p p = q.next[1] hvol += (h * q.cargo[1]) return hvol else: remove = self.list.remove reinsert = self.list.reinsert hvRecursive = self.hvRecursive p = sentinel q = p.prev[dimIndex] while (q.cargo != None): if (q.ignore < dimIndex): q.ignore = 0 q = q.prev[dimIndex] q = p.prev[dimIndex] while ((length > 1) and ((q.cargo[dimIndex] > bounds[dimIndex]) or (q.prev[dimIndex].cargo[dimIndex] >= bounds[dimIndex]))): p = q remove(p, dimIndex, bounds) q = p.prev[dimIndex] length -= 1 qArea = q.area qCargo = q.cargo qPrevDimIndex = q.prev[dimIndex] if (length > 1): hvol = (qPrevDimIndex.volume[dimIndex] + (qPrevDimIndex.area[dimIndex] * (qCargo[dimIndex] - qPrevDimIndex.cargo[dimIndex]))) else: qArea[0] = 1 qArea[1:(dimIndex + 1)] = [(qArea[i] * (- qCargo[i])) for i in range(dimIndex)] q.volume[dimIndex] = hvol if (q.ignore >= dimIndex): qArea[dimIndex] = qPrevDimIndex.area[dimIndex] else: qArea[dimIndex] = hvRecursive((dimIndex - 1), length, bounds) if (qArea[dimIndex] <= qPrevDimIndex.area[dimIndex]): q.ignore = dimIndex while (p is not sentinel): pCargoDimIndex = p.cargo[dimIndex] hvol += (q.area[dimIndex] * (pCargoDimIndex - q.cargo[dimIndex])) bounds[dimIndex] = pCargoDimIndex reinsert(p, dimIndex, bounds) length += 1 q = p p = p.next[dimIndex] q.volume[dimIndex] = hvol if (q.ignore >= dimIndex): q.area[dimIndex] = q.prev[dimIndex].area[dimIndex] else: q.area[dimIndex] = hvRecursive((dimIndex - 1), length, bounds) if (q.area[dimIndex] <= q.prev[dimIndex].area[dimIndex]): q.ignore = dimIndex hvol -= (q.area[dimIndex] * q.cargo[dimIndex]) return hvol def preProcess(self, front): 'Sets up the list data structure needed for calculation.' dimensions = len(self.referencePoint) nodeList = MultiList(dimensions) nodes = [MultiList.Node(dimensions, point) for point in front] for i in range(dimensions): self.sortByDimension(nodes, i) nodeList.extend(nodes, i) self.list = nodeList def sortByDimension(self, nodes, i): 'Sorts the list of nodes by the i-th value of the contained points.' decorated = [(node.cargo[i], node) for node in nodes] decorated.sort(key=(lambda x: x[0])) nodes[:] = [node for (_, node) in decorated]
class MultiList(): 'A special data structure needed by FonsecaHyperVolume. \n \n It consists of several doubly linked lists that share common nodes. So, \n every node has multiple predecessors and successors, one in every list.\n\n ' class Node(): def __init__(self, numberLists, cargo=None): self.cargo = cargo self.next = ([None] * numberLists) self.prev = ([None] * numberLists) self.ignore = 0 self.area = ([0.0] * numberLists) self.volume = ([0.0] * numberLists) def __str__(self): return str(self.cargo) def __init__(self, numberLists): "Constructor. \n \n Builds 'numberLists' doubly linked lists.\n\n " self.numberLists = numberLists self.sentinel = MultiList.Node(numberLists) self.sentinel.next = ([self.sentinel] * numberLists) self.sentinel.prev = ([self.sentinel] * numberLists) def __str__(self): strings = [] for i in range(self.numberLists): currentList = [] node = self.sentinel.next[i] while (node != self.sentinel): currentList.append(str(node)) node = node.next[i] strings.append(str(currentList)) stringRepr = '' for string in strings: stringRepr += (string + '\n') return stringRepr def __len__(self): 'Returns the number of lists that are included in this MultiList.' return self.numberLists def getLength(self, i): 'Returns the length of the i-th list.' length = 0 sentinel = self.sentinel node = sentinel.next[i] while (node != sentinel): length += 1 node = node.next[i] return length def append(self, node, index): 'Appends a node to the end of the list at the given index.' lastButOne = self.sentinel.prev[index] node.next[index] = self.sentinel node.prev[index] = lastButOne self.sentinel.prev[index] = node lastButOne.next[index] = node def extend(self, nodes, index): 'Extends the list at the given index with the nodes.' sentinel = self.sentinel for node in nodes: lastButOne = sentinel.prev[index] node.next[index] = sentinel node.prev[index] = lastButOne sentinel.prev[index] = node lastButOne.next[index] = node def remove(self, node, index, bounds): "Removes and returns 'node' from all lists in [0, 'index'[." for i in range(index): predecessor = node.prev[i] successor = node.next[i] predecessor.next[i] = successor successor.prev[i] = predecessor if (bounds[i] > node.cargo[i]): bounds[i] = node.cargo[i] return node def reinsert(self, node, index, bounds): "\n Inserts 'node' at the position it had in all lists in [0, 'index'[\n before it was removed. This method assumes that the next and previous \n nodes of the node that is reinserted are in the list.\n\n " for i in range(index): node.prev[i].next[i] = node node.next[i].prev[i] = node if (bounds[i] > node.cargo[i]): bounds[i] = node.cargo[i]
def load_dataset(path, s_label): data = pd.read_csv(path) data['workclass'] = data['workclass'].replace('?', 'Private') data['occupation'] = data['occupation'].replace('?', 'Prof-specialty') data['native-country'] = data['native-country'].replace('?', 'United-States') data.education = data.education.replace(['Preschool', '1st-4th', '5th-6th', '7th-8th', '9th', '10th', '11th', '12th'], 'left') data.education = data.education.replace('HS-grad', 'school') data.education = data.education.replace(['Assoc-voc', 'Assoc-acdm', 'Prof-school', 'Some-college'], 'higher') data.education = data.education.replace('Bachelors', 'undergrad') data.education = data.education.replace('Masters', 'grad') data.education = data.education.replace('Doctorate', 'doc') data['marital-status'] = data['marital-status'].replace(['Married-civ-spouse', 'Married-AF-spouse'], 'married') data['marital-status'] = data['marital-status'].replace(['Never-married', 'Divorced', 'Separated', 'Widowed', 'Married-spouse-absent'], 'not-married') data.income = data.income.replace('<=50K', 0) data.income = data.income.replace('>50K', 1) data.gender = data.gender.replace('Male', 0) data.gender = data.gender.replace('Female', 1) data1 = data.copy() data1 = pd.get_dummies(data1) data1 = data1.drop(['income', s_label], axis=1) X = StandardScaler().fit(data1).transform(data1) y = data['income'].values s = data[s_label].values return (X, y, s)
class ADULT(data.Dataset): def __init__(self, root='data/adult', split='train', sensible_attribute='gender', **kwargs): assert (split in ['train', 'val', 'test']) path = os.path.join(root, 'adult.csv') (x, y, s) = load_dataset(path, sensible_attribute) x = torch.from_numpy(x).float() y = torch.from_numpy(y).long() s = torch.from_numpy(s).long() (x_train, x_test, y_train, y_test, s_train, s_test) = train_test_split(x, y, s, test_size=0.2, random_state=1) (x_train, x_val, y_train, y_val, s_train, s_val) = train_test_split(x_train, y_train, s_train, test_size=0.125, random_state=1) if (split == 'train'): self.x = x_train self.y = y_train self.s = s_train elif (split == 'val'): self.x = x_val self.y = y_val self.s = s_val elif (split == 'test'): self.x = x_test self.y = y_test self.s = s_test print('loaded {} instances for split {}. y positives={}, {} positives={}'.format(len(self.y), split, sum(self.y), sensible_attribute, sum(self.s))) def __len__(self): '__len__' return len(self.x) def __getitem__(self, index): return dict(data=self.x[index], labels=self.y[index], sensible_attribute=self.s[index]) def task_names(self): return None
def load_dataset(root, s_label): raw_data = pd.read_csv(os.path.join(root, 'compas-scores-two-years.csv')) data = raw_data[(((((raw_data['days_b_screening_arrest'] <= 30) & (raw_data['days_b_screening_arrest'] >= (- 30))) & (raw_data['is_recid'] != (- 1))) & (raw_data['c_charge_degree'] != 'O')) & (raw_data['score_text'] != 'N/A'))] data = data[['age', 'c_charge_degree', 'race', 'age_cat', 'score_text', 'sex', 'priors_count', 'days_b_screening_arrest', 'decile_score', 'is_recid', 'two_year_recid', 'c_jail_in', 'c_jail_out']] def date_from_str(s): return datetime.strptime(s, '%Y-%m-%d %H:%M:%S') data['c_jail_in'] = data['c_jail_in'].apply(date_from_str) data['c_jail_out'] = data['c_jail_out'].apply(date_from_str) data['length_of_stay'] = (data['c_jail_out'] - data['c_jail_in']) data['length_of_stay'] = data['length_of_stay'].astype('timedelta64[h]') data = data.drop(['c_jail_in', 'c_jail_out'], axis=1) data['sex'] = data['sex'].replace('Male', 0) data['sex'] = data['sex'].replace('Female', 1) data1 = data.copy() data1 = data1.drop(['two_year_recid', 'sex'], axis=1) data1 = pd.get_dummies(data1) x = StandardScaler().fit(data1).transform(data1) y = data['two_year_recid'].values s = data['sex'].values return (x, y, s)
class Compas(torch.utils.data.Dataset): def __init__(self, split, root='data/compas', sensible_attribute='sex', **kwargs): assert (split in ['train', 'val', 'test']) (x, y, s) = load_dataset(root, sensible_attribute) x = torch.from_numpy(x).float() y = torch.from_numpy(y).long() s = torch.from_numpy(s).long() (x_train, x_test, y_train, y_test, s_train, s_test) = train_test_split(x, y, s, test_size=0.2, random_state=1) (x_train, x_val, y_train, y_val, s_train, s_val) = train_test_split(x_train, y_train, s_train, test_size=0.125, random_state=1) if (split == 'train'): self.x = x_train self.y = y_train self.s = s_train elif (split == 'val'): self.x = x_val self.y = y_val self.s = s_val elif (split == 'test'): self.x = x_test self.y = y_test self.s = s_test print('loaded {} instances for split {}. y positives={}, {} positives={}'.format(len(self.y), split, sum(self.y), sensible_attribute, sum(self.s))) def __len__(self): return len(self.y) def __getitem__(self, index): return dict(data=self.x[index], labels=self.y[index], sensible_attribute=self.s[index]) def task_names(self): return None
def load_dataset(root, s_label): data = pd.read_csv(os.path.join(root, 'UCI_Credit_Card.csv')) to_categorical = ['EDUCATION', 'MARRIAGE', 'PAY_0', 'PAY_2', 'PAY_3', 'PAY_4', 'PAY_5', 'PAY_6'] for column in to_categorical: data[column] = data[column].astype('category') data.SEX = data.SEX.replace(1, 0) data.SEX = data.SEX.replace(2, 1) data1 = data.copy() data1 = data1.drop(['default.payment.next.month', s_label], axis=1) data1 = pd.get_dummies(data1) x = StandardScaler().fit(data1).transform(data1) y = data['default.payment.next.month'].values s = data[s_label].values return (x, y, s)
class Credit(torch.utils.data.Dataset): def __init__(self, split, root='data/credit', sensible_attribute='SEX', **kwargs): assert (split in ['train', 'val', 'test']) (x, y, s) = load_dataset(root, sensible_attribute) x = torch.from_numpy(x).float() y = torch.from_numpy(y).long() s = torch.from_numpy(s).long() (x_train, x_test, y_train, y_test, s_train, s_test) = train_test_split(x, y, s, test_size=0.2, random_state=1) (x_train, x_val, y_train, y_val, s_train, s_val) = train_test_split(x_train, y_train, s_train, test_size=0.125, random_state=1) if (split == 'train'): self.x = x_train self.y = y_train self.s = s_train elif (split == 'val'): self.x = x_val self.y = y_val self.s = s_val elif (split == 'test'): self.x = x_test self.y = y_test self.s = s_test print('loaded {} instances for split {}. y positives={}, {} positives={}'.format(len(self.y), split, sum(self.y), sensible_attribute, sum(self.s))) def __len__(self): return len(self.y) def __getitem__(self, index): return dict(data=self.x[index], labels=self.y[index], sensible_attribute=self.s[index]) def task_names(self): return None
def method_from_name(method, **kwargs): if (method == 'ParetoMTL'): return ParetoMTLMethod(**kwargs) elif ('cosmos' in method): return COSMOSMethod(**kwargs) elif (method == 'SingleTask'): return SingleTaskMethod(**kwargs) elif ('hyper' in method): return HypernetMethod(**kwargs) elif (method == 'mgda'): return MGDAMethod(**kwargs) elif (method == 'uniform'): return UniformScalingMethod(**kwargs) else: raise ValueError('Unkown method {}'.format(method))
def evaluate(j, e, method, scores, data_loader, logdir, reference_point, split, result_dict): assert (split in ['train', 'val', 'test']) global volume_max global epoch_max score_values = np.array([]) for batch in data_loader: batch = utils.dict_to_cuda(batch) s = [] for l in method.eval_step(batch): batch.update(l) s.append([s(**batch) for s in scores]) if (score_values.size == 0): score_values = np.array(s) else: score_values += np.array(s) score_values /= len(data_loader) hv = HyperVolume(reference_point) volume = (hv.compute(score_values) if (score_values.shape[1] < 5) else (- 1)) if (len(scores) == 2): pareto_front = utils.ParetoFront([s.__class__.__name__ for s in scores], logdir, '{}_{:03d}'.format(split, e)) pareto_front.append(score_values) pareto_front.plot() result = {'scores': score_values.tolist(), 'hv': volume} if (split == 'val'): if (volume > volume_max): volume_max = volume epoch_max = e result.update({'max_epoch_so_far': epoch_max, 'max_volume_so_far': volume_max, 'training_time_so_far': elapsed_time}) elif (split == 'test'): result.update({'training_time_so_far': elapsed_time}) result.update(method.log()) if (f'epoch_{e}' in result_dict[f'start_{j}']): result_dict[f'start_{j}'][f'epoch_{e}'].update(result) else: result_dict[f'start_{j}'][f'epoch_{e}'] = result with open((pathlib.Path(logdir) / f'{split}_results.json'), 'w') as file: json.dump(result_dict, file) return result_dict
def main(settings): print('start processig with settings', settings) utils.set_seed(settings['seed']) global elapsed_time logdir = os.path.join(settings['logdir'], settings['method'], settings['dataset'], utils.get_runname(settings)) pathlib.Path(logdir).mkdir(parents=True, exist_ok=True) train_set = utils.dataset_from_name(split='train', **settings) val_set = utils.dataset_from_name(split='val', **settings) test_set = utils.dataset_from_name(split='test', **settings) train_loader = data.DataLoader(train_set, settings['batch_size'], shuffle=True, num_workers=settings['num_workers']) val_loader = data.DataLoader(val_set, settings['batch_size'], shuffle=True, num_workers=settings['num_workers']) test_loader = data.DataLoader(test_set, settings['batch_size'], settings['num_workers']) objectives = from_name(settings.pop('objectives'), train_set.task_names()) scores = from_objectives(objectives) rm1 = utils.RunningMean(400) rm2 = utils.RunningMean(400) method = method_from_name(objectives=objectives, **settings) train_results = dict(settings=settings, num_parameters=utils.num_parameters(method.model_params())) val_results = dict(settings=settings, num_parameters=utils.num_parameters(method.model_params())) test_results = dict(settings=settings, num_parameters=utils.num_parameters(method.model_params())) with open((pathlib.Path(logdir) / 'settings.json'), 'w') as file: json.dump(train_results, file) for j in range(settings['num_starts']): train_results[f'start_{j}'] = {} val_results[f'start_{j}'] = {} test_results[f'start_{j}'] = {} optimizer = torch.optim.Adam(method.model_params(), settings['lr']) if settings['use_scheduler']: scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, settings['scheduler_milestones'], gamma=settings['scheduler_gamma']) for e in range(settings['epochs']): print(f'Epoch {e}') tick = time.time() method.new_epoch(e) for (b, batch) in enumerate(train_loader): batch = utils.dict_to_cuda(batch) optimizer.zero_grad() stats = method.step(batch) optimizer.step() (loss, sim) = (stats if isinstance(stats, tuple) else (stats, 0)) print('Epoch {:03d}, batch {:03d}, train_loss {:.4f}, sim {:.4f}, rm train_loss {:.3f}, rm sim {:.3f}'.format(e, b, loss, sim, rm1(loss), rm2(sim))) tock = time.time() elapsed_time += (tock - tick) if settings['use_scheduler']: val_results[f'start_{j}'][f'epoch_{e}'] = {'lr': scheduler.get_last_lr()[0]} scheduler.step() if ((settings['train_eval_every'] > 0) and (((e + 1) % settings['train_eval_every']) == 0)): train_results = evaluate(j, e, method, scores, train_loader, logdir, reference_point=settings['reference_point'], split='train', result_dict=train_results) if ((settings['eval_every'] > 0) and (((e + 1) % settings['eval_every']) == 0)): val_results = evaluate(j, e, method, scores, val_loader, logdir, reference_point=settings['reference_point'], split='val', result_dict=val_results) test_results = evaluate(j, e, method, scores, test_loader, logdir, reference_point=settings['reference_point'], split='test', result_dict=test_results) if ((settings['checkpoint_every'] > 0) and (((e + 1) % settings['checkpoint_every']) == 0)): pathlib.Path(os.path.join(logdir, 'checkpoints')).mkdir(parents=True, exist_ok=True) torch.save(method.model.state_dict(), os.path.join(logdir, 'checkpoints', 'c_{}-{:03d}.pth'.format(j, e))) print('epoch_max={}, val_volume_max={}'.format(epoch_max, volume_max)) pathlib.Path(os.path.join(logdir, 'checkpoints')).mkdir(parents=True, exist_ok=True) torch.save(method.model.state_dict(), os.path.join(logdir, 'checkpoints', 'c_{}-{:03d}.pth'.format(j, 999999))) return volume_max
def parse_args(): parser = argparse.ArgumentParser() parser.add_argument('--dataset', '-d', default='mm', help='The dataset to run on.') parser.add_argument('--method', '-m', default='cosmos', help='The method to generate the Pareto front.') parser.add_argument('--seed', '-s', default=1, type=int, help='Seed') parser.add_argument('--task_id', '-t', default=None, type=int, help='Task id to run single task in parallel. If not set then sequentially.') args = parser.parse_args() settings = s.generic if (args.method == 'single_task'): settings.update(s.SingleTaskSolver) if (args.task_id is not None): settings['num_starts'] = 1 settings['task_id'] = args.task_id elif (args.method == 'cosmos'): settings.update(s.cosmos) elif (args.method == 'hyper_ln'): settings.update(s.hyperSolver_ln) elif (args.method == 'hyper_epo'): settings.update(s.hyperSolver_epo) elif (args.method == 'pmtl'): settings.update(s.paretoMTL) elif (args.method == 'mgda'): settings.update(s.mgda) elif (args.method == 'uniform'): settings.update(s.uniform_scaling) if (args.dataset == 'mm'): settings.update(s.multi_mnist) elif (args.dataset == 'adult'): settings.update(s.adult) elif (args.dataset == 'mfm'): settings.update(s.multi_fashion_mnist) elif (args.dataset == 'fm'): settings.update(s.multi_fashion) elif (args.dataset == 'credit'): settings.update(s.credit) elif (args.dataset == 'compass'): settings.update(s.compass) elif (args.dataset == 'celeba'): settings.update(s.celeba) settings['seed'] = args.seed return settings
class BaseMethod(): def model_params(self): return list(self.model.parameters()) def new_epoch(self, e): self.model.train() @abstractmethod def step(self, batch): raise NotImplementedError() def log(self): return {} @abstractmethod def eval_step(self, batch): raise NotImplementedError()
class Upsampler(nn.Module): def __init__(self, K, child_model, input_dim): '\n In case of tabular data: append the sampled rays to the data instances (no upsampling)\n In case of image data: use a transposed CNN for the sampled rays.\n ' super().__init__() if (len(input_dim) == 1): self.tabular = True elif (len(input_dim) == 3): self.tabular = False self.transposed_cnn = nn.Sequential(nn.ConvTranspose2d(K, K, kernel_size=4, stride=1, padding=0, bias=False), nn.ReLU(inplace=True), nn.ConvTranspose2d(K, K, kernel_size=6, stride=2, padding=1, bias=False), nn.ReLU(inplace=True), nn.Upsample(input_dim[(- 2):])) else: raise ValueError(f'Unknown dataset structure, expected 1 or 3 dimensions, got {dim}') self.child_model = child_model def forward(self, batch): x = batch['data'] b = x.shape[0] a = batch['alpha'].repeat(b, 1) if (not self.tabular): a = a.reshape(b, len(batch['alpha']), 1, 1) a = self.transposed_cnn(a) x = torch.cat((x, a), dim=1) return self.child_model(dict(data=x)) def private_params(self): if hasattr(self.child_model, 'private_params'): return self.child_model.private_params() else: return []
class COSMOSMethod(BaseMethod): def __init__(self, objectives, alpha, lamda, dim, n_test_rays, **kwargs): '\n Instanciate the cosmos solver.\n\n Args:\n objectives: A list of objectives\n alpha: Dirichlet sampling parameter (list or float)\n lamda: Cosine similarity penalty\n dim: Dimensions of the data\n n_test_rays: The number of test rays used for evaluation.\n ' self.objectives = objectives self.K = len(objectives) self.alpha = alpha self.n_test_rays = n_test_rays self.lamda = lamda dim = list(dim) dim[0] = (dim[0] + self.K) model = model_from_dataset(method='cosmos', dim=dim, **kwargs) self.model = Upsampler(self.K, model, dim).cuda() self.n_params = num_parameters(self.model) print('Number of parameters: {}'.format(self.n_params)) def step(self, batch): if isinstance(self.alpha, list): batch['alpha'] = torch.from_numpy(np.random.dirichlet(self.alpha, 1).astype(np.float32).flatten()).cuda() elif (self.alpha > 0): batch['alpha'] = torch.from_numpy(np.random.dirichlet([self.alpha for _ in range(self.K)], 1).astype(np.float32).flatten()).cuda() else: raise ValueError(f'Unknown value for alpha: {self.alpha}, expecting list or float.') self.model.zero_grad() logits = self.model(batch) batch.update(logits) loss_total = None task_losses = [] for (a, objective) in zip(batch['alpha'], self.objectives): task_loss = objective(**batch) loss_total = ((a * task_loss) if (not loss_total) else (loss_total + (a * task_loss))) task_losses.append(task_loss) cossim = torch.nn.functional.cosine_similarity(torch.stack(task_losses), batch['alpha'], dim=0) loss_total -= (self.lamda * cossim) loss_total.backward() return (loss_total.item(), cossim.item()) def eval_step(self, batch, test_rays=None): self.model.eval() logits = [] with torch.no_grad(): if (test_rays is None): test_rays = circle_points(self.n_test_rays, dim=self.K) for ray in test_rays: ray = torch.from_numpy(ray.astype(np.float32)).cuda() ray /= ray.sum() batch['alpha'] = ray logits.append(self.model(batch)) return logits
class MGDAMethod(BaseMethod): def __init__(self, objectives, approximate_norm_solution, normalization_type, **kwargs) -> None: super().__init__() self.objectives = objectives self.approximate_norm_solution = approximate_norm_solution self.normalization_type = normalization_type self.model = model_from_dataset(method='mdga', **kwargs).cuda() def new_epoch(self, e): self.model.train() def step(self, batch): if self.approximate_norm_solution: self.model.zero_grad() with torch.no_grad(): rep = self.model.forward_feature_extraction(batch) gradients = [] obj_values = [] for (i, objective) in enumerate(self.objectives): self.model.zero_grad() logits = self.model.forward_linear(rep, i) batch.update(logits) output = objective(**batch) output.backward() obj_values.append(output.item()) gradients.append({}) private_params = (self.model.private_params() if hasattr(self.model, 'private_params') else []) for (name, param) in self.model.named_parameters(): not_private = all([(p not in name) for p in private_params]) if (not_private and param.requires_grad and (param.grad is not None)): gradients[i][name] = param.grad.data.detach().clone() param.grad = None self.model.zero_grad() grads = gradients else: (grads, obj_values) = calc_gradients(batch, self.model, self.objectives) gn = gradient_normalizers(grads, obj_values, self.normalization_type) for t in range(len(self.objectives)): for gr_i in grads[t]: grads[t][gr_i] = (grads[t][gr_i] / gn[t]) grads = [[v for v in d.values()] for d in grads] (sol, min_norm) = MinNormSolver.find_min_norm_element(grads) self.model.zero_grad() logits = self.model(batch) batch.update(logits) loss_total = None for (a, objective) in zip(sol, self.objectives): task_loss = objective(**batch) loss_total = ((a * task_loss) if (not loss_total) else (loss_total + (a * task_loss))) loss_total.backward() return (loss_total.item(), 0) def eval_step(self, batch): self.model.eval() return [self.model(batch)]
class PHNHyper(nn.Module): 'Hypernetwork\n ' def __init__(self, kernel_size: List[int], ray_hidden_dim=100, out_dim=10, target_hidden_dim=50, n_kernels=10, n_conv_layers=2, n_hidden=1, n_tasks=2): super().__init__() self.n_conv_layers = n_conv_layers self.n_hidden = n_hidden self.n_tasks = n_tasks assert (len(kernel_size) == n_conv_layers), 'kernel_size is list with same dim as number of conv layers holding kernel size for each conv layer' self.ray_mlp = nn.Sequential(nn.Linear(2, ray_hidden_dim), nn.ReLU(inplace=True), nn.Linear(ray_hidden_dim, ray_hidden_dim), nn.ReLU(inplace=True), nn.Linear(ray_hidden_dim, ray_hidden_dim)) self.conv_0_weights = nn.Linear(ray_hidden_dim, ((n_kernels * kernel_size[0]) * kernel_size[0])) self.conv_0_bias = nn.Linear(ray_hidden_dim, n_kernels) for i in range(1, n_conv_layers): p = ((2 ** (i - 1)) * n_kernels) c = ((2 ** i) * n_kernels) setattr(self, f'conv_{i}_weights', nn.Linear(ray_hidden_dim, (((c * p) * kernel_size[i]) * kernel_size[i]))) setattr(self, f'conv_{i}_bias', nn.Linear(ray_hidden_dim, c)) latent = 25 self.hidden_0_weights = nn.Linear(ray_hidden_dim, (((target_hidden_dim * (2 ** i)) * n_kernels) * latent)) self.hidden_0_bias = nn.Linear(ray_hidden_dim, target_hidden_dim) for j in range(n_tasks): setattr(self, f'task_{j}_weights', nn.Linear(ray_hidden_dim, (target_hidden_dim * out_dim))) setattr(self, f'task_{j}_bias', nn.Linear(ray_hidden_dim, out_dim)) def shared_parameters(self): return list([p for (n, p) in self.named_parameters() if ('task' not in n)]) def forward(self, ray): features = self.ray_mlp(ray) out_dict = {} layer_types = ['conv', 'hidden', 'task'] for i in layer_types: if (i == 'conv'): n_layers = self.n_conv_layers elif (i == 'hidden'): n_layers = self.n_hidden elif (i == 'task'): n_layers = self.n_tasks for j in range(n_layers): out_dict[f'{i}{j}.weights'] = getattr(self, f'{i}_{j}_weights')(features) out_dict[f'{i}{j}.bias'] = getattr(self, f'{i}_{j}_bias')(features).flatten() return out_dict
class PHNTarget(nn.Module): 'Target network\n ' def __init__(self, kernel_size, n_kernels=10, out_dim=10, target_hidden_dim=50, n_conv_layers=2, n_tasks=2): super().__init__() assert (len(kernel_size) == n_conv_layers), 'kernel_size is list with same dim as number of conv layers holding kernel size for each conv layer' self.n_kernels = n_kernels self.kernel_size = kernel_size self.out_dim = out_dim self.n_conv_layers = n_conv_layers self.n_tasks = n_tasks self.target_hidden_dim = target_hidden_dim def forward(self, x, weights=None): x = F.conv2d(x, weight=weights['conv0.weights'].reshape(self.n_kernels, 1, self.kernel_size[0], self.kernel_size[0]), bias=weights['conv0.bias'], stride=1) x = F.relu(x) x = F.max_pool2d(x, 2) for i in range(1, self.n_conv_layers): x = F.conv2d(x, weight=weights[f'conv{i}.weights'].reshape(int(((2 ** i) * self.n_kernels)), int(((2 ** (i - 1)) * self.n_kernels)), self.kernel_size[i], self.kernel_size[i]), bias=weights[f'conv{i}.bias'], stride=1) x = F.relu(x) x = F.max_pool2d(x, 2) x = torch.flatten(x, 1) x = F.linear(x, weight=weights['hidden0.weights'].reshape(self.target_hidden_dim, x.shape[(- 1)]), bias=weights['hidden0.bias']) logits = [] for j in range(self.n_tasks): logits.append(F.linear(x, weight=weights[f'task{j}.weights'].reshape(self.out_dim, self.target_hidden_dim), bias=weights[f'task{j}.bias'])) return logits
class LeNetPHNHyper(PHNHyper): pass
class LeNetPHNTargetWrapper(PHNTarget): def forward(self, x, weights=None): logits = super().forward(x, weights) return dict(logits_l=logits[0], logits_r=logits[1])
class FCPHNHyper(nn.Module): def __init__(self, dim, ray_hidden_dim=100, n_tasks=2): super().__init__() self.feature_dim = dim[0] self.ray_mlp = nn.Sequential(nn.Linear(n_tasks, ray_hidden_dim), nn.ReLU(inplace=True), nn.Linear(ray_hidden_dim, ray_hidden_dim), nn.ReLU(inplace=True), nn.Linear(ray_hidden_dim, ray_hidden_dim)) self.fc_0_weights = nn.Linear(ray_hidden_dim, (60 * self.feature_dim)) self.fc_0_bias = nn.Linear(ray_hidden_dim, 60) self.fc_1_weights = nn.Linear(ray_hidden_dim, (25 * 60)) self.fc_1_bias = nn.Linear(ray_hidden_dim, 25) self.fc_2_weights = nn.Linear(ray_hidden_dim, (1 * 25)) self.fc_2_bias = nn.Linear(ray_hidden_dim, 1) def forward(self, ray): x = self.ray_mlp(ray) out_dict = {'fc0.weights': self.fc_0_weights(x).reshape(60, self.feature_dim), 'fc0.bias': self.fc_0_bias(x), 'fc1.weights': self.fc_1_weights(x).reshape(25, 60), 'fc1.bias': self.fc_1_bias(x), 'fc2.weights': self.fc_2_weights(x).reshape(1, 25), 'fc2.bias': self.fc_2_bias(x)} return out_dict
class FCPHNTarget(nn.Module): def forward(self, x, weights): x = F.linear(x, weight=weights['fc0.weights'], bias=weights['fc0.bias']) x = F.relu(x) x = F.linear(x, weight=weights['fc1.weights'], bias=weights['fc1.bias']) x = F.relu(x) x = F.linear(x, weight=weights['fc2.weights'], bias=weights['fc2.bias']) return {'logits': x}
class HypernetMethod(BaseMethod): def __init__(self, objectives, dim, n_test_rays, alpha, internal_solver, **kwargs): self.objectives = objectives self.n_test_rays = n_test_rays self.alpha = alpha self.K = len(objectives) if (len(dim) == 1): hnet = FCPHNHyper(dim, ray_hidden_dim=100) net = FCPHNTarget() elif (len(dim) == 3): hnet: nn.Module = LeNetPHNHyper([9, 5], ray_hidden_dim=100) net: nn.Module = LeNetPHNTargetWrapper([9, 5]) else: raise ValueError(f'Unkown dim {dim}, expected len 1 or len 3') print('Number of parameters: {}'.format(num_parameters(hnet))) self.model = hnet.cuda() self.net = net.cuda() if (internal_solver == 'linear'): self.solver = LinearScalarizationSolver(n_tasks=len(objectives)) elif (internal_solver == 'epo'): self.solver = EPOSolver(n_tasks=len(objectives), n_params=num_parameters(hnet)) def step(self, batch): if (self.alpha > 0): ray = torch.from_numpy(np.random.dirichlet([self.alpha for _ in range(len(self.objectives))], 1).astype(np.float32).flatten()).cuda() else: alpha = torch.empty(1).uniform_(0.0, 1.0) ray = torch.tensor([alpha.item(), (1 - alpha.item())]).cuda() img = batch['data'] weights = self.model(ray) batch.update(self.net(img, weights)) losses = torch.stack([o(**batch) for o in self.objectives]) ray = ray.squeeze(0) loss = self.solver(losses, ray, list(self.model.parameters())) loss.backward() return loss.item() def eval_step(self, batch): self.model.eval() test_rays = circle_points(self.n_test_rays, dim=self.K) logits = [] for ray in test_rays: ray = torch.from_numpy(ray.astype(np.float32)).cuda() ray /= ray.sum() weights = self.model(ray) logits.append(self.net(batch['data'], weights)) return logits
class Solver(): def __init__(self, n_tasks): super().__init__() self.n_tasks = n_tasks @abstractmethod def get_weighted_loss(self, losses, ray, parameters=None, **kwargs): pass def __call__(self, losses, ray, parameters, **kwargs): return self.get_weighted_loss(losses, ray, parameters, **kwargs)
class LinearScalarizationSolver(Solver): 'For LS we use the preference ray to weigh the losses\n ' def __init__(self, n_tasks): super().__init__(n_tasks) def get_weighted_loss(self, losses, ray, parameters=None, **kwargs): return (losses * ray).sum()
class EPOSolver(Solver): 'Wrapper over EPO\n ' def __init__(self, n_tasks, n_params): super().__init__(n_tasks) self.solver = EPO(n_tasks=n_tasks, n_params=n_params) def get_weighted_loss(self, losses, ray, parameters=None, **kwargs): assert (parameters is not None) return self.solver.get_weighted_loss(losses, ray, parameters)
class EPO(): def __init__(self, n_tasks, n_params): self.n_tasks = n_tasks self.n_params = n_params def __call__(self, losses, ray, parameters): return self.get_weighted_loss(losses, ray, parameters) @staticmethod def _flattening(grad): return torch.cat(tuple((g.reshape((- 1)) for (i, g) in enumerate(grad))), axis=0) def get_weighted_loss(self, losses, ray, parameters): lp = ExactParetoLP(m=self.n_tasks, n=self.n_params, r=ray.cpu().numpy()) grads = [] for (i, loss) in enumerate(losses): g = torch.autograd.grad(loss, parameters, retain_graph=True) flat_grad = self._flattening(g) grads.append(flat_grad.data) G = torch.stack(grads) GG_T = (G @ G.T) GG_T = GG_T.detach().cpu().numpy() numpy_losses = losses.detach().cpu().numpy() try: alpha = lp.get_alpha(numpy_losses, G=GG_T, C=True) except Exception as excep: print(excep) alpha = None if (alpha is None): alpha = (ray / ray.sum()).cpu().numpy() alpha *= self.n_tasks alpha = torch.from_numpy(alpha).to(losses.device) weighted_loss = torch.sum((losses * alpha)) return weighted_loss
class ExactParetoLP(object): 'modifications of the code in https://github.com/dbmptr/EPOSearch\n ' def __init__(self, m, n, r, eps=0.0001): cvxopt.glpk.options['msg_lev'] = 'GLP_MSG_OFF' self.m = m self.n = n self.r = r self.eps = eps self.last_move = None self.a = cp.Parameter(m) self.C = cp.Parameter((m, m)) self.Ca = cp.Parameter(m) self.rhs = cp.Parameter(m) self.alpha = cp.Variable(m) obj_bal = cp.Maximize((self.alpha @ self.Ca)) constraints_bal = [(self.alpha >= 0), (cp.sum(self.alpha) == 1), ((self.C @ self.alpha) >= self.rhs)] self.prob_bal = cp.Problem(obj_bal, constraints_bal) obj_dom = cp.Maximize(cp.sum((self.alpha @ self.C))) constraints_res = [(self.alpha >= 0), (cp.sum(self.alpha) == 1), ((self.alpha @ self.Ca) >= (- cp.neg(cp.max(self.Ca)))), ((self.C @ self.alpha) >= 0)] constraints_rel = [(self.alpha >= 0), (cp.sum(self.alpha) == 1), ((self.C @ self.alpha) >= 0)] self.prob_dom = cp.Problem(obj_dom, constraints_res) self.prob_rel = cp.Problem(obj_dom, constraints_rel) self.gamma = 0 self.mu_rl = 0 def get_alpha(self, l, G, r=None, C=False, relax=False): r = (self.r if (r is None) else r) assert (len(l) == len(G) == len(r) == self.m), 'length != m' (rl, self.mu_rl, self.a.value) = adjustments(l, r) self.C.value = (G if C else (G @ G.T)) self.Ca.value = (self.C.value @ self.a.value) if (self.mu_rl > self.eps): J = (self.Ca.value > 0) if (len(np.where(J)[0]) > 0): J_star_idx = np.where((rl == np.max(rl)))[0] self.rhs.value = self.Ca.value.copy() self.rhs.value[J] = (- np.inf) self.rhs.value[J_star_idx] = 0 else: self.rhs.value = np.zeros_like(self.Ca.value) self.gamma = self.prob_bal.solve(solver=cp.GLPK, verbose=False) self.last_move = 'bal' else: if relax: self.gamma = self.prob_rel.solve(solver=cp.GLPK, verbose=False) else: self.gamma = self.prob_dom.solve(solver=cp.GLPK, verbose=False) self.last_move = 'dom' return self.alpha.value
def mu(rl, normed=False): if len(np.where((rl < 0))[0]): raise ValueError(f'''rl<0 rl={rl}''') m = len(rl) l_hat = (rl if normed else (rl / rl.sum())) eps = np.finfo(rl.dtype).eps l_hat = l_hat[(l_hat > eps)] return np.sum((l_hat * np.log((l_hat * m))))
def adjustments(l, r=1): m = len(l) rl = (r * l) l_hat = (rl / rl.sum()) mu_rl = mu(l_hat, normed=True) a = (r * (np.log((l_hat * m)) - mu_rl)) return (rl, mu_rl, a)
def get_d_paretomtl_init(grads, losses, preference_vectors, pref_idx): ' \n calculate the gradient direction for ParetoMTL initialization \n\n Args:\n grads: flattened gradients for each task\n losses: values of the losses for each task\n preference_vectors: all preference vectors u\n pref_idx: which index of u we are currently using\n \n Returns:\n flag: is a feasible initial solution found?\n weight: \n ' flag = False nobj = losses.shape current_pref = preference_vectors[pref_idx] w = (preference_vectors - current_pref) gx = torch.matmul(w, (losses / torch.norm(losses))) idx = (gx > 0) active_constraints = w[idx] if (torch.sum(idx) <= 0): flag = True return (flag, torch.zeros(nobj)) if (torch.sum(idx) == 1): sol = torch.ones(1).cuda().float() else: gx_gradient = torch.matmul(active_constraints, grads) (sol, nd) = MinNormSolver.find_min_norm_element([[gx_gradient[t]] for t in range(len(gx_gradient))]) sol = torch.Tensor(sol).cuda() weight = torch.matmul(sol, active_constraints) return (flag, weight)
def get_d_paretomtl(grads, losses, preference_vectors, pref_idx): '\n calculate the gradient direction for ParetoMTL \n \n Args:\n grads: flattened gradients for each task\n losses: values of the losses for each task\n preference_vectors: all preference vectors u\n pref_idx: which index of u we are currently using\n ' current_weight = preference_vectors[pref_idx] rest_weights = preference_vectors w = (rest_weights - current_weight) gx = torch.matmul(w, (losses / torch.norm(losses))) idx = (gx > 0) if (torch.sum(idx) <= 0): (sol, nd) = MinNormSolver.find_min_norm_element_FW([[grads[t]] for t in range(len(grads))]) return torch.tensor(sol).cuda().float() else: vec = torch.cat((grads, torch.matmul(w[idx], grads))) (sol, nd) = MinNormSolver.find_min_norm_element([[vec[t]] for t in range(len(vec))]) sol = torch.Tensor(sol).cuda() n = preference_vectors.shape[1] weights = [] for i in range(n): weight_i = (sol[i] + torch.sum(torch.stack([(sol[j] * w[idx][((j - n), i)]) for j in torch.arange(n, (n + torch.sum(idx)))]))) weights.append(weight_i) weight = torch.stack(weights) return weight
class ParetoMTLMethod(BaseMethod): def __init__(self, objectives, num_starts, **kwargs): assert (len(objectives) <= 2) self.objectives = objectives self.num_pareto_points = num_starts self.init_solution_found = False self.model = model_from_dataset(method='paretoMTL', **kwargs).cuda() self.pref_idx = (- 1) self.ref_vec = torch.Tensor(circle_points(self.num_pareto_points)).cuda().float() def new_epoch(self, e): if (e == 0): self.pref_idx += 1 reset_weights(self.model) self.init_solution_found = False self.e = e self.model.train() def log(self): return {'train_ray': self.ref_vec[self.pref_idx].cpu().numpy().tolist()} def _find_initial_solution(self, batch): grads = {} losses_vec = [] for i in range(len(self.objectives)): self.model.zero_grad() batch.update(self.model(batch)) task_loss = self.objectives[i](**batch) losses_vec.append(task_loss.data) task_loss.backward() grads[i] = [] private_params = (self.model.private_params() if hasattr(self.model, 'private_params') else []) for (name, param) in self.model.named_parameters(): if ((name not in private_params) and (param.grad is not None)): grads[i].append(Variable(param.grad.data.clone().flatten(), requires_grad=False)) grads_list = [torch.cat([g for g in grads[i]]) for i in range(len(grads))] grads = torch.stack(grads_list) losses_vec = torch.stack(losses_vec) (self.init_solution_found, weight_vec) = get_d_paretomtl_init(grads, losses_vec, self.ref_vec, self.pref_idx) if self.init_solution_found: print('Initial solution found') self.model.zero_grad() for i in range(len(self.objectives)): batch.update(self.model(batch)) task_loss = self.objectives[i](**batch) if (i == 0): loss_total = (weight_vec[i] * task_loss) else: loss_total = (loss_total + (weight_vec[i] * task_loss)) loss_total.backward() return loss_total.item() def step(self, batch): if ((self.e < 2) and (not self.init_solution_found)): return self._find_initial_solution(batch) else: (gradients, obj_values) = calc_gradients(batch, self.model, self.objectives) grads = [torch.cat([torch.flatten(v) for (k, v) in sorted(grads.items())]) for grads in gradients] grads = torch.stack(grads) losses_vec = torch.Tensor(obj_values).cuda() weight_vec = get_d_paretomtl(grads, losses_vec, self.ref_vec, self.pref_idx) normalize_coeff = (len(self.objectives) / torch.sum(torch.abs(weight_vec))) weight_vec = (weight_vec * normalize_coeff) loss_total = None for (a, objective) in zip(weight_vec, self.objectives): logits = self.model(batch) batch.update(logits) task_loss = objective(**batch) loss_total = ((a * task_loss) if (not loss_total) else (loss_total + (a * task_loss))) loss_total.backward() return loss_total.item() def eval_step(self, batch): self.model.eval() return [self.model(batch)]
class SingleTaskMethod(BaseMethod): def __init__(self, objectives, num_starts, **kwargs): self.objectives = objectives if (num_starts > 1): self.task = (- 1) assert ('task_id' not in kwargs) else: assert (num_starts == 1) print(objectives) self.task = (kwargs['task_id'] - 1) for obj in objectives: if (kwargs['task_id'] == int(obj.label_name.replace('labels_', ''))): self.objectives = {kwargs['task_id']: obj} self.model = model_from_dataset(method='single_task', **kwargs).cuda() def model_params(self): return list(self.model.parameters()) def new_epoch(self, e): self.model.train() if (e == 0): self.task += 1 def step(self, batch): batch.update(self.model(batch)) loss = self.objectives[self.task](**batch) loss.backward() return loss.item() def log(self): return {'task': self.task} def eval_step(self, batch, test_rays=None): self.model.eval() with torch.no_grad(): return [self.model(batch)]
class UniformScalingMethod(BaseMethod): def __init__(self, objectives, **kwargs): self.objectives = objectives self.J = len(objectives) self.model = model_from_dataset(method='uniform_scaling', **kwargs).cuda() def model_params(self): return list(self.model.parameters()) def new_epoch(self, e): self.model.train() def step(self, batch): batch.update(self.model(batch)) loss = sum([((1 / self.J) * o(**batch)) for o in self.objectives]) loss.backward() return loss.item() def eval_step(self, batch, test_rays=None): self.model.eval() with torch.no_grad(): return [self.model(batch)]
class MBConvBlock(nn.Module): 'Mobile Inverted Residual Bottleneck Block.\n Args:\n block_args (namedtuple): BlockArgs, defined in utils.py.\n global_params (namedtuple): GlobalParam, defined in utils.py.\n image_size (tuple or list): [image_height, image_width].\n References:\n [1] https://arxiv.org/abs/1704.04861 (MobileNet v1)\n [2] https://arxiv.org/abs/1801.04381 (MobileNet v2)\n [3] https://arxiv.org/abs/1905.02244 (MobileNet v3)\n ' def __init__(self, block_args, global_params, image_size=None): super().__init__() self._block_args = block_args self._bn_mom = (1 - global_params.batch_norm_momentum) self._bn_eps = global_params.batch_norm_epsilon self.has_se = ((self._block_args.se_ratio is not None) and (0 < self._block_args.se_ratio <= 1)) self.id_skip = block_args.id_skip inp = self._block_args.input_filters oup = (self._block_args.input_filters * self._block_args.expand_ratio) if (self._block_args.expand_ratio != 1): Conv2d = get_same_padding_conv2d(image_size=image_size) self._expand_conv = Conv2d(in_channels=inp, out_channels=oup, kernel_size=1, bias=False) k = self._block_args.kernel_size s = self._block_args.stride Conv2d = get_same_padding_conv2d(image_size=image_size) self._depthwise_conv = Conv2d(in_channels=oup, out_channels=oup, groups=oup, kernel_size=k, stride=s, bias=False) image_size = calculate_output_image_size(image_size, s) if self.has_se: Conv2d = get_same_padding_conv2d(image_size=(1, 1)) num_squeezed_channels = max(1, int((self._block_args.input_filters * self._block_args.se_ratio))) self._se_reduce = Conv2d(in_channels=oup, out_channels=num_squeezed_channels, kernel_size=1) self._se_expand = Conv2d(in_channels=num_squeezed_channels, out_channels=oup, kernel_size=1) final_oup = self._block_args.output_filters Conv2d = get_same_padding_conv2d(image_size=image_size) self._project_conv = Conv2d(in_channels=oup, out_channels=final_oup, kernel_size=1, bias=False) self._swish = MemoryEfficientSwish() def forward(self, inputs, drop_connect_rate=None): "MBConvBlock's forward function.\n Args:\n inputs (tensor): Input tensor.\n drop_connect_rate (bool): Drop connect rate (float, between 0 and 1).\n Returns:\n Output of this block after processing.\n " x = inputs if (self._block_args.expand_ratio != 1): x = self._expand_conv(inputs) x = self._swish(x) x = self._depthwise_conv(x) x = self._swish(x) if self.has_se: x_squeezed = F.adaptive_avg_pool2d(x, 1) x_squeezed = self._se_reduce(x_squeezed) x_squeezed = self._swish(x_squeezed) x_squeezed = self._se_expand(x_squeezed) x = (torch.sigmoid(x_squeezed) * x) x = self._project_conv(x) (input_filters, output_filters) = (self._block_args.input_filters, self._block_args.output_filters) if (self.id_skip and (self._block_args.stride == 1) and (input_filters == output_filters)): if drop_connect_rate: x = drop_connect(x, p=drop_connect_rate, training=self.training) x = (x + inputs) return x def set_swish(self, memory_efficient=True): 'Sets swish function as memory efficient (for training) or standard (for export).\n Args:\n memory_efficient (bool): Whether to use memory-efficient version of swish.\n ' self._swish = (MemoryEfficientSwish() if memory_efficient else Swish())
class EfficientNet(nn.Module): "EfficientNet model.\n Most easily loaded with the .from_name or .from_pretrained methods.\n Args:\n blocks_args (list[namedtuple]): A list of BlockArgs to construct blocks.\n global_params (namedtuple): A set of GlobalParams shared between blocks.\n References:\n [1] https://arxiv.org/abs/1905.11946 (EfficientNet)\n Example:\n \n \n import torch\n >>> from efficientnet.model import EfficientNet\n >>> inputs = torch.rand(1, 3, 224, 224)\n >>> model = EfficientNet.from_pretrained('efficientnet-b0')\n >>> model.eval()\n >>> outputs = model(inputs)\n " def __init__(self, blocks_args=None, global_params=None): super().__init__() assert isinstance(blocks_args, list), 'blocks_args should be a list' assert (len(blocks_args) > 0), 'block args must be greater than 0' self._global_params = global_params self._blocks_args = blocks_args bn_mom = (1 - self._global_params.batch_norm_momentum) bn_eps = self._global_params.batch_norm_epsilon image_size = global_params.image_size Conv2d = get_same_padding_conv2d(image_size=image_size) out_channels = round_filters(32, self._global_params) self.stem_out_channels = out_channels self._conv_stem = Conv2d(self.my_in_channels, out_channels, kernel_size=3, stride=2, bias=False) image_size = calculate_output_image_size(image_size, 2) self._blocks = nn.ModuleList([]) for block_args in self._blocks_args: block_args = block_args._replace(input_filters=round_filters(block_args.input_filters, self._global_params), output_filters=round_filters(block_args.output_filters, self._global_params), num_repeat=round_repeats(block_args.num_repeat, self._global_params)) self._blocks.append(MBConvBlock(block_args, self._global_params, image_size=image_size)) image_size = calculate_output_image_size(image_size, block_args.stride) if (block_args.num_repeat > 1): block_args = block_args._replace(input_filters=block_args.output_filters, stride=1) for _ in range((block_args.num_repeat - 1)): self._blocks.append(MBConvBlock(block_args, self._global_params, image_size=image_size)) in_channels = block_args.output_filters out_channels = round_filters(1280, self._global_params) Conv2d = get_same_padding_conv2d(image_size=image_size) self._conv_head = Conv2d(in_channels, out_channels, kernel_size=1, bias=False) self._avg_pooling = nn.AdaptiveAvgPool2d(1) self._dropout = nn.Dropout(self._global_params.dropout_rate) self._fc = nn.Linear(out_channels, self._global_params.num_classes) self._swish = MemoryEfficientSwish() def set_swish(self, memory_efficient=True): 'Sets swish function as memory efficient (for training) or standard (for export).\n Args:\n memory_efficient (bool): Whether to use memory-efficient version of swish.\n ' self._swish = (MemoryEfficientSwish() if memory_efficient else Swish()) for block in self._blocks: block.set_swish(memory_efficient) def extract_endpoints(self, inputs): "Use convolution layer to extract features\n from reduction levels i in [1, 2, 3, 4, 5].\n Args:\n inputs (tensor): Input tensor.\n Returns:\n Dictionary of last intermediate features\n with reduction levels i in [1, 2, 3, 4, 5].\n Example:\n >>> import torch\n >>> from efficientnet.model import EfficientNet\n >>> inputs = torch.rand(1, 3, 224, 224)\n >>> model = EfficientNet.from_pretrained('efficientnet-b0')\n >>> endpoints = model.extract_endpoints(inputs)\n >>> print(endpoints['reduction_1'].shape) # torch.Size([1, 16, 112, 112])\n >>> print(endpoints['reduction_2'].shape) # torch.Size([1, 24, 56, 56])\n >>> print(endpoints['reduction_3'].shape) # torch.Size([1, 40, 28, 28])\n >>> print(endpoints['reduction_4'].shape) # torch.Size([1, 112, 14, 14])\n >>> print(endpoints['reduction_5'].shape) # torch.Size([1, 1280, 7, 7])\n " endpoints = dict() x = self._swish(self._conv_stem(inputs)) prev_x = x for (idx, block) in enumerate(self._blocks): drop_connect_rate = self._global_params.drop_connect_rate if drop_connect_rate: drop_connect_rate *= (float(idx) / len(self._blocks)) x = block(x, drop_connect_rate=drop_connect_rate) if (prev_x.size(2) > x.size(2)): endpoints['reduction_{}'.format((len(endpoints) + 1))] = prev_x prev_x = x x = self._swish(self._conv_head(x)) endpoints['reduction_{}'.format((len(endpoints) + 1))] = x return endpoints def extract_features(self, inputs): 'use convolution layer to extract feature .\n Args:\n inputs (tensor): Input tensor.\n Returns:\n Output of the final convolution\n layer in the efficientnet model.\n ' x = self._swish(self._conv_stem(inputs)) for (idx, block) in enumerate(self._blocks): drop_connect_rate = self._global_params.drop_connect_rate if drop_connect_rate: drop_connect_rate *= (float(idx) / len(self._blocks)) x = block(x, drop_connect_rate=drop_connect_rate) x = self._swish(self._conv_head(x)) return x def forward(self, inputs): "EfficientNet's forward function.\n Calls extract_features to extract features, applies final linear layer, and returns logits.\n Args:\n inputs (tensor): Input tensor.\n Returns:\n Output of this model after processing.\n " x = self.extract_features(inputs) x = self._avg_pooling(x) if self._global_params.include_top: x = x.flatten(start_dim=1) x = self._dropout(x) x = self._fc(x) return x @classmethod def from_name(cls, model_name, in_channels=3, **override_params): "create an efficientnet model according to name.\n Args:\n model_name (str): Name for efficientnet.\n in_channels (int): Input data's channel number.\n override_params (other key word params):\n Params to override model's global_params.\n Optional key:\n 'width_coefficient', 'depth_coefficient',\n 'image_size', 'dropout_rate',\n 'num_classes', 'batch_norm_momentum',\n 'batch_norm_epsilon', 'drop_connect_rate',\n 'depth_divisor', 'min_depth'\n Returns:\n An efficientnet model.\n " cls._check_model_name_is_valid(model_name) (blocks_args, global_params) = get_model_params(model_name, override_params) model = cls(blocks_args, global_params) model._change_in_channels(in_channels) return model @classmethod def from_pretrained(cls, model_name, weights_path=None, advprop=False, in_channels=3, num_classes=1000, **override_params): "create an efficientnet model according to name.\n Args:\n model_name (str): Name for efficientnet.\n weights_path (None or str):\n str: path to pretrained weights file on the local disk.\n None: use pretrained weights downloaded from the Internet.\n advprop (bool):\n Whether to load pretrained weights\n trained with advprop (valid when weights_path is None).\n in_channels (int): Input data's channel number.\n num_classes (int):\n Number of categories for classification.\n It controls the output size for final linear layer.\n override_params (other key word params):\n Params to override model's global_params.\n Optional key:\n 'width_coefficient', 'depth_coefficient',\n 'image_size', 'dropout_rate',\n 'batch_norm_momentum',\n 'batch_norm_epsilon', 'drop_connect_rate',\n 'depth_divisor', 'min_depth'\n Returns:\n A pretrained efficientnet model.\n " model = cls.from_name(model_name=model_name, num_classes=num_classes, **override_params) load_pretrained_weights(model, model_name, weights_path=weights_path, load_fc=(num_classes == 1000), advprop=advprop) model._change_in_channels(in_channels) return model @classmethod def get_image_size(cls, model_name): 'Get the input image size for a given efficientnet model.\n Args:\n model_name (str): Name for efficientnet.\n Returns:\n Input image size (resolution).\n ' cls._check_model_name_is_valid(model_name) (_, _, res, _) = efficientnet_params(model_name) return res @classmethod def _check_model_name_is_valid(cls, model_name): 'Validates model name.\n Args:\n model_name (str): Name for efficientnet.\n Returns:\n bool: Is a valid name or not.\n ' if (model_name not in VALID_MODELS): raise ValueError(('model_name should be one of: ' + ', '.join(VALID_MODELS))) def _change_in_channels(self, in_channels): "Adjust model's first convolution layer to in_channels, if in_channels not equals 3.\n Args:\n in_channels (int): Input data's channel number.\n " if (in_channels != 3): Conv2d = get_same_padding_conv2d(image_size=self._global_params.image_size) out_channels = round_filters(32, self._global_params) self._conv_stem = Conv2d(in_channels, out_channels, kernel_size=3, stride=2, bias=False)
class Swish(nn.Module): def forward(self, x): return (x * torch.sigmoid(x))
class SwishImplementation(torch.autograd.Function): @staticmethod def forward(ctx, i): result = (i * torch.sigmoid(i)) ctx.save_for_backward(i) return result @staticmethod def backward(ctx, grad_output): i = ctx.saved_tensors[0] sigmoid_i = torch.sigmoid(i) return (grad_output * (sigmoid_i * (1 + (i * (1 - sigmoid_i)))))
class MemoryEfficientSwish(nn.Module): def forward(self, x): return SwishImplementation.apply(x)
def round_filters(filters, global_params): 'Calculate and round number of filters based on width multiplier.\n Use width_coefficient, depth_divisor and min_depth of global_params.\n Args:\n filters (int): Filters number to be calculated.\n global_params (namedtuple): Global params of the model.\n Returns:\n new_filters: New filters number after calculating.\n ' multiplier = global_params.width_coefficient if (not multiplier): return filters divisor = global_params.depth_divisor min_depth = global_params.min_depth filters *= multiplier min_depth = (min_depth or divisor) new_filters = max(min_depth, ((int((filters + (divisor / 2))) // divisor) * divisor)) if (new_filters < (0.9 * filters)): new_filters += divisor return int(new_filters)
def round_repeats(repeats, global_params): "Calculate module's repeat number of a block based on depth multiplier.\n Use depth_coefficient of global_params.\n Args:\n repeats (int): num_repeat to be calculated.\n global_params (namedtuple): Global params of the model.\n Returns:\n new repeat: New repeat number after calculating.\n " multiplier = global_params.depth_coefficient if (not multiplier): return repeats return int(math.ceil((multiplier * repeats)))
def drop_connect(inputs, p, training): 'Drop connect.\n Args:\n input (tensor: BCWH): Input of this structure.\n p (float: 0.0~1.0): Probability of drop connection.\n training (bool): The running mode.\n Returns:\n output: Output after drop connection.\n ' assert (0 <= p <= 1), 'p must be in range of [0,1]' if (not training): return inputs batch_size = inputs.shape[0] keep_prob = (1 - p) random_tensor = keep_prob random_tensor += torch.rand([batch_size, 1, 1, 1], dtype=inputs.dtype, device=inputs.device) binary_tensor = torch.floor(random_tensor) output = ((inputs / keep_prob) * binary_tensor) return output
def get_width_and_height_from_size(x): 'Obtain height and width from x.\n Args:\n x (int, tuple or list): Data size.\n Returns:\n size: A tuple or list (H,W).\n ' if isinstance(x, int): return (x, x) if (isinstance(x, list) or isinstance(x, tuple)): return x else: raise TypeError()
def calculate_output_image_size(input_image_size, stride): "Calculates the output image size when using Conv2dSamePadding with a stride.\n Necessary for static padding. Thanks to mannatsingh for pointing this out.\n Args:\n input_image_size (int, tuple or list): Size of input image.\n stride (int, tuple or list): Conv2d operation's stride.\n Returns:\n output_image_size: A list [H,W].\n " if (input_image_size is None): return None (image_height, image_width) = get_width_and_height_from_size(input_image_size) stride = (stride if isinstance(stride, int) else stride[0]) image_height = int(math.ceil((image_height / stride))) image_width = int(math.ceil((image_width / stride))) return [image_height, image_width]
def get_same_padding_conv2d(image_size=None): 'Chooses static padding if you have specified an image size, and dynamic padding otherwise.\n Static padding is necessary for ONNX exporting of models.\n Args:\n image_size (int or tuple): Size of the image.\n Returns:\n Conv2dDynamicSamePadding or Conv2dStaticSamePadding.\n ' if (image_size is None): return Conv2dDynamicSamePadding else: return partial(Conv2dStaticSamePadding, image_size=image_size)
class Conv2dDynamicSamePadding(nn.Conv2d): '2D Convolutions like TensorFlow, for a dynamic image size.\n The padding is operated in forward function by calculating dynamically.\n ' def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1, groups=1, bias=True): super().__init__(in_channels, out_channels, kernel_size, stride, 0, dilation, groups, bias) self.stride = (self.stride if (len(self.stride) == 2) else ([self.stride[0]] * 2)) def forward(self, x): (ih, iw) = x.size()[(- 2):] (kh, kw) = self.weight.size()[(- 2):] (sh, sw) = self.stride (oh, ow) = (math.ceil((ih / sh)), math.ceil((iw / sw))) pad_h = max((((((oh - 1) * self.stride[0]) + ((kh - 1) * self.dilation[0])) + 1) - ih), 0) pad_w = max((((((ow - 1) * self.stride[1]) + ((kw - 1) * self.dilation[1])) + 1) - iw), 0) if ((pad_h > 0) or (pad_w > 0)): x = F.pad(x, [(pad_w // 2), (pad_w - (pad_w // 2)), (pad_h // 2), (pad_h - (pad_h // 2))]) return F.conv2d(x, self.weight, self.bias, self.stride, self.padding, self.dilation, self.groups)
class Conv2dStaticSamePadding(nn.Conv2d): "2D Convolutions like TensorFlow's 'SAME' mode, with the given input image size.\n The padding mudule is calculated in construction function, then used in forward.\n " def __init__(self, in_channels, out_channels, kernel_size, stride=1, image_size=None, **kwargs): super().__init__(in_channels, out_channels, kernel_size, stride, **kwargs) self.stride = (self.stride if (len(self.stride) == 2) else ([self.stride[0]] * 2)) assert (image_size is not None) (ih, iw) = ((image_size, image_size) if isinstance(image_size, int) else image_size) (kh, kw) = self.weight.size()[(- 2):] (sh, sw) = self.stride (oh, ow) = (math.ceil((ih / sh)), math.ceil((iw / sw))) pad_h = max((((((oh - 1) * self.stride[0]) + ((kh - 1) * self.dilation[0])) + 1) - ih), 0) pad_w = max((((((ow - 1) * self.stride[1]) + ((kw - 1) * self.dilation[1])) + 1) - iw), 0) if ((pad_h > 0) or (pad_w > 0)): self.static_padding = nn.ZeroPad2d(((pad_w // 2), (pad_w - (pad_w // 2)), (pad_h // 2), (pad_h - (pad_h // 2)))) else: self.static_padding = nn.Identity() def forward(self, x): x = self.static_padding(x) x = F.conv2d(x, self.weight, self.bias, self.stride, self.padding, self.dilation, self.groups) return x