glam4cm 0.1.0__py3-none-any.whl

glam4cm/downstream_tasks/gnn_node_classification.py

@@ -0,0 +1,103 @@
+import os
+from glam4cm.data_loading.graph_dataset import GraphNodeDataset
+from glam4cm.models.gnn_layers import GNNConv, NodeClassifier
+from glam4cm.downstream_tasks.utils import get_models_dataset
+from glam4cm.tokenization.special_tokens import *
+from glam4cm.trainers.gnn_node_classifier import GNNNodeClassificationTrainer as Trainer
+from glam4cm.utils import merge_argument_parsers, set_seed
+from glam4cm.downstream_tasks.common_args import get_common_args_parser, get_config_params, get_gnn_args_parser
+
+
+def get_parser():
+    common_parser = get_common_args_parser()
+    gnn_parser = get_gnn_args_parser()
+    parser = merge_argument_parsers(common_parser, gnn_parser)
+    return parser
+
+
+def run(args):
+
+    set_seed(args.seed)
+    
+    config_params = dict(
+        min_enr = args.min_enr,
+        min_edges = args.min_edges,
+        remove_duplicates = args.remove_duplicates,
+        reload = args.reload,
+        language = args.language
+    )
+    dataset_name = args.dataset
+
+    dataset = get_models_dataset(dataset_name, **config_params)
+    graph_data_params = get_config_params(args)
+
+    print("Loading graph dataset")
+    graph_dataset = GraphNodeDataset(dataset, **graph_data_params)
+    print("Loaded graph dataset")
+
+    graph_torch_data = graph_dataset.get_torch_dataset()
+
+    num_nodes_label = f"num_nodes_{args.node_cls_label}"
+    assert hasattr(graph_dataset, num_nodes_label), f"Graph dataset does not have attribute {num_nodes_label}"
+    num_classes = getattr(graph_dataset, f"num_nodes_{args.node_cls_label}")
+
+
+    input_dim = graph_torch_data[0].x.shape[1]
+
+    model_name = args.gnn_conv_model
+
+    hidden_dim = args.hidden_dim
+    output_dim = args.output_dim
+    num_conv_layers = args.num_conv_layers
+    num_mlp_layers = args.num_mlp_layers
+    num_heads = args.num_heads
+    residual = True
+    l_norm = args.l_norm
+    dropout = args.dropout
+    aggregation = args.aggregation
+
+    edge_dim = graph_dataset[0].data.edge_attr.shape[1] if args.num_heads else None
+    gnn_conv_model = GNNConv(
+        model_name=model_name,
+        input_dim=input_dim,
+        hidden_dim=hidden_dim,
+        out_dim=output_dim,
+        num_layers=num_conv_layers,
+        num_heads=num_heads,
+        residual=residual,
+        l_norm=l_norm,
+        dropout=dropout,
+        aggregation=aggregation,
+        edge_dim=edge_dim,
+    )
+
+    clf_input_dim = output_dim*num_heads if args.num_heads else output_dim
+    mlp_predictor = NodeClassifier(
+        input_dim=clf_input_dim,
+        hidden_dim=hidden_dim,
+        num_layers=num_mlp_layers, 
+        num_classes=num_classes,
+        bias=True,
+    )
+
+    logs_dir = os.path.join(
+        "logs",
+        dataset_name,
+        "gnn_node_cls",
+        f"{graph_dataset.config_hash}",
+    )
+
+    trainer = Trainer(
+        gnn_conv_model, 
+        mlp_predictor, 
+        graph_torch_data,
+        cls_label=args.node_cls_label,
+        exclude_labels=getattr(graph_dataset, f"node_exclude_{args.node_cls_label}"),
+        lr=args.lr,
+        num_epochs=args.num_epochs,
+        use_edge_attrs=args.use_edge_attrs,
+        logs_dir=logs_dir
+    )
+
+    print("Training GNN Node Classification model")
+    trainer.run()

glam4cm/downstream_tasks/tf_idf_text_classification.py

