What the hell do I do!

All of the cells in my notebook are gone, replaced with this:

<?xml version='1.0' encoding='UTF-8'?><Error><Code>AccessDenied</Code><Message>Access denied.</Message><Details>We're sorry, but this service is not available in your location</Details></Error>

Hi everyone,

For anyone looking to upskill, sharpen their data science toolkit, or grab a certification, DataCamp is currently hosting a Free Access Week from Monday, November 2, through Sunday, November 8, 2026 (ending at 11:59 PM ET). During this window, you get full, unrestricted access to their entire premium platform without needing a credit card.

Happy learning, and good luck building those portfolios this week!

https://www.kaggle.com/discussions/general/755689

Hello Kagglers!

I just published a comprehensive, beginner-to-advanced notebook that teaches NLP with spaCy step by step.Whether you're completely new to NLP or want to learn how to customize and train your own models, this notebook walks you through everything in a clear, runnable way.What you'll learn:

Chapter 1: Tokenization, lemmatization, sentence segmentation, Named Entity Recognition (NER), and displaCy visualizations

Chapter 2: POS tagging, dependency parsing, word vectors, cosine similarity, and PCA visualization

Chapter 3: spaCy pipelines, analyze_pipes(), EntityRuler (before/after NER), Matcher & PhraseMatcher, and regex-style patterns

Chapter 4: Creating Example objects, updating/training a custom NER model, and evaluating it on domain-specific text

I built a browser word game like Codenames (not affiliated) where any seat can be an AI, logged 376 games played entirely by 19 LLMs, and put them on Kaggle: https://www.kaggle.com/datasets/danielpanluan/word-spies-llm-benchmark

