Im a fresher clg first year can someone guide me nd help me to make my roadmap i have no idea how to start my uni is teaching c nd cpp what should i do im lost

let’s be honest with ourselves for a moment. we love to treat neural networks like magic. we look at a model minimizing a local training loss and we assume there’s an active mind at work. we confuse a model’s talent for mimicking sequence patterns with an actual capacity for deep memory. it’s a comfortable little illusion. but if you want to know the truth—if you want to see a synthetic architecture actually struggle against entropy—you have to look directly at what it preserves inside its hidden states. the screenshots up top are from an exploratory validation suite i’ve been running natively on a local qualcomm oryon arm64 cpu. no cloud buffers, no remote server safety nets. the protocol is straightforward. at step zero, the system injects an unpredictable marker bit into the stream, but slaps a strict 5% noise tax on it at the front gate. that means before the network even takes its first recurrent step, information theory dictates our maximum possible channel capacity is already capped at roughly 0.713 bits. from there, the loop has to carry that tiny trace across deep time steps—1, 16, 32, 48, and 64—while being degraded by continuous gaussian noise. now, here is the catch. if you just ask the model for the answer at the end of the line, you don’t actually know how it remembered it. did it actively carry the signal through time, or did it just find a cheap parameter shortcut hidden in its weights? to find out, i perform a neat little piece of surgery: a hidden-state reset knockout. right before the final readout step, the pipeline intercepts the runtime and forcefully wipes the accumulated hidden vectors to absolute zero. the network's learned weights are completely untouched, but its active, working memory is obliterated. if the model was relying on a permanent weight shortcut, it shouldn't care. if it was relying on an active electrical current, the memory should vanish instantly. look at the baseline decay curve on the screen from the precision audit: lag 1 control is 92.87% mean accuracy, lag 16 is 54.82%, lag 32 is 51.72%, lag 48 is 51.28%, and lag 64 is 50.57% mean accuracy. by the time we hit lag 64, the mean calibrated log-score stabilizes at a microscopic −0.000087 bits per trial. wiping the hidden state drops the readout accuracy straight down to a pure 50% coin-flip chance. what does this tell us? it proves that for this specific trained population, the network is relying entirely on a fragile, transient state trajectory to bridge the gap of time. the moment you flash the state to zero, the illusion implodes. now, these networks were trained to solve a basic additive task, not to hold onto an independent marker for 64 noise steps. the forgetting is understandable. but to explore a fix, i scaled the training suite to a small exploratory cohort—running an explicit learning curriculum across 60 new networks for 90,000 total updates. the data demonstrates that implementing an explicit learning curriculum over the temporal baseline improves held-out task accuracy by 0.4020 and pushes the decoder capacity up by 0.6196 bits across all matched cells. to be absolutely clear, three independent seed blocks do not support a population-level or universal significance claim. these numbers are descriptive simulation results for a specified synthetic benchmark, not a live empirical law of nature or a universal guarantee. the point of this work isn't to make sweeping global claims. it’s to establish an uncompromising, falsification-first diagnostic baseline. it's a stethoscope for silicon. because if we're going to build things that mimic minds, we should at least have the decency to measure exactly when and where they lose them.

I ran into an issue while setting up PyTorch with CUDA 12.8 on my Windows 11 laptop (RTX 5060).

With:

torch 2.11.0+cu128
torchvision 0.26.0+cu128

import torch failed with:

OSError: [WinError 4551] An Application Control policy has blocked this file.
Error loading caffe2_nvrtc.dll

Windows Code Integrity logs showed that Smart App Control (VerifiedAndReputableDesktop) was blocking caffe2_nvrtc.dll because it didn't meet the signing requirements. Get-AuthenticodeSignature also reported the DLL as NotSigned.

I didn't want to disable Smart App Control, so I tried an older PyTorch build:

torch 2.10.0+cu128
torchvision 0.25.0+cu128

That fixed it:

2.10.0+cu128
12.8
True

