OK so since forever I’ve seen that chat gpt struggled a lot with chess just because obviously its an LLM so it wasn’t actually playing chess and was more just trying to guess what the most likely move that would be played is. The problem is that it really has no idea what is happening so it starts making Illegal moves and really there was no way to play it.

But now not only is it not making illegal moves, its also just really good at chess now, I mean its not Grand Master nor engine level, but its a really good player thats probably in the Candidate Master or Fide Master range.

Now what I am wondering is what changed? Like it can’t just be more data because more data after a certain point produces diminishing returns, so I am assuming that the structure of how they think has been reshaped and I am also assuming this is also what is behind chat gpt breaking into frontier math problems.

But I remember when the deep think mode first started that made the AI at least somewhat have something resembling a thought process rather than just spitting out words. But I assume it really lacked any tools for imagination, but now it can actually write codes in real time to check its own assumptions and use the internet to look for information it needs, but is it possible its maybe made a simulation of a chess game in like a python code or something that at least keeps the AI grounded to reality. Or is there something else going on behind that Open AI has changed for it to finally think like a chess player?

Like in general is there a new concrete concept in ML that is or could be responsible for this kind of improvement?

I've been thinking about this lately. With more people building AI apps, I wonder how much time teams spend checking their data before feeding it to a model.

For example, you have a dataset with duplicate records, missing values, inconsistent formats, sensitive information or columns that suddenly changed. Maybe everything looks fine at first, but then you get weird results from your AI app.

I'm curious how people actually handle this in real projects.

Do you use existing tools for data quality and validation, write your own Python scripts, or just check things manually?

And for those working with AI datasets, is this a real pain point for you or am I overthinking it?

Would love to hear how you guys handle this.

Hello everyone!

I would like to share my Master’s thesis in Computational Design and ask for guidance from the community.

I want to adapt my research into an academic paper. However, since my background is in Architecture rather than Computer Science, I’m unsure if the methodology holds up for an Applied AI/ML journal, or which venues would be the best fit.

The Core Concept: The thesis develops a dual cascaded ANN system to optimize solar performance:

• ANN 1 (Surrogate Model): Replaces physics-based simulations (Ladybug Tools) to predict direct sunlight hours in milliseconds. Inputs: room and window characteristics; outputs: values of direct sun light per cell in a 10 by 10 grid.
• ANN 2 (Decision / Inverse Model): Classifies and identifies optimal window positions/orientations based on target performance goals. Inputs: room characteristics and values of direct sun light; outputs window characteristics than can be work in reverse to do the 3D model of the room including the window.

An Interesting Finding: Initially, the goal was to rely on ANN 2 for inverse design. However, because the ANN 1 surrogate model turned out to be orders of magnitude faster than conventional simulation engines, the system could brute-force evaluate all parametric spatial permutations and pick the optimal solution directly, making the decision-support network an optional secondary filter.

Technical Setup & Environment:

• Environment: Implemented natively within Rhinoceros 3D and Grasshopper (using ML components backed by Accord.NET / Python).
• Dataset: Synthetic dataset of 67,200 randomly reduced to 13,440 spatial permutations generated algorithmically under building codes.
• Architectures Used:
  • Regression (ANN 1): Resilient Backpropagation with ReLU activation.
  • Classification (ANN 2): Levenberg-Marquardt with Sigmoid, Softmax, and One-Hot Encoding.

My Questions:

1. Is this surrogate modeling approach and dataset workflow considered a strong enough contribution for a peer-reviewed paper in Applied ML or Computational Design journals?
2. Would you recommend targeting Applied AI journals (e.g., Applied Soft Computing) or domain-specific journals (e.g., Automation in Construction, Building and Environment)?
3. Does implementing ML models inside CAD/BIM environments (Rhino/Grasshopper) reduce or enhance the paper's value for the ML community?

I’ve attached a short demo video showing the real-time workflow. Any feedback on the pipeline or publication advice would be greatly appreciated!

Link to the thesis (is in spansih).

https://anahuac.primo.exlibrisgroup.com/permalink/52ANAHUAC_INST/1k9aq9k/alma994468153405016

