Semantic Graph Neural Networks for Sentiment Analysis: OOP Practice Unifying Dependency Graphs and Abstract Semantic Representations

This article introduces an open-source project aimed at unifying Universal Dependency (UD) graphs and Abstract Meaning Representation (AMR) into a general graph structure, using Relational Graph Convolutional Networks (RGCNs) for sentiment analysis. The project deeply applies object-oriented design patterns to build a scalable system, compares the performance of UD and AMR in sentiment analysis, reveals the limitations of pure structural methods, and proposes improvement directions such as hybrid architectures.

In the field of natural language processing, traditional bag-of-words models and sequence models struggle to capture complex dependencies between words. The rise of Graph Neural Networks (GNNs) provides new ideas for solving this problem. This project is derived from the final assignment of the CSCI5448 course in the Spring 2026 semester at the University of Colorado Boulder, attempting to unify two mainstream semantic graph representations—UD and AMR—into a general graph object and use RGCNs for sentiment analysis.

The project uses the Adapter pattern to create a unified Graph class, converting the heterogeneous interfaces of amrlib (for AMR) and stanza (for UD) into node/edge structures via the Featurizer class; uses the Template pattern to define an abstract Model base class, with the SentimentAnalysis class inheriting it to implement specific logic; encapsulates Model creation using the Factory pattern (model_factory.py); also applies the Strategy pattern (for feature extraction) and Decorator pattern to enhance functionality, ensuring the system is scalable and maintainable.

The Featurizer class is responsible for converting general graphs into PyTorch features: node features include word embeddings, part-of-speech tags, positions, etc.; edge features include source/target node IDs and relation types (partially under development). The core model is RGCN, which can handle multiple types of relational edges (adapting to the syntactic relations of UD graphs). It takes node/edge features as input, learns node representations via multi-layer convolution, and outputs sentiment classification results (negative/positive/neutral). Currently, UD graph support is complete, while AMR graph and edge feature support are still under development.

On the Kaggle sentiment analysis dataset, the UD graph (2000 sentences) achieved an accuracy of 65%, while the AMR graph (1000 sentences) achieved 55%. Analysis found: UD graph nodes correspond to original words, and features directly use compressed word embeddings, making it more suitable for sentiment analysis (specific words are more discriminative than abstract concepts); pure structural methods use static word embeddings, which struggle to capture the dynamic contextual semantics of Transformer models; data scale (1000-2000 sentences) and computational cost restrict performance improvement, especially since AMR parsing is costly.

Reflection: Is sentiment analysis suitable for RGCNs? RGCNs are more suitable for tasks like part-of-speech tagging, relation extraction, and semantic role labeling. Engineering practice: Implemented a command-line interface (custom hyperparameters, viewing historical results, selecting graph types/features), with results saved in CSV (overview) and JSON (detailed) formats; code is modularized (featurizer.py, model_factory.py, etc.), with full unit test coverage.

Future improvements: Migrate to a graphical user interface (GUI); explore hybrid architectures of GNNs and pre-trained language models (e.g., BERT); expand to tasks like part-of-speech tagging and relation extraction; optimize computational efficiency; complete AMR graph and edge feature support. Conclusion: The project demonstrates the application of software engineering practices in NLP, building a clear and scalable codebase. Although its performance does not reach state-of-the-art (SOTA), the insights gained provide guidance for subsequent research, balancing academic research and engineering practice, making it a good entry-level case for GNN+NLP.