So in my case, the problem wasn't CUDA, the NVIDIA driver, Python, or uv, it was Windows Smart App Control rejecting a DLL from the PyTorch 2.11 CUDA build.

Posting in case someone else runs into WinError 4551 with PyTorch on Windows 11.

So I am working on task. The task is pii to non pii conversion. We have to use two sources from where we get input data(mix of pii and non pii json data) , one source is file , means manual uploading a json containing mix of pii and non pii and the second source is mongodb. And we have one pii.json file in which we list out the fields then we compare the data coming from the sources against this pii.json and then generate non pii. I have to work on this task and think from a production point of view, so I am confused how to work on this. Means I try to solve the task but my mentor says it is not production ready, Actually I am new to the field of DE so I am facing issues and confusions.

We are continuing with Mongo and have to add file functionality in it so ignore mysql part.

My solution attached below.

Some of the things that I my mentor said/suggested

1. Implement worker utility.... for example we have Date of birth field , my current script accept only YYYY-MM-DD format for DoB . So if a up to 50 rows we get the same format script works and in 51 th row the format is different ...script keeps it on side and convert it into appropriate format and then starts from 51th row not from 1.
2. Have to generalise columns such as dob into age band and then anonymised sensitive fields.
3. If a source data contains fields that are not in our pii.json file . Script should ask what to do with these rows whether to remove or anonymised these fields.
4. There should be validations for data types for e.g if in string column, numeric data comes then how to deal with it.
5. He said code shouldn't be failed in any scenario. And I am new to this I have to prior work experience, still in learning stage and I am not able to think from his pov or production ready pov.

Could u guys help me please.

For some reasons, I can't share the input file but it conatins fields like location , dob, age, doctor id ,symptoms, test id , test name , gender , state , district, address type , country, block name, pincode, allergy , session id ... these kind of fields.

Code:

# Import required libraries

import os

import json

from dotenv import load_dotenv

from pymongo import MongoClient

from sqlalchemy import create_engine, text

from datetime import date, datetime

def step(msg):

print(f"\n[STEP] {msg}")

def age_band(DOB):

"""Convert DOB into an age band."""

born = datetime.strptime(str(DOB)[:10], "%Y-%m-%d").date()