I got this error while trying to import sklearn.metric after pip installing sickitlearn on python 3.10.0. Does anybody know how to fix this? Here is my importing code block

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow import keras
import tensorflow_hub as hub
import tensorflow_text as text
import pandas as pd
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau, ModelCheckpoint
from focal_loss import BinaryFocalLoss
from sklearn.metrics import classification_report, confusion_matrix, f1_score

Full error message

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[7], line 10
      8 from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau, ModelCheckpoint
      9 from focal_loss import BinaryFocalLoss
---> 10 from sklearn.metrics import classification_report, confusion_matrix, f1_score

File c:\Users\DELL\AppData\Local\Programs\Python\Python310\lib\site-packages\sklearn__init__.py:73
     62 # `_distributor_init` allows distributors to run custom init code.
     63 # For instance, for the Windows wheel, this is used to pre-load the
     64 # vcomp shared library runtime for OpenMP embedded in the sklearn/.libs
   (...)
     67 # later is linked to the OpenMP runtime to make it possible to introspect
     68 # it and importing it first would fail if the OpenMP dll cannot be found.
     69 from . import (  # noqa: F401 E402
     70     __check_build,
     71     _distributor_init,
     72 )
---> 73 from .base import clone  # noqa: E402
     74 from .utils._show_versions import show_versions  # noqa: E402
     76 _submodules = [
     77     "calibration",
     78     "cluster",
   (...)
    114     "compose",
    115 ]

File c:\Users\DELL\AppData\Local\Programs\Python\Python310\lib\site-packages\sklearn\base.py:20
     18 from .exceptions import InconsistentVersionWarning
     19 from .utils._metadata_requests import _MetadataRequester, _routing_enabled
---> 20 from .utils._missing import is_scalar_nan
     21 from .utils._param_validation import validate_parameter_constraints
     22 from .utils._repr_html.base import ReprHTMLMixin, _HTMLDocumentationLinkMixin

File c:\Users\DELL\AppData\Local\Programs\Python\Python310\lib\site-packages\sklearn\utils__init__.py:9
      7 from . import metadata_routing
      8 from ._bunch import Bunch
----> 9 from ._chunking import gen_batches, gen_even_slices
     11 # Make _safe_indexing importable from here for backward compat as this particular
     12 # helper is considered semi-private and typically very useful for third-party
     13 # libraries that want to comply with scikit-learn's estimator API. In particular,
     14 # _safe_indexing was included in our public API documentation despite the leading
     15 # `_` in its name.
     16 from ._indexing import (
     17     _safe_indexing,  # noqa: F401
     18     resample,
     19     shuffle,
     20 )

File c:\Users\DELL\AppData\Local\Programs\Python\Python310\lib\site-packages\sklearn\utils_chunking.py:11
      8 import numpy as np
     10 from .._config import get_config
---> 11 from ._param_validation import Interval, validate_params
     14 def chunk_generator(gen, chunksize):
     15     """Chunk generator, ``gen`` into lists of length ``chunksize``. The last
     16     chunk may have a length less than ``chunksize``."""

File c:\Users\DELL\AppData\Local\Programs\Python\Python310\lib\site-packages\sklearn\utils_param_validation.py:14
     11 from numbers import Integral, Real
     13 import numpy as np
---> 14 from scipy.sparse import csr_matrix, issparse
     16 from .._config import config_context, get_config
     17 from .validation import _is_arraylike_not_scalar

File c:\Users\DELL\AppData\Local\Programs\Python\Python310\lib\site-packages\scipy\sparse__init__.py:300
    294 # Original code by Travis Oliphant.
    295 # Modified and extended by Ed Schofield, Robert Cimrman,
    296 # Nathan Bell, and Jake Vanderplas.
    298 import warnings as _warnings
--> 300 from ._base import *
    301 from ._csr import *
    302 from ._csc import *

File c:\Users\DELL\AppData\Local\Programs\Python\Python310\lib\site-packages\scipy\sparse_base.py:5
      1 """Base class for sparse matrices"""
      3 import numpy as np
----> 5 from ._sputils import (asmatrix, check_reshape_kwargs, check_shape,
      6                        get_sum_dtype, isdense, isscalarlike,
      7                        matrix, validateaxis, getdtype)
      9 from ._matrix import spmatrix
     11 __all__ = ['isspmatrix', 'issparse', 'sparray',
     12            'SparseWarning', 'SparseEfficiencyWarning']

