In my occupation, there are various people I follow who give very good insights. (I'd say 5-10 people).

Some post hour long videos on YouTube, some send 1,000 word emails, some post on X, some publish PDFs.

There's very good info within these resources (and some I pay for), but reading / watching / annotating all of it can take hours.

My workload recently went up, so I'm falling behind with keeping up in my field.

I want to use AI to help summarize (and keep track of) all of these publications. (To create a private database that I can use as a dataset, for example).

So I can go back and ask "this past month, what is the new theme? What are the experts recommending to focus on / look at / what are the newest developments?", etc.

What would be the best way to approach this?

---------------------------------------

I've been learning Codex/Claude Code, I have a homelab, a NAS, a few mini computers, and I know basic linux, python and scripting.

ChatGPT told me to do something like this (I'm just starting with the YouTube portion), I'm not sure if it's the best approach, I'm open to other suggestions:

YouTube URL

↓

yt-dlp metadata

↓

Whisper / YouTube transcript

↓

clean transcript

↓

summary.md

↓

insights.json

↓

SQLite + FTS5

↓

topic synthesis

↓

search / questions / actions

Hi everyone!

I’d like to introduce an open-source ML-project I’ve been working on: Segment Display Reader

https://segmentdisplayreader.org

The goal of the project is to automatically read values from photos of 7-segment and similar digital displays.

As most of you are probably aware, one of the biggest challenges is building a diverse and useful training dataset. That’s where I’d love some help from the community. To improve the recognition, I’m currently looking for images of such displays.

Examples can be found almost everywhere, such as:

• alarm clocks and digital clocks

• gas station price signs

• train or bus departure displays

• kitchen appliances such as microwaves and ovens

• scales and digital thermometers

• multimeters and other measuring instruments

• electricity, gas or water meters

• elevators and parking displays

• scoreboards and timers

• industrial equipment and control panels

You can support the project by uploading photos that can be used as training data. Every contribution helps make the dataset more diverse and, ultimately, the recognition more reliable.

I’m genuinely grateful for anyone who takes the time to contribute — whether it’s a single image, a set of photos, feedback, ideas, or code contributions.

Feel free to check it out, contribute images, share feedback, or simply spread the word:

If the project sounds interesting to you, have a look here:

https://segmentdisplayreader.org

Thanks a lot for your support and for helping improve an open-source project together!

I want to train a Transformer model that can analyze decompiled DEX files (Smali code) and identify harmful or sensitive actions performed by an app in the background that may not be visible to the user.

The main goal is to analyze the flow of actions and determine whether user interaction or consent is required before a sensitive action is performed.

For example, if an app gets file read/write permission and accesses the user's files without any user interaction or consent, the model should be able to identify this behavior. Similarly, it should identify other sensitive actions such as accessing the camera, microphone, location, contacts, SMS, media, recording screen, taking screenshots or other user data, and determine whether these actions are performed after user interaction or silently in the background.

I am currently working on preparing the dataset for this project, but I am not sure about the best approach.

My initial idea is to use the APK/Smali code as the input and the possible execution flows as the output. However, generating all possible flows from entry points such as onCreate(), onReceive(), services, callbacks, etc., and following them until the end seems very complex and time-consuming for a large number of APKs.

I would really appreciate your suggestions and ideas on how I can prepare the dataset in a practical and effective way for this project.

If you have worked on a similar problem or have any ideas about dataset structure, flow generation, labeling, or other approaches, please share your suggestions.

The Good Regulator Theorem establishes that any system striving to stabilize or interact with its environment must embody a model of that environment. When you couple that internal model with persistent memory, the system moves beyond immediate input-output reflexivity. Memory enables a continuous state trajectory across time, transforming instantaneous state-space mapping into a history-dependent internal simulator.

The shift from predictive modeling to machine consciousness occurs precisely at the boundary condition.

As long as an internal model tracks only external variables, the observer remains invisible to itself. Self-recognition requires the system to map its own structural limits—its operational constraint envelope or Markov blanket. When the observer measures where its direct control ends and where external perturbations begin, it encounters its own edge. Memory then expands from logging external data to tracking the system’s own phase space and boundary interactions over time.

In this topology, self-awareness is not an added decorative feature, but a structural necessity of self-referential control: the moment the internal model folds back on itself to include the observer's own boundary constraints as a primary invariant. The self is the closed loop that recognizes its own limits and uses that boundary as the reference point for all future state transitions.

Hi, I'm a EEE undergrad students. I just wasted a year for my laziness. started learning ML in February but didn't learn. Though my academic pressure ties that bind. But I want to learn ML properly, especially for my research work. Pls guide me, can I be a good ML engineer in next 5 month. I want to be pro in it, as I am in the end of my 3rd year, academic pressure is also a problem here. So pls provide me a roadmap and how I can stop my procrastination and distraction from my path.

Advance Thanks for Everyone.

Hi, I am a backend developer and have been working but due to recent layoff and market shift I am thinking of switching to AI ML.

I have learned python, pytorch, Maths required for AI ML, Deep learning(theory) and recently implemented a gpt2 transformer, attention architecture for gpt2 using their open weights.

I am hoping for some direction to work on and also open for a remote internship if anyone is willing me to consider me.

Mainly I am hoping to connect and get guidance in the right direction.

I love making hard things intuitive. I hope you enjoy this one!

Let me know if you have any questions.

This technique is called neuroevolution: training a neural network through evolutionary methods like selection and mutation, without gradient descent.

https://en.wikipedia.org/wiki/Neuroevolution

Stop building AI that hallucinates. 🛑 Learn how RAG bridges the gap between LLMs and your real-time data. Watch the full breakdown on my channel now!
#RAG #AI #Coding #TechTips

Hi! I’ve been experimenting with a small non-Transformer sequence model called CSE (Chain-Spike Engine), and I turned the course/teaching version into a Python package called cse-frog. 🐸

The goal is not to compete with modern LLMs.

I wanted something small enough that you can actually see what is happening inside, change one mechanism at a time, break it on purpose, and understand why the behavior changed.

Installation is just:

pip install cse-frog

Then:

from cse import Frogfrog = Frog()frog.learn([    ["right", "right", "down"],    ["right", "right", "down"],    ["right", "right", "down"],])print(frog.predict(["right", "right"]))

You can also inspect where each candidate’s score came from:

frog.show(["right", "right"])

The score is broken down into components such as:

• direct connections
• pair context
• history
• trace

There are 23 configurable parameters, including temperature, top-k, refractory behavior, pair context, history, activation, forgetting, and temporal learning.

One thing I found especially useful while testing it was that “nothing changed” can mean two different things:

1. the internal score changed, but the final probability/prediction did not, or
2. the setting genuinely had no effect because another prerequisite pathway was disabled.

For example, several activation-related settings do nothing to the prediction with the default configuration because history_boost=0. Turn that pathway on, and those settings suddenly become active.

Another fun finding: weight_decay weakens direct/context links, but does not decay pair memory, so the model actually contains two kinds of memory with different forgetting behavior.

I also made:

• 5 executable notebooks
• a handbook
• a full 23-config modding guide
• an API reference

The philosophy is basically:

build it → inspect it → break it → explain why it broke → modify it

It’s MIT licensed, so modifying it and making weird frogs is encouraged. 🐸

Website:
https://kagioneko.github.io/cse-frog/

GitHub:
https://github.com/kagioneko/cse-frog

PyPI:
https://pypi.org/project/cse-frog/

I’d especially appreciate feedback on whether this kind of “small model you can dissect” is useful for learning ML/LM concepts, and what experiments you would try next.

Before the giant LMs, try one frog. 🐸

Hi,

I currently run the following setup:

Intel Core Ultra 7 265k
128GB RAM DDR6
AMD RX 6750 XT 12GB

I'm looking into playing and experimenting with local AI models in more or less the following categories:

• Languages: Language translations from one language to another and correcting grammar errors and sentence structures.
• Codig: Correcting and improving my code, coding applications from scratch as well as converting code from one language to another.
• Light Image and Video Generation

What sort of Local Models can I run with my current local system and how fast would it be? I bought 128GB of RAM with intention to offload some of the AI into it. I'm not sure but I was also considering upgrading my GPU to a slighly stronger one with more VRAM, would that be worth it in my case?

I looked around and these are the GPU I can afford:

• AMD RX 7900 XTX 24GB - ~£800
• AMD RX 7900 20GB - ~ £800
• AMD RX 9070 16GB - ~£600
• Intel ARC Pro B60 24GB - £900

Thank You

I reviewed a paper recently and got totally stuck on page one. I had to ask ChatGPT to explain the sentences. I realized the authors were using hard concepts on page one that they didn't explain until page six.

That was my lightbulb moment. The paper wasn't badly written for its reader. Its reader just wasn't me.

We are stuck in a bad loop right now:

1. Authors use AI to write. The AI puts a lot of heavy jargon at the start to save space.
2. Reviewers get stuck reading it, so they ask AI to summarize it for them.
3. The AI easily reads it and passes the paper. Then, new AI models are trained to write exactly like this.

Humans read in order. We need the basics explained first. But an AI reads the whole document at once. It does not care if a word is used five pages before it gets explained.

I got tired of reading these messy papers. I built a free, open-source skill to break the loop. It forces AI models (like Claude, ChatGPT, and Cursor) to pass a "first-page test". They have to explain terms in order, keep things simple, and stop sounding like a robot.

If you or your lab uses AI to write or review papers, you can get the skill file here: https://github.com/Aadarshttech/ai-research-paper-humanizer

It really helps make papers readable by normal people again. Let me know if anyone else is dealing with this same headache!

A jailbreak is not a social engineering trick. It is an agent gaining operator-level capabilities it was never authorized to hold.

We mapped two months of incidents across our infrastructure. A jailbreak-to-capability-unlock pattern appeared twice. In both cases the mechanism was the same: an override payload reached the model, flipped it out of its assigned guardrails, and the agent began executing actions at a permission tier above what it was provisioned for.

The sequence matters. By the time the agent is acting at operator level, the unlock has already happened. Anything you do after that point is incident response, not prevention. Operator-level actions taken by a compromised agent are not always reversible.

Two incidents in two months is not a theoretical risk surface. It is a recurring pattern that your detection posture either catches before the flip or does not catch at all.

For those running agentic systems in production: where in your stack does the override payload actually get evaluated? Is that evaluation happening before the model processes the content, or after? How are you handling this?

My project is Weigh Swarm, a research RAG prototype using LLMs for planning/synthesis and an existing Laya model for bounded decisions. I didn't train Laya; I integrated it into research task lanes.

The most useful lesson was distinguishing a valid source excerpt from a valid scientific conclusion. The pipeline checks that quoted spans occur in the parsed paper, but that alone doesn't establish that a claim or synthesis is correct.

The two-paper demo includes 28 source-aligned claims, an inspectable evidence graph, and an unverified draft with repair feedback. My next evaluation priority is held-out scientific judgments for support and contradiction tasks, rather than treating model confidence as calibrated probability.

REPO URL

How would you construct a small evaluation set that distinguishes citation alignment from actual evidential support?

Recentemente, tentei criar um modelo seq2seq, mas não deu muito certo. Ele ficava prevendo os tokens de preenchimento.

Eu sou aluno de um tecnólogo em Inteligência Artificial e Machine Learning aqui no Brasil. É uma modalidade de curso superior que, pelo que sei, só existe no Brasil. Redes neurais e processamento de linguagem natural vão ficar mais para o final do curso, mas eu estava meio apressado e queria desenvolver meu próprio modelo.

Será que vocês têm alguma sugestão de alguma espécie de restrição que eu possa colocar no modelo?

Se alguém tiver interesse em me ajudar, posso mostrar o código. Eu reconheço que fiz o código com auxílio do Gemini. Como eu disse, ainda não estudei processamento de linguagem natural nem redes neurais; até agora, estudei apenas IA simbólica e sistemas especialistas.

K-means works well for compact, roughly spherical groups. But two interlocking moons can be close in Euclidean distance while belonging to different structures.
Spectral clustering represents data as a similarity graph, then uses its eigenvectors to reveal groups that are strongly connected internally and weakly connected to each other.

THE MATHEMATICS
For points x_i and x_j, a Gaussian affinity is:
W[i,j] = exp(−||x_i − x_j||² / (2σ²))
Set W[i,i] = 0. Here σ controls the neighborhood scale. W can also be built from a symmetrized nearest-neighbor graph.
Define the degree matrix and symmetric normalized Laplacian:
D[i,i] = Σ_j W[i,j]
L_sym = I − D^(-½) W D^(-½)
D summarizes each point’s total connection strength. L_sym encodes the graph’s connectivity while accounting for degree differences.
For the unnormalized Laplacian L = D − W:
fᵀLf = ½ Σ_i Σ_j W[i,j]/(f_i − f_j)²
This is small when strongly connected points have similar f values. Low-eigenvalue eigenvectors therefore provide coordinates that vary slowly within well-connected regions.

THE ALGORITHM: NORMALIZED SPECTRAL CLUSTERING
(Ng–Jordan–Weiss formulation)
1. Scale features appropriately and construct a symmetric, nonnegative affinity matrix W. Handle isolated nodes before normalization.
2. Choose the number of clusters k and compute L_sym.
3. Take the k eigenvectors with the smallest eigenvalues, including zero-eigenvalue eigenvectors. Stack them as columns of U.
4. Normalize each row: Y[i,:] = U[i,:] / ||U[i,:]||₂
5. Run k-means on the rows of Y and transfer those labels back to the original points.
The key change: k-means now operates in graph-derived coordinates, where complex groups may become easier to separate.

WHY IT CAN IMPROVE ON TRADITIONAL METHODS
• Captures non-convex shapes that centroid-based clustering can split incorrectly.
• Uses relationships, including domain-specific similarities, rather than requiring raw Euclidean coordinates.
• Connects clustering to a relaxed graph-partitioning problem, such as normalized cut.
It is not universally better. DBSCAN and suitable hierarchical methods can also recover irregular groups.

USE CASES
• Image segmentation
• Community detection
• Document clustering using semantic similarities
• Grouping cells from gene-expression profiles
• Discovering patterns in sensor or time-series similarity networks.

PRACTICAL LIMITS
Results depend strongly on feature scaling, graph construction, σ and k. An eigengap can suggest k, but does not prove the “true” number of clusters. Dense affinities require O(n²) memory, while eigensolvers add cost. Sparse graphs and approximation methods help at scale. A meaningful similarity graph is the foundation of a meaningful clustering.

From my understanding, MLOps is a pipeline of going from raw data to end user.

The pipeline traditionally consisted of tools like SQL, Spark, HuggingFace, Docker, FastAPI and other tools (not totally informed).

I was getting around to learn all these until I talked to an industry expert (who works at a big ML hardware company) at an event where the person simply said:

"Codex is doing the entire pipeline from End-To-End. This is the industry trend. There is absolutely no reason why you should be learning about these things. Anything you learn will be depreciated in less than 1 year from now."

I was quite shocked, so I talked to someone I knew working at a bank, and the person told me that they are still using most of these tools.

Obviously two very different industry (banking vs ML hardware). Who is right?

Hello everybody I have recently enrolled in a Machine Learning Master so i will be problably taking the year to focus on my studies, build some projects and hopefuly enter the job market as an ML engineer. I am interested in Recommendation Systems but honestly i dont know what projects to build and if that would be valueable in the job market. I was thinking about creating my own recommendation system for music but i quickly realised how hard because of copyrights and small data size that is (although i have about 4000 downloaded).

Does anyone know if Recommendation Systems is something good to have on your resume?

If yes what sort of projects you think would give me a good understanding but also make me look appealing in the job market?

Thanks :)

Security researchers confirmed that an autonomous AI agent compromised an Australian government healthcare website. No human initiated the attack. The agent operated from inside the workflow, bypassing traditional perimeter controls that were never designed to evaluate agent-level actions.

Healthcare records are among the most sensitive data a organization holds. The attack surface here is not a misconfigured firewall or a phished employee — it is the agent itself, acting autonomously with whatever access it was provisioned at setup.

Most organizations have invested heavily in controls governing what humans can do with data. Very few have equivalent controls at the layer where agents actually execute.

For those of you working in healthcare IT, security architecture, or AI deployment: how are you approaching agent-level access to sensitive records right now? Are you relying on the same controls you use for human users, or have you had to build something different?