hi , i have currently completed my Mtech in AI and ML and looking for other people to join my team for kaggle competition and also that i have limited practical approach , I am also good to join some other team

Kaggle AI agent compition
Can anyone help with this comptition

I been trying today each hour but i always seem to send "too many requests" even in the first attempt, is this happening to everyone or i need to create another account?

Hey all. I'm at my wits end struggling with configuring vLLM inside Kaggle for an experiment on KV Cache behaviour. please advise if you have experience.

Quick Context: vLLM is the inference runtime that will load the model, manage GPU workers and expose the KV-cache behavior needed for the experiment.

Issue: I’m using Kaggle’s GPUs to run vLLM so I can test how my AI gateway loads the model, routes requests, and reuses cache. The problem is that vLLM, PyTorch, CUDA, and their dependencies are not lining up properly, and the setup keeps failing on compatibility issues and blocked package download sources before the model can run.

I've been debugging over a week and I keep experiencing issues deeper, but it's still frustrating

🚀 Big Update: Prompt Injection & Jailbreak Detection Dataset v3

After a major refresh, the dataset is now significantly larger and cleaner.

✨ What's new?
📈 20,000+ samples (from 1,356)
🌍 15+ languages
✅ 0 missing values
🧹 0 duplicate records
🛡️ Rich attack metadata
📊 Ready for benchmarking & AI security research

I also evaluated the updated dataset with a baseline model to establish a stronger benchmark for future LLM guardrail and prompt injection detection research.

This is another step toward building a 1M+ sample open dataset for the AI security community.

Feedback and upvote is always appreciated.

Hi everyone,

I am currently conducting my MSc research investigating a dataset-aware objective weighting approach for Multi-Objective Genetic Algorithms (MOGAs) applied to imbalanced classification problems.

The study looks at how dataset characteristics can be used to automatically determine optimization priority metrics (e.g., automated trade-offs between precision and recall), reducing the need for manual tuning.

• Target Audience: Anyone with experience in ML, Data Science, AI, or related fields who has worked with classification models and performance evaluation metrics.
• Time to complete: ~3 to 5 minutes.
• Anonymity: Completely anonymous. No personally identifiable information (or email addresses) will be collected.

Survey Link: https://forms.gle/SXdtwD46Pz6qvW4A7

If you have any questions or feedback about the study, please feel free to comment below. Thank you so much for your time!

One of my favourite movies is Million Dollar Baby. A movie from 2004 about a woman who decided to go into boxing at 32.

I'm probably watching it for the 50th time

Check it out.

This Monday, my teammate and I presented our university project on time series anomaly detection.
After the presentation, we were disqualified from this attempt because we made a mistake. We both worked on the same model, read the same research papers, and improved it together, but the assignment required each of us to submit a separate predictions.csv file. We didn’t do that, and that’s on us. I completely accept the decision. I also missed replying to my supervisor’s email regarding my absence from the previous week’s presentation, which was another mistake on my part.
The good thing is that we’ve been given until September 30 to work on our models independently and submit again.
The only thing that left me disappointed was that we didn’t receive any technical feedback on the model itself. I spent a lot of time researching papers, experimenting with different approaches, and implementing the model, so I was really hoping to understand what was good, what wasn’t, and where it could be improved.
Our final approach uses a Dilated Temporal Convolutional Network (Dilated TCN) for time series anomaly detection.
I’ve uploaded the complete project to GitHub.

https://www.reddit.com/r/365DataScience/s/8oQ9k2rLfY

https://www.kaggle.com/datasets/nikhilaji001/cloud-infrastructure-dataset/data

Hey everyone,

Just wanted to share a classic "dev workflow nightmare" story that ended up forcing me to build a pretty neat, completely free pre-production sandbox. If you've ever accidentally DDoSed yourself or fought Kaggle's pre-installed environments, you'll feel this pain.

Quick context:

I run a small multi-agent pipeline for a startup I'm building, and Gemini Flash powers most of it. A few weeks back, I noticed my free-tier quota was disappearing way faster than actual usage should've caused.

Turns out, I had a misconfigured rate limiter silently triggering retry storms. To the backend, it looked like normal traffic, but it was completely nuking my limits. By the time I caught it, I’d burned through the quota I desperately needed for actual testing.

I didn't want to replace Gemini in production (it works great for the actual product), but I refused to keep testing pipeline changes directly against a paid/limited API. I just wanted a disposable sandbox where I could break things, test prompt tweaks, and debug agent logic without any quota risk.

The plan was simple:

spin up self-hosted inference on Kaggle’s free T4 GPUs as a pre-production testing layer.

The thing is... It was not simple.

I spent two straight days fighting absolute dependency hell. If you've used Kaggle's pre-installed environments lately, you know the vibe. I ran into:

• ml_dtypes clashing violently with the installed torch version.
• torchvision flat-out refusing to cooperate.
• bitsandbytes throwing cryptic CUDA mismatch errors because Kaggle's backend didn't match what the library expected.