File c:\Users\DELL\AppData\Local\Programs\Python\Python310\lib\site-packages\scipy\sparse_sputils.py:10
      8 from math import prod
      9 import scipy.sparse as sp
---> 10 from scipy._lib._util import np_long, np_ulong
     13 __all__ = ['upcast', 'getdtype', 'getdata', 'isscalarlike', 'isintlike',
     14            'isshape', 'issequence', 'isdense', 'ismatrix', 'get_sum_dtype',
     15            'broadcast_shapes']
     17 supported_dtypes = [np.bool_, np.byte, np.ubyte, np.short, np.ushort, np.intc,
     18                     np.uintc, np_long, np_ulong, np.longlong, np.ulonglong,
     19                     np.float32, np.float64, np.longdouble,
     20                     np.complex64, np.complex128, np.clongdouble]

File c:\Users\DELL\AppData\Local\Programs\Python\Python310\lib\site-packages\scipy_lib_util.py:13
     10 from typing import TypeAlias, TypeVar
     12 import numpy as np
---> 13 from scipy._lib._array_api import array_namespace, is_numpy, xp_size
     14 from scipy._lib._docscrape import FunctionDoc, Parameter
     17 AxisError: type[Exception]

File c:\Users\DELL\AppData\Local\Programs\Python\Python310\lib\site-packages\scipy_lib_array_api.py:15
     12 from typing import Any, Literal, TypeAlias
     14 import numpy as np
---> 15 import numpy.typing as npt
     17 from scipy._lib import array_api_compat
     18 from scipy._lib.array_api_compat import (
     19     is_array_api_obj,
     20     size as xp_size,
   (...)
     27     is_array_api_strict_namespace as is_array_api_strict
     28 )

File c:\Users\DELL\AppData\Local\Programs\Python\Python310\lib\site-packages\numpy\typing__init__.py:158
      1 """
      2 ============================
      3 Typing (:mod:`numpy.typing`)
   (...)
    153 
    154 """
    155 # NOTE: The API section will be appended with additional entries
    156 # further down in this file
--> 158 from numpy._typing import (
    159     ArrayLike,
    160     DTypeLike,
    161     NBitBase,
    162     NDArray,
    163 )
    165 __all__ = ["ArrayLike", "DTypeLike", "NBitBase", "NDArray"]
    167 if __doc__ is not None:

File c:\Users\DELL\AppData\Local\Programs\Python\Python310\lib\site-packages\numpy_typing__init__.py:102
     86 from ._scalars import (
     87     _CharLike_co as _CharLike_co,
     88     _BoolLike_co as _BoolLike_co,
   (...)
     96     _VoidLike_co as _VoidLike_co,
     97 )
     98 from ._shape import (
     99     _Shape as _Shape,
    100     _ShapeLike as _ShapeLike,
    101 )
--> 102 from ._dtype_like import (
    103     DTypeLike as DTypeLike,
    104     _DTypeLike as _DTypeLike,
    105     _SupportsDType as _SupportsDType,
    106     _VoidDTypeLike as _VoidDTypeLike,
    107     _DTypeLikeBool as _DTypeLikeBool,
    108     _DTypeLikeUInt as _DTypeLikeUInt,
    109     _DTypeLikeInt as _DTypeLikeInt,
    110     _DTypeLikeFloat as _DTypeLikeFloat,
    111     _DTypeLikeComplex as _DTypeLikeComplex,
    112     _DTypeLikeTD64 as _DTypeLikeTD64,
    113     _DTypeLikeDT64 as _DTypeLikeDT64,
    114     _DTypeLikeObject as _DTypeLikeObject,
    115     _DTypeLikeVoid as _DTypeLikeVoid,
    116     _DTypeLikeStr as _DTypeLikeStr,
    117     _DTypeLikeBytes as _DTypeLikeBytes,
    118     _DTypeLikeComplex_co as _DTypeLikeComplex_co,
    119 )
    120 from ._array_like import (
    121     NDArray as NDArray,
    122     ArrayLike as ArrayLike,
   (...)
    145     _UnknownType as _UnknownType,
    146 )
    148 from ._ufunc import (
    149     _UFunc_Nin1_Nout1 as _UFunc_Nin1_Nout1,
    150     _UFunc_Nin2_Nout1 as _UFunc_Nin2_Nout1,
   (...)
    153     _GUFunc_Nin2_Nout1 as _GUFunc_Nin2_Nout1,
    154 )

