Algorithm for Semantic Network Generation from Texts of Low Resource Languages Such as Kiswahili

Barack Wamkaya Wanjawa; Evans Miriti; Lawrence Muchemi

REVIEW 5 major objections 6 minor 4 references

Algorithm for Semantic Network Generation from Texts of Low Resource Languages Such as Kiswahili

T0 review · 5 major / 6 minor · reviewed 2026-08-10 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read A purely rule-based algorithm maps Kiswahili's subject-verb-object sentences into semantic-network triples from part-of-speech tags alone, and the resulting network answers sampled Swahili questions with up to 78.6% exact match, with no…

desk verdict A clearly specified rule-based triple extractor for Swahili, but the headline QA numbers rest on an unspecified question-to-query step. read the letter →

arxiv 2501.09326 v1 pith:U35W5FEI submitted 2025-01-16 cs.CL

Barack Wamkaya Wanjawa , Lawrence Muchemi , Evans Miriti This is my paper · ORCID

classification cs.CL

keywords algorithmlow-resourcelanguagesKiswahilisemanticnetworksquestionansweringpart-of-speechtaggingrule-basedsystemSVOwordorder

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper proposes a rule-based algorithm that turns raw Kiswahili text into a semantic network without any training data, using only part-of-speech tags. The claim is that because Kiswahili sentences follow a subject-verb-object order, each verb can anchor a mapping into subject-predicate-object triples, the same shape as a semantic network triple. The authors test the generated networks on three Swahili question-answering sets, reporting exact match scores of 63.7%, 64.8%, and 78.6%, the last on the KenSwQuAD dataset. The point of the work is to show that low-resource languages can be structured for machine processing through language-structure rules rather than large annotated corpora.

What carries the argument

The load-bearing mechanism is an SVO-to-SPO rule set anchored on the verb. For each sentence, the algorithm tags parts of speech, finds each verb, lists every noun to its left as a subject candidate and every noun to its right as an object candidate, then emits all left-noun plus verb plus right-noun combinations as triples; when no verb is present, it applies fallback rules such as noun-'is-a'-noun. This Cartesian-product step is what generates the semantic network, and it is also the main source of spurious triples when named entities or long phrases are split into separate nouns.

What would settle it

A concrete check: run the algorithm on a set of fifty Kiswahili contexts from the TyDiQA gold set, list every emitted triple, and have native speakers label each one as a valid fact or a spurious pairing. If the majority of triples are spurious yet exact-match QA still reaches the reported 78.6%, then the paper's account of how the network answers questions is incomplete; if the majority are valid, the Cartesian-product rule is doing the work the paper claims.

Watch

Extended reading notes

Core claim

The paper shows that a semantic network for Kiswahili can be generated from raw text by finding each verb, collecting all nouns on the left and right of the verb, and forming the Cartesian product of those nouns into subject-predicate-object triples, with additional 'is-a' rules for noun-noun phrases. The resulting RDF triples can be queried with SPARQL, and the paper reports that this network supports question answering: 287 of 365 sampled KenSwQuAD questions answered exactly (78.6% exact match). The authors argue that this demonstrates that part-of-speech tags alone, without word embeddings or trained models, are sufficient to create a usable knowledge structure for a low-resource SVO language.

Load-bearing premise

The algorithm assumes that any noun to the left of a verb and any noun to the right of it can be stitched together into a true fact, even though real sentences contain named entities, pronouns, and clauses that do not pair that way.

Editorial extensions

If this is right

A POS tagger, not training data, is the only language resource needed to build a queryable semantic network for an SVO low-resource language.
The generated RDF triple store can be queried with SPARQL, so the structured output can plug into existing linked-data tooling.
Question answering from the network is strong on factual lookup questions such as who, what, where, and when, and weak on explanatory questions such as define and why, matching the paper's per-type results.
Adapting the rules to SOV-type languages should be possible, extending the method beyond Kiswahili.
Named-entity decomposition and coreference gaps leave the network noisy and partially disconnected, so better preprocessing tools would likely raise accuracy.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

