Designing Vector-Symbolic Architectures for Biomedical Applications: Ten Tips and Common Pitfalls

Introduction

Tip 1: For Electronic Health Records – Use Bundling to Create Holistic Patient Vectors

How to Create a Patient Vector

First, you need a dictionary that maps every elementary piece of information to its own unique and random 1-dimensional vector in 10,000 size. This is your codebook. Your atomic concepts would include:

• Keys for data types: diagnosis, medication, lab_test, value;
• Specific diagnose: diabetes_type_2, hypertension;
• Specific medications: metformin, lisinopril;
• Specific lab tests: hba1c, creatinine;
• Discretized lab values: high, normal, low.

Using hdlib, we can create this with a simple list of concepts, as shown in Code 1 below.

For each piece of information in a patient's record, you can create a vector by binding the key to its value. Binding combines them to create a new, distinct product vector that is dissimilar to its original components:

• A diagnosis of hypertension becomes: patient_diagnosis = diagnosis ⊗ hypertension
• A prescription for metformin becomes: patient_prescription = medication ⊗ metformin
• A HbA1c result of 8.1% (which we categorize as high) becomes: patient_hba1c = (lab_test ⊗ hba1c) ⊕ (value ⊗ high)

Notice that we bundled two bound pairs to represent a more complex fact (the test and its result)

This translates to the following code using hdlib (Code 2).

Now, you simply bundle all of a patient’s fact vectors together to create their final, comprehensive representation.

Let’s consider Patient A: high hypertension, takes metformin, has high HbA1c. Their patient vector would be calculated as:

patient_A = (diagnosis ⊗ hypertension) ⊕ (medication ⊗ metformin) ⊕ ((lab_test ⊗ hba1c) ⊕ (value ⊗ high))

Now, consider Patient B, for whom we only have a diagnosis: has hypertension. Their vector is simply:

patient_B = diagnosis ⊗ hypertension

This can be simply achieved using hdlib as shown in Code 3.

Tip 2: For Genomics and Proteomics – Leverage Permutations to Encode Sequences

Encoding Positions

HDC solves this problem using the positional vector binding or the permutation operator . Permutation systematically shuffles the elements of a hypervector in a deterministic way. For example, a single permutation might rotate the vector’s 10,000 elements one position to the left. Applying it again rotates it one more position. Each amount of shift represents a specific location in a sequence, thereby preserving positional information during encoding. Crucially, each permutation creates a new hypervector that is dissimilar (quasi-orthogonal) to the original and to other permutations of itself. This property allows us to encode an element’s relative position within a sequence [25,26,27]. On the other hand, positional binding with separate vectors assigned to specific positions is another approach. In this method, each position (symbolic information) is represented by a unique hypervector. Let’s explore the two primary ways to do this:

Method 1: binding with a position vector – This method is like putting labeled tags on items. You create a generic position vector and permute it to create a unique tag for each position (position_0, position_1, position_2). You then bind each sequence element to its corresponding position tag. This method is best suitable for answering the question “what is at a specific position?”. This can be easily achieved using hdlib as in Code 4.

Method 2: directly permuting element vectors – This more direct method alters the element’s vector itself based on its position. The first element’s vector is permuted 0 times, the second is permuted once, the third twice, and so on. This is best for answering the question “where is a specific element?”. A Python snippet using hdlib is reported in Code 5.

Returning to the example of ACG and GCA; when encoding ACG by permuting approach, the vector for A is left unshifted for the first position, while C and G are permuted by one and two positions, respectively, before binding and bundling into a single representation. For GCA, the vector for G remains unshifted, while C and A are permuted by one and two positions, respectively. As a result, even though both sequences contain the same symbols, their encodings yield distinct hypervectors, preserving order information.

Furthermore, this encoding can be extended to capture higher-level biological knowledge, such as the codon wobble base phenomenon. By bundling the sequence vector of a codon with the vector for the amino acid it encodes, we can create biologically-aware representations. In this model, vectors for synonymous codons (e.g., GCA and GCC) become highly similar, as they share the same core amino acid vector, while vectors for non-synonymous codons remain dissimilar. This demonstrates how VSAs can move beyond literal sequence representation to encode abstract functional relationships.

Tip 3: For Medical Imaging – Combine Vector-Symbolic Architectures with Convolutional Neural Networks for Explicable Artificial Intelligence

Building a Queryable Scene Description

Instead of replacing CNNs, we can augment them with VSAs to create a hybrid, explainable AI model. Think of it like a two-part team:

• CNN acts as a junior technician. It has incredible eyes and can spot thousands of tiny, low-level patterns (textures, edges, shapes) in an image but cannot articulate what they mean;
• VSA acts as a senior pathologist. It takes the technician’s findings, gives them symbolic names (e.g., “spindle-shaped cells”, “high nuclear density”), notes their locations, and assembles everything into a structured, queryable report.