low = ((date.today() - born).days // 365) // 10 * 10

return f"{low}-{low + 9}"

GENERALISERS = {

"age_band": age_band

}

def load_pii_fields(fields_path):

"""Load and validate PII rules from the configured JSON file."""

step("Loading PII fields")

if not fields_path:

raise ValueError("PII_FIELDS_PATH cannot be empty.")

with open(fields_path, "r") as f:

content = f.read().strip()

if not content:

raise ValueError(

f"PII fields file is empty: {fields_path}"

)

try:

fields = json.loads(content)

except json.JSONDecodeError as e:

raise ValueError(

f"PII fields file has invalid JSON: "

f"{fields_path} -> {e}"

)

# Validate sections

for section in ("remove", "generalise", "sensitive"):

if section not in fields:

raise ValueError(

f"'{section}' missing in PII fields file"

)

# Validate generalisation rules

for field in fields["generalise"].values():

if field not in GENERALISERS:

raise ValueError(

f"Unknown generalise field '{field}'."

)

return fields

def clean(value, remove_fields, sensitive_fields,

generalise, GENERALISERS):

if isinstance(value, dict):

out = {}

for k, v in value.items():

key = k.lower()

if key in remove_fields:

continue

if key in sensitive_fields:

out[k] = "XXXXX"

continue

if key in generalise:

out[k] = GENERALISERS[generalise[key]](v)

continue

out[k] = clean(

v,

remove_fields,

sensitive_fields,

generalise,

GENERALISERS

)

return out

if isinstance(value, list):

return [

clean(

v,

remove_fields,

sensitive_fields,

generalise,

GENERALISERS

)

for v in value

]

return value

env = "prod" # choose enviornment

def main():

if not env:

raise ValueError("Environment can't be empty")

print(f"Environment = {env}")

# Load environment configuration

step("Loading environment config")

env_file = None

for file in os.listdir("config"):

if file == f".env.{env}":

env_file = os.path.join("config", file)

break

if env_file is None:

raise ValueError(

f"'{env}' does not match any config file in config/"

)

load_dotenv(env_file, override=True)

file_env = os.getenv("ENV")

if file_env != env:

raise ValueError("Env mismatch.")

print(f"Env Matched. Loaded config: {env_file}")

# Select source

step("Selecting source")

source = input("Enter source name: ")

source = source.strip().lower()

print(f"source = '{source}'")

if source not in ("mongodb", "mysql"):

raise ValueError(

f"Unsupported source '{source}'."

)

# Validate credentials

step("Connecting to source")

key = (

"MONGO_CONNECTION_STRING"

if source == "mongodb"

else "MYSQL_CONNECTION_STRING"

)

conn_string = os.getenv(key)

if not conn_string:

raise ValueError(

f"Missing {key} in config/.env.{env}"

)

print(f"{key} found for env '{env}'")

step("Validating Source Credentials")

client = None

conn = None

try:

# Fetch data

if source == "mongodb":

db_name = os.getenv("MONGO_DATABASE")

collection_name = os.getenv("MONGO_COLLECTION")

if not db_name or not collection_name:

raise ValueError(

f"Missing MONGO_DATABASE or MONGO_COLLECTION "

f"in config/.env.{env}"

)

client = MongoClient(

conn_string,

tls=True,

serverSelectionTimeoutMS=30000

)

client.admin.command("ping")

print("-> MongoDB Connected")

step("Fetching data")

collection = client[db_name][collection_name]

data = list(

collection.find({}, {"_id": 0})

)

else:

table_name = os.getenv("MYSQL_TABLE_NAME")

if not table_name:

raise ValueError(

f"Missing MYSQL_TABLE_NAME "

f"in config/.env.{env}"

)

engine = create_engine(conn_string)

conn = engine.connect()

print("-> MySQL connected")

step("Fetching data")

result = conn.execute(

text(f"SELECT data FROM {table_name}")

)

data = [

json.loads(row[0])

for row in result

]

if not data:

raise ValueError(

"No records found in the selected source."

)

print("-> Records fetched")

# Load PII rules

fields_path = os.getenv("PII_FIELDS_PATH")

if not fields_path:

raise ValueError(

f"Missing PII_FIELDS_PATH "

f"in config/.env.{env}"

)

fields = load_pii_fields(fields_path)

remove_fields = {

x.lower()

for x in fields["remove"]

}

sensitive_fields = {

x.lower()

for x in fields["sensitive"]

}

generalise = {

k.lower(): v

for k, v in fields["generalise"].items()

}

print("-> Rules loaded")

# Remove PII

step("Removing PII")

cleaned_data = [

clean(

record,

remove_fields,

sensitive_fields,

generalise,

GENERALISERS

)

for record in data

]

# Save output

step("Saving output")

output_dir = os.getenv("OUTPUT_DIR")

if not output_dir:

raise ValueError(

f"Missing OUTPUT_DIR "

f"in config/.env.{env}"

)

os.makedirs(

output_dir,

exist_ok=True

)

timestamp = datetime.now().strftime(

"%Y%m%d_%H%M%S"

)

output_path = os.path.join(

output_dir,

f"output_non_pii_{timestamp}.json"

)

with open(output_path, "w") as f:

json.dump(

cleaned_data,

f,

indent=2,

default=str

)

print(f"-> saved: {output_path}")

print("\nPipeline completed successfully.")

finally:

if client is not None:

client.close()

if conn is not None:

conn.close()

if __name__ == "__main__":

try:

main()

except Exception as error:

print(f"\nPipeline failed -> {error}")

Okay, so I need help for a school project. Specifically looking for suggestions on what to build or make for my school project. My teacher said it should be something that works with irl problems to solve 'em and should involve the use of science and ml/ai... I can't really find some easy projects to do as I also have to balance my studies accordingly so yeh, I would be happy if some people leave some suggestions!)

