SynaptIX

Librería integral de Machine Learning para Python. Una API unificada y en español que cubre aprendizaje supervisado, no supervisado, por refuerzo, redes neuronales y preprocesamiento de datos — pensada para AI Engineers y analistas de modelos.

Documentación completa + playground en línea: https://synaptix-blue.vercel.app/ (sitio Next.js en web/ de este repo — el docs-web/ anterior queda deprecado tras la migración).

pip install synaptix            # núcleo (sklearn incluido)
pip install synaptix[dl]        # + tensorflow (redes neuronales y DQN)
pip install synaptix[bayes]     # + pymc (inferencia bayesiana completa)
pip install synaptix[viewx]     # + ViewX (dashboards HTML, PDF, presentaciones)
pip install synaptix[stats]     # + StatsLibX (diagnóstico estadístico de modelos)
pip install synaptix[polars]    # + polars (DataFrames polars como entrada)
pip install synaptix[all]       # todo

Inicio rápido

import synaptix as sx

# 1. Cargar un dataset incluido
df = sx.load_dataset("iris")

# 2. Preparar los datos
X, y = df.drop(columns="species"), df["species"]
X_train, X_test, y_train, y_test = sx.preprocessing.train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 3. Entrenar y evaluar
model = sx.supervised.RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)
model.evaluate(X_test, y_test, plot=True)  # métricas + matriz de confusión

Módulos

Ejemplos por área

AutoPipeline: ML en una línea (para empezar sin experiencia)

import synaptix as sx

df = sx.load_dataset("penguins")

pipe = sx.AutoPipeline()          # el sistema se encarga de los parámetros
pipe.fit(df, target="species")    # limpia, compara 7 modelos, ajusta y evalúa
pipe.report()                     # ranking + métricas + matriz de confusión

predicciones = pipe.predict(df_nuevo)   # acepta datos crudos (con nulos)
pipe.save("mi_pipeline.pkl")

Todo es configurable: AutoPipeline(models=["random_forest", "svm"], cv=10, tune=False, scale_method="robust", param_grids={"random_forest": {"n_estimators": [300]}}).

También hay un Pipeline declarativo por pasos, donde el sistema rellena los parámetros de cada paso:

from synaptix.pipeline import Pipeline

pipe = Pipeline([
    "clean",                            # DataCleaner con defaults
    ("outliers", {"method": "iqr"}),    # params propios opcionales
    ("model", "random_forest"),         # o "model" solo = elegir automático
    "tune",                             # rejilla por defecto del modelo
    ("evaluate", {"plot": True}),
])
pipe.fit(df, target="species")

Modelos bayesianos (con incertidumbre)

from synaptix.supervised import BayesianRidgeRegression, GaussianProcessRegressor

model = BayesianRidgeRegression()
model.fit(X_train, y_train)

# Además de la predicción puntual, un intervalo de incertidumbre:
media, inferior, superior = model.predict_interval(X_test, std=2)  # ~95%

Con el extra [bayes] (PyMC) se obtiene la distribución posterior completa:

from synaptix.supervised import PyMCLinearRegression

model = PyMCLinearRegression(draws=1000)
model.fit(X_train, y_train)                       # inferencia MCMC
media, low, high = model.predict_interval(X_test, hdi=0.94)
model.summary()                                   # posteriores de cada parámetro
model.plot_posterior()

Preprocesamiento

from synaptix.preprocessing import DataCleaner

cleaner = DataCleaner(impute_strategy="median", scale_method="standard")
cleaner.analyze(df)                    # reporte: nulos, outliers, tipos
df_listo = cleaner.clean(df, target="precio")

Comparar modelos automáticamente

from synaptix.model_selection import compare_models

tabla = compare_models(X, y, task="classification", cv=5)
# Entrena 7 modelos con validación cruzada y devuelve un ranking

Clustering (no supervisado)

from synaptix.unsupervised import KMeans

KMeans.elbow(X, k_max=10)              # elegir k con el método del codo
km = KMeans(n_clusters=3)
labels = km.fit_predict(X)
km.plot(X)                             # scatter coloreado por cluster
print(km.silhouette(X))

Aprendizaje por refuerzo

from synaptix.reinforcement import GridWorld, QLearningAgent

env = GridWorld(rows=5, cols=5, obstacles=[(1, 1), (2, 3)])
agent = QLearningAgent(env.n_states, env.n_actions)
agent.train(env, episodes=500)
agent.plot_rewards()
env.render(agent.policy())             # política aprendida con flechas

Redes neuronales

from synaptix.neural import MLP, LSTMNet

# Clasificación tabular
net = MLP(task="classification", hidden_layers=(64, 32), dropout=0.2)
net.fit(X_train, y_train, epochs=50)
net.evaluate(X_test, y_test)
net.plot_history()

# Series de tiempo
lstm = LSTMNet(window=12, units=(64,))
lstm.fit(serie, epochs=50)
futuro = lstm.forecast(serie, steps=6)

Gráficas a partir de datos y modelos

from synaptix.visualization import (
    plot_distributions,     # histogramas de todas las numéricas
    plot_correlation,       # heatmap de correlación
    plot_boxplots,          # outliers, segmentables por categoría
    plot_missing,           # % de nulos por columna
    plot_residuals,         # diagnóstico de regresión
    plot_decision_boundary, # frontera de decisión 2D
    model_report,           # reporte visual completo en una llamada
)

