models/gsn/graph_filters/utils_graph_learning.py

• 2 F821: undefined name 'embedding' (and 1 similar)

  • Undefined name 'embedding':

    161 embedding = torch.cat((embedding, embedding_i),1) if i>0 else embedding_i

  • Undefined name 'onehot':

    185 onehot = torch.cat((onehot, onehot_i), 1) if i>0 else onehot_i
• 1 F401: 'torch.nn.functional as F' imported but unused
  • 2 import torch.nn.functional as F
• 45 W293: blank line contains whitespace
  • 12
  • 24
  • 28
  • 33
  • 49
  • 52
  • 56
  • 89
  • 95
  • 101
  • 119
  • 121
  • 125
  • 135
  • 137
  • 139
  • 141
  • 153
  • 157
  • 166
  • 171
  • 173
  • 175
  • 177
  • 181
  • 186
  • 188
  • 191
  • 194
  • 196
  • 198
  • 200
  • 204
  • 206
  • 212
  • 214
  • 216
  • 221
  • 224
  • 227
  • 240
  • 244
  • 259
  • 261
  • 262
• 26 E501: line too long (94 > 79 characters) (and 16 similar)

  • Line too long (94 > 79 characters):

    19 raise NotImplementedError('Reduction {} not currently implemented.'.format(reduction))

  • Line too long (95 > 79 characters):

    26 index = torch.stack([batch, torch.tensor(list(range(batch.shape[0])), device=x.device)], 0)

  • Line too long (107 > 79 characters):

    27 x_sparse = torch.sparse.FloatTensor(index, x, torch.Size([torch.max(batch)+1, x.shape[0], x.shape[1]]))

  • Line too long (95 > 79 characters):

    35 index = torch.stack([batch, torch.tensor(list(range(batch.shape[0])), device=x.device)], 0)

  • Line too long (107 > 79 characters):

    36 x_sparse = torch.sparse.FloatTensor(index, x, torch.Size([torch.max(batch)+1, x.shape[0], x.shape[1]]))

  • Line too long (91 > 79 characters):

    46 def __init__(self, encoder_name, d_in_features, d_in_encoder, d_out_encoder, **kwargs):

  • Line too long (99 > 79 characters):

    55 # d_in_encoder: number of unique values that will be encoded (size of embedding vocabulary)

  • Line too long (107 > 79 characters):

    82 #-------------- embedding of categorical data (linear projection without bias of one hot encodings)

  • Line too long (103 > 79 characters):

    84 self.encoder = multi_embedding(d_in_encoder, d_out_encoder, kwargs['aggr'], kwargs['init'])

  • Line too long (131 > 79 characters):

    92 full_atom_feature_dims = get_atom_feature_dims() if kwargs['features_scope'] == 'full' else get_atom_feature_dims()[:2]

  • Line too long (132 > 79 characters):

    98 full_bond_feature_dims = get_bond_feature_dims() if kwargs['features_scope'] == 'full' else get_bond_feature_dims()[:2]

  • Line too long (100 > 79 characters):

    118 raise NotImplementedError('Encoder {} is not currently supported.'.format(encoder_name))

  • Line too long (103 > 79 characters):

    128 x = x.float() if self.encoder_name == 'linear' or self.encoder_name == 'mlp' else x.long()

  • Line too long (123 > 79 characters):

    140 #-------------- embedding of multiple categorical features. Summation or concatenation of the embeddings is allowed

  • Line too long (89 > 79 characters):

    161 embedding = torch.cat((embedding, embedding_i),1) if i>0 else embedding_i

  • Line too long (121 > 79 characters):

    165 raise NotImplementedError('multi embedding aggregation {} is not currently supported.'.format(self.aggr))

  • Line too long (89 > 79 characters):

    183 onehot_i = torch.zeros((tensor.shape[0], self.d_in[i]), device=tensor.device)

  • Line too long (92 > 79 characters):

    218 #-------------- This is a way to create a dummy variable that represents self loops.

  • Line too long (119 > 79 characters):

    220 #-------------- Two ways are allowed: extra dummy variable (one hot or embedding) or a vector filled with zeros

  • Line too long (86 > 79 characters):

    230 self.encoder = DiscreteEmbedding('one_hot_encoder', 1, [d_ef+1], None)

  • Line too long (91 > 79 characters):

    237 self.encoder = DiscreteEmbedding('embedding', None, [1], d_ef, aggr='sum')

  • Line too long (84 > 79 characters):

    247 zero_extension = torch.zeros((x_nb.shape[0], 1), device=x_nb.device)

  • Line too long (81 > 79 characters):

    249 x_central = torch.zeros((num_nodes,1), device=x_nb.device).long()

  • Line too long (84 > 79 characters):

    252 x_central = torch.zeros((num_nodes, self.d_out), device=x_nb.device)

  • Line too long (81 > 79 characters):

    255 x_central = torch.zeros((num_nodes,1), device=x_nb.device).long()

  • Line too long (84 > 79 characters):

    258 x_central = torch.zeros((num_nodes, self.d_out), device=x_nb.device)