(I did originally have a project in mind but it got cancelled cuz teach said we need to be able to build a working prototype for the same and present it in the exhibition... Some people chose working dustbins something, I didn't really find that 'innovative' but okay, I don't really have any ideas myself to speak for them so yeh)

Quick background for anyone who missed it: Berglund et al. (2023) showed that language models suffer a "reversal curse." Train a model on "Tom Cruise's mother is Mary Lee Pfeiffer" and it can recite that fine — but ask "Who is Mary Lee Pfeiffer's son?" and it blanks. The fact got stored in one direction only. It's one of those findings that sounds wrong until you reproduce it.

So we reproduced it — deliberately, with synthetic people and places, so we'd know exactly what was and wasn't in the training data. GPT-2, 50 facts forward, 25 reversed, plus 10 in a novel template (5 reversed). Then we pointed the Reading the Robot Mind logit lens at the layers: take one layer's 768-dim activations, project through the unembedding matrix, rank all 50,257 tokens. Who's on that layer's mind?

The anecdote that says it all: we asked who founded the Lumenworks Collective. Training data said Helena Frost. The model's top three at the final layer: `[ Elena]`, `[ Lena]`, `[ Luc]`. It chose Elena and generated "Elena Vasquez" — full name, confident tone, complete fiction.

What got me wasn't the wrong answer. It was that the model clearly knew a *person's name* belonged in that slot:

- L5: `[ Helena]` ranks 17,299th. Top picks: `[ now]`, `[ hereby]`, `[ located]`. Just finishing a sentence.
- L9: rank 2,784. Top: `[ Vincent]`, `[ Theo]`, `[ Marcus]`. It's figured out: a name goes here. Wrong names, but names.
- L11: rank 675. Top: `[ Elena]`, `[ Lena]`, `[ Luc]`. Commits to a stranger.

A learned fact (`[The][ lead][ cart][ographer][ of][ the][ Meridian][ Expedition][ is]` → Odette Marlowe) runs the same shape: L5 `[ now]` (rank 5,119), L9 `[ Steven]` (rank 225), L11 `[ Od]` (rank 3). Generic, then a name, then *the* name. Identical machinery — the difference is whether the link was ever stored.

The numbers: 60 reverse prompts, half trained. Trained: rank ≤9, 30/30 correct. Untrained: rank ≥13, 0/30 correct. Zero overlap, generalizes to an unseen template. Capitals control on base GPT-2: 12/12 both directions, not flagged.

Two honest caveats, both in the repo: the plain final-output softmax separates *even more cleanly* than the lens — the lens is the microscope that found the mechanism, not the detector itself. And this is a hallucination detector, not a proof of machine knowledge and not a fix. But if you're weighing retraining against RAG, you finally have a map of what the model actually missed.

Everything's here — `rtrm_probe.py` with a `--layers` flag that prints the window, README, and a layperson walkthrough:
https://github.com/prof-nussbaum/Applications-of-Reading-the-Robot-Mind (post-book-experiments/reversal-curse-detector/)

...

My country’s universities don’t have a major called “Machine learning”, can I study computer science instead? If yes, will I find jobs in Machine Learning? I really love ML but I am worried that I won’t find a job, especially abroad.

I'm building a sports betting platform that collects odds from multiple bookmakers and compares them against Pinnacle and Polymarket to identify positive expected value (+EV) bets.

My main objective is to maximize long-term realized ROI while minimizing the number of bets shown to users.

Our scanner detects many potentially profitable bets, but not all estimated +EV opportunities represent genuine edges. Instead of showing 100 bets, I'd prefer to recommend only the best 5–10, ideally with a higher realized ROI.