File c:\Users\DELL\AppData\Local\Programs\Python\Python310\lib\site-packages\numpy_typing_dtype_like.py:194
    162 _DTypeLikeInt: TypeAlias = (
    163     type[int]
    164     | type[np.signedinteger[Any]]
   (...)
    177     | _IntCodes
    178 )
    179 _DTypeLikeFloat: TypeAlias = (
    180     type[float]
    181     | type[np.floating[Any]]
   (...)
    190     | _LongDoubleCodes
    191 )
    192 _DTypeLikeComplex: TypeAlias = (
    193     type[complex]
--> 194     | type[np.complexfloating[Any]]
    195     | np.dtype[np.complexfloating[Any]]
    196     | _SupportsDType[np.dtype[np.complexfloating[Any]]]
    197     | _Complex64Codes
    198     | _Complex128Codes
    199     | _CSingleCodes
    200     | _CDoubleCodes
    201     | _CLongDoubleCodes
    202 )
    203 _DTypeLikeDT64: TypeAlias = (
    204     type[np.timedelta64]
    205     | np.dtype[np.timedelta64]
    206     | _SupportsDType[np.dtype[np.timedelta64]]
    207     | _TD64Codes
    208 )
    209 _DTypeLikeTD64: TypeAlias = (
    210     type[np.datetime64]
    211     | np.dtype[np.datetime64]
    212     | _SupportsDType[np.dtype[np.datetime64]]
    213     | _DT64Codes
    214 )

TypeError: Too few arguments for numpy.complexfloating

Interesting for some reason, sickitlearn uninstall numpy 1.23 despite for sickitlean 1.7.2 only need NumPy (>= 1.22.0) to install 2.2.6 which mess up every other packages' installation. How do I fix this?

Hi all! I'm an AI engineer with a few years of experience, and I've always loved teaching and science comunication. For a couple of years I've been thinking about starting a Youtube channel, but I never found the courage to actually do it. I finally took the leap and I'd love to share my first video with peaople who are as passionate about this topic as I am.

This is the first video on my channel. I tried to build Adam from scratch, motivating each step by a concrete problem of the previous one. All animations are made with Manim. I'd really appreciate feedback, especially on anything that's mathematically imprecise or unclear.

Video: https://www.youtube.com/watch?v=lRu8_6cP3AQ&t=2s

I also put together an 8-slide summary of the video (formulas and cheat sheet).

English isn't my first language, and for years reading ML papers felt like something reserved for people with more

patience than me — every page was a wall of jargon. AI tools finally changed that for me, so I started a small

YouTube channel that rebuilds one paper per episode with animation, 3Blue1Brown-style.

The first episode is the Transformer paper. A few things that only clicked for me while animating it:

- Attention is a soft lookup: every word asks a question (query), and every word advertises what it has (key) and

what it hands over (value). The whole mechanism is dot products and a softmax (2:14).

- The √dₖ division isn't cosmetic: without it the softmax saturates and the gradients die (3:18).

- Multi-head attention is nearly free: eight heads at one-eighth width cost about as much as one full-width head (5:36).

- Attention by itself is order-blind — every bit of word-order information comes from the positional encodings (7:01).

Video (14 min): https://youtu.be/dMWzOf9VwD4

To be upfront: it's my own channel. The animations are made with Manim and the narration is AI text-to-speech —

honestly, the robot's accent is better than mine. Every number on screen comes from the paper; anything

illustrative is labelled as such.

A question for people learning transformers right now: which part stayed confusing even after the usual

explanations? I pick the next papers partly from answers like this.

Digital Logic - YouTube

I have a YouTube channel where I talk about DS/ML topics, usually projects that I've done. If anyone is interested in going through a project or wants me to make a video about what they've made then feel free to reach out.