@@ -0,0 +1,22 @@
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.svm import SVC
+from sklearn.pipeline import make_pipeline
+from sklearn.metrics import classification_report
+
+
+def run(data):
+    X_train, X_test = data['train_nodes'], data['test_nodes']
+    y_train, y_test = data['train_node_classes'], data['test_node_classes']
+
+    pipeline = make_pipeline(TfidfVectorizer(), SVC(kernel='linear'), verbose=True)
+
+    print("Fitting SVM classifier")
+    # Train the model
+    pipeline.fit(X_train, y_train)
+
+    print("Predicting")
+    # Predict on the test set
+    y_pred = pipeline.predict(X_test)
+
+    # Print classification report
+    print(classification_report(y_test, y_pred))

glam4cm/downstream_tasks/utils.py

@@ -0,0 +1,35 @@
+from glam4cm.data_loading.models_dataset import (
+    ArchiMateDataset, 
+    EcoreDataset
+)
+
+
+dataset_to_metamodel = {
+    'modelset': 'ecore',
+    'ecore_555': 'ecore',
+    'mar-ecore-github': 'ecore',
+    'eamodelset': 'ea'
+}
+
+
+def get_metamodel_dataset_type(dataset):
+    return dataset_to_metamodel[dataset]
+
+
+def get_model_dataset_class(dataset_name):
+    dataset_type = get_metamodel_dataset_type(dataset_name)
+    if dataset_type == 'ea':
+        dataset_class = ArchiMateDataset
+    elif dataset_type == 'ecore':
+        dataset_class = EcoreDataset
+    else:
+        raise ValueError(f"Unknown dataset type: {dataset_type}")
+    return dataset_class
+
+
+def get_models_dataset(dataset_name, **config_params):
+    dataset_type = get_metamodel_dataset_type(dataset_name)
+    if dataset_type != 'ea' and 'language' in config_params:
+        del config_params['language']
+    dataset_class = get_model_dataset_class(dataset_name)
+    return dataset_class(dataset_name, **config_params)

glam4cm/downstream_tasks/word2vec_text_classification.py

@@ -0,0 +1,108 @@
+import os
+import fasttext
+from sklearn.svm import SVC
+from sklearn.metrics import classification_report
+from sklearn.preprocessing import LabelEncoder
+import numpy as np
+import torch
+from torch.utils.data import DataLoader, TensorDataset
+
+import torch.nn as nn
+import torch.optim as optim
+
+# Step 4: Train a neural network classifier using the embeddings
+class SimpleNN(nn.Module):
+	def __init__(self, input_dim, output_dim):
+		super(SimpleNN, self).__init__()
+		self.fc1 = nn.Linear(input_dim, 128)
+		self.fc2 = nn.Linear(128, output_dim)
+	
+	def forward(self, x):
+		x = torch.relu(self.fc1(x))
+		x = self.fc2(x)
+		return x
+
+# Step 2: Use the embeddings to transform the dataset
+def get_embeddings(texts, model):
+	embeddings = []
+	for text in texts:
+		words = text.split()
+		word_vectors = [model.get_word_vector(word) for word in words]
+		if word_vectors:
+			embeddings.append(np.mean(word_vectors, axis=0))
+		else:
+			embeddings.append(np.zeros(model.vector_size))
+	return np.array(embeddings)
+
+
+def run(data):
+    sentences = [text.split() for text in data['train_nodes'] + data['test_nodes']]    
+    with open('data.txt', 'w') as f:
+        f.write("\n".join(sentences))
+        
+    word2vec_model = fasttext.train_unsupervised(
+        'data.txt', 
+        dim=128, 
+        ws=5, 
+        minCount=1,
+        epoch=100,
+        lr=0.05, 
+        workers=4
+    )
+    os.remove('data.txt')   
+
+    X_train_embeddings = get_embeddings(data['train_nodes'], word2vec_model)
+    X_test_embeddings = get_embeddings(data['test_nodes'], word2vec_model)
+
+    # Encode labels
+    label_encoder = LabelEncoder()
+    y_train = label_encoder.fit_transform(data['train_node_classes'])
+    y_test = label_encoder.transform(data['test_node_classes'])
+
+    # Step 3: Train an SVM classifier using the embeddings
+    svm_classifier = SVC(kernel='linear')
+    svm_classifier.fit(X_train_embeddings, y_train)
+    y_pred_svm = svm_classifier.predict(X_test_embeddings)
+    print("SVM Classification Report:")
+    print(classification_report(y_test, y_pred_svm))
+
+
+    input_dim = X_train_embeddings.shape[1]
+    output_dim = len(np.unique(y_train))
+
+    model = SimpleNN(input_dim, output_dim)
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.Adam(model.parameters(), lr=0.001)
+
+    # Convert data to PyTorch tensors
+    X_train_tensor = torch.tensor(X_train_embeddings, dtype=torch.float32)
+    y_train_tensor = torch.tensor(y_train, dtype=torch.long)
+    X_test_tensor = torch.tensor(X_test_embeddings, dtype=torch.float32)
+
+    train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
+    train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
+
+    # Train the neural network
+    num_epochs = 10
+    for epoch in range(num_epochs):
+        model.train()
+        for X_batch, y_batch in train_loader:
+            optimizer.zero_grad()
+            outputs = model(X_batch)
+            loss = criterion(outputs, y_batch)
+            loss.backward()
+            optimizer.step()
+        print(f"Epoch {epoch+1}/{num_epochs}, Loss: {loss.item()}")
+
+        # Evaluate the neural network
+        model.eval()
+        with torch.no_grad():
+            outputs = model(X_test_tensor)
+            _, y_pred_nn = torch.max(outputs, 1)
+            y_pred_nn = y_pred_nn.numpy()
+            print("Neural Network Classification Report:")
+            report = classification_report(y_test, y_pred_nn)
+		
+        print(f"Epoch {epoch+1}/{num_epochs}, Loss: {loss.item()}")
+        print(f"Classification Report: {report}")
+		