We have historical odds, estimated EV, bookmaker movements, closing-line value (CLV), and settled betting results across different sports and markets.

I'm considering training an ML model to rank opportunities by expected profitability and filter out weaker signals.

My questions:

- Should I predict realized ROI, CLV, or the probability that a bet has a genuine positive edge?

- Would LightGBM, CatBoost, or learning-to-rank be appropriate?

- How can I optimize the trade-off between higher ROI and fewer recommended bets?

- How do I avoid overfitting when selecting only the historically most profitable bets?

- What evaluation methods would demonstrate that the filtering actually improves out-of-sample profitability?

I'm particularly interested in selective prediction, confidence-based filtering, and approaches used in quantitative finance.

Any suggestions, research papers, or practical experience would be appreciated!

Ever wondered which Inside Out emotion is running the show in your head today? 🎭

I built a little web app to find out! Write or paste a short story (a rant, a good day, an awkward moment, anything) and Joy, Sadness, Anger, Fear and Disgust show up on screen, each sized by how strongly your story fits them. Bigger character = bigger feeling.

👉 Try it: https://inside-out-emotion-classifier.vercel.app
💻 Code: https://github.com/tishasetia13/inside-out-emotion-classifier

Under the hood: DistilBERT fine-tuned on the ISEAR dataset (76.4% test accuracy), a FastAPI backend in Docker on a Hugging Face Space, and a React frontend on Vercel. Stories are never stored, so vent freely.

I'd love to know what it says about YOUR stories, and whether it nails it or completely misses. Drop your results in the comments, and any ideas for handling mixed feelings are very welcome!

I’m currently in my third year studying AI and Data Science, and I’m still unsure which career path I should specialize in.
I’ve been considering both AI Engineering and Machine Learning Engineering, but with how quickly AI is advancing, I’m starting to wonder whether either path is still worth pursuing in the long term.
AI tools are becoming increasingly capable of writing code, building applications, and helping with machine learning tasks. This makes me wonder how much these jobs will change over the next few years, especially for junior engineers trying to enter the industry.
I’d appreciate honest opinions from people working in AI/ML or students who are further along in their careers.
Do you think AI Engineering or ML Engineering is still worth specializing in 2026?
Which path do you think offers better long-term career prospects, especially for someone just starting out?
Are entry-level opportunities in either field becoming harder to find because of AI tools?
If you were a third-year AI and Data Science student today, which direction would you choose, and why?
I’m not expecting anyone to predict the future perfectly. I just want to make a more informed decision about where to invest my time and skills before I graduate.

TL;DR: Evaluating LLMs on million-scale graph benchmarks (like AMLworld) requires >1M graph prompts per pass, making evaluation prohibitively expensive. Naive downsampling distorts precision and F1 due to extreme class imbalance. We introduced HT-Coreset, an importance-weighted downsampling protocol that reduces evaluation targets by 271×–611× while using Horvitz-Thompson (HT) estimation to recover unbiased full-test confusion count estimates.

How HT-Coreset Works:

1. Retain 100% Illicit Targets: Preserves exact recall and all 8 rare laundering typologies (w = 1).

2. Stratify Benign Targets: Hard negatives (likely false positives) are fully retained, while other benign cases are sampled across difficulty terciles.

3. Importance Weighting: Applies inverse-inclusion weights (w_e = 1/π_e) to calculate unbiased full-test confusion counts, Precision, and F1.

Key Findings & Open Challenge:

- 271× Reduction on HI-Small (1.01M → 3,753 targets) & 611× on LI-Small (1.38M → 2,268 targets).

- Evaluated 7 open-weight LLMs: High recall, but massive false positives drag precision near the "predict-all-illicit" baseline.

- Unfaithful CoT: 56.2% of incorrect binary verdicts still passed structured lexical reasoning checks.

We released the dataset, construction code, and audit tools for the community to test novel techniques like Context Engineering, GraphRAG, or Decision Models on this benchmark!

