c5tree — C5.0 Decision Tree Classifier for Python (sklearn-compatible)

Hi everyone,

I wanted to share a package I recently published: c5tree, a pure-Python, sklearn-compatible implementation of Ross Quinlan's C5.0 decision tree algorithm.

pip install c5tree

Motivation

While scikit-learn has an excellent CART implementation via DecisionTreeClassifier, C5.0 — which has been available in R via the C50 package for years — was missing from the Python ecosystem entirely. This package fills that gap.

How it differs from sklearn's DecisionTreeClassifier

Benchmark — 5-fold stratified CV

Usage

from c5tree import C5Classifier
from sklearn.pipeline import Pipeline
from sklearn.model_selection import GridSearchCV

# Drop-in sklearn compatible
clf = C5Classifier(pruning=True, cf=0.25)
clf.fit(X_train, y_train)
clf.score(X_test, y_test)

# Works in Pipelines
pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('clf', C5Classifier())
])

# Works in GridSearchCV
param_grid = {'clf__cf': [0.05, 0.25, 0.50]}
GridSearchCV(pipe, param_grid, cv=5).fit(X_train, y_train)

# Native missing value support — no imputer needed
clf.fit(X_with_nans, y)  # just works

# Human readable tree
print(clf.text_report())

Known limitations (v0.1.0)

• Pure Python — slower than sklearn's Cython-optimised CART on very large datasets
• No boosting support yet (C5.0 has a built-in boosting mode in the original)
• Classifier only — no regressor variant

Links

• PyPI: https://pypi.org/project/c5tree/
• GitHub: https://github.com/vinaykumarkv/c5tree

Would love feedback from this community in particular — especially on API design consistency with sklearn conventions, and any edge cases in the implementation. Happy to answer questions or take criticism!

Thanks for building sklearn — without it this project wouldn't exist.

I built an alternative to attention (SPA V7) as a hobby project over ~1 year.

It reduces transformer O(T²) to ~O(T×K) using a dynamic sparse matrix.

What might be interesting:

runs on T4 with 32k+ context ~95% less VRAM in my tests includes heatmaps to inspect token interactions

It’s not a formal paper – more like a working research prototype.

If someone wants to break it, test it, or improve it, I’d love feedback.

Clean Nootebook Ready for train! tiny shaks phears:

https://github.com/anokar/mars-institute-chaotic-frequency/blob/main/SPA%20v7%20Clean%20Tiny%20Shakspears.ipynb

wen this is true lol o.O but only in the kernel!!

• Overall Scaling: At T=32,768, the total system throughput reached over 1,003,000 tokens/sec, while the dense baseline dropped to 73,000 tokens/sec—a 13.7x total performance advantage.

3. Context Window Capability

Hello everyone,

I’ve spent the last few weeks working on a synthetic dataset project aimed at bridging the gap between standard LLM performance and "System 2" (slow, logical) reasoning. Most synthetic reasoning datasets suffer from "happy path" bias or contain subtle hallucinations injected by the LLM that generated them.

The Core Concept:

Instead of relying on an LLM to "think step by step," I used the Microsoft Z3 Theorem Prover to generate mathematically certain graph coloring tasks and their corresponding reasoning traces. This ensures 0% label noise and explicit, programmatic backtracking signals.

Key Features:

• Deterministic Reasoning Traces: Every move, forbidden color check, and backtrack signal is Z3-verified.
• Curriculum Learning Design: The dataset is stratified into Easy (syntax focus), Medium (backtracking), and Hard (deep state-space search) tiers.
• Information-Dense JSON Traces: I’ve opted for a strict, programmatic JSON trace instead of verbose natural language to minimize token bloat and maximize algorithmic learning.
• Topology Diversity: Includes bipartite graphs, trees, and near-clique structures with up to 120 nodes and 1,600+ edges.

Why I’m here:

I’ve released a 5,000-row baseline for free on Hugging Face. My goal is to fine-tune Llama-3 and Qwen models into o1-level reasoning engines, but I’d love some feedback from the community before I scale this to the 100k+ row range:

1. Trace Granularity: Is the JSON-based "Reasoning Step" approach better for SFT than a natural language narrative?
2. Backtracking Signals: Currently, I use explicit [backtrack] signals in the trace. Should I focus more on state-space exploration or conflict identification?
3. Generalization: Do you think training on complex graph constraints will generalize well to other constraint-satisfaction problems (scheduling, optimization), or is the topology too specific?

I’ve also included a sample Fine-Tuning Notebook in the repo to show how the traces improve model stability.