Beyond the paper, publishing the full triple lists with false-triple counts would let others see how much noise the Cartesian-product step produces and how much the SPARQL queries tolerate.
Beyond the paper, replacing the missing named-entity and coreference resolution with a small resolver would provide a direct test of whether spurious triples are the main limitation on accuracy.
Beyond the paper, the same rule set should transfer to other SVO low-resource languages that have a POS tagger, turning the claim from a Kiswahili-specific result into a general method.
Beyond the paper, the near-zero scores on 'define' and 'why' questions suggest the semantic network is best used as a fact retriever feeding a separate reasoning component rather than as a complete question-answering system.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Read this one for the algorithm description, not for the 78.6% claim. The paper gives a concrete, step-by-step procedure for converting Kiswahili text into RDF triples using POS tags, with a worked Chelsea example and honest discussion of failure modes (named entity splitting, coreference, comma ambiguity). That is a real engineering contribution for low-resource languages, and the authors don't hide the limitations.

The soft spot is the QA evaluation, and it's load-bearing. To answer questions from the generated network, you need a mechanism that turns a natural-language question into a SPARQL query. The paper never specifies this. The one example query in Section 3.4 is hand-written, with manual choices of concepts (e.g., :chelsea, :mwaka) that look tailored to the known answer. Sections 3.5 report 35/54 and 287/365 exact matches with no description of how those queries were produced. If those were also hand-crafted per question, the accuracy is measuring the query writer, not the algorithm. This is a bigger problem than the Cartesian-product noise, because a human query writer can work around noisy triples.

The other weaknesses are in proportion. The samples are small and purposive. The POS tagger used in experiments isn't identified (the paper points to an online tool in the example but doesn't say which one produced the reported numbers). No code or data is shipped, so nothing is independently checkable. KenSwQuAD is the authors' own dataset, and the approach builds on their own prior model, which is fine as long as the evaluation pipeline is transparent—but here it isn't.

What holds up: the core SVO-to-SPO mapping idea is straightforward and the algorithm as written does generate triples; the authors' admission that explanatory questions (define, why) score 0 and that NER is unsolved is refreshingly direct. This is not a deceptive paper; it's an under-validated one.

Who should read it: people working on rule-based/low-resource NLP who want a starting point for POS-driven triple extraction. It deserves a serious referee because the problem is relevant and the method is described in enough detail to be tested, but the revision must specify the query generation, release code and data, and report error rates from the triple extraction itself. Right now the headline result is not reproducible.

Referee Report

5 major / 6 minor

Summary. The paper proposes a rule-based algorithm that uses part-of-speech (POS) tags to convert raw Kiswahili text, which has subject-verb-object (SVO) structure, into RDF semantic-network triples with subject-predicate-object (SPO) structure. The algorithm anchors on the verb, collects all nouns on its left and right, forms Cartesian-product triples, and adds supplementary rules for constructions such as 'is-a'. The authors report QA experiments on Tusome, TyDiQA, and KenSwQuAD, with the headline result being 78.6% exact match on a purposive sample of 365 KenSwQuAD questions, with no training data for the semantic network generation. The paper also provides a worked example, per-question-type accuracy tables, and an explicit list of limitations including named-entity splitting and coreference failures.

Significance. If substantiated, the work would offer a training-data-free pipeline for structuring low-resource-language text and supporting simple entity-lookup question answering. The paper gives an explicit algorithm listing, a concrete example of generated triples, and an honest discussion of limitations such as named-entity decomposition and comma ambiguity. However, the central QA claim is currently not attributable to the proposed algorithm: the question-to-SPARQL translation step is unspecified, the evaluation uses small purposive samples with no baselines, and the main benchmark was created by the same authors. The contribution is best regarded as a preliminary demonstration, not a fully validated method.

major comments (5)