My statistics skills are pretty weak, and I want to learn from the basics. I don't have a background in statistics I just want to get better at statistics for DS/ML

Can someone recommend any good books, courses, or other resources for a dummy like me?

Hi everyone,

I'm a fresher trying to break into the AI/ML industry in India, and I'd really appreciate some honest advice from people already working in the industry. I've been applying for jobs, but getting interview calls has been difficult, especially when many companies ask for full-time work experience.

🎓 My Education

• PGP in AI & Data Science — Praxis Business School (2026) | 78%
• Data Science & Business Analytics — Great Learning (2024) | 87%
• B.Tech in Electrical Engineering — Narula Institute of Technology, Kolkata (2022) | 80%

💻 My Technical Skills

• Programming & Data Analysis: Python, SQL, NumPy, Pandas, Matplotlib, Seaborn
• Machine Learning: Supervised & Unsupervised Learning, Regression, Classification, Scikit-learn, XGBoost, Random Forest, Logistic Regression, Feature Engineering, Model Evaluation, Hyperparameter Tuning, Statistical Analysis, PCA, Ensemble Methods,Anomaly detection.
• Deep Learning & NLP: PyTorch, TensorFlow, CNNs, RNNs, LSTMs, Transformers, Hugging Face, DistilBERT
• Generative AI: LLMs, RAG, Multi-hop RAG, Agentic AI, LangChain, LangGraph, Chroma, FAISS, Groq
• Deployment & Tools: FastAPI, Streamlit, Docker, Git, GitHub, pytest

🚀 Some of my projects

1. CodePilot Agent: Built a code-repair agent using LangGraph, LangChain, and Groq with an iterative patch-test-retry workflow. Achieved 12/12 repairs on the QuixBugs benchmark.
2. Iterative Multi-hop RAG Agent: Built a RAG system with embedding-based retrieval and iterative reasoning. Improved strict exact match from 38% to 52% on a 50-question HotpotQA validation set.
3. Financial Sentiment Analyzer: Compared DistilBERT against TF-IDF + Logistic Regression for financial sentiment classification, improving accuracy from 79% to 86%.
4. Loan Default Prediction: Built a leakage-aware ML pipeline on 1.3M+ loan records using XGBoost, achieving 0.722 ROC-AUC, with SHAP for model interpretability.

I've also worked on deploying projects using tools like FastAPI, Streamlit, and Docker.

🙏 I need some guidance

• Are there companies in India currently hiring freshers for AI Engineer, GenAI Engineer, ML Engineer, or Associate Data Scientist roles?
• Given my education, skills, and projects, do I have a realistic chance of getting interview calls, or am I missing something important?
• Would anyone be willing to refer me for a suitable fresher position or review my profile?
• Should I focus on a particular skill or build more production-level projects to improve my chances?

I'm open to opportunities across India and willing to learn whatever is required for the role. My goal is to get an opportunity where I can demonstrate my skills and grow as an AI/ML engineer.

I understand that projects alone may not replace industry experience, but I'm ready to prove myself.

Any honest feedback, advice, referrals, or leads would mean a lot. Thank you!

If you want to understand how a neural network learns, Andrej Karpathy's Zero to Hero course starts with backpropagation and builds toward language models. The micrograd lesson is a concrete place to begin: work through the code, then change a small example and follow how its gradients change. The course expects Python and some introductory maths. https://karpathy.ai/zero-to-hero.html

If you want to experiment with an existing language model, Simon Willison's LLM tool has a command-line interface and a Python library. It can store prompts and responses in SQLite, which gives you something to inspect after an experiment. A starting exercise is to run the same small task with two prompt versions and compare the saved outputs against examples you've checked yourself. https://llm.datasette.io/en/stable/

Those exercises teach different things. The first takes you through the mechanics of training; the second lets you examine the behaviour of a model you can already run. Choose the one that fits the project you want to make. Check the model's access and costs before running it.

Disclosure: topmoller.com is my site. AI was used to research and write this summary and the longer guide, which includes ten practitioners, original resources and the background each assumes: https://topmoller.com/articles/ai-builders-to-follow-on-x/

Has anybody done the six month part time program from UTI at Austin, classes conducted by Great Learning?