This hybrid model gives you the best of both worlds: the pattern-recognition power of deep learning and the reasoning and interpretability of symbolic architectures [33,34,35].

Because a full implementation is highly complex, we will use a mix of descriptive steps and pseudocode to illustrate the logic:

Step 1: divide the image and extract features with a CNN – First, we break the input image (e.g., a large histology slide) into a grid of smaller patches (e.g., 16x16 grid). We then feed each patch into a pre-trained CNN. Instead of using the CNN’s final classification, we intercept the output from an earlier layer, a rich feature vector that numerically describes the contents of that path. As anticipated earlier, since the implementation of this step could involve getting deep into many details about neural networks in general, we are going to assume that this method is implemented in a function called cnn_feature_extractor that, given an image patch, returns the feature vector;

Step 2: build a VSA codebook for features and locations – Next, we create a VSA codebook to hold the symbolic representations of the image’s contents. This involves two sets of concepts: vectors for each spatial location in our grid, and vectors for the low-level features the CNN finds. Since we do not know what the raw numerical features from the CNN mean ahead of time, we must first discover and then name them. This is a two-step process:

• Discover feature groups: we first run a clustering algorithm (like K-Means) on all the feature vectors produced by the CNN from a training set of images. This groups the thousands of slightly different numerical feature vectors into a small number of distinct clusters. Each cluster represents a recurring visual pattern, like a certain texture or cell shape;
• Assign symbolic names: we then treat each cluster as a single, unified concept. We assign a symbolic name to each one and generate a unique, random hypervector for each of these symbolic names in our codebook.

The numerical cluster centroid (the average feature in a group) is only used temporarily to determine which symbolic name a new, unseen CNN feature belongs to. The VSA model itself works exclusively with the final symbolic hypervectors.

Step 3: create the composite image vector – Now, we loop through each patch of the image. For each patch, we get its CNN feature vector, find the closest matching symbolic feature in our VSA codebook, and bind that symbolic feature to the patch’s location vector. Finally, we bundle all these bound pairs into a single hypervector that represents the entire image.

The whole process is summarized in Code 6.

Why This Works

The image_hv in Code 6 is now a fully symbolic and queryable model of the image’s contents. You can interrogate it using VSA operations to ask questions that a standard CNN could never answer.

Query: “What features are present in the top-right corner (position 0, 3)?”

To answer this, we take our composite image_hv and unbind the location vector for position_0_3. In hdlib, this is done by binding, as shown in Code 7.

This process turns the black box into an explainable model. A doctor can now not only see the final classification but can also probe the model’s intermediate reasoning, potentially discovering novel biomarkers reflected in the learned features.

Pitfall: meaningless VSA feature codebook – if the clusters generated from the CNN’s feature vectors are not distinct or meaningful, the VSA codebook will map to noisy, overlapping concepts (e.g., feature_7 and feature_12 represent very similar patterns). The symbolic model will then be built on a faulty foundation.

How to avoid the pitfall: tune the CNN and clustering – ensure the CNN is well-trained for feature extraction. Experiment with different clustering algorithms and a varying number of clusters. Manually inspect the image patches corresponding to each cluster to see if they present visually coherent patterns. The goal is to create a VSA codebook where each feature corresponds to a recognizable visual element. Finally, remember that the quality of the VSA codebook directly affects vector generation: similar items should map to hypervectors with high correlation, while dissimilar items should map to nearly orthogonal hypervectors. This alignment ensures that symbolic reasoning is grounded in meaningful representations.

Tip 4: For Biosignal Processing (EEG/ECG) – Encode Time-Frequency Data Symbolically

A Symbolic Snapshot of the Signal’s State

The VSA approach is capable of transforming the raw, numerical signal into a series of symbolic snapshots. Instead of working with the waveform directly, we first use standard signal processing techniques (like the Short-Term Fourier Transform) to analyze a short window of the signal [38]. This tells us which frequency bands (e.g., Delta, Theta, Alpha, Beta) are powerful at that time stamp. We then encode this frequency information into a single hypervector that represents the signal’s state for that specific window.

By stringing these snapshot vectors together, we can create a rich, symbolic representation of the signal’s evolution over time, perfect for classification and event detection [5,39,40,41,42,43].

Here, we are going to use a simplified EEG example, but the same logic applies to ECG, EMG, or other time-series data:

Step 1: pre-process the signal into time-frequency windows – this step does not involve VSAs. You would use a standard library like scipy [44] or mne [45] in Python to take your raw EEG signal and process it. The goal is to get the average power in each standard frequency band (Delta: 0.5–4 Hz, Alpha: 8–12 Hz, etc.) for short, overlapping time windows (e.g., 1-second windows);

