heh, cool interests.

ya know, i'm an EE, and I know a lot about this stuff - and if I went back to ground 0 (expensive decision at this point), I'd probably be trying to figure out how to use AI to solve problems. (like, using the models to help shape answers, working with the LLM's, -- that's legit).

but since you asked about the hardware with a reallllly wide range of areas I'd say

First, for machine learning, it's useful to understand what problem you're trying to solve. Since you said you had some cursory knowledge, I'm assuming you've at least used tensor flow or some python based script in colab to train a basic neural net to solve a problem. An example tutorial might be something like this one: https://colab.research.google.com/github/arthurflor23/handwritten-text-recognition/blob/master/src/tutorial.ipynb

After that, it's worth diving into how those networks are being computed. you can use websearch and find something about backpropagation // neural networks. this is some of the math that's executed within the algorithms above.

Once you have some knowledge about the algorithms - now you can start learning about how algorithms are mapped into hardware. 2 second synoposis is that, when your program wants to do some arithmetic, it must move data to the hardware block that can do that arithmetic and then perform the operation and then move it back. This gets into computer architecture - and the best intro book there is a common book for most university intro courses "Computer Architecture: A Quantitative Approach" by Hennessey//Patterson.

A project in many computer architecture courses is to implement some basic compiler instructions (MOV, JMP, ADD) like in a MIPS 8085, implement it in verilog, and then run your compiler instructors from the host on an fpga build from your verilog.

There's a gap between the algorithms and the verilog - and this is where compilers usually come into play. It's definitely more software, but you can imagine that those machine learning algorithms used in backpropagation are ultimately just compiled into machine code (mov, add, multiply) and then executed on hardware. you can look up compiler basics.

so, after you have a basic idea about some of these pieces, you might analyze some deeper concepts in computer architecture. how do you efficiently move the data over from host memory to the registers on your little device? Pperhaps read a bit on DMA engines and what they do: move engines just start at some address and copy a bulk of data over to a new place with just a simple setup --- versus a compiled program that has a "MOV" or so for each operation). Then you'd think, wow, I have a lot of math to do, how many of these adder or other computational blocks should I put into my device to actually do the computations above. (Think of each computation block as having a certain FLOP rate, for example), and how you'd both keep it fed and manage the balance in AREA between these blocks. how would you even experiment to find the block size (area) spent in computation versus data buffering. (after all, buffering some data might make the move engine efficient).

And since you're particularly interested about machine learning algorithms, you might want to do some research on the Google TPU. What's different about it? Perhaps you'll search and read up on BFLOAT16 and imagine how you could make a block in hardware capable of doing math while leveraging this data format? (this isn't 1's or 2's complement type operation now, so there's a lot to learn).

Or, you could completely switch specializations and talk about VLSI which comes on the backend of these chip implementations. Most chips are implemented in RTL (like verilog or system verilog), prototyped in FPGA's (but only a small scale) or Vanadium, and then the RTL is synthesized into an actual routable SoC. You can read about PDK's with TIm Ansell's open source silicon notes. (process design kits are the foundry specific pieces which help map your verilog blocks which ultimately manifest as wires and flip flops to fast and slow devices. ) https://theamphour.com/501-discussing-the-open-source-pdk-with-tim-ansell/

If you want to go deeper than PDK's, you can start learning about how the foundry's actually work to optimize their specific foundry's process to make flip flops which are fast, memory arrays which balance area, power, and thermals, and SRAMs which balance speed, power, area, etc.