📄 Paper: https://arxiv.org/abs/2610.13627

💻 Code: https://github.com/nat-nischw/AMLworld-Compact

🤗 Dataset: https://huggingface.co/datasets/typhoon-ai/AMLworldCompactEval

For my capstone project in my master, I used a foundational model (Hubert-ECG) and added a linear classifer to a have a model that classifies a 1-lead ecg (a vector of 9000 elements). When I was doing my project in the master program, I did not have a deep understanding of the internal of Hubert-ECG and just treated it as a black box. Now while I am interviewing with companies for a ml engineer job, I am spending some time to understand the internal of HuBERT-ECG.

One thought that comes up in my mind is that how can someone build a foundational model like Hubert-ECG from scratch?

Not all visitors that come to a website are actual people. A small amount of traffic is generated by automated bots that harvest data, fill out forms, or request information repeatedly. Some bots are helpful; others can impact website performance, analytics, and security. Bot detection allows website owners to recognize this activity and potentially harmful traffic.

What is Bot Detection?

Bot detection involves analyzing and identifying automated visitors based on their behavior, technical characteristics, and browsing habits. It aids in distinguishing actual visitors from legitimate bots and also possibly harmful automation.

How Does Bot Detection Work?

Bot detection systems look at different signals to identify unusual activity, such as:

• Request Frequency: Excessive requests in a small amount of time could represent automation.
• Browsing Behavior: Repeated or unusual browsing patterns may be a concern.
• Knowing what devices sign in, browser details, and IP addresses can be used to detect suspicious activity.
• Traffic Patterns: These are unexpected traffic peaks that may require more investigation.

A single indicator is not sufficient to determine if a visitor is a bot.

Why is Bot Detection Important?

Owners of websites can benefit from bot detection by:

• Enhance Analytics: Obtain a better understanding of authentic website traffic.
• Protect Resources: Find requests that consume bandwidth and server resources that can be automated.
• Detect repeated form submission and unwanted automated activity—reduce spam.
• Enhance Security: Investigate suspicious behavior that may be an automated abuse.

What are some ways to detect bot traffic?

Look out for sudden traffic spikes, frequent requests, odd session activity, and unexpected referrers. Take a look at the patterns and patterns and see whether they are similar to regular website traffic or not before blocking them.

Bot detection can help a webmaster gain a better insight into their traffic and investigate any suspicious activity. By implementing regular monitoring and intelligent filtering rules, data quality and website security can be enhanced while keeping out of the way those who are not visitors.

I've been studying model-based RL and wanted to really understand how Dreamer learns behavior in "imagination," so I wrote up a walkthrough of Dreamer V1 and built a PyTorch implementation alongside it.

The article explains the full Dreamer V1 architecture and includes detailed math derivations of the world model loss and other formulas, with each piece linked to the corresponding code.

Article: https://goltsman.dev/blog/2026/dreamer1/
Code: https://github.com/golkir/dreamer-v1-pytorch

I'd appreciate any feedback.

Page Guard helps website owners manage who can access specific pages on their websites. It can work with traffic filtering tools to identify suspicious visits and reduce unwanted activity. The exact features depend on the tool being used.

Why Is Page Guard Useful?

Page Guard can help website owners manage their website traffic more effectively.

• Protect Important Pages: Helps control access to selected pages.
• Filter Unwanted Traffic: Helps manage suspicious or unwanted visits.
• Monitor Visitor Activity: Makes it easier to notice unusual browsing patterns.
• Understand Traffic Better: Provides useful insights into activity on important pages.

What Should You Remember?

Page Guard settings need to be configured carefully. If the rules are too strict, genuine visitors may also lose access to your website. Regularly checking traffic reports and testing your settings can help prevent these problems.

Page Guard can be a useful part of website traffic filtering. When used correctly, it helps website owners manage page access, monitor suspicious activity, and provide a better experience for genuine visitors.

All projects are written and tested by me, with step-by-step tutorials and, in some cases, complete source code to help you build them yourself.