Step 2: build a VSA codebook for signal features – now we create our VSA dictionary. The concepts will be the names of our frequency bands and the different brain regions (channels) from which the signal is recorded;

Step 3: create a composite hypervector for each time window – for each window of time, we create a single hypervector that captures the state of the entire brain. We loop through each EEG channel, find its dominant frequency band for that window, and bind the channel vector to the band vector. Then, we bundle all these bound pairs together.

This process is summarized in Code 8.

Why This Works

After repeating this process for many time windows, you will have a set of brain_state_hv vectors. You can now use these for high-level tasks. For example, to build a classifier for focused vs. relaxed states:

• Create a prototype: collect many brain_state_hv samples while a subject is focused and bundle them together to create a single prototype_focused vector. Do the same for the relaxed state to create prototype_relaxed;
• Classify new data: to classify a new, unseen brain_state_hv after following the same encoding steps of a single test sample, simply check whether it is more similar to the focused or relaxed prototype (see Code 9 for a pseudocode using hdlib).

This approach transforms a complex, continuous signal processing problem into a much simpler symbolic reasoning task, making it easy to build robust and transparent classifiers for dynamic biological state.

Pitfall: wrong window size – if the time window for your analysis is too short, you will not have the frequency resolution to accurately detect low-frequency bands (like Delta waves). If it is too long, you will average out rapid, transient events and miss them entirely.

How to avoid the pitfall: match the window size to the phenomenon of interest – this is a classic signal processing trade-off. If you are looking for slow-changing cognitive states, a longer window (1-2 seconds) is fine. If you are trying to detect sharp, brief events like epileptic spikes, you need a much shorter window (e.g., 100-250 milliseconds). You may even need to run your analysis in parallel with multiple window sizes to capture different types of events.

It is important to craft hypervectors independently, especially for band and channel symbols. Keep the random source separate for each symbol, and ideally for each concept, to preserve strong orthogonality (rather than merely near-orthogonality).

Tip 5: For Molecular Structures – Decompose Molecules into Atomic Fragments

A Sum of Its Parts

The VSA approach treats a molecule as a composition of its local atomic environments. Instead of trying to encode the entire molecular graph at once, we break it down into smaller, overlapping fragments. A fragment can be as simple as an atom and its immediate bonding partner. We then create a hypervector for each of these fragments and bundle them together to form a single hypervector that represents the entire molecule.

This method elegantly captures the principle that a molecule’s function is determined by the sum of its constituent chemical groups (e.g., hydroxyl groups, benzene rings). Molecules with similar functional groups will have similar hypervectors, allowing us to predict properties and behavior.

Let’s use a simplified representation of a water molecule (H-O-H) and a hydrogen peroxide molecule (H-O-O-H) to illustrate the process:

Step 1: define your atomic and bonding codebook – first, we create a VSA codebook for the basic building blocks, i.e., the different types of atoms (elements);

Step 2: define and encode atomic fragments – an atomic fragment is the local environment around a central atom. We can represent it by bundling the central atom’s vector with vectors representing each of the neighboring atoms. The fragments in a water molecule are defined as:

• o oxygen fragment: one central oxygen atom connected to two hydrogens via single bonds;
• o hydrogen fragment: each hydrogen is connected to one oxygen via a single bond.

Step 3: bundle fragments into a molecular hypervector – finally, we sum the hypervectors of all the atomic fragments in the molecule to get the final molecular representation.

Code 10 summarizes these steps using the hdlib library:

Tip 6: For Biomedical Knowledge Graphs – Use Binding to Represent Relational Triples

Facts as Vectors

VSAs provide a powerful way to encode an entire knowledge graph into a single, dense hypervector (or a collection of them). The fundamental unit of a knowledge graph is the relational triple <subject, predicate, object> (e.g., <caffeine, inhibits, adenosine_receptor>).

The VSA solution is to use the binding operation to compress this entire triple into a single hypervector. This fact vector represents the complete relationship. By bundling thousands of these fact vectors together, we can create a composite vector that represents a vast body of knowledge:

Step 1: building a codebook for entities and predicates – first, we create a dictionary that maps every entity (like a drug, gene, or disease) and every predicate (a relationship, like causes, inhibits, or interacts_with) to a unique hypervector;

Step 2: encode each fact using binding – now, for each triple in our knowledge graph, we create a fact vector by binding the subject, predicate, and object together;

Step 3: bundle facts into a knowledge base vector – to create our final knowledge base, we simply bundle all the individual fact vectors together. The single vector now contains all the information from our original graph, stored in a distributed, superimposed manner.

Code 11 summarizes the whole procedure.

