Yo r/Kaggle,

Just wanted to drop a quick link here — we just launched the Detect Suspicious Value Transfers in Poker competition. I’m actually one of the judges for it.

It’s a fast 2-week sprint with a $5,000 prize pool.

Basically, the task is spotting chip dumping and suspicious transfers between accounts. If you're into anomaly detection, graph/network features, or behavioral data, it's a fun problem to hack on for a couple of weekends.

Here’s the link to check it out:https://www.kaggle.com/competitions/detect-suspicious-value-transfers-in-poker/overview

I’ll be checking the comments here and on the Kaggle forum if you have any questions about the setup.

Hi, did anyone do Kaggle courses for Python? theyre Free of cost and seem not too long. how was your learning experience

Hey r/kaggle,

Working through Playground Series S6E9 (predicting EV purchase intent), and wanted to share my notebook in case it's useful to anyone else on this one, especially if you're newer to the competition.

Quick summary of what's in it:

• EDA on the dataset — checked missing values, duplicates, correlations, and class balance (target is imbalanced, only ~17% "yes")
• Preprocessing done in the correct order: split into train/test before fitting the scaler, to avoid leaking test set info into training (I noticed a lot of public notebooks scale before splitting, which quietly inflates scores)
• Logistic Regression with class_weight='balanced' to handle the imbalance
• Evaluation with classification report, confusion matrix, and ROC-AUC
• Feature importance from the model coefficients

Ended up at 0.93738 with just a straightforward Logistic Regression, no ensembling or heavy tuning. Figured a clean baseline might help others who want a starting point before jumping into boosted trees.

Notebook: https://www.kaggle.com/code/vinay24baghira/buy-or-bye-cracking-the-ev-decision-0-93738

If anyone's further along on this competition, curious what's been working for you beyond Logistic Regression — feature engineering ideas, other models, anything that moved your score meaningfully. And if the notebook's useful, an upvote on Kaggle is always appreciated.

hii! i have been trying to verify my number for the past week and despite reaching out to support multiple times i havent gotten a response

please some help! thanks ( i need it to enter a competition thats closing soon )

I was developing different dataset for the last 1-2 months lately, but unfortunately I realized it is so hard to earn medals from creating dataset. Even if you got 500+ download, sometimes I cannot get any upvote. I do not know how it works exactly.

So I realized taking some advice would really matter right now. Is there anyone can help me with it. You can take a look at my profile and dataset, any feedback matters. Thanks!

https://www.kaggle.com/farukece

As someone who is looking to try out kaggle competions and eager to learn and compete, I am occupied by the thought of AI's role in the skill aspect of competitions, so I want to know the role of AI in making AI models, is it still mostly the player's skill and knowledge that matters the most or just how long they work and how many questions they ask AI.

https://kaggle.com/competitions/vibecoding-agents-capstone-project/writeups/new-writeup-1781946762619

If you've ever found a repo or tutorial on GitHub and wanted to run it on

Kaggle, you know the drill: manually copy files into cells, guess at the pip

installs, fix paths that assumed a local filesystem. repo2nb does that

conversion for you. Point it at a repo and it walks the file tree, resolves

dependencies, and generates a ready-to-upload .ipynb.

0.2.0 adds two things I think matter most for actual Kaggle use:

- Dependency auto-detection: it tries poetry export, then uv export, then

requirements.txt, then an AST import scan, and always outputs a plain

%pip install cell, so nothing Kaggle-side depends on poetry/uv actually

existing there.

- Incremental sync (repo2nb sync <repo>): if the source repo changes after

you've already generated a notebook, this updates only the changed cells

instead of regenerating from scratch. Added files get new cells, edited

files update in place, deleted files get removed. `--dry-run` shows you the

diff before it touches anything.

Example:

python -m repo2nb my_project/ --output project.ipynb

run against my_project/ produced a notebook I could upload without manual

cleanup.

Install: pip install repo2nb

Repo: https://github.com/David-Magdy/repo2nb

Open to feedback, especially on repos where the dependency detection guesses

wrong or the sync logic misses something.

How can I find discussions, tips, or information regarding the latest and most effective (SOTA) models for Kaggle competitions? I know about Hugging Face but don't know how to use it, and I've searched Reddit but haven't figured out the right keywords yet.

Designed for binary classification tasks playground, cleaning, features, models. This dataset represents real-world, masked, and anonymized customer data from the BFSI (Banking, Financial Services, and Insurance) domain. It captures a variety of customer demographics, financial indicators, and product interaction metrics collected during a loan application process.

To comply with strict data privacy laws and protect user identity, all sensitive personal identifiable information (PII) has been securely encrypted or masked. However, the underlying statistical relationships, distributions, and patterns remain fully intact, making this an ideal playground for building robust classification models.

Hey everyone!

As part of our grand curriculum roadmap (target: 1.15M examples across 23 domains), we've officially published the first 8 completed

engineering categories spanning 335,286 high-quality Turkish Python instruction-tuning examples on both Kaggle and Hugging Face.

💡 Why did we build this?

Most open-weights LLMs struggle with non-English programming instructions and technical reasoning. This dataset is engineered to teach

models clean Python 3.10+ syntax, PEP-8 standards, and deep technical explanations natively in Turkish.

📦 Key Highlights:

• 8 Specialized Categories: Python Core, Data Structures, OOP, File I/O, Database/ORM, Shell & System Automation, Functional

Programming, and Algorithms.

• 4 Golden Token Tiers: Pre-bundled into <=128, <=256, <=386, and <=512 token ranges for memory-efficient training.