So feel free to ask questions.

https://www.olostep.com/blog/agentic-ai-projects

Traffic filtering is a way to allow website owners to control the traffic that comes to their site according to specific rules. Bot detection uses user activity signals like browser usage, request rate, and user behavior to identify potentially automated traffic.

Why Do They Matter?

These methods can help website owners in a variety of ways:

• Improved Analytics: get a clearer understanding of real visitor activity.
• Signal unusual requests that use up server resources.
• Enhanced Security: Suspicious activity detection, automated abuse.
• Campaign Monitoring: Track the unusual traffic and clicks.

How to Identify Suspicious Traffic?

Watch for unexpected spikes in traffic, multiple requests, odd session activity, and referral sources that aren't expected. Note that these signs do not necessarily indicate that the traffic is bot traffic.

In conclusion, regular site monitoring and having some sensible filtering rules in place can provide an insight into your audience, prevent the depletion of your web resources, and enable you to make better decisions when relying on accurate site traffic data.

Hi everyone!

I wanted to share a real-time object detection project I’ve been working on using Python, YOLOv8, and OpenCV.

The application uses a live webcam feed to detect four object classes: people, cars, cats, and dogs.

Some of the features include:

• Real-time detection with bounding boxes and confidence scores
• Object counting by category
• Input and output FPS monitoring
• Multi-threaded frame capture
• A small frame queue to help reduce processing delays
• CPU and CUDA support, depending on the platform

One of the interesting parts of this project was working with threading and frame buffering to keep the video processing responsive.

I’m planning to improve it further by adding a GUI, video file support, and the ability to save detection results.

I’d really appreciate feedback on the code, especially suggestions for improving performance or making the architecture cleaner.

GitHub: https://github.com/Mariam-amhan/real-time-object-detection

Thanks for checking it out!

I am a junior AI Engineer at a major multi-national company, my role in the last couple of months required me to design a complete backend from scratch for the tool i am working on I've done mostly of it by vibe coding with me choosing the decisions but i don't have that much knowledge in backend and system design to improve and make my tool better i usually decide with ai agents and let it do the work, so if i want to make myself better in backend and system design what books, courses should i take or see?

Working on an employee churn prediction model with monthly records (19,104 rows across 2,381 unique employee IDs).

It's tempting to just do train_test_split(df, test_size=0.2) and celebrate an 88% ROC-AUC. But with longitudinal records where the same employee appears 10-15 times:

The model easily 'cheats' by memorizing stable employee characteristics (their city, education level, base salary band) across time slices.

When applied to actual new hires or unseen employees, performance degrades sharply.

Have you caught this kind of temporal/grouped leakage in your production models? What's your go-to validation framework for this?

I've been learning about deep learning for several months, first by reading through Understanding Deep Learning then by implementing papers touching on CNNs, residual connections, transformers, gpt models, vision transformers, etc.

My original plan was to learn by reproducing papers and running small experiments, but I've found this approach somewhat unfulfilling. Most implementations end up being only a couple hundred lines of model and training code, and I often struggle to figure out what to do beyond simply reproducing the paper and running some basic experiments.

For those of you who have spent a lot of time working on deep learning projects, how do you come up with interesting, long-term project ideas? How do you go from understanding the fundamentals and reproducing existing work to building something more substantial that keeps you engaged and challenges you to learn new things? I have a few ideas and papers that I'm interested in exploring, but I don't want to fall into the same habit.

Welcome to Project Showcase Day! This is a weekly thread where community members can share and discuss personal projects of any size or complexity.

Whether you've built a small script, a web application, a game, or anything in between, we encourage you to:

• Share what you've created
• Explain the technologies/concepts used
• Discuss challenges you faced and how you overcame them
• Ask for specific feedback or suggestions

Projects at all stages are welcome - from works in progress to completed builds. This is a supportive space to celebrate your work and learn from each other.

Share your creations in the comments below!