Why This Works

The true power of this representation lies in its ability to answer questions and infer relationships through vector arithmetic. We can query the knowledge base by providing parts of a triple and using the inverse operation to find the missing piece.

Question: “What does caffeine inhibit?”

To answer this question, we create a query vector by binding caffeine and inhibits, and then bind this to our knowledge base along with the query vector as shown in Code 12.

This VSA technique allows for powerful, fuzzy queries on massive datasets. It can be used to infer novel drug-repurposing candidates, discover potential gene-disease associations, and build systems that can reason over the vast and ever-growing body of biomedical literature.

Pitfall: ambiguity of the unbind operation – when you query the knowledge base, the result vector is an approximation, not a clean answer. It is a superposition of the correct answer plus noise from all other facts in the knowledge base. If your knowledge base is very dense with similar relationships, the noise can overwhelm the signal, and the top match for your query might be incorrect.

How to avoid the pitfall: use cleanup memory – after you get your result_hv, do not just find the single best match in your codebook. Instead, find the top 3-5 closest matches and bundle them together. Then, use this new, cleaner vector to re-query the codebook. This process, also called iterative cleanup, helps to amplify the signal and suppress the noise, leading to more accurate query results.

Tip 7: For Classification Tasks – Build and Refine Prototype Vectors

Learning the Average Case

The VSA approach for classification is beautifully simple and effective. Instead of learning a complex decision boundary, we create a single prototype vector for each class. A prototype vector is simply the bundle of all the sample vectors belonging to that class. The learning process happens incrementally, with each sample contributing additively to the prototype hypervector. Thus, the reverse operation, unlearning, is simply subtracting that contribution.

Let’s consider an hypothetical prototype_diabetic vector that represents the central tendency of all diabetic patients in your training set. To classify a new patient, you simply check if their vector is more similar to the diabetic prototype or the non-diabetic prototype. This method is transparent, computationally cheap, and works remarkably well even with very few training samples.

Let’s assume we have already encoded our data into hypervectors. For this example, we will use the patient vectors created in Tip 1, where each vector represents a patient’s EHR data. Our goal is to classify patients as either diabetic or non_diabetic:

Step 1: encode your training data – first, ensure every sample in your labeled training set is represented as a hypervector. We will presuppose this step is complete and we have a list of patient vectors and their corresponding labels;

Step 2: create a prototype vector for each class – now, we iterate through our training data. We will add each patient’s vector to a running sum for their respective class;

Step 3: classify a new sample with similarity search – with our prototypes built, classification is incredibly straightforward. For any new, unlabeled patient vector, we calculate its cosine distance to each prototype vector. The class of the prototype with the lowest distance score is our predicted class (see Code 13 for a code overview).

Tip 8: For Data Fusion – Map All Modalities into a Common Vector Space

A Universal Language

The elegance of VSAs is that hypervectors act as a universal language. As long as all your vectors share the same dimensionality, they can be mathematically combined, regardless of their origin. The strategy for data fusion is simple:

• Encode each modality separately into its own hypervector using the most appropriate technique (e.g., methods from Tip 1 for text/EHRs, Tip 2 for genetic sequences, Tip 3 for images);
• Bundle the resulting vectors together to create a single, multimodal hypervector that represents the complete picture.

This allows to create a holistic patient representation that is richer than any single data source alone. Let’s imagine our goal is to create a single patient vector that combines the findings from a written radiology report and the corresponding MRI scan:

Step 1: encode the text modality – first, we process the text from the radiology report. We can use a method similar to Tip 1, creating a simple bag-of-words vector by bundling the vectors for key terms found in the report;

Step 2: encode the image modality – next, we process the MRI scan. As described in Tip 3, we would use a hybrid CNN-VSA approach to convert the image into a single hypervector. This image_hv symbolically represents the key features and their locations within the scan;

Step 3: bundle the modalities into a unified vector – this is the easiest and most powerful step. To create the final, multimodal representation of the patient’s case, we simply bundle the report_hv and the image_hv together.

This is all summarized in Code 14 below.

Tip 9: For Interpreting Results – Probe Composite Vectors with Clean Pointers

Asking Your Vector Questions

A composite hypervector is not a black box. It is a queryable database. Because it was constructed using symbolic components, you can reverse the process to inspect its contents. The technique involves using a clean pointer and the inverse of the binding operation to ask the composite vector a question. This process essentially asks “What information in you is associated with this pointer I am holding?”. This makes VSA models highly interpretable and transparent [58,59,60,61].

Let’s use the composite patient_A we created back in Tip 1. Recall that it was constructed from three facts: a diagnosis of hypertension, a prescription for metformin, and a high HbA1C lab result. Here is the question: “What was this patient’s diagnosis?”