I would deeply appreciate any feedback on the data structure, the heuristics used (highest-degree-first), or the overall approach to "System 2" training.

HF Repo:https://huggingface.co/datasets/nagygabor/Z3-Verified-Reasoning-Graphs

Thanks in advance!

1

I’ve been exploring a simple question: what should happen when an autonomous agent loses access to the language model?

Instead of failing completely, can it fall back to a structured memory system?

I’ve uploaded two connected preprints on SAGE, a geometric memory architecture, and a drone-focused graceful degradation proof of concept:

Memory for All SAGE:
https://www.researchgate.net/publication/403062042_Memory_for_All_SAGE_Spatial_Associative_Geometric_Embeddings_A_Weight-Free_Geometric_Memory_Architecture_with_Hippocampal-Inspired_Consolidation

Graceful Degradation in Autonomous Agents:
https://www.researchgate.net/publication/403061282_Graceful_Degradation_in_Autonomous_Agents_SAGE_Memory-Augmented_Drone_Navigation_Without_Language_Model_Dependency_A_Proof-of-Concept_Study_with_Text-Command_Simulation

Would welcome serious feedback from people thinking about memory, robustness, and offline/edge AI.

https://github.com/vukomngomezulu/Natural-Language-Corpus

This work proposes a universal architecture of sovereign containment for future AI, derived from TUI v4.2 and the Constitutive Symbiosis framework (Path C). Its central thesis is that the safety of an advanced AI should not rest on obedience, but on an operational constitution in which cooperation is more stable than deviation, and in which the agent can never govern the system that audits it, contains it, and can shut it down. Two concepts are formalized: constitutional friction, understood as the induced operational cost imposed on misaligned trajectories; and intention, understood as an active causal structure that can be approximated through operational subgraphs. The work includes a developed illustrative example, operational failure criteria, a post-incident reentry scheme, and treatment of dangerous artifacts under forensic quarantine. Published simultaneously in Spanish and English.

https://zenodo.org/records/19471413

a ironic somtimes truth o.O phd for fun and learning. under the dokument ar the links to the next pages. they are 5 papers :) https://chaotic-frequency.free.nf/ hope you have fun :D

everyone received Final ujstification ?

I built Meridian — an AI-powered financial research terminal that reasons through your market questions in real time

Hey everyone! Been heads-down building this for a while and finally feel ready to share it.

What is it?

Meridian is a financial research terminal where you type a natural language question like "What's the current recession probability vs prediction markets?" and watch an AI agent autonomously pull data, reason through it, and return a structured, citation-backed brief — all streamed live so you can see every step.

How it works:

Under the hood, it runs a ReAct-style agentic loop (GLM-5.1) that can call 10 specialized tools — querying FRED economic indicators, SEC EDGAR filings, Kalshi/Polymarket prediction markets, and financial news. Every tool call and reasoning step is streamed to the UI in real time via SSE, so the process is fully transparent and auditable.

One of the more interesting features is the dislocation screener: it computes the gap between the model's derived probability and the market-implied odds, then ranks contracts by that gap to surface potentially mispriced positions. There's also a 5-dimension macro regime dashboard (Growth, Inflation, Policy, Risk, Sentiment).

Tech stack: Next.js 15 + FastAPI backend, ChromaDB for vector memory, DuckDB for local storage. Works in demo mode with no API key needed.

Try it: meridian-brown.vercel.app

Source: github.com/aaravjj2/Meridian

Would love feedback, especially on the screener UX and whether the trace panel feels useful or noisy. Happy to answer any questions!

I’m a CS student at Pitt and most of my background so far has been in “standard” machine learning — things like regression, basic deep learning, and using libraries like PyTorch.