plot_correlation(df)
plot_boxplots(df, by="species")
model_report(modelo, X_test, y_test)  # métricas + gráficos según la tarea

Búsqueda de hiperparámetros

from synaptix.supervised import RandomForestClassifier
from synaptix.model_selection import GridSearch

search = GridSearch(
    RandomForestClassifier(),
    {"n_estimators": [50, 100, 200], "max_depth": [3, 5, None]},
)
mejor_modelo = search.fit(X, y)
print(search.best_params_)

Integración con ViewX y StatsLibX

SynaptIX es el motor de machine learning del ecosistema GhostAnalyst, junto con StatsLibX (estadística) y ViewX (visualización y reportes). Las tres comparten el mismo contrato de payload y cargadores de datasets, y cada una funciona por separado:

flowchart TD
    U["Datos crudos<br/>(CSV, DataFrame, arrays)"]
    SLX["StatsLibX<br/>estadistica + manejo de datos + simulacion"]
    SYN["SynaptIX<br/>modelos + evaluacion y mejora"]
    VX["ViewX<br/>dashboards, EDA, PDF, slides"]
    U --> SLX
    U --> SYN
    U --> VX
    SLX -->|"DataFrame / polars"| SYN
    SLX -->|"to_report_data() payload"| VX
    SYN -->|"to_report_data() payload"| VX
    SYN -->|"diagnostics() usa InferentialStats"| SLX
    VX -->|"HTML / PDF / slides"| U

SynaptIX hace todo el machine learning; las integraciones son opcionales y cada librería funciona por separado.

Flujo completo del ecosistema (StatsLibX → SynaptIX → ViewX)

# pip install statslibx[viewx] synaptix[viewx,stats] viewx
from statslibx import DescriptiveStats, load_iris
import synaptix as sx
from viewx import from_report_payload

df = load_iris()

# 1. Estadística y calidad de datos (StatsLibX)
DescriptiveStats(df).summary()

# 2. Modelo, evaluación y diagnóstico estadístico (SynaptIX + StatsLibX)
X, y = df.drop(columns="species"), df["species"]
modelo = sx.supervised.RandomForestClassifier().fit(X, y)
evaluacion = modelo.evaluate(X, y)
diagnostico = modelo.diagnostics(X, y)   # requiere synaptix[stats]

# 3. Todo en un dashboard (ViewX)
payload = evaluacion.to_report_data(include_figures=True)
from_report_payload(payload, target="html", filename="analisis.html")

Portal con documentación y playground unificado de las tres librerías: Libraries_of_Emms (en este workspace).

Exportar resultados con ViewX (pip install synaptix[viewx])

Los resultados de evaluate(), cross_validate() y compare_models() siguen siendo dicts/DataFrames normales, pero además se pueden exportar a dashboards HTML, reportes PDF y presentaciones:

import synaptix as sx

df = sx.load_dataset("iris")
X, y = df.drop(columns="species"), df["species"]

model = sx.supervised.RandomForestClassifier().fit(X, y)
resultado = model.evaluate(X, y)            # dict de métricas, como siempre

# Requiere: pip install synaptix[viewx]
resultado.to_html("evaluacion.html", theme="dark_enterprise")   # dashboard
resultado.to_report("evaluacion")                               # PDF
resultado.to_presentation("evaluacion_slides.html")             # slides

# La tabla de compare_models sigue siendo un DataFrame; para el dashboard usa to_dashboard()
tabla = sx.model_selection.compare_models(X, y, task="classification")
tabla.to_dashboard("comparacion.html")

# Pipeline manual con el mismo contrato de payload que StatsLibX
payload = resultado.to_report_data(include_figures=True)
from viewx import from_report_payload
from_report_payload(payload, target="html", filename="evaluacion.html")

Sin ViewX instalado: el análisis funciona normal. Los métodos .to_html() / .to_report() / .to_presentation() lanzan un error claro con la instrucción de instalación.

Diagnóstico estadístico con StatsLibX (pip install synaptix[stats])

# Regresión: normalidad de residuos + test de media cero
# Clasificación: chi-cuadrado de asociación real vs. predicho
diagnostico = model.diagnostics(X_test, y_test)
diagnostico["normalidad_residuos"].interpretation

Entrada polars

Los modelos y pipelines aceptan DataFrames de polars directamente (se convierten internamente), por lo que la salida de StatsLibX con backend polars entra sin conversión manual:

df_pl = sx.load_dataset("iris", backend="polars")   # requiere synaptix[polars]
model.fit(df_pl.drop("species"), df_pl["species"])

X, y = sx.load_dataset("iris", return_X_y=True)     # misma firma que statslibx/viewx

API legacy (v0.x)

Las clases de la versión 0.x siguen disponibles: IntelligenceArtificial (agentes, búsqueda, algoritmos genéticos, chatbots), MachineLearning y NaturalLanguageProcessing. La API key de OpenRouter ahora se lee de la variable de entorno OPENROUTER_API_KEY.

from synaptix import IntelligenceArtificial

ia = IntelligenceArtificial(backend_ia=("mistral", ""))  # usa OPENROUTER_API_KEY

Licencia

MIT. Autor: Emmanuel Ascendra — github.com/GhostAnalyst30/SynaptIX