Step 1: construct your query vector (the clean pointer) – your query is the part of the fact that you already know. In this case, we know the key is diagnosis;

Step 2: unbind the pointer from the composite vector – to retrieve the value associated with our pointer, we use the binding operation;

Step 3: find the closest match in your codebook – the resulting vector is not a perfect, clean vector. It is a noisy approximation of the answer because it also contains remnants of all other bundled information. To get our final answer, we search our codebook to find the vector that is most similar to the retrieved one (see Code 15 below).

Pitfall: noisy or ambiguous answers – when unbinding a pointer, the resulting vector is an approximation that is contaminated by noise from all the other bundled vectors. If your composite vector is extremely dense (contains hundreds of bundled facts), this noise can become so strong that the similarity to the correct answer is low, and the similarity to incorrect answers might be non-zero, creating ambiguity.

How to avoid the pitfall: use cleanup memory – the process of finding the closest match in the codebook is itself a form of cleanup. To make it more robust, you can perform an extra cleanup step. Instead of taking just the single best match, take the top 2-3 matches, bundle them together, and then search the codebook again with this new, denoised vector. For most applications, however, a direct search is sufficient. A better long-term solution is to design your encoding scheme hierarchically (as discussed in the solution proposed to avoid Tip 2 pitfall) to limit how many items get bundled into a single vector.

Tip 10: For Reproducibility and Impact – Practice Open Science

Conclusions

Abbreviations

References