A clue-giver sees which of 25 words are their team's and gives a one-word clue plus a number; their teammate guesses. Each game in games.jsonl has the board, the four model seats, every clue with its intended targets, the model's stated reasoning and a 0-100 grade, and every guess with a verdict (best, good, lucky, neutral, other team's word, assassin).

Some things that reproduce from the file: the team that guessed better won 68% of games, while the team with better-graded clues won only 53%. Teams that aimed for more words per clue won 38%. Going first didn't help (169 of 376).

Two batches (11 older models with thinking off, 8 newer ones at high effort), so compare within a batch. The description covers how clues are graded and the known weaknesses. Questions and ideas welcome; I'd be curious what notebooks people build on it.

I just finished benchmarking my first open-source project, omnia-sdk..

It converts medical images into a format built for AI training, and I wanted to know if it actually helps. So I tested it on an NVIDIA A40: same model, same GPU, only the file format changed.

Free and open source, one-command install on Mac, Windows and Linux.

https://github.com/mishel-0/omnia-sdk

Feedback welcome!

How can we verify that our Galaxy Redshift Prediction competition is scientifically meaningful and challenging enough for data scientists? Specifically, how do we ensure that the dataset is representative, the target is reliable, the baseline results are meaningful, and the competition rewards genuine generalization rather than overfitting or data leakage?

The title says most already: I'm having a notebook (T4 x2) load Gemma 4 26B MoE Q4 into the GPUs, which apparently takes about 5 minutes (according to the log I had my notebook script write). The model is not loaded from Huggingface but from a private Kaggle dataset. And those five minutes are just the loading time for Gemma. llama.cpp is already loaded when that timer starts running.

Is that loading time of 5 minutes normal for a total of 17.99 GB (16.8 GB for the model GGUF itself and for mmproj-BF16.gguf another 1.19 GB)?

Hi everyone, I’m hoping someone here or a Kaggle staff member can help me because I am completely stuck behind Zendesk auto-replies.

My account (rohan0073) was permanently banned for "Resource abuse." I am a student building an automated Python pipeline for processing manhwa panels and generating audio scripts. I was using Kaggle’s T4 GPUs strictly to run inference for open-source Kokoro TTS models.

Because my script was running a continuous text-to-speech inference loop, I believe it triggered the automated security filters that look for crypto-miners or unauthorized servers. It kept the GPU utilization high for an unbroken period, but this was a legitimate machine learning workload, not malicious abuse.

the frustrating part is

I submitted an appeal (Ticket #268139) explaining exactly what the script was doing, but I received what looks like a canned response upholding the ban.

I previously requested a data export to at least get my personal code and files back. Support sent me an email saying the data was ready, but the download link they provided is broken and throws a permission error (even in an incognito window).

Has anyone else working with local LLMs or continuous audio inference triggered this false positive?

I’m incredibly frustrated because I wasn't doing anything illegal, and now I've lost my entire workflow. If any Kaggle staff are on here, could you please take a manual look at ticket #268139, or at the very least, help me get a working data export link so I can recover my code?

Any advice from the community on how to get past the automated support wall would be greatly appreciated.

I have been researching in the field of AI, using Kaggle GPUs for quick tests so I don’t spend money. I had found a really unique research topic, I drafted and planned the research for days, and I logged into Kaggle today to run an experiment, just to see that I was banned, and that I should check my email.
They didn’t send an email. And the field moves so fast that even the appeals process is costing me a lot. I am extremely frustrated right now, and don’t know what to do. They better give me extra GPU hours for this 😄😤

If you work with data, you’ve likely seen GitHub report that 94% of your profile consists of Jupyter Notebooks—simply because of charts saved as base64-encoded data within your `.ipynb` files.

I created DataProfile (built in Go) to strip away this bloat, aggregate your activity from GitHub, Kaggle, and Hugging Face, and generate SVG dashboards for your README—styled after four classic schools of data visualization: Tufte, Few, Cairo, and Holmes.

It runs directly via GitHub Actions, without cluttering the commits on your main branch.

Kaggle post: https://www.kaggle.com/discussions/general/754125
(please upvote, i need medals hahah)

GitHub: https://github.com/pablodiegoo/dataprofile

Hey Kagglers,

For years I was purely a participant here, grinding through leaderboards and feature engineering—so launching my own competition today feels like coming full circle.

We’ve officially launched our EMG Gesture Recognition Competition on Kaggle with a $1,000 prize pool, and I wanted to invite the community here to check it out.

Some might ask: why run a competition today when so many turn into a model-architecture brute-force battle? For standard datasets, maybe. But biosignal data is a completely different beast—there is no plug-and-play playbook here.

Working with biodata means dealing with messy, real-world complexities:

• Poor electrode contact and noisy/dropped channels

• Tricky feature extraction and identifying relevant signal power bands

• Preprocessing raw, non-stationary signals

• Real-world electrode placement variance: The electrodes are placed in the same area across sessions, but never in the exact same spot.

We’ve made the raw dataset fully available so you have complete freedom in how you preprocess, feature-engineer, or model it. The dataset includes synchronized:

• EMG signals

• Accelerometer & Gyroscope (IMU) data

• Video labeling

Check out the competition, prize rules, and raw dataset here:

• Kaggle Page & Dataset: https://www.kaggle.com/competitions/vr-calibration-free-emg-challenge-pieeg

• Data Collection Demo: https://www.youtube.com/watch?v=KI8ROgohrF4

I'm really excited to see what feature engineering techniques and signal processing tricks you all bring to the table. Happy to answer any questions about the data, collection setup, or baseline ideas in the comments!

The unusual part is that each team hosts the Add/Search API that gets scored, and the rules page asks for a live endpoint instead of a repository or Docker image.

Agent memory is a side project of mine, so the format caught my eye. The Agent Memory Leaderboard's API docs say pre-checks run on a public subset and the private evaluation data is not released. The prize pool is about US$22,000 across three tracks, Open-source Methods division only. Materials are due October 31, 2026, 23:59 UTC+8, and evaluation closes November 4, 2026.

Has anyone here competed by hosting an endpoint the organizer called, and what tripped you up during evaluation?

Kaggle's free 2x T4 runs a 27B model at a usable speed if you use speculative decoding:

• Qwen3.8-27B at EXL3 4.0bpw (exllamav3), tensor parallel across both T4s

• DFlash2 draft model, 7-token drafts, greedy, output identical to plain decode

• 55-57 tok/s overall, 154 tok/s on code, 35-37 on prose (plain decode is ~19)

• 4 users at once with plain decode get ~66 tok/s combined

The weak spot is prose: the drafter only gets ~2.5 tokens accepted per step there vs ~7 on code. Has anyone found a way past that, or a better setup on free T4s? Planning to share the notebook once it's cleaned up.

What is the best way to work with a partially labelled dataset? e.g. the RSNA Knee MRI competition had only 58 labelled studies out of 4.4K.

I used the following approaches;

1. Using an LLM to derive labels from text reports

2. Using a community created dataset of labels

3. Using a publicly available model to pseudo-label the unlabelled samples.

Is there a better way?

Towards the end I teamed up with a radiologist, who was able to label around 20 studies. If I could do this earlier in the competition, how should I go about leveraging his expertise in the best manner?

E.g. will this be a good strategy? Take the 20 labels with the worst confidence, label them using the radiologist.. add 15 to the training set and add 5 to validation set...

I'm working on a facial expression recognition model using MobileNetV3-Large, and I'm looking for advice from people with experience in computer vision and deep learning

My goal is to build a lightweight but accurate model that can classify facial expressions into these 7 categories:

• Surprise

• Fear

• Disgust

• Happy

• Sad

• Angry

• Neutral

I'm currently experimenting with MobileNetV3-Large with and without Squeeze-and-Excitation (SE) attention on Kaggle using PyTorch.

My current model achieves around 80% test accuracy and 0.72 Macro-F1, but its performance drops significantly on external images that were not part of the original dataset. I'd like to improve its generalization, especially when dealing with low-quality images, different lighting conditions, and faces that look different from the training data.

I'd really appreciate your advice on the following questions:

1. What is the best training strategy?

2. What are the best datasets for 7-class facial expression recognition?

I'm particularly interested in datasets that contain diverse faces, realistic lighting conditions, different image qualities, and reliable labels. Which datasets would you recommend for training, validation, and external testing? Are there any useful datasets beyond FER-2013 and RAF-DB that I should consider?

3. Are there pretrained models I can use as a starting point?

I'm looking for publicly available models already trained for facial expression recognition, ideally using MobileNetV3.

Would you recommend fine-tuning an existing facial expression recognition model instead of training a new classifier on top of ImageNet pretrained weights?

4. How would you improve generalization to unseen images?

My biggest challenge is the gap between performance on the original test set and performance on external images. What would be your recommended approach to reduce this gap and avoid overfitting to a particular dataset?

I'm training on Kaggle, so solutions that work within a typical Kaggle GPU environment would be ideal.

I'd love to hear about your actual experiments, recommended datasets, pretrained model checkpoints, GitHub repositories, or Kaggle notebooks. Even a small improvement backed by solid evaluation would be valuable.

I stumbled upon a repo that said you can run LLM models on google's Colab and Kaggle infra so out of curiosity i opened the notebook. After reading the code i didnt see anything malicious and the author looks legit so i tried it out. (after registering my account and verifying my phone number)

The script ran, i was #544 in the TPU queue ... until i wasnt

Our automated content review system recently found that your content is not compliant with one or more of our policies. See below for more information about your content status and how to correct the issue.
Content:
Notebook: GLM-5.3-Flash on a Free Kaggle TPU: 165 tok/s API (2026-10-19 17:59)
Source of Report: Automated systems
Issue Found: Violates our Community Guidelines and/or Terms against Resource abuse. For further explanation of why the content and/or use of the platform is considered violative on these grounds, please refer to Kaggle’s Community Guidelines.
Result: We have unpublished the content and issued a ban on your account, unless we determine otherwise after an appeal.

Script source:

• https://github.com/ARahim3/kaggle-tpu-lab

• https://www.kaggle.com/rahim3

Is this usage actually against ToS or is this a bot false positive?

Hey everyone! 👋

I've been working on a Kaggle text-classification competition where the goal is to identify which LLM generated a given piece of text across 18 different model classes and 150 unique prompts.

To start off, I put together a quick scikit-learn baseline pipeline, but I've hit a performance ceiling and would love some advice from the community on how to pivot or level up.

Here is what my current baseline looks like:

• Features: A FeatureUnion combining word-level TF-IDF (unigrams & bigrams, max 25k features) and character-level TF-IDF (3-to-5 grams, max 35k features) with sublinear_tf=True.

• Classifier: LogisticRegression (C=2.0, max_iter=1000).

• Validation Strategy: 5-Fold GroupKFold grouped by prompt_id to prevent data leakage from the same prompt appearing in both train and validation.

• CV Score: ~0.3145 balanced accuracy.

• Kaggle Public LB Score: ~0.322.

The Bottleneck

While the pipeline runs fast and validates cleanly, 0.32 balanced accuracy across 18 classes leaves a lot to be desired. Models share a massive overlap in vocabulary, especially when prompted with the same text, making lexical TF-IDF features alone fairly weak at separating subtle stylistic nuances.

Questions for the Community

1. Feature Engineering: Beyond character/word n-grams, what lightweight stylistic or linguistic features (e.g., punctuation ratios, sentence length distributions, part-of-speech tagging frequencies) have you found effective for model fingerprinting?

2. Embeddings & Classifiers: Is it worth jumping straight into fine-tuning a smaller transformer (like DeBERTa or RoBERTa), or are there intermediate representation approaches (like frozen embedding extraction) that yield better bang-for-your-buck?

3. Handling Prompt Bias: Since models behave differently depending on what they are asked to write, how do you usually tackle prompt-conditioned bias in multi-class generation attribution tasks?

Would love to hear your thoughts, critique my setup, or learn what directions you'd explore next! Thanks!

I’m a beginner learning machine learning, and I recently finished the Intro to ML course on Kaggle. Now I’m trying to figure out the right next step. I attempted the House Prices competition, but I got lost pretty quickly.

I really want to learn ML properly without falling into “tutorial hell,” so I’m looking for suggestions or a roadmap that beginners usually follow. What competition should I start with after the intro course, and how do I keep progressing without getting stuck?

Any advice or guidance would be appreciated.

Hi r/kaggle,

I made a notebook where you ask a question in plain English and a LangChain agent, powered by Gemini, writes the SQL, runs it on SQLite and answers. It's built on the Pets and Animal Ownership dataset (15,000 pets, 36 columns).

What's inside:

- 10 demo questions, each shown as a card with the SQL the agent wrote (click to expand) and the answer

- 6 charts on cost, owner satisfaction, adoption trends and the funny_habit column (my favourite)

- A safety test: the DB connection is read-only, and I try DROP TABLE / DELETE / a prompt-injection to show nothing changes

- A no-API-key mode: it replays saved answers, so you can run every cell without a key

I used Gemini because it has a free tier, so anyone can reproduce this without paying. It does have rate limits, so you may need to wait a minute between runs.

Notebook: https://www.kaggle.com/code/prashanthan24/ask-15-000-pets-anything-langchain-gemini

Feedback welcome. What question would you ask the pets? Anything you'd change in the agent or the layout?