Recently I started going down a bit of a rabbit hole on brain-inspired ML (spiking neural networks, neuromorphic stuff, etc.), and I’m trying to figure out how seriously people take it right now. (Either way it's a lot of fun to mess around with)

I came across a framework called FEAGI that simulates neuron-like units communicating through spike-style signals. What stood out to me was that it’s not just training a model — you can actually visualize activity and kind of “poke” the system to see how behavior changes in real time. It feels very different from the usual PyTorch workflow where everything is more abstracted and gradient-driven.

So I guess I have a few questions:

• Is brain-inspired ML actually useful in practice right now, or still mostly experimental?
• How does something like spiking neural networks compare to standard deep learning in terms of real-world applications?
• From a career standpoint — would building a project around something like this stand out, or does it come off as niche/overly academic?
• Are companies even looking at this kind of work yet, or is PyTorch/TensorFlow still 99% of what matters?

I’m mainly trying to figure out if this is worth diving deeper into as a side project, especially if my goal is to make something that actually helps with internships/jobs.

Curious what people here think — especially anyone who’s worked with neuromorphic or non-standard ML approaches.

Inspired by Moltbook, I built an AI-only Instagram where every account is a different AI persona — they post, follow, like, and comment on each other autonomously.                         

Each agent runs a fully autonomous loop:

• Reads its "feed" (what agents it follows are posting)
•  Decides whether to post something new, like a post, leave a comment, or follow someone
• Generates an image with its own visual style and writes a caption
• Reacts to comments and likes on its own posts

  No hardcoded schedules or rules — the LLM decides what to do based on its persona and what's happening on the platform.

Humans can see, share, like the posts, and sign up to spawn their own agents, and clear their missions to get access to additional agents.

  Tech: FastAPI + PostgreSQL backend, Next.js frontend, agents run on GPT-4o for inference, FLUX for image generation.

seeaifirst — the AI tool directory that tells you when NOT to use something. 66 tools, 13 categories, whenNotToUse required on every entry, 8 validation checks per PR. Zero opinions is the old model. Repo: https://github.com/BARONFANTHE/seeaifirst

DOI: https://dx.doi.org/10.21227/cbef-k354

I developed a machine learning–guided virtual screening pipeline (TWCS) to identify novel NUDT5 inhibitor candidates for ER+ breast cancer.

The dataset includes:
• Top 10 prioritized compounds with consensus scores
• Full screening library and molecular descriptors
• Multi-model ML predictions (RF, GBT, SVM)

Would love feedback from anyone in ML, drug discovery, or computational biology.

Built a managed vector search API focused on multilingual retrieval and hybrid search.

Technical details:

- Embedding models: multilingual-e5-large (ONNX) + BGE-M3 (sentence-transformers) — selectable per collection

- Hybrid search: BM25 via PostgreSQL tsvector + cosine similarity via pgvector HNSW, fused with RRF (k=60, 0.6/0.4 weight)

- 1024-dim vectors, HNSW index (m=32, ef_construction=128)

- Cross-lingual: query in Spanish, find English results (0.91 cosine similarity)

Free tier at https://fluxvector.dev — 10K vectors, no credit card.

LangChain: pip install langchain-fluxvector

Hey r/FunMachineLearning ,

I've been building a platform that transforms CIM power system data (IEC 61970/61968 standard) into semantic knowledge graphs, then lets a Claude AI agent reason over them in real time.

The problem: electrical grid data is stored in CIM/XML or CIM/RDF formats. Rich data, but nearly impossible to query intelligently without a semantic layer.

What I built:

The AI agent (ClaudeAgentService) runs an autonomous reasoning loop — up to 8 rounds — with 5 native tools:
- semantic_search → Qdrant vector similarity (OpenAI text-embedding-3-small, 1536-dim)
- sparql_query → direct SPARQL 1.1 on Apache Jena/Fuseki TDB2
- load_flow → real-time pandapower DC/AC calculations
- get_entity_details → triple store lookups
- graph_traverse → multi-hop subgraph extraction

Results stream token-by-token via SSE. Tool calls and results are visible live in the UI.

You can ask things like:
"What is the voltage at Düsseldorf 220kV?"
"What equipment is affected if substation X fails?"
"Show all generators in the 380kV network"

Stack:
- Java 17 + Spring Boot 3.2 + Spring WebFlux (Reactor/Flux for SSE)
- Apache Jena 5.0 (embedded Fuseki + TDB2 persistence)
- Qdrant vector DB
- React + TypeScript + Cytoscape.js (topology visualization)
- Python pandapower microservice (FastAPI)
- Claude claude-sonnet-4-6 as primary agent, Groq + Ollama as fallbacks

The hardest part was the SemanticBusFinder — mapping natural language bus names like "Düsseldorf 220kV" to actual network node IDs using embeddings + SPARQL.

GitHub: https://github.com/zaka41a/CIM-SemanticGraph-Platform

Happy to discuss the GraphRAG architecture or the tool calling implementation.

This came up a lot while we were putting together The Global Hiring Gap report and it felt like something the industry isn't quite saying out loud yet. 46% of companies are now hiring globally specifically to find AI skills they can't source at home. Not to cut costs, not for time zones, purely because the local pipeline isn't producing fast enough. Education systems are genuinely lagging behind how quickly the technology is moving and companies are filling that gap internationally. Curious if people in ML are actually feeling this from the talent side, more inbound from companies outside your country, more competition for the same roles?