glam4cm/embeddings/bert.py

@@ -0,0 +1,72 @@
+from transformers import AutoModel, AutoTokenizer
+import torch
+from typing import List, Union
+from glam4cm.embeddings.common import Embedder
+from glam4cm.data_loading.encoding import EncodingDataset
+from torch.utils.data import DataLoader
+from glam4cm.settings import device
+import numpy as np
+
+class BertEmbedder(Embedder):
+    def __init__(self, model_name, ckpt=None):
+        super().__init__(name='BERT')
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModel.from_pretrained(ckpt if ckpt else model_name)
+        self.model.to(device)
+        self.finetuned = bool(ckpt)
+    
+
+    @property
+    def embedding_dim(self) -> int:
+        """
+        Returns the embedding dimension of the model
+        By Running the model on a dummy input and extracting the output shape
+        """
+        with torch.no_grad():
+            dummy_input = self.tokenizer('Hello World!', return_tensors='pt')
+            outputs = self.model(**{k: v.to(device) for k, v in dummy_input.items()})
+            embedding_dim = outputs.last_hidden_state.shape[-1]
+        return embedding_dim
+    
+    def embed(self, text: Union[str, List[str]], aggregate='cls'):
+        torch.cuda.empty_cache()
+        if isinstance(text, str):
+            text = [text]
+            
+        print("Number of Texts: ", len(text))
+
+        dataset = EncodingDataset(self.tokenizer, texts=text, remove_duplicates=False)
+        loader = DataLoader(dataset, batch_size=256)
+
+        embeddings = list()
+        with torch.no_grad():
+            for batch in loader:
+                # Move inputs to device and process
+                input_ids = batch['input_ids'].to(device)
+                attention_mask = batch['attention_mask'].to(device)
+                
+                outputs = self.model(input_ids, attention_mask)
+                
+                # Collect embeddings
+                embeddings.append(outputs.last_hidden_state.cpu().numpy())
+                
+                # Free memory of the batch inputs
+                del input_ids, attention_mask, outputs
+                torch.cuda.empty_cache()  # Clear GPU memory
+                
+
+            # Combine all the embeddings
+            embeddings = np.concatenate(embeddings, axis=0)
+            
+            if aggregate == 'mean':
+                embeddings = np.mean(embeddings, axis=-1)
+            elif aggregate == 'max':
+                embeddings = np.max(embeddings, axis=-1)
+            elif aggregate == 'cls':
+                embeddings = embeddings[:, 0, :]
+            else:
+                raise ValueError(f'Unknown aggregation method: {aggregate}')
+            
+        # print("Embeddings Shape: ", embeddings.shape)
+        assert embeddings.shape[0] == len(text)
+        return embeddings

glam4cm/embeddings/common.py