If so, can you provide your experience during the course?

Were you able to make a career from it?

Thanks in advance!

I got the idea from Tree graphs and Genetic Algorithms. Instead of training an AI, what if we just start from a node that branches outwards until a branch that yields a successful result is obtained. We then can destroy the branches that weren't successful and keep the one that succeeded. We could use the Predictive coding algorithm where Layer1 predicts Layer2 while the errors for Layer1 are stored at Layer2, but in this case it would be the nodes of the branches. Each node would need to contain 3 values. Value1 is for the input path, Value 2 is for output path and Value3 is for protecting the branch against destruction. The inputs are inserted from the root of the tree and sent back out after traversing each node of the tree. I think this could result in an evolving/learning AI.

Guys I need help with making right decisions for my ml journey.

I am a first year, first semester student of CS. I am very passionate and curious about learning ML. But nothing works out.

I currently have basic to intermediate level knowledge of c++ and python. Recently, also started numpy and pandas for data manipulation but have no idea what to do next.

Some seniors advised me to simply focus on programming fundamentals and maths and then pivot to ml later but I think earlier is better especially with less course load in the first year.

I also did sql middway and then stopped. I did ml fundamentals to some extent and stopped and DSA as well and stopped.

Wait , before you call me a quitter. This is what I have heard on internet. That you can't be an ml engineer or ai engineer in isolation you need to have SWE skills to add that layer of ml on top. That's why I started dSA but ahhh internet advice (ai advice ) is driving g me crazy. I am all over the place and not able to lock in for one skill.

My course is teaching c++ fundamentals while I am training my brain to think and work in python. Well yes python after learning app is quite easier.

I am fearful that I might me making the wrong step and learning a skill at wrong time that is why I am not able to focus on anything.

I am overwhelmed with guides and advices and feels like wasting of my energy and time.

I am just desperate to get a job as seeing my peers landing internships this early is making me loose my senses.

If any of you can help. I will appreciate that.

I know this question has been asked before and at the time my answer was always no. But man.... This year has been a crazy development for AI and has changed my way of thinking about how far it can go.

I would like to pursue a Master's soon and I always thought about Comp Sci since it covers a lot of different subjects but I am seriously considering a AI/ML Masters degree to get ahead of the curve.

What are your thoughts?

Was trying to picture a way to grok the gist of what defines a (large) family of current methods.

Mainly the deep learning branch. As opposed to other ML methods (GBMs, random forests, etc.).

The usual neural nets are the main example. Some other notable cousins & variants are HDC/VSA, Hopfield nets, RVFL, etc.

Messy example/attempt (looking for better):

AI = high-dimensional (dimension-exploiting) adaptive filtering + content-addressable memory

Regular (location-addressable) memory: address -> data

Associative (content-addressable) memory: data-fragment -> rest-of-data (mask-filling)

Chasing that thread led to reading up on Shannon's Blockhead) thought experiment. An interesting counterargument to the Turing test:

A disadvantage of the Turing definition of thinking is that it is possible, in principle, to design a machine with a complete set of arbitrar­ily chosen responses to all possible input stimuli (see, in this volume, the Culbertson and the Kleene papers). Such a machine, in a sense, for any given input situation (including past history) merely looks up in a "dictionary" the appropriate response. With a suitable dictionary such a machine would surely satisfy Turing’s definition but does not reflect our usual intuitive concept of thinking. This suggests that a more fundamental definition must involve something relating to the manner in which the machine arrives at its responses - something which corresponds to differenti­ating between a person who solves a problem by thinking it out and one who has previously memorized the answer.

- John McCarthy & Claude Shannon, Automata Studies (Annals of Mathematics, No. 34)

1956

Their framing, roughly, seems to be: AI defined as a way to approximate an idealized infinite-dimensional, infinitely large lookup-table with infinite storage speed & retrieval speed.

In domains like RL there's sometimes a literal LUT used in place of a later neural model that can store more and generalize/interpolate, etc.

In the net-as-fuzzy-LUT framing:

1. Storage/encoding into the table/tensor is done through adaptive filtering (a.k.a. "learned"/non-hand-coded lossy compression).
2. Stored form of the tensor and its retrieval process resembles a kind of associative memory done entirely in software. A "virtual" space/geometry/manifold?