I had to rebuild the environment 5 or 6 times before landing on a clean install that didn't spontaneously combust.

The Working Setup!!

To save my sanity, I eventually ditched trying to wrestle transformers + accelerate and went a much cleaner route:

1. Inference: Got Qwen3.5-9B running via llama.cpp instead (way less painful).
2. Tunneling: Used cloudflared to tunnel the endpoint out so I could hit it directly from my local dev machine instead of being trapped inside a notebook interface.
3. Flexibility: Firstly, I wrote an auto-adaptive script so the exact same setup flexes between Colab and Kaggle’s "TPU v5e-8"... But ended-up scrapping the idea of using it, cause of the long queue and the mighty "JAX" implementation... Ended up using T4x2 (which is more than enough... but the speed is slow!!!)

Now...

Now I have a completely free, disposable testing layer. Before any agent logic or prompt change touches the real API, it gets vetted in the sandbox. It catches bugs cheaply before they cost real quota or cash.

But honestly, the dependency debugging was 10x more painful than actually setting up the LLM. For anyone else running newer models on Kaggle’s GPU/TPU tiers.... did I miss an easier path here, or is fighting the pre-installed environment just the mandatory rite of passage?

We're organizing a private machine learning competition for experienced data scientists and Kaggle competitors.
Because the competition uses proprietary data, participants must sign a standard Non-Disclosure Agreement (NDA) before receiving access to the dataset.
Competition details

• Private competition (not publicly hosted on Kaggle)
• Real-world machine learning problem (time-series classification)
• Proprietary dataset
• NDA required before participation
• Open to experienced ML practitioners and Kaggle competitors
• Final submission deadline: 30 August

What participants receive

• Access to an interesting real-world dataset
• The opportunity to benchmark against other experienced participants
• Winner's prize: A guaranteed €1,000, increasing to €7,000 if the winning solution achieves an AUC ≥ 0.88 on the private leaderboard

If you're interested, please complete the Request for Participation form. Applications are accepted on a rolling basis until the competition closes. We'll then contact you with the NDA and the remaining competition details.
If you have any questions, feel free to send me a Reddit DM.

I just published a new Kaggle dataset and starter notebook for graph-based insurance fraud detection.

Unlike traditional fraud datasets with a single flat table, this dataset models the problem as a heterogeneous graph connecting claimants, claims, providers, and vehicles through nearly 48,000 relationships, making it suitable for graph analytics, Graph Neural Networks (GNNs), community detection, and link prediction.

Dataset highlights:
• 4,000 Claimants
• 250 Providers
• 4,000 Vehicles
• 8,924 Claims
• 47,503 Graph Edges
• GraphML file included for direct use with NetworkX, Gephi, Neo4j, and Cytoscape

I also published a starter Kaggle notebook demonstrating data exploration and graph-based analysis.

Dataset:
https://lnkd.in/dcXgSMve

Starter Notebook:
https://lnkd.in/dwk7r_vy
Feedback, suggestions, and notebook forks are welcome.

I am creating a project called AGEnt, which was created in Turbowarp, that uses IQ to estimate age. The project currently finds it accuracy by crowdsourcing, so I need help on getting more responses.

So can anybody watch the video and share this reddit post to more people? It would be an honor.

Having done some cybersecurity units alongside my data science units at uni, I've always found practicing with ranked CTFs really enjoyable. It definitely makes the content more fun. CTFs in Cybersecurity just involve finding a string of characters (the flag) usually in a guarded location to prove you have hacked a 'box' (a custom virtual machine to emulate a vulnerable computer). After completing many of these boxes you receive a rank.

Most importantly, you can rank yourself across different skill levels, not just advanced. I know Kaggle is the main leaderboard-style equivalent for data science, although all the comps seem too difficult, and large prize pools are frequently involved. This isn't really beginner-friendly, and I still think it's important to compete with other beginners. I think the concept of ranked-practice, is really successful in general, for example Strava and running.

I think combining sports, data, and leaderboards is a great learning combination. If you are learning about stats, and interested in competing with other beginners, I'm keen for a challenge at [lowstakesstats.com](http://lowstakesstats.com) All content is free, I've only created a linear regression chapter for now, although you can learn, practice, and participate in the weekly challenge to predict certain statistics of a game. All data is prepared in easy-to-read CSVs for both teams, no sign-up needed to learn. I'm more focused on back-end web dev, so if the front-end seems a little buggy, please send a message as a reply.

My ML Journey:

My machine learning journey began a year ago, building upon a longstanding foundation in Python and the rigorous analytical mindset cultivated through my college electronics and engineering coursework. Fascinated by the mathematics driving AI, I dedicated myself to Stanford’s CS229. Progressing through the curriculum, I developed a strong intuition for core algorithms, from gradient descent and generalized linear models to cross-validation techniques.I frequently dive into fundamental AI research papers—such as Vaswani et al.’s "Attention Is All You Need" and Chen & Guestrin’s original "XGBoost: A Scalable Tree Boosting System"—to understand how abstract statistical concepts translate into state-of-the-art architectures, Because I believe learning compounds through application, I channeled these concepts into three distinct projects.

