OSCR

Polynomial Perceptrons for Compact, Robust, and Interpretable Machine Learning Models.

Code ↔ Paper

5 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

2 blocks of code here have a permanent identifier (oscr:b:…), listed with the matches below: citable for good, with a page of its own. Select a match and press Cite to copy it. What a block identifier is.

The 5 matches
  1. [1] § 4. Polynomial Perceptrons in Practical Use Cases › 4.4. Natural Language Processing › 4.4.1. Architecture ↔ Experiments/text_experiments/text_preprocessing.ipynb, lines 239 to 310 · score 0.67 · Weighted Word Embedding, TfidfVectorizer · Report a mismatch
  2. [2] § 4. Polynomial Perceptrons in Practical Use Cases › 4.4. Natural Language Processing › 4.4.1. Architecture ↔ Experiments/text_experiments/text_preprocessing.ipynb, lines 239 to 310 · score 0.58 · TF IDF weight, weighted embedding, matrix, vector · Report a mismatch
  3. [3] § 4. Polynomial Perceptrons in Practical Use Cases › 4.3. Image Classification › 4.3.4. Interpretability via Structured Contribution Decomposition ↔ visualization/project_zalando.py, lines 1 to 23 · score 0.56 · Ankle Boot, Sandal, Sneaker, MNIST · block oscr:b:Q19M5F6EY1E8S-F · Report a mismatch
  4. [4] § 4. Polynomial Perceptrons in Practical Use Cases › 4.2. Multiclass Classification › 4.2.2. Evaluation ↔ Experiments/tabular_experiments/tabular_pp.ipynb, lines 59 to 98 · score 0.55 · hidden layer, support vectors, MLPs, multiclass, polynomial, model · Report a mismatch
  5. [5] § 4. Polynomial Perceptrons in Practical Use Cases › 4.4. Natural Language Processing › 4.4.1. Architecture ↔ Utils/Text_Explainer.py, lines 67 to 74 · score 0.51 · TF IDF, weighted embedding · block oscr:b:ZPGJ7CYHQ56ZQ-U · Report a mismatch

Paper