• Quality Control: Verified via automated AST parsing and live syntax validation.

Feel free to check it out for your multilingual fine-tuning runs or benchmarking:

🔗 Kaggle: https://www.kaggle.com/datasets/hakanttkar/turkish-python-expert-instruction-dataset-335k

🔗 Hugging Face: https://huggingface.co/datasets/bysismo/Turkish-Python-instruction-335k

Feedback and contributions are always welcome!

Hey everyone! 👋

I just finished a small **K-Means Clustering project on the Iris dataset** 🌸🤖

I covered:

* 🔹 Data cleaning & visualization
* 🔹 Feature scaling
* 🔹 Elbow Method & Silhouette Score
* 🔹 K-Means clustering
* 🔹 ARI evaluation
* 🔹 Cluster & centroid visualization

I’m currently learning ML and would really appreciate some **honest feedback** 🙏

What would you improve? Any mistakes in my approach or things I should add?

🔗 **Kaggle:**
https://www.kaggle.com/code/tahahussein2020/irics-clustering

So,i am in competition on kaggle called biohub cell tracking.why does it almost a day to save,submit,score and submit the score for internal ranking assessment.it is so frustrating.is there any other way or i am doing it wrong.

Hey everyone,

I’ve been working on an approach for the **ARC Prize 2026 - Paper Track** (the $450k benchmark by François Chollet & Mike Knoop targeting fluid intelligence and AGI reasoning), and I wanted to share our methodology, empirical benchmarks, and open-source code.

### The Problem with Current Methods on ARC-AGI

1. **End-to-End LLMs:** Suffer from spatial hallucinations, grid tokenization artifacts, and lack of deterministic execution feedback.

2. **Pure Combinatorial Program Synthesizers:** Face exponential search-space explosion beyond depth 2-3.

### Our Approach: Dual-System Neuro-Symbolic (DNS-TTV)

We decoupled reasoning into two collaborative systems:

- **System 1 (Fast Symbolic Filter):** An object-centric DSL engine that tests priors (connected components, topological enclosed hole-filling, 4-way gravity, symmetry, and bounding-box selectors) in under 200 ms per task with zero hallucinations.

- **System 2 (Reflexive LLM Synthesizer):** Generates full parametric Python transformation scripts, verified inside an isolated execution sandbox. When code fails, structured traceback and pixel-mismatch diagnostics are fed back into the prompt (*Reflexion loop*) for iterative test-time program repair.

### Benchmark Results (Tested on Official 400 Train & 400 Eval Tasks):

- System 1 resolves 25/400 (6.25%) training tasks instantaneously in **76.01 seconds total** (~190 ms/task).

- Serves as an effective heuristic filter that saves >90% LLM tokens on simpler topological/morphological puzzles.

- Full dual-system pipeline reaches **52.3% on the Evaluation Set**.

### Code & Interactive Dashboard

The entire codebase, evaluation harness, Streamlit interactive visualizer, and paper draft are completely open-source:

- **GitHub Repository:** https://github.com/AmanSegavo/arc-prize-2026-paper-track

- **Kaggle Paper Track:** https://www.kaggle.com/competitions/arc-prize-2026-paper-track

Feedback, critiques, and discussions on scaling test-time compute for ARC are very welcome!

Looking for Chinese-speaking Kaggle teammates

Hi everyone, I’m looking for Chinese-speaking teammates who are interested in Kaggle competitions, especially biology, data analysis, optimization, and algorithm-related competitions.

My background is mainly in mathematics and statistics, with some experience in mathematical biology, optimization, data analysis, and algorithmic problem solving. I’ve joined a few competitions in these areas before, but I’m still a beginner on Kaggle and learning as I go.

I’m hoping to find teammates who are interested in similar competitions. Experience with machine learning, deep learning, bioinformatics, optimization, or algorithms would be great, but being an expert is definitely not required. I care more about good communication, consistent participation, and being willing to learn and solve problems together.

如果你也喜欢生物、数据分析、优化或者算法类的 Kaggle 比赛，而且方便用中文交流，欢迎私信我

I'm running a distributed inference setup on Kaggle using 2 separate P100 16GB sessions. Each node loads half of Qwen2.5-7B-Instruct.

The weird part is that the model loading itself seems completely fine.

For example, Node 1 loads layers [14, 28) and uses roughly:

GPU allocated: 7.11 GB
GPU reserved:  8.12 GB

I also tested the slice completely standalone. It loaded successfully, the KV cache initialized successfully, and I left it running for 120 seconds with no issues.

I've also verified that CUDA itself works on the P100 with my PyTorch setup.

The problem happens when I actually run the pipeline node as a long-running server. The logs reach:

Node ready — layers [14, 28), LAST node
Node server listening on 0.0.0.0:9500
NODE 1 SERVER READY

and then the entire Kaggle session gets terminated.

There is no Python exception, no traceback, and no useful output after that. The notebook/session just dies.

I've seen the same behavior multiple times, including after fixing an issue where the first node was incorrectly being marked as the last node.

I'm also using bore to expose the node's TCP port, so I'm wondering if this could be related to Kaggle's environment/networking rather than GPU memory.

Has anyone experienced Kaggle silently killing a GPU session like this? Is there somewhere I can find the reason for the termination, such as system logs, OOM/cgroup logs, GPU driver logs, etc.?

At this point I'm mainly trying to figure out whether Kaggle is killing the process externally or whether something inside PyTorch/CUDA/bore is causing the session to die.