[§3.4–3.5] The exact-match results in Tables 2 and 3 cannot be attributed to the proposed algorithm because the paper never specifies how natural-language questions are converted into SPARQL queries. Section 3.4 presents a single hand-written query with UNION patterns and manually chosen concept URIs (:chelsea, :mwaka), but the 54 TyDiQA and 365 KenSwQuAD questions are not accompanied by any automated query-generation procedure. If the queries were composed by a human using the visualized graph, the reported 64.8% and 78.6% figures measure the human query writer and the graph, not the SN-generation algorithm alone. A reproducible evaluation requires either a fully specified deterministic question-to-query module or a clear separation of human-authored queries from algorithm-only queries.
[Algorithm lines 22–38] The core extraction step forms the Cartesian product of every noun left of the verb with every noun right of the verb (lines 22–38). The paper acknowledges that this produces spurious triples, as when 'Chelsea Football Club' is decomposed into three separate subjects, each linked to 'club'. However, it does not quantify the proportion of spurious triples, nor does it describe how the QA pipeline selects among the many candidate triples when multiple answers are possible. Without triple-level precision or recall, or a filtering mechanism, the semantic network's quality is unknown and the QA accuracy cannot be interpreted.
[§3.5, Tables 2 and 3] The evaluation uses purposive samples of 33, 54, and 365 questions with no sampling protocol, no confidence intervals, and no baseline comparisons. Table 3 shows that the 'Define/How/Why' category has 0 correct out of 36, and Table 2 also shows 0 for 'Define'. This indicates the system is limited to simple entity lookup, yet the paper's abstract and conclusion frame the QA performance as general evidence of successful structuring. The authors should report how the sample was selected, include simple baselines (e.g., extracting the most frequent date or number from the context, or lexical-overlap retrieval), and qualify the QA claim to entity-lookup questions only.
[§3.5 and §5] The main QA evaluation uses KenSwQuAD (Wanjawa et al., 2023), a dataset created by the same authors, while the algorithm builds on the authors' own prior model (Wanjawa & Muchemi, 2021). This creates a risk of implicit circularity: the rule set and the dataset annotations may share unstated assumptions about Kiswahili structure. The authors should test the algorithm on an independent Swahili QA corpus (e.g., the full TyDiQA test set with a defined query generator, or AfriQA), or at a minimum describe how the development of the rule set was kept independent from the KenSwQuAD annotation scheme.
[§2 and §3.2.1] The paper claims that the method requires 'no training data,' but the algorithm depends on a POS tagger. The POS tagger used in the actual experiments is not identified; the text only mentions an online demo tool (aflat) in the worked example. The choice of tagger and its error rate are load-bearing for the reproducibility of the QA results, because POS errors propagate directly to the generated triples. The authors should name the tagger, its version or model, and report its accuracy on Kiswahili.

minor comments (6)

[Abstract and §5] The phrase 'upto 78.6% exact match' contains a typo and should be 'up to 78.6%'. The claim should also mention the dataset, sample size, and that this is on a purposive sample of 365 questions.
[§3.2.1.1, Table 1] The table entries for T7, T9, and T10 are not self-explanatory: the rows labeled 'N PROPNAME' produce triples with predicate :ni, but it is unclear how the 'is-a' rule maps the copula to :ni and how this differs from the verb-anchored triples in T1–T3.
[§3.4] The SPARQL query uses the concept :mwaka, but the triple-generation example in Table 1 does not show a triple containing :mwaka. The paper should explain how question tokens such as 'mwaka' are lemmatized and linked to nodes in the semantic network, including whether this linking is automatic or manual.
[Algorithm lines 43–46] The rule set in the 'OTHER_RULES' procedure is left open with 'etc.'; the authors should list all implemented rules and their coverage across the test corpora, since these rules produce a substantial fraction of the triples in the worked example.
[References] Several references are incomplete or informal (e.g., 'Wu & Wu, n.d.', 'omniglot, 2021', and the online POS tagger reference). The authors should provide complete bibliographic details and, where possible, archival versions or DOIs.
[Figure 3] The visualization is used as evidence that a connected semantic network is formed, but the figure is not self-contained. It would help to annotate a few of the displayed triples or list them in the caption so that a reader can connect the graph to Table 1.

Circularity Check

0 steps flagged · score 1.0 of 10

No significant circularity: the SN-generation derivation is self-contained; the QA evaluation has an unspecified query step, but that is a reporting/validity gap, not a circular reduction.

full rationale