Loaded from Europe PMC by your browser; OSCR does not store it: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Jupyter notebook · 315 lines · 12 KB · CC-BY-4.0 · 2 matches

  1. # %% [markdown]
  2. # # **Libraries and Paths**
  3. # %%
  4. import re
  5. import wordninja
  6. import numpy as np
  7. import pandas as pd
  8. import seaborn as sns
  9. from shap.plots import colors
  10. import matplotlib.pyplot as plt
  11. from gensim.models import KeyedVectors
  12. from sklearn.model_selection import train_test_split
  13. from sklearn.feature_extraction.text import TfidfVectorizer
  14. # %%
  15. color = colors.red_white_blue
  16. np.set_printoptions(linewidth=200, threshold=10000)
  17. # %%
  18. PATH_DATA = '../../data/Text/text_raw/hs-en.tsv'
  19. PATH_DATA_CLF = '../../data/Text/data_to_classification/'
  20. PATH_MODEL_GLOVE = '../../Models/Text_models/glove_models/glove-twitter-100.kv'
  21. # %% [markdown]
  22. # # **Load Text Data**
  23. # %%
  24. data_dict = {
  25. 'train': pd.read_csv(f'{PATH_DATA}.train', sep='\t', header=0),
  26. 'test': pd.read_csv(f'{PATH_DATA}.test', sep='\t', header=0),
  27. 'dev': pd.read_csv(f'{PATH_DATA}.dev', sep='\t', header=0)
  28. }
  29. data_dict['test'].drop([1560, 2451], inplace=True)
  30. # %%
  31. data_dict['train']
  32. # %% [markdown]
  33. # # **Clean Text**
  34. # %%
  35. def divide(match):
  36. tag = match.group(0)[1:]
  37. words = wordninja.split(tag)
  38. return " ".join(words)
  39. def re_clean(text, split_hashtag=False):
  40. text = text.replace("’", "'").replace("‘", "'") # Normaliza apóstrofes raros
  41. text = re.sub(r"(?:\@|https?\://)\S+", "", text) # Quita menciones y URLs
  42. text = re.sub(r"[^A-Za-z0-9#']+", " ", text) # Quita caracteres no permitidos
  43. text = re.sub(r"(\s)'(?=\w)", r"\1", text) # <espacio>'<letra> => <espacio><letra>
  44. text = re.sub(r"(?<=\w)'(\s)", r"\1", text) # <letra>'<espacio> => <letra><espacio>
  45. text = re.sub(r"\s'\s", " ", text) # <espacio>'<espacio> => <espacio><espacio>
  46. text = re.sub(r"\s+", " ", text) # Elimina espacios de más
  47. if split_hashtag:
  48. text = re.sub(r"#\w+", divide, text) # Divide hashtags si se pide
  49. return text.lower()
  50. def plot_dist(len_texts, p_min, p_max, percents, bins, ax=None, title=""):
  51. if ax is None:
  52. _, ax = plt.subplots()
  53. sns.histplot(len_texts, bins=bins, kde=True, color=color(0.0), ax=ax)
  54. ax.axvline(p_min, color=color(1.0), linestyle='--', label=f'Percentil {percents[0]}')
  55. ax.axvline(p_max, color=color(1.0), linestyle='--', label=f'Percentil {percents[1]}')
  56. ax.set_xlabel('Text length (number of words)')
  57. ax.set_ylabel('Frequency')
  58. ax.set_title(title)
  59. ax.legend()
  60. def clean_text(text, p_min, p_max, split_hashtags):
  61. # Limpieza básica
  62. text_clean = text.apply(re_clean, args=(split_hashtags,))
  63. text_clean = text_clean[~((text_clean == '') | (text_clean == ' '))]
  64. # Calcular longitudes antes de filtrar
  65. len_texts = text_clean.apply(lambda x: len(str(x).split()))
  66. percentile_min = np.percentile(len_texts, p_min)
  67. percentile_max = np.percentile(len_texts, p_max)
  68. # Filtrar según percentiles
  69. text_clean = text_clean[(len_texts >= percentile_min) & (len_texts <= percentile_max)]
  70. return text_clean, len_texts, (percentile_min, percentile_max)
  71. def get_data_celan(data_dict, p_min=2.5, p_max=97.5, split_hashtags=False, show_plot=True):
  72. train, test, dev = data_dict['train'], data_dict['test'], data_dict['dev']
  73. # Limpiamos cada partición
  74. texts_train, len_train, p_train = clean_text(train.text, p_min, p_max, split_hashtags)
  75. texts_test, len_test, p_test = clean_text(test.text, p_min, p_max, split_hashtags)
  76. texts_dev, len_dev, p_dev = clean_text(dev.text, p_min, p_max, split_hashtags)
  77. y_train = train.loc[texts_train.index, :].HS
  78. y_test = test.loc[texts_test.index, :].HS
  79. y_dev = dev.loc[texts_dev.index, :].HS
  80. if show_plot:
  81. # Creamos una figura con 3 subplots
  82. fig, axes = plt.subplots(1, 3, figsize=(14, 4), tight_layout=True)
  83. plot_dist(len_train, p_train[0], p_train[1], (p_min, p_max), bins=30, ax=axes[0], title=f"Distribution: Train {y_train.size}")
  84. plot_dist(len_test, p_test[0], p_test[1], (p_min, p_max), bins=30, ax=axes[1], title=f"Distribution: Test {y_test.size}")
  85. plot_dist(len_dev, p_dev[0], p_dev[1], (p_min, p_max), bins=14, ax=axes[2], title=f"Distribution: Dev {y_dev.size}")
  86. plt.tight_layout()
  87. plt.show()
  88. return (texts_train, y_train), (texts_test, y_test), (texts_dev, y_dev)
  89. # %%
  90. # Clean the text data
  91. #train_h, test_h, dev_h = get_data_celan(data_dict, p_min=2.5, p_max=97.5, split_hashtags=False, show_plot=True) # Mantiene los hashtags tal como están
  92. train_sp, test_sp, dev_sp = get_data_celan(data_dict, p_min=2.5, p_max=97.5, split_hashtags=True, show_plot=True) # Divide los hashtags en las palabras que los componen
  93. # %% [markdown]
  94. # # **Show Distributions of Labels**
  95. # %%
  96. def show_dist(train, test, dev):
  97. series_list = [train[1], test[1], dev[1]]
  98. titles = ['Train', 'Test', 'Dev']
  99. fig, axes = plt.subplots(1, 3, figsize=(15, 5))
  100. for i, (serie, title) in enumerate(zip(series_list, titles)):
  101. counts = serie.value_counts().sort_index()
  102. labels = [f'{int(k)} ({v})' for k, v in counts.items()]
  103. axes[i].pie(
  104. counts,
  105. labels=[f'{int(k)}' for k in counts.index],
  106. autopct='%1.1f%%',
  107. startangle=90,
  108. colors=[color(0.15), color(0.85)]
  109. )
  110. axes[i].set_title(f'{title} set')
  111. axes[i].legend(labels, title='Valor (Cantidad)', loc='lower right')
  112. plt.tight_layout()
  113. plt.show()
  114. # %%
  115. show_dist(train_sp, test_sp, dev_sp)
  116. # %% [markdown]
  117. # ## **Function to balance data**
  118. # %%
  119. def balanced(train, test, dev):
  120. data_conc = pd.concat([train, test, dev]).reset_index(drop=True)
  121. data_label_1 = data_conc[data_conc.label == 1]
  122. data_label_0 = data_conc[data_conc.label == 0]
  123. data_label_0 = data_label_0.sample(frac=1, random_state=42).reset_index(drop=True)
  124. data_label_0 = data_label_0.iloc[:len(data_label_1)]
  125. data_balanced = pd.concat([data_label_0, data_label_1]).reset_index(drop=True)
  126. X, X_t = train_test_split(data_balanced, test_size=0.1, random_state=42, shuffle=True, stratify=data_balanced.label)
  127. X_tr, X_d = train_test_split(X, test_size=0.1, random_state=42, shuffle=True, stratify=X.label)
  128. return (X_tr.text, X_tr.label), (X_t.text, X_t.label), (X_d.text, X_d.label)
  129. def data_balanced(train, test, dev):
  130. make = lambda X, y: pd.concat([X, y], axis=1).rename(columns={'HS': 'label'})
  131. texts_train_B = make(train[0], train[1])
  132. texts_test_B = make(test[0], test[1])
  133. texts_dev_B = make(dev[0], dev[1])
  134. train_b, test_b, dev_b = balanced(texts_train_B, texts_test_B, texts_dev_B)
  135. return train_b, test_b, dev_b
  136. # %%
  137. # train_h_b, test_h_b, dev_h_b = data_balanced(train_h, test_h, dev_h)
  138. train_sp_b, test_sp_b, dev_sp_b = data_balanced(train_sp, test_sp, dev_sp)
  139. # %%
  140. show_dist(train_sp_b, test_sp_b, dev_sp_b)
  141. # %% [markdown]
  142. # # **TF–IDF Sequence Encoding**
  143. # %%
  144. def fit_tfidf(texts):
  145. corpus = texts.values.tolist() if isinstance(texts, (pd.Series, pd.DataFrame)) else texts
  146. vectorizer = TfidfVectorizer(token_pattern=r"(?u)#?\b\w\w+\b", lowercase=True)
  147. vectorizer.fit(corpus)
  148. vocabulary = vectorizer.vocabulary_
  149. analyzer = vectorizer.build_analyzer()
  150. return vectorizer, vocabulary, analyzer
  151. def sequence_tfidf(X, corpus, vocabulary, analyzer, max_len):
  152. sequences = []
  153. for i, doc in enumerate(corpus):
  154. tokens = analyzer(doc)[:max_len]
  155. seq = [X[i, vocabulary[token]] if token in vocabulary else 0.0 for token in tokens]
  156. if len(seq) < max_len:
  157. seq += [0.0] * (max_len - len(seq))
  158. sequences.append(seq)
  159. return np.array(sequences)
  160. def transform_tfidf(texts, vectorizer, vocabulary, analyzer, max_len=50):
  161. corpus = texts.values.tolist() if isinstance(texts, (pd.Series, pd.DataFrame)) else texts
  162. X = vectorizer.transform(corpus)
  163. X_seq = sequence_tfidf(X, corpus, vocabulary, analyzer, max_len)
  164. return X_seq
  165. def tokenizer(text, analyzer, max_len=50):
  166. text_tok = analyzer(text)[:max_len]
  167. return np.array(text_tok)
  168. def make_dataset(X, y, vectorizer, vocabulary, analyzer):
  169. X_seq = transform_tfidf(X, vectorizer, vocabulary, analyzer)
  170. text_tokenized = X.apply(tokenizer, args=(analyzer, 50))
  171. text_tfidf_seq = pd.Series(list(X_seq), index=X.index)
  172. label = y
  173. data = pd.DataFrame({
  174. 'text_raw': X,
  175. 'text_tokenized': text_tokenized,
  176. 'embedding': text_tfidf_seq,
  177. 'label': label
  178. }).reset_index(drop=True)
  179. return data
  180. def save_data(train, test, dev, dir_name):
  181. vectorizer, vocabulary, analyzer = fit_tfidf(train[0])
  182. data_train_seq = make_dataset(train[0], train[1], vectorizer, vocabulary, analyzer)
  183. data_test_seq = make_dataset(test[0], test[1], vectorizer, vocabulary, analyzer)
  184. data_dev_seq = make_dataset(dev[0], dev[1], vectorizer, vocabulary, analyzer)
  185. save_data_path_seq = f'{PATH_DATA_CLF}{dir_name}/'
  186. data_train_seq.to_pickle(f'{save_data_path_seq}data_train_seq.pkl')
  187. data_test_seq.to_pickle(f'{save_data_path_seq}data_test_seq.pkl')
  188. data_dev_seq.to_pickle(f'{save_data_path_seq}data_dev_seq.pkl')
  189. # %%
  190. # Save data original and balanced
  191. save_data(train_sp, test_sp, dev_sp, 'SE')
  192. # save_data(train_h_b, test_h_b, dev_h_b, 'SE_B')
  193. save_data(train_sp_b, test_sp_b, dev_sp_b, 'SE_B')
  194. # %% [markdown]
  195. # # **TF–IDF Weighted Words Embedding Averaging**
  196. # %%
  197. def embedding_matrix(vectorizer, word_vector):
  198. features = vectorizer.get_feature_names_out()
  199. dim = word_vector.vector_size
  200. E = np.zeros((len(features), dim), dtype=np.float32)
  201. for j, tok in enumerate(features):
  202. if tok in word_vector:
  203. E[j] = word_vector[tok]
  204. return E
  205. def fit_(texts, path_model=PATH_MODEL_GLOVE):
  206. corpus = texts.values.tolist()
  207. word_vector = KeyedVectors.load(path_model, mmap='r')
  208. vectorizer = TfidfVectorizer(vocabulary=word_vector.key_to_index, lowercase=False)
  209. vectorizer.fit(corpus)
  210. E = embedding_matrix(vectorizer, word_vector)
  211. return vectorizer, word_vector, E
  212. def weighted_embedding(texts, vectorizer, E):
  213. corpus = texts.values.tolist() if isinstance(texts, (pd.Series, pd.DataFrame)) else texts
  214. X_tfidf = vectorizer.transform(corpus)
  215. X_emb_sum = X_tfidf.dot(E)
  216. # Normaliza los embeddings por la suma de TF-IDF de cada documento
  217. row_sums = np.array(X_tfidf.sum(axis=1)).reshape(-1, 1)
  218. nonzero = row_sums.squeeze() != 0
  219. X_emb = np.zeros_like(X_emb_sum)
  220. X_emb[nonzero] = X_emb_sum[nonzero] / row_sums[nonzero]
  221. return X_emb
  222. def tokenize_for_embedding(X, vectorizer, word_vector):
  223. analyzer = vectorizer.build_analyzer()
  224. tokenized = []
  225. for doc in X:
  226. toks = analyzer(doc)
  227. toks = [tok for tok in toks if tok in word_vector]
  228. tokenized.append(toks)
  229. return tokenized
  230. def make_dataset_weighted(X, y, vectorizer, word_vector, E):
  231. X_emb = weighted_embedding(X, vectorizer, E)
  232. text_tokenized = tokenize_for_embedding(X, vectorizer, word_vector)
  233. data = pd.DataFrame({
  234. 'text_raw': X,
  235. 'text_tokenized': text_tokenized,
  236. 'embedding': pd.Series(list(X_emb), index=X.index),
  237. 'label': y
  238. }).reset_index(drop=True)
  239. return data
  240. def save_data_w(train, test, dev, dir_name):
  241. vectorizer, word_vector, E = fit_(train[0])
  242. data_train_wwe = make_dataset_weighted(train[0], train[1], vectorizer, word_vector, E)
  243. data_test_wwe = make_dataset_weighted(test[0], test[1], vectorizer, word_vector, E)
  244. data_dev_wwe = make_dataset_weighted(dev[0], dev[1], vectorizer, word_vector, E)
  245. save_data_path_wee = f'{PATH_DATA_CLF}{dir_name}/'
  246. data_train_wwe.to_pickle(f'{save_data_path_wee}data_train_wwe.pkl')
  247. data_test_wwe.to_pickle(f'{save_data_path_wee}data_test_wwe.pkl')
  248. data_dev_wwe.to_pickle(f'{save_data_path_wee}data_dev_wwe.pkl')
  249. # %%
  250. # Save data original and balanced
  251. save_data_w(train_sp, test_sp, dev_sp, 'WWEA')
  252. save_data_w(train_sp_b, test_sp_b, dev_sp_b, 'WWEA_B')