1. Kanerva, P. Hyperdimensional computing: An introduction to computing in distributed representation with high-dimensional random vectors. Cognit Comput. 2009, 1, 139–159. [Google Scholar] [CrossRef]
2. Kanerva, P. Hyperdimensional computing: An algebra for computing with vectors. Advances in Semiconductor Technologies. Wiley; 2022. pp. 25–42. [CrossRef]
3. Zhang S, Wang R, Zhang JJ, Rahimi A, Jiao X. Assessing robustness of hyperdimensional computing against errors in associative memory : (invited paper). 2021 IEEE 32nd International Conference on Application-specific Systems, Architectures and Processors (ASAP). IEEE; 2021. [CrossRef]
4. Zhang S, Juretus K, Jiao X. Exploring hyperdimensional computing robustness against hardware errors. IEEE Trans Comput. 2025, 74, 1963–1977. [Google Scholar] [CrossRef]
5. Burrello A, Schindler K, Benini L, Rahimi A. Hyperdimensional Computing With Local Binary Patterns: One-Shot Learning of Seizure Onset and Identification of Ictogenic Brain Regions Using Short-Time iEEG Recordings. IEEE Trans Biomed Eng. 2020, 67, 601–613. [Google Scholar] [CrossRef]
6. Burrello A, Schindler K, Benini L, Rahimi A. One-shot learning for iEEG seizure detection using end-to-end binary operations: Local binary patterns with hyperdimensional computing. 2018 IEEE Biomedical Circuits and Systems Conference (BioCAS). IEEE; 2018. [CrossRef]
7. Rahimi A, Tchouprina A, Kanerva P, Millán J del R, Rabaey JM. Hyperdimensional Computing for Blind and One-Shot Classification of EEG Error-Related Potentials. Mobile Networks and Applications. 2017, 25, 1958–1969. [Google Scholar] [CrossRef]
8. Nair DR, Purushothaman A. Brain Inspired One Shot Learning Method for HD Computing. VLSI Design and Test. 2019, 286–297. [Google Scholar] [CrossRef]
9. Cumbo F, Chicco D. Hyperdimensional computing in biomedical sciences: a brief review. PeerJ Comput Sci. 2025, 11, e2885. [Google Scholar] [CrossRef]
10. Stock M, Van Criekinge W, Boeckaerts D, Taelman S, Van Haeverbeke M, Dewulf P, et al. Hyperdimensional computing: A fast, robust, and interpretable paradigm for biological data. PLOS Computational Biology. 2024, 20, e1012426. [Google Scholar] [CrossRef]
11. Cumbo F, Weitschek E, Blankenberg D. hdlib: A Python library for designing Vector-Symbolic Architectures. J Open Source Softw. 2023, 8, 5704. [Google Scholar] [CrossRef]
12. Sæthre E, Osborg Ose S, Krokstad S, Østgård Gismervik S. “Terrible Stuff. We’ve been had“: hospital staff reactions to a new electronic health record and implications for employee well-being – A qualitative study. International Journal of Medical Informatics. 2025, 204, 106039. [Google Scholar] [CrossRef]
13. Tavabi N, Singh M, Pruneski J, Kiapour AM. Systematic evaluation of common natural language processing techniques to codify clinical notes. PLoS One. 2024, 19, e0298892. [Google Scholar] [CrossRef]
14. Sheikhalishahi S, Miotto R, Dudley JT, Lavelli A, Rinaldi F, Osmani V. Natural Language Processing of Clinical Notes on Chronic Diseases: Systematic Review. JMIR Med Inform. 2019, 7, e12239. [Google Scholar] [CrossRef]
15. Kuo T-T, Rao P, Maehara C, Doan S, Chaparro JD, Day ME, et al. Ensembles of NLP Tools for Data Element Extraction from Clinical Notes. AMIA Annu Symp Proc. 2016, 2016, 1880–1889. [Google Scholar]
16. Wells BJ, Chagin KM, Nowacki AS, Kattan MW. Strategies for handling missing data in electronic health record derived data. EGEMS (Wash DC). 2013, 1, 1035. [Google Scholar] [CrossRef]
17. Jones JA, Farnell B. Missing and Incomplete Data Reduces the Value of General Practice Electronic Medical Records as Data Sources in Research. Aust J Prim Health. 2007, 13, 74–80. [Google Scholar] [CrossRef]
18. Joel LO, Doorsamy W, Paul BS. A Review of Missing Data Handling Techniques for Machine Learning. IJITIS. 2022, 5, 971–1005. [Google Scholar] [CrossRef]
19. Emmanuel T, Maupong T, Mpoeleng D, Semong T, Mphago B, Tabona O. A survey on missing data in machine learning. Journal of Big Data. 2021, 8, 1–37. [Google Scholar] [CrossRef]
20. Rizvi STH, Latif MY, Amin MS, Telmoudi AJ, Shah NA. Analysis of Machine Learning Based Imputation of Missing Data. Cybernetics and Systems. 2023, 818–832. [Google Scholar] [CrossRef]
21. Bai T, Chanda AK, Egleston BL, Vucetic S. EHR phenotyping via jointly embedding medical concepts and words into a unified vector space. BMC Medical Informatics and Decision Making. 2018, 18, 15–25. [Google Scholar] [CrossRef]
22. Chang E-J, Rahimi A, Benini L, Wu A-YA. Hyperdimensional computing-based multimodality emotion recognition with physiological signals. 2019 IEEE International Conference on Artificial Intelligence Circuits and Systems (AICAS). IEEE; 2019. [CrossRef]
23. Zhao Q, Yu X, Hu S, Rosing T. MultimodalHD: Federated learning over heterogeneous sensor modalities using hyperdimensional computing. 2024 Design, Automation & Test in Europe Conference & Exhibition (DATE). IEEE; 2024. pp. 1–6. [CrossRef]
24. Fanizzi N, d’Amato C. The blessing of dimensionality. Neurosymbolic Artificial Intelligence. 2025. [Google Scholar] [CrossRef]
25. Imani M, Nassar T, Rahimi A, Rosing T. HDNA: Energy-efficient DNA sequencing using hyperdimensional computing. 2018 IEEE EMBS International Conference on Biomedical & Health Informatics (BHI). IEEE; 2018. [CrossRef]
26. Zou Z, Chen H, Poduval P, Kim Y, Imani M, Sadredini E, et al. BioHD. Proceedings of the 49th Annual International Symposium on Computer Architecture. New York, NY, USA: ACM; 2022. [CrossRef]
27. Xu W, Hsu P-K, Moshiri N, Yu S, Rosing T. HyperGen: compact and efficient genome sketching using hyperdimensional vectors. Bioinformatics. 2024, 40, btae452. [Google Scholar] [CrossRef]
28. Salehi AW, Khan S, Gupta G, Alabduallah BI, Almjally A, Alsolai H, et al. A Study of CNN and Transfer Learning in Medical Imaging: Advantages, Challenges, Future Scope. Sustainability. 2023, 15, 5930. [Google Scholar] [CrossRef]
29. Yao W, Bai J, Liao W, Chen Y, Liu M, Xie Y. From CNN to Transformer: A Review of Medical Image Segmentation Models. Journal of Imaging Informatics in Medicine. 2024, 37, 1529–1547. [Google Scholar] [CrossRef]
30. Li Q, Cai W, Wang X, Zhou Y, Feng DD, Chen M. Medical image classification with convolutional neural network. 2014 13th International Conference on Control Automation Robotics & Vision (ICARCV). IEEE; 2014. [CrossRef]
31. Xie Y, Zhang J, Shen C, Xia Y. CoTr: Efficiently Bridging CNN and Transformer for 3D Medical Image Segmentation. Medical Image Computing and Computer Assisted Intervention – MICCAI 2021. 2021; 171–180. [CrossRef]
32. Yuan F, Zhang Z, Fang Z. An effective CNN and Transformer complementary network for medical image segmentation. Pattern Recognition. 2023, 136, 109228. [Google Scholar] [CrossRef]
33. Hassan E, Halawani Y, Mohammad B, Saleh H. Hyper-dimensional computing challenges and opportunities for AI applications. IEEE Access. 2022, 10, 97651–97664. [Google Scholar] [CrossRef]
34. Luczak P, Slot K, Kucharski J. Combining deep convolutional feature extraction with hyperdimensional computing for visual object recognition. 2022 International Joint Conference on Neural Networks (IJCNN). IEEE; 2022. pp. 1–8. [CrossRef]
35. Lee H, Kim J, Chen H, Zeira A, Srinivasa N, Imani M, et al. Comprehensive integration of hyperdimensional computing with deep learning towards neuro-symbolic AI. 2023 60th ACM/IEEE Design Automation Conference (DAC). IEEE; 2023. pp. 1–6. [CrossRef]
36. Alotaiby TN, Alshebeili SA, Alshawi T, Ahmad I, Abd El-Samie FE. EEG seizure detection and prediction algorithms: a survey. EURASIP Journal on Advances in Signal Processing. 2014, 2014, 1–21. [Google Scholar] [CrossRef]
37. Ein Shoka AA, Dessouky MM, El-Sayed A, Hemdan EE-D. EEG seizure detection: concepts, techniques, challenges, and future trends. Multimedia Tools and Applications. 2023, 82, 42021–42051. [Google Scholar] [CrossRef] [PubMed]
38. Rizal A, Priharti W, Hadiyoso S. Seizure detection in epileptic EEG using Short-Time Fourier Transform and support vector machine. Int J Onl Eng. 2021, 17, 65–78. [Google Scholar] [CrossRef]
39. Pale U, Teijeiro T, Atienza D. Systematic Assessment of Hyperdimensional Computing for Epileptic Seizure Detection. Annu Int Conf IEEE Eng Med Biol Soc. 2021, 2021, 6361–6367. [Google Scholar] [CrossRef]
40. Ge L, Parhi KK. Applicability of hyperdimensional computing to seizure detection. IEEE Open J Circuits Syst. 2022, 3, 59–71. [Google Scholar] [CrossRef]
41. Schindler KA, Rahimi A. A Primer on Hyperdimensional Computing for iEEG Seizure Detection. Front Neurol. 2021, 12, 701791. [Google Scholar] [CrossRef]
42. Asgarinejad F, Thomas A, Rosing T. Detection of Epileptic Seizures from Surface EEG Using Hyperdimensional Computing. Annu Int Conf IEEE Eng Med Biol Soc. 2020, 2020, 536–540. [Google Scholar] [CrossRef]
43. Du Y, Ren Y, Wong N, Ngai ECH. Hyperdimensional computing with multiscale local binary patterns for scalp EEG-based epileptic seizure detection. IEEE Internet Things J. 2024, 11, 26046–26061. [Google Scholar] [CrossRef]
44. Virtanen P, Gommers R, Oliphant TE, Haberland M, Reddy T, Cournapeau D, et al. SciPy 1.0: fundamental algorithms for scientific computing in Python. Nat Methods. 2020, 17, 261–272. [Google Scholar] [CrossRef]
45. Gramfort A, Luessi M, Larson E, Engemann DA, Strohmeier D, Brodbeck C, et al. MEG and EEG data analysis with MNE-Python. Front Neurosci. 2013, 7, 267. [Google Scholar] [CrossRef]
46. Ma D, Thapa R, Jiao X. MoleHD: Efficient drug discovery using brain inspired hyperdimensional computing. 2022 IEEE International Conference on Bioinformatics and Biomedicine (BIBM). IEEE; 2022. [CrossRef]
47. Jones D, Zhang X, Bennion BJ, Pinge S, Xu W, Kang J, et al. HDBind: encoding of molecular structure with hyperdimensional binary representations. Scientific Reports. 2024, 14, 1–16. [Google Scholar] [CrossRef]
48. Cumbo F, Dhillon K, Joshi J, Raubenolt B, Chicco D, Aygun S, et al. Predicting the toxicity of chemical compounds via Hyperdimensional Computing. bioRxiv. 2025. [Google Scholar] [CrossRef]
49. Nicholson DN, Greene CS. Constructing knowledge graphs and their biomedical applications. Computational and Structural Biotechnology Journal. 2020, 18, 1414–1428. [Google Scholar] [CrossRef] [PubMed]
50. Bonner S, Barrett IP, Ye C, Swiers R, Engkvist O, Bender A, et al. A review of biomedical datasets relating to drug discovery: a knowledge graph perspective. Brief Bioinform. 2022, 23. [Google Scholar] [CrossRef]
51. Harnoune A, Rhanoui M, Mikram M, Yousfi S, Elkaimbillah Z, El Asri B. BERT based clinical knowledge extraction for biomedical knowledge graph construction and analysis. Computer Methods and Programs in Biomedicine Update. 2021, 1, 100042. [Google Scholar] [CrossRef]
52. Bugnon LA, Yones C, Milone DH, Stegmayer G. Deep Neural Architectures for Highly Imbalanced Data in Bioinformatics. IEEE Trans Neural Netw Learn Syst. 2020, 31, 2857–2867. [Google Scholar] [CrossRef]
53. Pes, B. Learning from high-dimensional biomedical datasets: The issue of class imbalance. IEEE Access. 2020, 8, 13527–13540. [Google Scholar] [CrossRef]
54. Cumbo F, Cappelli E, Weitschek E. A Brain-Inspired Hyperdimensional Computing Approach for Classifying Massive DNA Methylation Data of Cancer. Algorithms. 2020, 13, 233. [Google Scholar] [CrossRef]
55. Cumbo F, Truglia S, Weitschek E, Blankenberg D. Feature selection with vector-symbolic architectures: a case study on microbial profiles of shotgun metagenomic samples of colorectal cancer. Brief Bioinform. 2025, 26, bbaf177. [Google Scholar] [CrossRef]
56. Cumbo F, Dhillon K, Joshi J, Chicco D, Aygun S, Blankenberg D. A novel Vector-Symbolic Architecture for graph encoding and its application to viral pangenome-based species classification. bioRxiv. 2025. [CrossRef]
57. Chicco D, Cumbo F, Angione C. Ten quick tips for avoiding pitfalls in multi-omics data integration analyses. PLoS Comput Biol. 2023, 19, e1011224. [Google Scholar] [CrossRef]
58. Barkam HE, Yun S, Chen H, Gensler P, Mema A, Ding A, et al. Reliable hyperdimensional reasoning on unreliable emerging technologies. 2023 IEEE/ACM International Conference on Computer Aided Design (ICCAD). IEEE; 2023. [CrossRef]
59. Mitrokhin A, Sutor P, Summers-Stay D, Fermüller C, Aloimonos Y. Symbolic Representation and Learning With Hyperdimensional Computing. Front Robot AI. 2020, 7, 535245. [Google Scholar] [CrossRef]
60. Chang C-Y, Chuang Y-C, Huang C-T, Wu A-Y. Recent progress and development of hyperdimensional computing (HDC) for edge intelligence. IEEE J Emerg Sel Top Circuits Syst. 2023, 13, 119–136. [Google Scholar] [CrossRef]
61. Amrouch H, Imani M, Jiao X, Aloimonos Y, Fermuller C, Yuan D, et al. Brain-inspired hyperdimensional computing for ultra-efficient edge AI. 2022 International Conference on Hardware/Software Codesign and System Synthesis (CODES+ISSS). IEEE; 2022. [CrossRef]
62. Sim, I. Data Sharing and Reuse. Principles and Practice of Clinical Trials. 2022, 2137–2158. [Google Scholar] [CrossRef]
63. Wilkinson MD, Dumontier M, Aalbersberg IJ, Appleton G, Axton M, Baak A, et al. The FAIR Guiding Principles for scientific data management and stewardship. Scientific Data. 2016, 3, 1–9. [Google Scholar] [CrossRef]
64. Heddes M, Nunes I, Vergés P, Kleyko D, Abraham D, Givargis T, et al. Torchhd: An Open Source Python Library to Support Research on Hyperdimensional Computing and Vector Symbolic Architectures. Journal of Machine Learning Research. 2023, 24, 1–10. [Google Scholar]
65. Wang J, Huang S, Imani M. DistHD: A learner-aware dynamic encoding method for hyperdimensional classification. 2023 60th ACM/IEEE Design Automation Conference (DAC). IEEE; 2023. pp. 1–6. [CrossRef]
66. Kang J, Khaleghi B, Rosing T, Kim Y. OpenHD: A GPU-Powered Framework for Hyperdimensional Computing. IEEE Trans Comput. 2022, 71, 2753–2765. [Google Scholar] [CrossRef]
67. Simon WA, Pale U, Teijeiro T, Atienza D. HDTorch: Accelerating Hyperdimensional Computing with GP-GPUs for Design Space Exploration. ICCAD ’22: Proceedings of the 41st IEEE/ACM International Conference on Computer-Aided Design. [CrossRef]
68. Aygun S, Moghadam MS, Najafi MH. UHD: Unary processing for lightweight and dynamic hyperdimensional computing. 2024 Design, Automation & Test in Europe Conference & Exhibition (DATE). IEEE; 2024. pp. 1–6. [CrossRef]