@@ -0,0 +1,43 @@
+from abc import abstractmethod
+import json
+import os
+from typing import List, Union
+import torch
+from glam4cm.settings import (
+    WORD2VEC_MODEL,
+    TFIDF_MODEL
+)
+
+
+class Embedder:
+    def __init__(self, name: str):
+        self.name = name
+        self.finetuned = False
+
+    @abstractmethod
+    def embed(self, text: Union[str, List[str]], aggregate='mean') -> torch.Tensor:
+        pass
+
+    @property
+    def embedding_dim(self) -> int:
+        pass
+
+
+def get_embedding_model(
+        model_name: str,
+        ckpt: str = None
+    ) -> Embedder:
+    if ckpt:
+        model_name = json.load(open(os.path.join(ckpt, 'config.json')))['_name_or_path']
+        
+    if 'bert' in model_name:
+        from glam4cm.embeddings.bert import BertEmbedder
+        return BertEmbedder(model_name, ckpt)
+    elif WORD2VEC_MODEL in model_name:
+        from glam4cm.embeddings.w2v import Word2VecEmbedder
+        return Word2VecEmbedder()
+    elif TFIDF_MODEL in model_name:
+        from glam4cm.embeddings.tfidf import TfidfEmbedder
+        return TfidfEmbedder()
+    else:
+        raise ValueError(f'Unknown model name: {model_name}')

glam4cm/embeddings/tfidf.py

@@ -0,0 +1,25 @@
+import numpy as np
+from typing import List, Union
+from glam4cm.embeddings.common import Embedder
+from sklearn.feature_extraction.text import TfidfVectorizer
+
+
+class TfidfEmbedder(Embedder):
+    def __init__(self):
+        super().__init__(name='TFIDF')
+        pass
+
+    def train(self, texts: List[str]):
+        print("TFIDFEmbedder: Training TF-IDF model")
+        self.model = TfidfVectorizer()
+        self.model.fit(texts)
+        print("TFIDFEmbedder: Model trained")
+
+    @property
+    def embedding_dim(self) -> int:
+        return len(self.model.get_feature_names_out())
+    
+    def embed(self, text: Union[str, List[str]]):
+        if isinstance(text, str):
+            text = [text]
+        return self.model.transform(text)

glam4cm/embeddings/w2v.py

@@ -0,0 +1,41 @@
+import os
+from typing import List, Union
+from glam4cm.embeddings.common import Embedder
+from glam4cm.settings import W2V_CONFIG
+import numpy as np
+import fasttext
+
+
+class Word2VecEmbedder(Embedder):
+    def __init__(self):
+        super().__init__(name='Word2Vec')
+
+    @property
+    def embedding_dim(self) -> int:
+        return self.model.vector_size
+    
+    def train(self, texts: List[str]):
+        print("Word2VecEmbedder: Training Word2Vec model")
+        texts = [text.split() for text in texts]
+        with open('data.txt', 'w') as f:
+            f.write("\n".join(" ".join(words) for words in texts))
+        self.model = fasttext.train_unsupervised('data.txt', **W2V_CONFIG)
+        os.remove('data.txt')
+        print("Total words in the model:", len(self.model.wv))
+        print("Word2VecEmbedder: Word2Vec model trained")
+    
+    def embed(self, text: Union[str, List[str]]):
+
+        def get_text_embedding(text: str):
+            words = text.split()
+            word_vectors = [self.model.wv[word] for word in words if word in self.model.wv]
+            if word_vectors:
+                return np.mean(word_vectors, axis=0)
+            else:
+                return np.zeros(self.embedding_dim)
+
+        if isinstance(text, str):
+            text = [text]
+        word_vectors = [get_text_embedding(t) for t in text]
+        return np.array(word_vectors)
+        

glam4cm/encoding/encoders.py

