From rules to relationships: how machines learn to understand each other

Communication systems have evolved from simple bit transmission to intelligent information sharing. Traditional systems focus on moving raw data from point A to point B as reliably as possible. Currently, the explosion of machine-to-machine communications in IoT devices, autonomous systems and smart infrastructures hits basic bottlenecks.

Modern networks own unnecessary data. However, the machine does not need all the information that traditional systems send.

Let's take a look at the following security monitoring interactions:

Security camera: Someone walks around restricted areas outside business hours and captures high resolution video frames of size 5 MB

Traditional systems: Sends an entire 5MB frame per bit

Central monitoring: Analyze and determine: “Invalid Persons Detected in Zone A”

In this interaction, the surveillance system primarily cares about security alerts rather than the details of a person's clothing, facial features, or background. But traditional communication is equally important to every pixel, sending millions of unrelated bits with a small number of people important for decision-making.

Semantic communication emerged as a paradigm shift that conveys meaning rather than bits. Instead of sending an entire 5MB video frame, the semantic communications system extracts and sends only “Zone_a, unauthorized_person, threat_level_high” but requires a small portion of the data, while storing information related to all decisions.

The receiving system gets exactly what it takes to make the right decision by zone azonizing security personnel for unauthorized intrusions.

Early systems relied on the Semantic Knowledge Base (SKB) to reduce bandwidth usage without losing the actual meaning of the message.

However, SKB-based systems have limitations. It works well in a controlled environment, but fails when encountering an unknown scenario. This limitation has led to the development of knowledge graph-based semantic communications that promises to resolve unknown situations through relational inference.

Why does SKBS-based semantic communication fail?

The SKB system has a major weakness. To understand that, you first need to see how they handle the information.

In the example of security surveillance, both cameras and surveillance stations maintain a shared knowledge base k = {k_m ∈R^d}_{m∈M}Here, each k_m Represents the semantic attribute of category m. If the security camera captures video frame X, the semantic encoder S_α(in) extraction feature s∈R^d.

Instead of sending “s” directly, the system uses cosine similarity to find the closest match.

Here, d(s,k_m) represents the similarity of the cosines of S and K_m.

In this example, the camera looks at someone in a restricted area and extracts features such as “human shape, uniformity, nighttime movements.” Comparing these to the knowledge base, we can see that they are “Unauthorized_Person” in the knowledge base Index V. Instead of sending out all the feature details, you just send “V”.

This simple approach significantly reduces bandwidth usage while storing all the information the surveillance system needs to make decisions.

Where does this break?

The system works well until something unexpected appears. What happens when the camera finds something that is not in the knowledge base?

Let's take a look at the following example:

Security camera: Find workwear maintenance workers who carry tools outside of business hours.

SKB System: Only know “unautorized_person”, “authorized_person”, “ver”, “animal”

System decision: Confidently classify workers as “Unauthorized_person” with high threat level

result: False report – Security team dispatched to stop legitimate maintenance work

The mathematics behind this may seem simple, but they are actually very problematic. The system always selects the “best” match, even if all options are terrible. It's like being forced to select an answer in a multi-choice test if the choice makes no sense. You still need to choose something and the system doesn't know.

These issues get worse in real developments. For example, if the training data does not contain shadows, the system will start calling them “intruders.” If you train without the example of winter clothing, you consider a heavy coat to be “suspecting gear.” The system never acknowledges uncertainty. Even if you're completely wrong, you're always confident.

How does the Knowledge Graph fix this?

Knowledge graph-based semantic communication resolves SKB limitations by encoding relationships between nodes rather than merely separate categories. Instead of asking, “Which category does this category match?” it asks, “How does this have anything to do with what I already know?”

Let's walk through the example maintenance worker and see the difference.

Step 1: Detection and Feature Extraction
The camera detects the same features as before, such as “human shapes, work clothes, mobile phones, and timing outside business hours.”

Step 2: Relationship Mapping
Instead of enforcing these features into a single category, the Knowledge Graph maps them to multiple connected nodes.

Human Shape → Trigger “Human” node
Workwear + Tools → trigger work_tools and maintenance_equipment nodes
Timing outside business hours → trigger “anual_access_time” node

Step 3: Relationship Traversal
To track connections between nodes, the system uses the following formula:

Here is “Z”_v' indicates an updated representation of node V, and the sum aggregates information from all adjacent nodes u. Each node picks up its meaning from its connected neighborhood.

work_tools →View →Mainatement_activity
Maintenance_Activity→performed_by→maintenation_worker
Maintenation_Worker→IS_A→Authorized_Personnel (conditionally)
off_hours_access + authorized_personnel→→validation required

Step 4: Contextual reasoning
The Knowledge Graph combines these relationship paths. “This looks like a maintenance activity by a potentially licensed personnel, but at timing, verification is required before determining the threat level.”

The final classification is done using the following formula:

where ŷ is the predicted category, φ(y) is the knowledge graph embedded in category y, and ŝ is the received semantic information. This will “verify before the alarm” instead of SKB's forced “invalidator” classification.

Important differences

The difference from the example maintenance worker is that the SKB system is forced to look at “people in restricted areas outside of business hours” and choose from existing categories. In this example, I chose “Unauthorized_person” because the system is the closest match.

Knowledge graph-based systems take a completely different approach. It sees the same person, but starts connecting the dots. Working tools carryrs usually suggest maintenance activities that serve legitimate purposes. However, what happens outside of business hours means that verification is required first. The system generates a smart response – “Check before the alarm.” The system was not trained for this scenario, but it was possible to infer using relational graphs.

evaluation

The Knowledge Graph System showed significant improvement over the SKB-based system, with 70-80% accuracy in both familiar and unfamiliar environments. The system has proven to work well even when signal quality is not high, and it can actually work in real-world situations where communication is noisy.

However, the Knowledge Graph System has its own limitations. Graph building requires domain expertise and critical computing power. Our tests were limited to specific datasets with given categories, so we don't know how they work in large real-world deployments. These systems require more testing before completely replacing SKB-based systems.

Conclusion

The SKB system was great when everything was predictable, but failed in unfamiliar environments. Knowledge Graph solves this problem by truly understanding how nodes connect to each other. This allows the system to infer through unfamiliar environments through these connections, rather than requiring explicit training in any situation. They are difficult to build and more expensive, but are suitable for real scenarios.