• 18 E265: block comment should start with '# '
  • 25 #-------------- global sum pooling
  • 34 #-------------- global average pooling
  • 50 #-------------- various different embedding layers
  • 57 #-------------- fill embedding with zeros
  • 62 #-------------- linear pojection
  • 67 #-------------- mlp
  • 77 #-------------- multi hot encoding of categorical data
  • 82 #-------------- embedding of categorical data (linear projection without bias of one hot encodings)
  • 90 #-------------- for ogb: multi hot encoding of node features
  • 96 #-------------- for ogb: multi hot encoding of edge features
  • 102 #-------------- for ogb: embedding of node features
  • 107 #-------------- for ogb: embedding of edge features
  • 112 #-------------- no embedding, use as is
  • 140 #-------------- embedding of multiple categorical features. Summation or concatenation of the embeddings is allowed
  • 217 #-------------- For the neighbor aggregation: central node embedding
  • 218 #-------------- This is a way to create a dummy variable that represents self loops.
  • 219 #-------------- Useful when working with edge features or GSN-e
  • 220 #-------------- Two ways are allowed: extra dummy variable (one hot or embedding) or a vector filled with zeros
• 11 W291: trailing whitespace
  • 8 from ogb.utils.features import get_atom_feature_dims, get_bond_feature_dims
  • 26 index = torch.stack([batch, torch.tensor(list(range(batch.shape[0])), device=x.device)], 0)
  • 35 index = torch.stack([batch, torch.tensor(list(range(batch.shape[0])), device=x.device)], 0)
  • 54 # d_in_features: input feature size (e.g. if already one hot encoded),
  • 70 d_out_encoder,
  • 131 return x.float()
  • 152 self.encoder = nn.ModuleList(self.encoder)
  • 154 return
  • 178 return
  • 201 return
  • 208 return '{}({})'.format(self.__class__.__name__, self.d_out)
• 6 E221: multiple spaces before operator
  • 97 elif encoder_name == 'bond_one_hot_encoder':
  • 99 self.encoder = one_hot_encoder(full_bond_feature_dims)
  • 104 self.encoder = AtomEncoder(d_out_encoder)
  • 108 elif encoder_name == 'bond_encoder':
  • 109 self.encoder = BondEncoder(emb_dim = d_out_encoder)
  • 114 self.encoder = None
• 5 E231: missing whitespace after ','
  • 159 embedding_i = self.encoder[i](tensor[:,i])
  • 161 embedding = torch.cat((embedding, embedding_i),1) if i>0 else embedding_i
  • 184 onehot_i.scatter_(1, tensor[:,i:i+1], 1)
  • 249 x_central = torch.zeros((num_nodes,1), device=x_nb.device).long()
  • 255 x_central = torch.zeros((num_nodes,1), device=x_nb.device).long()
• 4 E225: missing whitespace around operator
  • 39 graph_sizes[graph_sizes==0.0] = 1.0
  • 161 embedding = torch.cat((embedding, embedding_i),1) if i>0 else embedding_i
  • 163 embedding = embedding + embedding_i if i>0 else embedding_i
  • 185 onehot = torch.cat((onehot, onehot_i), 1) if i>0 else onehot_i
• 4 E251: unexpected spaces around keyword / parameter equals

  • Unexpected spaces around keyword / parameter equals (in 2 places):

    109 self.encoder = BondEncoder(emb_dim = d_out_encoder)

  • Unexpected spaces around keyword / parameter equals (in 2 places):

    136 def __init__(self, d_in, d_out, aggr = 'concat', init=None):
• 1 E222: multiple spaces after operator
  • 128 x = x.float() if self.encoder_name == 'linear' or self.encoder_name == 'mlp' else x.long()
• 1 E271: multiple spaces after keyword
  • 98 full_bond_feature_dims = get_bond_feature_dims() if kwargs['features_scope'] == 'full' else get_bond_feature_dims()[:2]