圖卷積實戰——文字分類

### Tfidf
vectorizer = TfidfVectorizer(input="content", max_features=None, tokenizer=dummy_fun, preprocessor=dummy_fun)
vectorizer.fit(df_data["c"])df_tfidf = vectorizer.transform(df_data["c"])
df_tfidf = df_tfidf.toarray()
vocab = vectorizer.get_feature_names()
vocab = np.array(vocab)
df_tfidf = pd.DataFrame(df_tfidf,columns=vocab)

### PMI between words
window = 10 # sliding window size to calculate point-wise mutual information between words
names = vocaboccurrences = OrderedDict((name, OrderedDict((name, 0) for name in names)) for name in names)
# Find the co-occurrences:no_windows = 0; print("calculating co-occurences")for l in df_data["c"]:    
for i in range(len(l)-window):        
no_windows += 1        
d = l[i:(i+window)]; 
dum = []       
 for x in range(len(d)):            
for item in d[:x] + d[(x+1):]:                
if item not in dum:                    
occurrences[d[x]][item] += 1; dum.append(item)        
df_occurences = pd.DataFrame(occurrences, columns=occurrences.keys())
df_occurences = (df_occurences + df_occurences.transpose())/2 
## symmetrize it as window size on both sides may not be samedel occurrences
### convert to PMIp_i = df_occurences.sum(axis=0)/no_windows
p_ij = df_occurences/no_windowsdel 
df_occurencesfor col in p_ij.columns:    
p_ij[col] = p_ij[col]/p_i[col]for row in p_ij.index:   
p_ij.loc[row,:] = p_ij.loc[row,:]/p_i[row]
p_ij = p_ij + 1E-9for col in p_ij.columns:   
 p_ij[col] = p_ij[col].apply(lambda x: math.log(x))

def word_word_edges(p_ij):   
 dum = []; word_word = []; counter = 0    
cols = list(p_ij.columns); cols = [str(w) for w in cols]    
for w1 in cols:        
for w2 in cols:            
if (counter % 300000) == 0:               
 print("Current Count: %d; %s %s" % (counter, w1, w2))            
if (w1 != w2) and ((w1,w2) not in dum) and (p_ij.loc[w1,w2] > 0):               
 word_word.append((w1,w2,{"weight":p_ij.loc[w1,w2]})); dum.append((w2,w1))           
 counter += 1   
 return word_word   
 ### Build graphG = nx.Graph()G.add_nodes_from(df_tfidf.index) 
## document nodesG.add_nodes_from(vocab) 
## word nodes### build edges between document-word
 pairsdocument_word = [(doc,w,{"weight":df_tfidf.loc[doc,w]}) for doc in df_tfidf.index for w in df_tfidf.columns]
G.add_edges_from(document_word)
### build edges between word-word 
pairsword_word = word_word_edges(p_ij)G.add_edges_from(word_word)

class gcn(nn.Module):   
 def __init__(self, X_size, A_hat, bias=True): # X_size = num features      
  super(gcn, self).__init__()      
  self.A_hat = torch.tensor(A_hat, requires_grad=False).float()     
   self.weight = nn.parameter.Parameter(torch.FloatTensor(X_size, 330))      
  var = 2./(self.weight.size(1)+self.weight.size(0))     
   self.weight.data.normal_(0,var)   
     self.weight2 = nn.parameter.Parameter(torch.FloatTensor(330, 130))  
      var2 = 2./(self.weight2.size(1)+self.weight2.size(0))     
   self.weight2.data.normal_(0,var2)     
   if bias:         
   self.bias = nn.parameter.Parameter(torch.FloatTensor(330))      
      self.bias.data.normal_(0,var)    
        self.bias2 = nn.parameter.Parameter(torch.FloatTensor(130))     
       self.bias2.data.normal_(0,var2)    
    else:        
    self.register_parameter("bias", None)   
     self.fc1 = nn.Linear(130,66)        
    def forward(self, X): ### 2-layer GCN architecture   
     X = torch.mm(X, self.weight)   
     if self.bias is not None:   
         X = (X + self.bias)    
    X = F.relu(torch.mm(self.A_hat, X))   
     X = torch.mm(X, self.weight2)      
  if self.bias2 is not None:       
     X = (X + self.bias2)    
    X = F.relu(torch.mm(self.A_hat, X))    
    return self.fc1(X)