text_preprocessing.ipynb, under CC-BY-4.0 · at the source

Overview

  1. Cinvestav, Unidad Tamaulipas, Ciudad Victoria 87130, Mexico; (E.A.-B.); (J.C.-H.); (M.G.-F.)
  2. Secihti—Centro de Investigación en Ciencias de Información Geoespacial, Scientific and Technological Park of Yucatan, Merida 97302, Mexico
Journal: Entropy (Basel, Switzerland), volume 28, issue 4, article 453
Dates: received 26 September 2025; accepted 11 April 2026; published online 15 April 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3390/e28040453 · PMID 42072578 · PMCID PMC13115206 · OpenAlex W7154484349
Open access: gold, a free copy (OpenAlex)
Status: code verified (how the code is found and verified)
Methods: Machine learning, Statistics, Connectivity, Preprocessing
Keywords: Polynomial Perceptrons, resource-efficient machine learning, model interpretability, explainable AI
Topic: Explainable Artificial Intelligence (XAI) (Artificial Intelligence, Computer Science), according to OpenAlex
Funding: Cinvestav, Unidad Tamaulipas and the Consejo Tamaulipeco de Ciencia y Tecnología (COTACYT)
Citations: not cited yet (Europe PMC); 25 references in the paper

Abstract

This paper introduces the Polynomial Perceptron (PP), a structured extension of the classical perceptron that incorporates explicit polynomial feature expansions to model nonlinear interactions while preserving analytical transparency. By expressing feature interactions in closed functional form, PP captures higher-order dependencies through a compact set of learned coefficients, establishing a principled trade-off between expressivity and parameter efficiency. The proposed architecture is evaluated across heterogeneous domains, including text, image, and structured data tasks, under controlled experimental settings with parameter-matched baselines. Performance is assessed using standard metrics such as classification accuracy and model complexity (parameter count). Empirical results demonstrate that low-degree PP models achieve competitive accuracy compared to multilayer perceptrons and convolutional neural networks, while requiring significantly fewer parameters. An ablation study further analyzes the impact of polynomial degree on predictive performance, revealing diminishing returns beyond moderate degrees and highlighting favorable efficiency–accuracy trade-offs. A key advantage of PP lies in its intrinsic interpretability. Unlike conventional deep learning models that rely on post hhoc explanation methods, PP provides direct analytical insight through its explicit polynomial structure, enabling decomposition of predictions into feature-, token-, or patch-level contributions without surrogate approximations. Overall, the results indicate that PP offers a lightweight, interpretable, and computationally efficient alternative to standard neural architectures, particularly well-suited for resource-constrained environments and applications where transparency is critical.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repositories