The space seems tuned during training to a high enough dimensionality to linearize/"smooth" the functions needed to smoothly interpolate/bridge between its gaps.

Biases like convolution & attention add more structure/scaffolding to the space, to interpolate things that seem plausible, but farther away from the original training data distribution.

The vectors for different input/output modalities can be co-located, so images can be associated with words in the same way each can be associated with each other, for things like typical Q/A pairs.

Traversing and operating on this high-dimensional space involves linear algebra & matrix ops.

Since those ops can be parallelized (SIMD/SIMT, MIMD, etc.), the traversal speed can scale horizontally all the way up to bandwidth/interconnect/other bottlenecks instead of scalar compute bottlenecks.

And the main use case is basically some variant of content-based "semantic search" over that repository of info.

The analogies probably don't hold well, or even mislead, in several places.

Kinda curious how other folks try to capture it. Also looking for any papers similar to the above.

Hey everyone! As a college freshman in CS that has been dabbling here and there in ML for the last year or two, I have decided to get a copy of Hands on Machine Leaning with Scikit-Learn and Pytorch from O'Reilly. I do already have intermediate background in python and I have Calculus 1 knowledge (currently taking Calc 2) as well as a very raw idea of Linear Algebra. If anyone has experience going through this book, could you kindly provide me with the process you took to get the most out of the learning process? Also, a more general question is whether I should have any additional resources aside from this book and doing starter Kaggle competitions like the Playground competitions every month. Thanks for the input!

I am too undecided, can someone guide me?

I've been experimenting with an optimizer idea and would love feedback.

Idea. Two copies of the weights. a1 is the main copy. a2 is a scout that runs ahead with AdamW at its own adaptive learning rate. Every k steps I compare a1 and a2 on one fresh batch (paired per-example losses). If the scout is better, a1 slides toward it and the scout's lr goes up. If not, the scout is sent back to a1, its Adam moments are reset and its lr goes down. So bad steps are filtered out before they reach the main weights.

I know it's close to Lookahead plus trust-region / line-search ideas, so I'm not claiming a new class of optimizer, just a simple combination I wanted to measure properly.

Results (small MLPs, NumPy, equal gradient budget, both methods tuned separately, 10 fresh test seeds):

- sklearn digits: 97.40% vs 97.44% for tuned AdamW (same within noise)

- noisy 6-class synthetic data: 48.6% vs 48.5% (same), test loss slightly better (1.425 vs 1.463)

- Starting at a way-too-high lr (0.1): plain AdamW collapses (54% / 20%). Without any lr cap my method recovers on digits (96.8%), but only partly on the noisy task (36.7%). Clamping AdamW's lr to a ceiling also fixes it, so much of the robustness is just the ceiling. The ablation is in the README.

What I'm NOT claiming: that it beats AdamW with a well-tuned lr. In my tests it doesn't. It also costs an extra copy of the weights and about 2 extra forward passes on the test batch every k steps.

Things that didn't work: a third "b1" path splitting into two branches with different lrs. No gain.

Caveats: only small tasks so far. The PyTorch port passes its tests (including a check that the scout step matches torch.optim.AdamW); benchmarks are NumPy-only. BatchNorm isn't handled.

Code, benchmark protocol and tests (Apache-2.0): https://github.com/zeyartson-cmd/HowToSteneros

Questions: (1) is there prior work doing exactly this accept/reject on a scout copy? (2) would you expect the benefit to grow or vanish on large models? (3) is there a better test statistic than a paired z-test on one batch?

Hey yall,

Im a data scientist trying to develop the skills/knowledge to become a researcher or at least research engineer.

Currently following https://vladfeinberg.com/2026/05/10/how-to-land-a-job-at-a-frontier-lab.html and working on this suggested exercise:

> Code a ~10M transformer using only jax, flax, optax in free colab using tpu. Hard code it to accept digits 0-9, space, +, =. Generate a dataset of simple up-to-3-digit numbers, have it learn addition. Should train quickly on T4 GPU (pad examples to fixed length)

Hit me up if youre on a similar path and want to learn and share progress together :)