EE_cross_domain

Event Extraction Annotation Interface

Overview

This is a comprehensive web-based annotation interface for cross-domain event extraction tasks. It allows users to annotate documents using event detection and argument extraction tasks across multiple datasets.

Demostration Video

demo_event_extraction.mp4

Features

Application Features

This section highlights the UI features with placeholders for screenshots captured from the running web_dash_app.py interface. The application guides users from document upload and selection through multi-mode event detection and argument extraction, with combined visualizations to compare outputs. It also supports complete end-to-end extraction and schema-aware result saving across datasets.

Document Ingestion and Selection

• Upload JSON or JSONL files and review load status.
• Select documents from a dropdown with text previews.

Event Detection (Stage 1)

• Run trigger detection across pipeline, e2e, and merged modes.
• Compare mode outputs with tabs, badges, and character offsets.

Argument Extraction (Stage 2)

• Extract arguments from detected triggers with role labels.
• Review event cards and structured argument lists per mode.

Combined Annotation View

• Visualize triggers and arguments together with consistent event colors.
• Compare modes with tabbed views.

Complete End-to-End Extraction

• Run complete e2e extraction in one step.
• Inspect both combined annotations and event cards.

Saving Results Across Schemas

• Save stage 1/2 and complete e2e outputs with schema-aware labels.
• Continue annotating the same document across datasets.

1. File Upload

• Upload JSON files containing document strings
• Expected format: {"documents": [{"id": "doc1", "text": "..."}, ...]}
• Supports batch processing of multiple documents

2. Dataset (Event Schema) Selection

• Choose from 6 datasets:
  • geneva: General semantic event frames covering 120+ event types (communication, movement, conflict, commerce, change of state, etc.) based on FrameNet-style semantics
  • wikievents: Hierarchical event schema with 50+ event types across categories of Battle, Revolution, Revolt, Campaign, etc from Wikipedia text.
  • casie: Cybersecurity incidents, focusing on five event types: Databreach, Phishing, Ransom, Discover, and Patch.
  • genia2013: Biomedical events
  • m2e2: Multimedia events
  • rams: News events

3. Model Type Selection

• Domain-Specific: Individual models trained per dataset
• Cross-Domain: Single model trained on all 6 datasets

4. Multi-Stage Workflow

Stage 1: Event Detection

Detect and classify event triggers with three modes:

• Pipeline Mode: Trigger Identification -> Classification (sequential)
• E2E Mode: Joint trigger identification and classification
• Merged Mode: Combines results from both pipeline and e2e modes

Results are displayed with:

• Trigger text highlighting in the source document
• Event type badges
• Character offset information

Stage 2: Argument Extraction

Extract event arguments based on detected triggers:

• Arguments shown with role labels
• Color-coded highlights for different argument roles
• Support for arguments from different detection modes

Stage 3: Multi-Dataset Annotation

• After validation, seamlessly switch to another dataset
• Annotate the same document with different dataset schemas
• Save results for multiple datasets hierarchically

5. Result Saving

Results are saved with hierarchical structure:

{
  "doc_id": "...",
  "source": "...",
  "events": {
    "geneva": {
      "pipeline": [{"trigger": {...}, "arguments": [...]}, ...],
      "e2e": [...],
      "merged": [...]
    },
    "m2e2": {
      "pipeline": [...],
      "e2e": [...],
      "merged": [...]
    }
  }
}

Installation

Dependencies

pip install dash dash-bootstrap-components transformers torch

Required Files

• web_infer.py: Core inference functions
• pattern_tagprime.py: Event schema definitions
• Trained T5 models in https://huggingface.co/sili03

Running the Application

python web_dash_app.py

The application will start at http://localhost:8050

User Workflow

Step 1: Load Documents

1. Upload a JSON file with documents
2. File should have format: {"documents": [{"id": "...", "text": "..."}, ...]}

Step 2: Configure

1. Select a dataset (e.g., "geneva")
2. Choose model type (domain-specific or cross-domain)

Step 3: Select Document

• Pick a document from the dropdown

Step 4: Run Event Detection

• Click "Run Event Detection"
• View triggers in pipeline mode, e2e mode, and merged mode
• Highlighted text shows where triggers were found

Step 5: Validate & Extract Arguments

• Click "Validate & Extract Arguments"
• Review argument extraction results
• Argument roles are color-coded

Step 6: Save Results

Two options:

• Save & Switch Dataset: Save current results and annotate the same document with a different dataset
• Save & Finish: Complete annotation and save all results

Key Features

Visual Highlighting

• Yellow: Pipeline mode triggers
• Blue: E2E mode triggers
• Green: Merged mode triggers
• Colored underlines: Argument roles (auto-assigned from palette)

Smart Result Display

• Triggers shown in multiple tabs (pipeline/e2e/merged)
• Events grouped with their triggers and arguments
• Offset information for debugging

Model Caching

• Models are cached in memory to avoid reloading
• Efficient for processing multiple documents

GPU Capacity Planning (T5-Base)

Assumptions used for the table below:

• T5-Base has 220M parameters
• FP32 weights only ($4$ bytes/parameter)
• Storage and inference GPU memory are weights-only (no activation buffers)

Per-model weight size (FP32): $$ 220\text{M} \times 4\text{ bytes} \approx 0.82\text{ GiB} $$

If you plan to run larger batch sizes or longer sequences, add extra headroom for activations.

Error Handling

• Model not found errors with helpful messages
• Graceful handling of empty predictions
• Detailed error messages for debugging

Output Format

Results are saved in JSON with the following structure:

{
  "doc_id": "unique_document_id",
  "source": "original_text",
  "events": {
    "dataset_name": {
      "pipeline": [
        {
          "trigger": {
            "text": "word",
            "type": "EventType",
            "offset": [start, end]
          },
          "arguments": [
            {
              "text": "arg_text",
              "role": "Role",
              "offset": [start, end]
            }
          ]
        }
      ],
      "e2e": [...],
      "merged": [...]
    }
  }
}

Configuration

Model Paths

Model paths are configured in MODEL_PATHS within web_dash_app.py and are resolved in get_model_path().

• Cross-domain key: cross-domain
• Domain-specific keys: geneva, wikievents, casie, genia2013, m2e2, rams

Integration with infer.py

The application uses these functions from infer.py:

• run_single_inference_event_detection(): Run trigger detection
• parse_and_merge_single_inference_event_detection_results(): Parse and merge results
• run_single_inference_event_argument_extraction(): Extract arguments
• structure_argument_extraction_pipeline_predictions(): Structure argument results

Example Model Loading Output

Loading model: domain-specific from sili03/EE_geneva
config.json: 1.47kB [00:00, 6.70MB/s]
model.safetensors: 100%|#############################| 892M/892M [00:09<00:00, 95.9MB/s]
generation_config.json: 100%|###########################| 152/152 [00:00<00:00, 1.53MB/s]