Its files are read in the Code ↔ Paper reader above, with 5 matches between paragraphs and lines of code.

figshare 31983450

License: CC-BY-4.0
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Data Availability Statement”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (14 files), Matplotlib (13 files), PyTorch (12 files), pandas (9 files), scikit-learn (6 files), SHAP (6 files), seaborn (5 files), SciPy (3 files), scikit-image (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers (HTTP 200)
  • 29 September 2026: the link answers (HTTP 200)
15 files

zalandoresearch/fashion-mnist

License: MIT
State: the link answers, verified on 30 October 2026
Evidence: files inventoried
Commit: b2617bb6d3ffa2e429640350f613e3291e10b141, 21 March 2022
Languages: Python (11), JavaScript (1)
Size: 51 files, 12 scripts
Software Heritage: archived
Found in: “Data Availability Statement”
Holds: README, license file, environment (Dockerfile, requirements.txt), documentation
Not found: CITATION.cff, tests, continuous integration
Tools: NumPy (5 files), scikit-learn (2 files), TensorFlow (2 files), Matplotlib (1 file)
Availability: 2 checks, the latest on 30 October 2026: the link answers
  • 30 October 2026: the link answers
  • 27 September 2026: the link answers
14 files

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 26 scripts, each with its path and the digest of its content;
  • 5 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

Datasets cited

Data Availability Statement

The source code and experimental materials supporting this study are publicly available at: https://doi.org/10.6084/m9.figshare.31983450. The repository includes the full implementation of the proposed Polynomial Perceptron models, along with notebooks required to reproduce all experiments. The datasets used in this study are publicly available from their official sources and are not redistributed as part of this work: Fashion-MNIST dataset (accessed on 10 April 2026): https://github.com/zalandoresearch/fashion-mnist; and SemEval-2019 Task 5 (accessed on 10 April 2026): https://huggingface.co/datasets/valeriobasile/HatEval. Instructions for downloading and preparing these datasets are provided in the repository. Users are required to download the datasets from the official sources and place them in the designated data/directory prior to running the experiments. Synthetic datasets used in tabular experiments are generated directly within the provided notebooks. All materials are provided to ensure full reproducibility of the reported results.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 29 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 4 authors, 4 keywords, 1 funder, 7 references.

Cite

This paper

Aldana-Bobadilla, E., Molina-Villegas, A., Cesar-Hernandez, J., & Garza-Fabre, M. (2026). Polynomial Perceptrons for Compact, Robust, and Interpretable Machine Learning Models. Entropy (Basel, Switzerland), 28(4), 453. https://doi.org/10.3390/e28040453

BibTeX

@article{aldanabobadilla2026polynomial,
author = {Aldana-Bobadilla, Edwin and Molina-Villegas, Alejandro and Cesar-Hernandez, Juan and Garza-Fabre, Mario},
title = {{Polynomial Perceptrons for Compact, Robust, and Interpretable Machine Learning Models}},
journal = {Entropy (Basel, Switzerland)},
year = {2026},
month = apr,
volume = {28},
number = {4},
pages = {453},
publisher = {Multidisciplinary Digital Publishing Institute (MDPI)},
issn = {1099-4300},
doi = {10.3390/e28040453},
url = {https://doi.org/10.3390/e28040453},
pmid = {42072578},
pmcid = {PMC13115206}
}

RIS

TY - JOUR
AU - Aldana-Bobadilla, Edwin
AU - Molina-Villegas, Alejandro
AU - Cesar-Hernandez, Juan
AU - Garza-Fabre, Mario
TI - Polynomial Perceptrons for Compact, Robust, and Interpretable Machine Learning Models
T2 - Entropy (Basel, Switzerland)
J2 - Entropy (Basel)
PY - 2026
DA - 2026/04/15
VL - 28
IS - 4
SP - 453
SN - 1099-4300
PB - Multidisciplinary Digital Publishing Institute (MDPI)
DO - 10.3390/e28040453
UR - https://doi.org/10.3390/e28040453
LA - en
ER -

CSL-JSON

{
"id": "10.3390/e28040453",
"type": "article-journal",
"title": "Polynomial Perceptrons for Compact, Robust, and Interpretable Machine Learning Models",
"container-title": "Entropy (Basel, Switzerland)",
"author": [
{
"family": "Aldana-Bobadilla",
"given": "Edwin"
},
{
"family": "Molina-Villegas",
"given": "Alejandro"
},
{
"family": "Cesar-Hernandez",
"given": "Juan"
},
{
"family": "Garza-Fabre",
"given": "Mario"
}
],
"container-title-short": "Entropy (Basel)",
"volume": "28",
"issue": "4",
"page": "453",
"DOI": "10.3390/e28040453",
"PMID": "42072578",
"PMCID": "PMC13115206",
"ISSN": "1099-4300",
"publisher": "Multidisciplinary Digital Publishing Institute (MDPI)",
"URL": "https://doi.org/10.3390/e28040453",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
15
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: SHAP, TensorFlow, scikit-image, 7 other tools
[2] doi:10.1038/s41467-025-57027-x [code]
Topological identification and interpretation for single-cell epigenetic regulation elucidation in multi-tasks using scAGDE.
Journal: Nature communications
In common: SHAP, TensorFlow, scikit-image, 7 other tools
[3] doi:10.1126/sciadv.aed3650 [code]
Truthful visualizations for mass spectrometry imaging enable high-spatial-resolution interactive &lt;i&gt;m/z&lt;/i&gt; mapping and exploration.
Journal: Science advances
In common: SHAP, TensorFlow, scikit-image, 6 other tools
[4] doi:10.1038/s41531-025-00982-5 [code]
Baseline [&lt;sup&gt;18&lt;/sup&gt;F]FP-CIT PET-based deep learning prediction of levodopa-induced dyskinesia in Parkinson's disease.
Journal: NPJ Parkinson's disease
In common: SHAP, TensorFlow, scikit-image, 6 other tools
[5] doi:10.1007/s12021-024-09675-5 [code]
Classifying Neuronal Cell Types Based on Shared Electrophysiological Information from Humans and Mice.
Journal: Neuroinformatics
In common: SHAP, TensorFlow, seaborn, 5 other tools, 1 reference
[6] doi:10.1007/s10143-023-02114-0 [code]
Enhancing the prediction for shunt-dependent hydrocephalus after aneurysmal subarachnoid hemorrhage using a machine learning approach.
Journal: Neurosurgical review
In common: SHAP, TensorFlow, seaborn, 5 other tools, 1 reference
[7] doi:10.1007/s10994-022-06167-y [code]
Scrutinizing XAI using linear ground-truth data with suppressor variables.
Journal: Machine learning
In common: SHAP, TensorFlow, seaborn, 5 other tools, 1 reference
[8] doi:10.1111/acel.70656 [code]
Deep Learning Predicts Hematopoietic Stem Cell Aging From 3D Chromatin Images.
Journal: Aging cell
In common: SHAP, TensorFlow, scikit-image, 6 other tools
[9] doi:10.1371/journal.pcbi.1014615 [code]
Toward reliable machine learning models for neural circuit inference: A diagnostic study of CNNs on spike trains.
Journal: PLoS computational biology
In common: SHAP, TensorFlow, PyTorch, 6 other tools
[10] doi:10.1038/s41598-026-48613-0 [code]
An snRNA-seq aging clock for the fruit fly head sheds light on sex-biased aging.
Journal: Scientific reports
In common: SHAP, TensorFlow, PyTorch, 6 other tools

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Add the badge to the code's README

OSCR: the badge of this paper

If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.

Markdown
<!-- oscr-badge:start -->
[![OSCR](https://openscicode.org/badge/doi/10.3390/e28040453.svg)](https://openscicode.org/badge/doi/10.3390/e28040453)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.3390/e28040453.svg
   :target: https://openscicode.org/badge/doi/10.3390/e28040453
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.3390/e28040453"><img src="https://openscicode.org/badge/doi/10.3390/e28040453.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->

On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".

If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.

Report a mismatch between the code and the paper · Report a code error (signed in)

Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.

Report a reproduction failure (signed in)

Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.