The paper's derivation chain is: POS tagging -> candidate SVO/SPO triples (Fig. 2) -> RDF store -> SPARQL query -> answer. No equation or fitted parameter makes the output equal to the input by construction. The algorithm's Cartesian-product rule (lines 22-38) is admittedly noisy, but noise is a correctness limitation, not circularity. The main self-citations are (i) the prior Swahili processing model (Wanjawa & Muchemi 2021), which motivates the SVO-anchoring step but is not used as an unverified premise for the reported result; and (ii) the KenSwQuAD dataset (Wanjawa et al. 2023), which is used as an evaluation benchmark, not as a source of fitted parameters. The paper does not show an automated question-to-SPARQL module; the only query exhibited in Section 3.4 is hand-written, and Section 3.5 reports aggregate EM scores without specifying how all queries were generated. This is a serious reproducibility and validity gap in the QA claim, but it does not make the SN-generation result circular: the claimed mapping from POS tags to triples is a deterministic rule set, and the accuracy numbers are not shown to be imposed by the rules themselves. Because the central algorithm is independently describable and testable against external data, the circularity score is low despite the evaluation weaknesses. The acknowledged limitations (named-entity splitting, coreference failures, comma ambiguity) further confirm that the algorithm is not guaranteed to reproduce its inputs, i.e., the QA answers are not definitionally contained in the triples.

Assumptions & free parameters 0 free parameters · 4 assumptions · 0 invented entities

The algorithm is a rule-based system with no numeric free parameters, but it relies on several domain assumptions and an ad hoc Cartesian-product rule for triple generation. No new entities are postulated.

assumptions (4)

domain assumption Kiswahili is an SVO language.
The mapping to SPO triples depends on the claim, cited to Gell-Mann & Ruhlen (2011) and Sánchez-Martínez et al. (2020), that Kiswahili uses subject-verb-object order.
domain assumption A part-of-speech tagger for Kiswahili is available and sufficiently accurate for the rule-based algorithm.
The algorithm requires POS tags for every token; the paper mentions an online tool (aflat) for the example but does not specify which tagger was used in the reported evaluations or its error rate.
ad hoc to paper The Cartesian product of left-side nouns and right-side nouns around a verb yields a usable set of subject-predicate-object triples.
Algorithm lines 22-38 generate all L x R combinations; the paper concedes this fragments named entities and produces spurious triples, yet assumes the noise does not dominate QA answers.
domain assumption Questions can be converted into SPARQL queries that retrieve the correct answer from these triples.
The QA protocol is not described; the worked example uses a handcrafted UNION query, and the generic mapping from question text to queries is never specified.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Algorithm for Semantic Network Generation from Texts of Low Resource Languages Such as Kiswahili." pith.science (2026). https://pith.science/paper/U35W5FEI

@misc{pith2026250109326,
  author       = {Pith},
  title        = {Pith review of: Algorithm for Semantic Network Generation from Texts of Low Resource Languages Such as Kiswahili},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/U35W5FEI}},
  note         = {Machine review of arXiv:2501.09326}
}

read the original abstract

Processing low-resource languages, such as Kiswahili, using machine learning is difficult due to lack of adequate training data. However, such low-resource languages are still important for human communication and are already in daily use and users need practical machine processing tasks such as summarization, disambiguation and even question answering (QA). One method of processing such languages, while bypassing the need for training data, is the use semantic networks. Some low resource languages, such as Kiswahili, are of the subject-verb-object (SVO) structure, and similarly semantic networks are a triple of subject-predicate-object, hence SVO parts of speech tags can map into a semantic network triple. An algorithm to process raw natural language text and map it into a semantic network is therefore necessary and desirable in structuring low resource languages texts. This algorithm tested on the Kiswahili QA task with upto 78.6% exact match.

Figures

Figures reproduced from arXiv: 2501.09326 by the authors.

**Figure 1.** Flowchart for semantic network generation from natural language text (Source: author) The algorithm formulated in this research is shown in [PITH_FULL_IMAGE:figures/full_fig_p005_1.png] view at source ↗

