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.

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–310 · score 0.67 · Weighted Word Embedding, TfidfVectorizer
  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–310 · score 0.58 · TF IDF weight, weighted embedding, matrix, vector
  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–23 · score 0.56 · Ankle Boot, Sandal, Sneaker, MNIST
  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–98 · score 0.55 · hidden layer, support vectors, MLPs, multiclass, polynomial, model
  5. [5] § 4. Polynomial Perceptrons in Practical Use Cases › 4.4. Natural Language Processing › 4.4.1. Architecture ↔ Utils/Text_Explainer.py, lines 67–74 · score 0.51 · TF IDF, weighted embedding

Paper

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

Authors: Edwin Aldana-Bobadilla1, Alejandro Molina-Villegas2, Juan Cesar-Hernandez1, Mario Garza-Fabre1
ORCID iDs: Edwin Aldana-Bobadilla, Alejandro Molina-Villegas, Juan Cesar-Hernandez, Mario Garza-Fabre
  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
Institutions: Centro de Investigación y de Estudios Avanzados del Instituto Politécnico Nacional (Mexico); Centro de Investigación en Ciencias de Información Geoespacial (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
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
At the source: doi.org/10.6084/m9.figshare.31983450

zalandoresearch/fashion-mnist

License: MIT
State: the link answers, verified on 27 September 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: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
14 files
At the source: github.com/zalandoresearch/fashion-mnist

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.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
[3] 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
[4] 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
[5] doi:10.1038/s41467-026-76837-1 [code]
Drug screen and machine learning predict neuroprotective agents in a preclinical human model of childhood dementia.
Journal: Nature communications
In common: SHAP, scikit-image, PyTorch, 6 other tools
[6] doi:10.1016/j.isci.2026.116825 [code]
Social hierarchy shapes behavioral and transcriptional responses to chronic stress and ketamine in male mice.
Journal: iScience
In common: SHAP, scikit-image, PyTorch, 6 other tools
[7] doi:10.1016/j.bpj.2026.06.005 [code]
Curvature-based machine-learning method for automated segmentation of dendritic spines.
Journal: Biophysical journal
In common: SHAP, TensorFlow, scikit-image, 5 other tools
[8] doi:10.7554/elife.110588 [code]
Opening the black box toward a modular approach to spike sorting.
Journal: eLife
In common: TensorFlow, scikit-image, PyTorch, 6 other tools
[9] doi:10.1016/j.isci.2026.117010 [code]
Deep learning-assisted mapping of dendritic spines using sequential 2D two-photon calcium imaging.
Journal: iScience
In common: TensorFlow, scikit-image, PyTorch, 6 other tools
[10] doi:10.1371/journal.pcbi.1014571 [code]
SynAPSeg: A novel dataset and image analysis framework for deep learning-based synapse detection and quantification.
Journal: PLoS computational biology
In common: TensorFlow, scikit-image, 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.

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: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

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