@@ -0,0 +1,100 @@
+from sklearn.feature_extraction.text import TfidfVectorizer
+from transformers import AutoTokenizer
+from sklearn.preprocessing import LabelEncoder
+import fasttext
+from scipy.sparse import csr_matrix
+import numpy as np
+from encoding.common import (
+    doc_tokenizer, 
+    SEP
+)
+
+
+class TFIDFEncoder:
+    def __init__(self, X=None):
+        self.encoder = TfidfVectorizer(
+            lowercase=False, tokenizer=doc_tokenizer, min_df=3
+        )
+
+        if X:
+            self.encode(X)
+
+    def encode(self, X):
+        # print('Fitting TFIDF')
+        X_t = self.encoder.fit_transform(X)
+        X_sp = csr_matrix(np.vstack([x.toarray() for x in X_t]))
+        # print('TFIDF Encoded')
+        return X_sp
+
+
+class BertTokenizerEncoder:
+    def __init__(self, name, X=None):
+        self.tokenizer = AutoTokenizer.from_pretrained(name)
+
+        if X:
+            self.encode(X)
+        
+
+    def encode(self, X, batch_encode=False, percentile=100):
+        # print('Tokenizing Bert')
+        tokens = self.tokenizer(X)
+
+        if batch_encode:
+            lengths = [len(i) for i in tokens['input_ids']]
+            size = int(np.percentile(lengths, percentile)) if percentile < 100 else max(lengths)
+            if size > 512:
+                print(f'WARNING: Max size is {size}. Truncating to 512')
+            size = max(size, 512)
+            
+            tokenized_data = self.tokenizer(
+                X, 
+                padding=True, 
+                truncation=True, 
+                max_length=size
+            )
+        else:
+            tokenized_data = self.tokenizer(X)
+        # print('Bert Tokenized')
+
+        return tokenized_data
+
+
+class BertTFIDF:
+    def __init__(self, name, X=None):
+        self.bert = BertTokenizerEncoder(name)
+        self.tfidf = TFIDFEncoder()
+
+        if X:
+            self.encode(X)
+
+    def encode(self, X):
+        X_b = [f"{SEP}".join([str(j) for j in i]) for i in self.bert.encode(X)['input_ids']]
+        X_t = self.tfidf.encode(X_b)
+        return X_t
+
+
+class FasttextEncoder:
+    def __init__(self, model_name, X=None):
+        self.model = fasttext.load_model(model_name)
+        if X:
+            self.encode(X)
+
+    def encode(self, X):
+        def get_sentence_embedding(sentence):
+            return self.model.get_sentence_vector(sentence)
+        
+        # print('Encoding Fasttext')
+        X_t = [" ".join(doc_tokenizer(i)) for i in X]
+        X_t = np.array([get_sentence_embedding(i) for i in X_t])
+        # print('Fasttext Encoded')
+        return X_t
+
+
+class ClassLabelEncoder(LabelEncoder):
+    def __init__(self, y=None) -> None:
+        super().__init__()
+        if y:
+            self.fit(y)
+    
+    def encode(self, y):
+        return self.fit_transform(y)

glam4cm/graph2str/common.py

@@ -0,0 +1,34 @@
+from collections import deque
+import re
+
+
+remove_extra_spaces = lambda txt: re.sub(r'\s+', ' ', txt.strip())
+
+def find_nodes_within_distance(graph, start_node, distance):
+    q, visited = deque(), dict()
+    q.append((start_node, 0))
+    
+    while q:
+        n, d = q.popleft()
+        if d <= distance:
+            visited[n] = d
+            neighbours = [neighbor for neighbor in graph.neighbors(n) if neighbor != n and neighbor not in visited]
+            for neighbour in neighbours:
+                if neighbour not in visited:
+                    q.append((neighbour, d + 1))
+    
+    sorted_list = sorted(visited.items(), key=lambda x: x[1])
+    return sorted_list
+
+
+def get_node_neighbours(graph, start_node, distance):
+    neighbours = find_nodes_within_distance(graph, start_node, distance)
+    max_distance = max(distance for _, distance in neighbours)
+    distance = min(distance, max_distance)
+    return [node for node, d in neighbours if d == distance]
+
+
+def has_neighbours_incl_incoming(graph, node):
+    edges = list(graph.edges(node))
+    edges += list(graph.in_edges(node))
+    return len(edges) != 0

glam4cm/graph2str/constants.py

@@ -0,0 +1,15 @@
+SEP = "[SEP]"
+STEREOTYPE = "[STEREOTYPE]"
+
+e_s = {'rel': 'relates', 'gen': 'generalizes'}
+
+frequent_stereotypes = [
+    'kind', 
+    'subkind', 
+    'phase', 
+    'role', 
+    'category', 
+    'mixin', 
+    'rolemixin', 
+    'phasemixin'
+]