**Figure 2.** Algorithm for Semantic Network Generation from natural language text (Source: author) This research determined, through analysis of semantic network (SN) structures and language structure, that there was possibility of direct mapping of SPO to SVO, with unit of consideration being a sentence of phrase. Preliminary preprocessing of any text therefore determines the sentence or phrase lengths using full stops and comm… view at source ↗

**Figure 3.** Visualization of RDF triples created using the algorithm (Source: author) 3.4 Proof of Concept Question We test the SN on a typical NLP QA task. The network in [PITH_FULL_IMAGE:figures/full_fig_p011_3.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

4 extracted references · 2 canonical work pages

[1]

aflat. (2020). Kiswahili Part-of-Speech Tagger - Demo AfLaT.org. Retrieved 14 December 2020, from https://www.aflat.org/swatag Berners-Lee, T. (2006). Linked Data. Retrieved 06 July 2022, from https://www.w3.org/DesignIssues/LinkedData.html Besacier, L., Barnard, E., Karpov, A., & Schultz, T. (2014). Automatic speech recognition for under-resourced langua...

arXiv 2020
[20]

18 Welbl, J., Stenetorp, P., & Riedel, S. (2018). Constructing datasets for multi-hop reading comprehension across documents. Transactions of the Association for Computational Linguistics, 6, 287–302. Wu, C., & Wu, T. (n.d.). Typologically Diverse QA: How many training examples do you need for a new language anyway? Yan, P., & Jin, W. (2017). Building sem...

work page 2018
[1183]

https://doi.org/10.3389/fpsyg.2015.01183 omniglot. (2021). Swahili alphabet, pronunciation and language. Retrieved 08 September 2022, from https://omniglot.com/writing/swahili.htm Pennington, J., Socher, R., & Manning, C. D. (2014). GloVe: Global vectors for word representation. EMNLP 2014 - 2014 Conference on Empirical Methods in Natural Language Process...

work page arXiv 2021
[1270]

https://doi.org/10.1145/2872427.2883068 Markovic, V., & Nelamangala, V. (2017). Building the Activity Graph, Part I. Retrieved 05 July 2020, from https://engineering.linkedin.com/blog/2017/06/building-the-activity-graph-- part-i Marno, H., Langus, A., Omidbeigi, M., Asaadi, S., Seyed-Allaei, S., & Nespor, M. (2015). A new perspective on word order prefere...

arXiv 2017

Pith tools

Reviewed August 10, 2026 · model on record in the stance chip above.

[1] [1]

aflat. (2020). Kiswahili Part-of-Speech Tagger - Demo AfLaT.org. Retrieved 14 December 2020, from https://www.aflat.org/swatag Berners-Lee, T. (2006). Linked Data. Retrieved 06 July 2022, from https://www.w3.org/DesignIssues/LinkedData.html Besacier, L., Barnard, E., Karpov, A., & Schultz, T. (2014). Automatic speech recognition for under-resourced langua...

arXiv 2020

[2] [20]

18 Welbl, J., Stenetorp, P., & Riedel, S. (2018). Constructing datasets for multi-hop reading comprehension across documents. Transactions of the Association for Computational Linguistics, 6, 287–302. Wu, C., & Wu, T. (n.d.). Typologically Diverse QA: How many training examples do you need for a new language anyway? Yan, P., & Jin, W. (2017). Building sem...

work page 2018

[3] [1183]

https://doi.org/10.3389/fpsyg.2015.01183 omniglot. (2021). Swahili alphabet, pronunciation and language. Retrieved 08 September 2022, from https://omniglot.com/writing/swahili.htm Pennington, J., Socher, R., & Manning, C. D. (2014). GloVe: Global vectors for word representation. EMNLP 2014 - 2014 Conference on Empirical Methods in Natural Language Process...

work page arXiv 2021

[4] [1270]

https://doi.org/10.1145/2872427.2883068 Markovic, V., & Nelamangala, V. (2017). Building the Activity Graph, Part I. Retrieved 05 July 2020, from https://engineering.linkedin.com/blog/2017/06/building-the-activity-graph-- part-i Marno, H., Langus, A., Omidbeigi, M., Asaadi, S., Seyed-Allaei, S., & Nespor, M. (2015). A new perspective on word order prefere...

arXiv 2017