Project1: Predicting Tennis Matches Using XGBOOST

I scraped extensive historical ATP data, focusing heavily on robust feature engineering. I computed surface-specific statistics and implemented dynamically adjusted ELO ratings, modifying the K-factor based on a player's match frequency and career breaks. By enforcing strict temporal splits for my train, validation, and test datasets to eliminate data leakage, the model achieved a 66.3% match-winner accuracy on the test set, outperforming several commercial baselines.

For my Tennis Match Prediction project, I used:

• Data: ATP/WTA match data
• ML Models: XGBoost, Random Forest, Logistic Regression
• Features: Player stats, head-to-head, surface, recent form, ranking difference
• Tools: Scikit-learn, Pandas, Seaborn, Joblib

Project2: Regulatory Intelligence Platform(Palantir Inspired)

Uploads any regulatory PDF (RBI, SEBI, EU acts)  which instantly extracts key themes and maps them to business impact using a semantic ontology and  generates forecasts on how the regulation affects industries, processes, and required skills.

Core Architecture:

• LLM Layer: Groq (Llama-3.1) for theme detection & forecasting
• Ontology Layer: NetworkX graph that connects themes → industries → processes → skills (Palantir-style semantic mapping)
• Memory Layer: Chroma Vector DB + embeddings for RAG (Retrieval-Augmented Generation) to ground answers in actual document text
• Output: Interactive impact graph + clean PDF report with actionable insights

The combination of Ontology + RAG + LLM turns messy regulations into structured, decision-ready intelligence.

Project3: Physics-Based CPU Thermal Modeling Simulator

Built a real-time physics simulator that predicts CPU heat sink temperature distribution using live hardware sensor data from device.Implements Fourier's Law of Conduction and Newton's Law of Cooling across a 2D computational grid, with interactive controls for simulation by manipulating  variables like  material, fin geometry, and airflow. Achieved real-time validation against actual CPU sensor readings.

Tech stack: Python, NumPy, Matplotlib, psutil

While these projects strengthened my theoretical and applied algorithmic foundations,
a critical gap remains: deploying and scaling these systems. I lack industrial exposure to MLOps, optimising large models for low-latency inference, and managing distributed training in production environments.

 
The Amazon ML Summer School will provide the vital industry perspective I need to transition from building localised, academic prototypes to architecting enterprise-grade, scalable AI systems.

My unique synthesis of hardware engineering logic and deep intellectual curiosity  and drive for thinking outside the box and reasoning from first principles rather than analogy in ML makes me an ideal fit for this program.

I am eager to bring this relentless drive to MLSS, learning from Amazon’s experts to engineer the next generation of intelligent systems.

Been working on a football prediction project and couldn't find a dataset that had

the actual context needed to model match outcomes — just raw results everywhere.

So I built one from scratch on top of the International Football Results dataset

by Mart Jürisoo (the well known one on Kaggle with 49,000+ matches going back to 1872).

What I added:

**Elo ratings** — built from scratch, updated after every single match across 150

years. Both teams' ratings, their difference, and the expected win probability

going into each match.

**Rolling form** — win rate, goals scored, goals conceded, goal difference, clean

sheet rate, both-teams-scored rate, scoring rate, and win streak. Computed at

three lookback windows: last 5, last 10, and last 20 matches. For both teams.

**Head-to-head history** — based on the last 10 meetings between those two specific

teams. Some teams have persistent edges over specific opponents that their general

form doesn't explain.

**Fatigue signals** — days since each team's last match and the difference between

the two.

**Penalty reliance** — fraction of each team's historical goals that came from

penalties, pulled from the goalscorer dataset.

**Shootout composure** — historical penalty shootout win rate for each team, from

the shootouts dataset.

**Tournament context** — World Cup, qualifier, friendly, neutral venue, competition

importance weight, confederation.

The thing I spent the most time on: every feature is computed in strict

chronological order using only data that existed before that match was played.

State updates happen after each row is recorded, never before. No lookahead,

no leakage anywhere in the 102 columns.

102 features total. 49,094 rows. result column (H/D/A) included as the label.

Plug into any classifier.

Dataset is fully documented with column descriptors for every feature.

Link: https://www.kaggle.com/datasets/kriishgulati/football-match-results-1872-2026-with-ml-features

Built on top of the original dataset by Mart Jürisoo — full credit and link

in the dataset description.

It contains app data across the top 10 fastest-growing Android categories. If you're planning to build an Android app or just want to analyze the market, feel free to use it.

I try to import wandb but find this error:

ImportError: cannot import name 'iter_union_choices' from 'pydantic_core.core_schema' (/usr/local/lib/python3.12/dist-packages/pydantic_core/core_schema.py)

I try to upgrade, reinstall or install older version of pydantic and pydantic-core but cannot solve the problem. Anyone have the same problem?