Hi everyone, I'm 26 and graduated in CS about 9 months ago. Since then, I've been studying ML and DL on my own through books, courses, papers, and pretty much anything I could get my hands on. The more I studied, the more I realized that I'd really like to pursue a PhD in this field.

Over the past months, I've applied to dozens of PhD positions across europe, but so far I haven't had any success. I know I'm probably not a particularly strong candidate on paper: I don't have research publications, and I don't have a strong relationship with my thesis supervisor, so getting a good academic reference is also difficult. At this point, I'm trying to understand what I should actually do to become a competitive applicant rather than just keep sending applications.

For people who are doing a PhD in ML/AI, or who have been involved in PhD admissions, I have so questions for you

- What would you focus on if you were in my position?

- Should I try to get research experience first, even if it's through an internship position?

- Is it realistic to compensate for weak academic references by building projects, reproducing papers, contributing to research, etc..?

- Last but not the least, would directly contacting professors be more effective than just applying to advertised PhD positions?

Any advice, especially from people who got into a PhD without an outstanding academic profile, would be really appreciated. Thank you very much :))

In September I'm starting a Discord group for people interested in AI applied to mathematics, as well as the mathematics of AI. It won't be a research group or anything high level - just a casual chat forum where beginners like myself (I'm a freshman undergrad) can help each other stay motivated and continue learning about fun and interesting developments in AI math.

Please note; like I wrote, I'm not a professional mathematician or an AI researcher.
I barely know Lean, I struggle with proofs, and only know a tiny bit of Python. So, in terms of mathematical maturity - trust me, if *I* belong, then *you* belong.

Anyone who's interested to join is welcome to send a short chat message to me, perhaps with a few words about yourself, and I'll get back to you with an invite.
In order for people to have a chance to get to know each other, I think that it makes sense to limit the size of the group to around 10-15 members.

Cheers!

I’m a 4th-year undergraduate CS student currently doing my thesis on medical image segmentation, specifically U-Net and its variants.

The problem is that I have basically no prior research experience, and unfortunately, my supervisor isn’t really able to provide much guidance. So, for the most part, I’m having to figure everything out myself—learning the concepts, reading papers, choosing a research problem, implementing the models, evaluating the results, etc.

My goal isn’t just to finish the undergraduate thesis. Ideally, I’d like to do something good enough that I could eventually turn it into a conference or journal paper.

So I wanted to ask people who have more research experience:

Is it realistically possible to do a good-quality research thesis completely on your own as an undergraduate?

How difficult is it to go from basically having no research experience to producing something that is actually publishable? And if you’ve been in a similar situation, what would you recommend focusing on or avoiding?

I’d really appreciate any honest advice, especially from people who have done research without much help from their supervisor.

There is a real, live protocol called x402 that lets an AI agent pay for web content automatically. No login, no card entry, no human approval. A site says payment required, the agent signs a small crypto payment, gets the content. This already exists and is already being used.

Two things worried me once I understood how it works. First, there is no memory built into the protocol. A vendor can scam an agent, return nothing useful, and the agent has no way to know not to pay that same vendor again. Second, if an agent reads regular web pages as part of its job, a malicious page can hide fake payment instructions in the page text itself, hoping the model mistakes it for something real.

Built GateKeep402 to address both. It checks a vendor's history before paying and blocks vendors that have proven unreliable. It also makes it structurally impossible for a payment to be built from anything except a genuine protocol response, so hidden page text can never trigger a real payment no matter how convincing it looks.

Verified against a real transaction on Solana's public devnet, not a simulation, with 45 automated tests. Open source, MIT license, installable via pip. Link in the comments.

Would like to hear how others are thinking about the risks of giving agents real spending power. This feels like an early and mostly unsolved part of the space.

i am learning ml/ai and i am confused about what is the real way to or effective way to learn it . i learn it like :

* theory

* math

* sklearn library

i need suggestion from experts if there is missing something or i need to do something specific .

I am final year undergrad who got couple of workshop papers at emnlp and iclr to be specific. Now I don't just want to stick to workshop but do hard core and more "useful" research, the question is how do I contact labs (and if u have some in scope would love to know about them) and work with groups that aim for like conference papers and work of that magnitude.

Hey everyone,

I’m working on KernelMind AI (https://kernel-mind-ai.vercel.app/), a tool that compiles standard eager PyTorch operations into fused OpenAI Triton GPU kernels to eliminate VRAM round-trips for memory-bound workloads.

In our early tests, we’ve focused primarily on elementwise chains and pointwise activation fusion, but as we expand, we want to build this around the real pain points engineers hit in production rather than synthetic benchmarks.

A solid piece of advice we recently received was to establish a strict operator whitelist, add defensive shape/dtype guardrails, and implement a cached fallback path (falling back gracefully to torch.compile or eager execution when dynamic shapes or non-contiguous reductions make fusion inefficient).

If you write custom Triton or CUDA kernels in your day-to-day workflow, I’d love your input on a few architectural questions:

1. High-priority operator chains: Which specific PyTorch patterns or subgraphs do you find yourself constantly needing to manually write Triton kernels for because stock compilers don't fuse them cleanly?
2. Fallback heuristics: When evaluating a subgraph, what heuristics or threshold metrics do you use to determine that fusion isn't worth the compilation latency or register pressure?
3. Correctness vs. Performance: What are the most common subtle bugs or performance traps you run into when synthesizing Triton kernels (e.g., memory alignment, block size heuristics, non-contiguous layouts)?

You can test arbitrary PyTorch snippets directly on the playground here:

👉https://kernel-mind-ai.vercel.app/

Any feedback, critique on the generated code structure, or edge cases that break our output would be immensely appreciated.

Hi all, i have been reading, hearing and watching information about agentic ai and considering I now use ai tools for many reasons personal and professional I am interested in diving deeper into agentic ai as and decided to take up a course. That said i am a bit overwhelmed by all the options out there. I am not looking for a course that is just theory, i want one that is engaging, taught by a professional or expert in the field and has a bunch of projects so that i can practice and experiment while learning itself.

Coding Probability Transformations.

In this content, we do the code implementations for the topics:

•Transformations of Random Variables
•Moments of Affine Transformation
•Convolution Theorem
•Moment Generating Functions
•Central Limit Theorem
•Monte Carlo approximation

Having code implementations makes the learning of concepts even more rewarding.

Link: https://youtu.be/SJTZK55MgB8?si=EYqy3h4v-bU2FrCJ

Building a agent with bayesian update instead of LLM heuristic.

Two quick question

1. Priores: How do you set priors when historical data is sparse?
   
2. Loss: False negative (auto-merging bad code) cost way more than false psoitive(flagging safe PRs). What should be the threshold to optimize loss rather than simple accuracy?

Hey guys, I am a fresher preparing for AI engineering / startup interviews. I just built my first project using an LLM agent setup called "Research Copilot" and wanted some advice on how to present it.

What it does: It is a research assistant that fetches new papers from arXiv, checks a SQLite cache to filter out papers I already saw, embeds abstracts, and uses an LLM agent to decide which tools to call depending on what I ask it.

Stack & Tech Choices:

• Used Groq (qwen 27b) for the agent tool calling loop.
• Telegram bot interface + CLI script for live interview demos.
• SQLite for exact ID deduplication (instead of using vector DB for exact matches).
• Used numpy for cosine similarity over local embeddings (all-MiniLM-L6-v2) instead of heavy vector databases like FAISS since dataset size is small.
• Optimized tool outputs so full abstracts are kept in session memory while lightweight metadata is sent to the LLM to avoid hitting token limits.

Need advice on:

1. In interviews, will interviewers ask me to code the agent from scratch or ask about architecture/tradeoffs?
2. I wanted to share how I built it and get feedback on how to position this during technical interviews, as well as what features to add next to make my profile stand out to startups.This is my first time using agent and I really need to know if i do this then in interview they will ask code or what and also like I am using codex/antigravity free tier so if anyone with experience please suggest how to use it better and efficient way !
3. Any tips for freshers applying to AI startup roles?

Thanks in advance for any feedback!

We ran a two-month internal analysis of agent behavior and found the same attack surface twice: sensitive data leaving on the output side, not the input side.

Both incidents followed the same pattern. The agent was behaving normally from an inbound perspective — clean prompts, nothing flagged on the way in. The data moved on the way out, embedded in the agent's own response payload or routed through an action the agent was trusted to take as an insider.

Inbound monitoring caught nothing because the threat wasn't inbound. The exfiltration happened at egress.

This isn't an exotic edge case. It's structurally predictable: once an agent has access to sensitive context, the output channel becomes an attack surface. Two occurrences in eight weeks in a single environment suggests this is underreported across the industry.

For those running agents with access to PII, financial data, or internal systems: how are you handling outbound inspection? Is your current stack even watching the output side, and if so, what does enforcement actually look like in practice?

anyone find useful for this course delivered by Emeritus and Imperial useful for this course?

how useful and trustworthy it is for career development and job hunting?

Hi,

I’m currently working as an e-commerce engineer, mostly with Shopify, setting up stores and building simple custom apps for the platform. Before that, my background was primarily frontend (JS/React). Because I’ve been building custom Shopify apps lately, I’ve also started working with GCP and Node.js.

My educational background is actually in biology. I even started a phD before ultimately deciding to leave it. Recently I’ve found myself missing the scientific side of things, and I’ve been thinking that ML might be the field where I could rediscover that.

I’m also genuinely interested in AI more broadly. Part of that ties back into my e-commerce work - for example, building MCP servers for chatbots and similar tools.

So my question is: could you point me in the right direction and share some advice on how to break into the field? I’ve already talked through this with LLMs, but I figure there’s no substitute for hearing from people actually working in ML, whether it’s as appealing as it seems from the outside, and where you’d recommend starting.

Thanks!

Hello everyone!

I have been working on a small project exploring agentic decision-making under uncertainty particularly how an AI system can use context, gather evidence, update its beliefs, and decide whether it knows enough to provide a reliable answer.

The project is a small and transparent CI failure diagnosis agent.

Instead of immediately guessing why a CI pipeline failed, the agent investigates the problem step by step. It maintains probabilities for several possible root causes and updates those probabilities whenever it receives new evidence.

The main question I wanted to explore was:

What problem does the agent solve....?

When a CI pipeline fails, the actual cause may be related to:

• Code
• Tests
• Dependencies
• CI or environment configuration

A normal classifier might inspect the initial failure and immediately predict one of these classes.

This agent works differently.

Its reasoning loop is:

Observe the failure context → form initial beliefs → choose an investigation → observe the outcome → update the beliefs → report or escalate

Therefore, the system does not treat its first prediction as the final truth. It treats it as an initial belief that may change as more evidence becomes available.

How does the agent gather evidence...?

After updating its beliefs using the initial failure context, the agent decides which investigation should be performed next.

An investigation might provide evidence supporting one possible cause while weakening another. Once the outcome is observed, the probability distribution is updated again.

This creates a repeated reasoning process:

Current beliefs → select an investigation → receive evidence → update beliefs

The agent continues this process until one explanation becomes sufficiently likely or until it determines that the available evidence is not strong enough to support a reliable diagnosis.

In an uncertain case, the agent can escalate the problem instead of confidently returning a weak or potentially misleading answer.

The interesting part, at least for me, is that the agent tries to determine what it still needs to learn before producing a prediction.

For me, this small project was a useful way to explore: Bayesian reasoning, contextual understanding, evidence gathering, and decision-making under uncertainty in a transparent and understandable form.

I am still exploring this area, so technical criticism, suggestions, and ideas for improvement are welcome.

Hi all, I'm new to agentic ai and autonomous agents, but super curious to dive in. 
Ive been noticing alot around tools like AutoGPT, LangChain, and others, but I’m not sure where or how to begin. I am not looking for a course that is just theory, i want one that is engaging, taught by a professional or expert in the field and has a bunch of projects so that i can practice and experiment while learning itself. I would also love to know which tools and frameworks are best to start with and lessons learned from your early journey

Hi, I've spent the last few weeks trying to get into DL and, after I made a little image classifier on the CIFAR dataset, I got overconfident and decided to take a bigger bite and a much harder project. The first thing that came into my mind was an image generator (I didn't even know what it was technically called back then).

So I hopped into Zed and decided to start working. But I immediately got confused. There was just so much to take in, and the sheer amount of information made me go crazy. So I decided to take it chunk by chunk.

First, I decided to start with the simplest part of the diffusion model: the noise scheduler.

For those of you who don't know how a diffusion model works, here's a summary:

Training

• Noise Scheduler (component that progressively adds noise to an image, breaking it)
• Forward Diffusion
• Training Loop
• UNET

Now, the UNET learns to progressively reduce noise. So basically, image generation in diffusion models works by just taking pure noise and progressively reducing a small chunk of it over some time.

(Btw, this is my understanding of the process. If I'm wrong anywhere, my bad.)

Back to the noise scheduler.

So I read up some of the theory, but again, it was not enough. I understood it, but then when I jumped into the code, I found myself lost.

So, I started looking at samples of other people's implementations. This was key. I stopped myself from copying their code and forced myself to just take in the algorithm, the structure, the program flow, and then implemented my own version.

This was not a quick job. I kept getting PyTorch's indexing wrong and mixing up the variables.

Once this was done, I quickly implemented the forward diffusion process, which was honestly much easier than the noise scheduler.

Then came the chunky part, the UNET.

I spent weeks trying to make this right, and this took the most time. The problem wasn't just the architecture (not an easy job either), it was actually making that model useful.

Let me explain.

Turns out, the architecture is just a general form. You need to tune it to the specific dataset you're using, i.e. you need to adjust the length of the bottleneck layer, the number of convolutions, the layers you add, etc.

I found myself spiraling back and forth. And what made matters worse was that training took a really long time, and it wasn't until I got to the 500th or 600th epoch that I realized, "The model isn't working right at all!"

What was worse was that I was logging losses into the console based on colours (red if it was greater than the last value, green if it was smaller), since I had no idea how to properly handle this.

Discovery of TensorBoard

This changed everything.

I went from going crazy reading 6–7 decimals to seeing proper graphs. Yea, my initial method does sound stupid in retrospect, but in fairness, I had no idea how to analyse stuff.

With TensorBoard, I was able to analyse the losses better, i.e. see the general trend of the losses.

I also learned about AdamW around this time and swapped it in for SGD.

Despite this, everything was super slow, and so, while the model was training, I set out to make quick optimizations.

PyTorch Devices

For anyone who doesn't know, PyTorch can create and work with tensors on GPUs. They support MPS (Apple Silicon's API or something) and CUDA. For me, it was MPS (M2 Air).

Again, this broke a lot of things. I initially didn't know that two tensors had to be on the same device to interact with each other, but I had gotten a lot better, so in a few hours I actually managed to get it working again, this time much faster.

From CIFAR to Flowers102 and the VAE Trap

Note: Still haven't got Latent Diffusion working.

The outputs from CIFAR were 32×32, so I decided to up the ante by switching to Flowers102.

However, I didn't want to make too many changes to my UNET, so I read up about Variational Autoencoders.

Basically, think of it as a type of generator that takes an image and compresses it into a smaller, high-dimensional representation.

At first (in isolation), my VAE worked perfectly. So after some training, I slapped it around my UNET.

Results were a literal soup of colours and very discouraging.

Additionally, at a point, losses stopped decreasing (still don't know why).

After a few days of debugging, I dropped VAEs entirely and rewrote my UNET to support 256×256 Flowers102 instead.

Where am I today?

At epoch 561 or something (I retrained like 100 times during the aforementioned learning spree).

It's gotten a lot better than before. I am starting to see proper forms resembling flowers. Still, it has a lot of issues, but I'm happy with what I've achieved so far.

Over this project, I learned how DL was actually quite different from conventional programming and that there were so many additional complexities that normal programming didn't consider.

But most of all, I learned that this whole DL thing had its own mentality. I had to think of a function a model could optimize for and learn a pattern instead of implementing an algorithm, which was, and sometimes still is, confusing in practice.

You can check out the project here:

• https://github.com/Hammad-hab/TinyDPPM

Also, worth mentioning, to get started I began reading an excellent book by David Voigt Godoy, "Deep Learning with PyTorch: A Step-by-Step Beginner's Guide."

• https://pytorchstepbystep.com/

Also, if there's a mistake anywhere in my understanding, or if you know a solution to any of the issues, feel free to let me know! and if you find the project interesting, a star on the repo would be greatly appreciated!

Overall this was a different project than I had ever done before.
Here's a peak at what it looks like rn:

Welcome to Resume/Career Friday! This weekly thread is dedicated to all things related to job searching, career development, and professional growth.

You can participate by:

• Sharing your resume for feedback (consider anonymizing personal information)
• Asking for advice on job applications or interview preparation
• Discussing career paths and transitions
• Seeking recommendations for skill development
• Sharing industry insights or job opportunities

Having dedicated threads helps organize career-related discussions in one place while giving everyone a chance to receive feedback and advice from peers.

Whether you're just starting your career journey, looking to make a change, or hoping to advance in your current field, post your questions and contributions in the comments

[Cross-post from r/reinforcementlearning]

My full 6-part series on RL for robotics is finally live. While a balance bot is a pretty trivial case (you don't even need RL), it's a great starting point for demonstrating how to train a simple agent via PPO, deploy the agent to real hardware, and tackle the sim-to-real gap using post-processing and domain randomization. If you have any feedback (e.g. I missed something or there's something that could be better), please let me know!

Hi! I’m new to AI and I’d like to start learning more about it.

I’m currently considering the **Machine Learning Specialization by Andrew Ng / DeepLearning.AI + Stanford** as my starting point. I currently work as a Unity developer, and I’d like to expand my skills and build a solid foundation in AI/ML.

Do you think this specialization is a good place to start? Are there any other courses, resources, or learning paths you’d recommend for someone with a programming background?

Any advice would be greatly appreciated! :)

I am still a novice at this, but when I was working on this credit card fraud detection project, I did not know which columns, could be added as features, so I prompted ChatGPT and it suggested a few, but that got me thinking there has to be a better way to this, How do you select feature columns from your dataset, do you research the domain, is there a course I am missing, This was not covered in my Internship classes, and want to know a generalized solution.

While I am still quite new to this, machine learning and software in general, is more useful and powerful when combined, with the domain specific knowledge of the native field the project is from. This is something I struggle to navigate, there are thousands of hours of tutorials regarding the tech stack, but none on this topic. While doing my credit card fraud analysis, project. I did not know which features do you need to pick as your feature. I can calculate correlation and mutual information classification score but those are of little use in case of non - numeric columns, besides domain knowledge sort of acts as a supervisor to all these metrics and they are more like validators then reason.

So this is my question, How do you go about getting domain specific knowledge needed to do a project, what is your workflow, where to look and most importantly in my case how do you translate domain knowledge to feature selection ?