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?

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.

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).

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?

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?

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.

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.

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!

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 am too undecided, can someone guide me?

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!

Here's a small evaluation exercise you can do without training a model.

Imagine 100 examples: 90 negative and 10 positive. Your classifier predicts “negative” for every example.

Its accuracy is 90/100 = 90%. Its recall for the positive class is 0/10 = 0%. It found none of the positive cases.

That doesn't make accuracy useless. It means “90% accurate” needs context: which examples, which class balance, and which mistakes matter for the task?

A useful check on your next classification exercise:

1. Compare with a simple baseline on the same evaluation data. Scikit-learn's DummyClassifier can make constant or majority-class predictions.
2. Inspect the confusion matrix rather than only the headline score.
3. Decide which errors matter before judging the result. Recall asks how many actual positives you found; it doesn't measure how many of your positive predictions were correct.

Try changing the class balance to 50/50. What happens to the always-negative classifier's accuracy and positive-class recall?

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 :)

Hey everyone!

I'm an ML Engineer with 5+ years of experience, planning to switch to a better org, preferably FAANG. My goal is to be interview-ready within the next 3 months.

What I'm preparing for:

- ML and DL fundamentals

- GenAI and ML system design

- DSA

Who I'm looking for:

A study partner who is also an experienced developer preparing for a similar switch. This is specifically for people with industry experience, not first-time learners.

The plan:

Keep things fast-paced and focused. We can discuss concepts, solve problems, conduct mock interviews, share learnings, and hold each other accountable consistently.

We can also tweak the plan based on what works best for both of us and exchange useful resources, interview experiences, and prep strategies along the way.

If you're in the same boat and serious about the goal, DM me with a short intro, your YOE, and what you're currently focusing on!

I'm a 3rd-semester B .Tech AI student and I need ideas for a semester project. I want something useful, fun to build, and ideally strong enough to grow into a small paper.

Background: strong Python, some C++, DSA, OOP, probability/stats, linear algebra. This semester: DBMS, algorithm analysis, AI, intro data science, differential equations.

What I'm looking for:

- A real problem or open question, not another CRUD app with an 'AI' label

- Doable by one person in one semester

- Public data, or data I can realistically collect

What would you build if you were in my position? Ideas from research, industry, or your own student projects (including ones that failed and why) are all welcome.

Thanks!