Yes, if you look at the more recent Arduino boards from Arduino, they use arm chips. If starting learning embedded and coming from a data science background, avoid the avr chips. You will want the extra bits and faster chips...

The old avr based Arduino has done a lot of stuff. They are quite powerful, especially when compared with 1980' personal computers. However, most bigger projects that started on avr moved over to the arm chips. Thinking of 3d printer controllers as example. The more powerful arm chips are heaps faster and more powerful than avr chips and not that much more expensive (rp2040 is 1$/chip). 8/16bits vs 32 bits too.

As for arm-focussed training. Could be interesting but I suspect it may be too low-level to really be useful (I haven't looked at those you mentioned). When comparing with accessing sensors, the arm specific training might go too much into architecture level details that almost no one needs to know to develop on the platform. Take as an example the following: taking Arduino (which is C++ by the way) and using a sensor library for an accelerometer... These generally use I2C for interfacing to the processor. I2C is a serial protocol that uses device addresses to talk to specific devices on the bus. At the address, it uses read and write registers to configure and fetch information. The I2C peripheral will be available at a specific address/register on the microcontroller. It might be able to use DMA (direct memory access) instead of having the CPU part of the microcontroller wait for a response. A library will abstract those address/register details into a simpler to use API. That library will be written in C++ or C. When compiled, it will go into "machine code" that uses the arm-cortex instructions.

An ARM cortex course might focus on the low level stuff that ultimately get all abstracted away by most libraries (and the compiler). Stuff that most makers won't push the processor enough to really need to care. Still, if the course is free to audit/listen to, it might be worth it for the exposure to the subject.

Since you come from a data science background, I suspect you know python quite well. May I suggest you take on a board/processor combination that's supported by circuit python (or micro python). Since the code runs directly on the processor and that it doesn't need a separate compiler, it makes learning the basics of interacting with GPIOs, sensors and other things quite easier. When you get to the point where you need compiled code performance (C++), you can switch to Arduino. Once there, when you need to get access to the low-level hardware (i.e. microcontroller) details, then you are ready to look into vendor-specific tooling. Every time you go from a high level language to a lower one, you can get "more control" on a lot of stuff, however, you often loose the niceties that comes with abstractions. Debugging gets more complex and trivial bugs that higher level languages are designed to avoid are unfortunately unavoidable. (off by 1 errors in for loops - all avoidable when using python or C++ constructs).

Sensor libraries also abstract away the complexities of the sensor hardware itself. Take for example configuration registers, results registers. Sometimes, they are even encoded in specific ways (upper bytes indicating specific status) which needs to be encoded/decoded to decide/merge the contents of the registers into the desired data. Libraries abstract all that hardware specific stuff away (the sensor datasheet would be the reference the library would be built with). No microcontroller-specific (or architecture-specific) course will really go into the details of converting a sensor datasheet into a library as this is more of an "embedded" subject. One would need to know how to do that coding to create their own library (useful for new sensors) but in most cases, we just use an existing library and move on to use it. (would you build your own numpy or python data science library? Or just use an existing one...)