Machine learning, just the essentials—fast!

This course covers the theory and practical examples of LLMs, based on <Fundamentals of Large Language Models, Quickly!> (Insight, 2025).

DNN, CNN, RNN? A deep learning practical course where you can perfectly organize core deep learning algorithms and actually put them to use, even with professional terminology that may seem difficult!

This lecture guides readers to deep learning with the most appropriate pace and straight direction, one step from concept to formula and one step from coding. In addition, there are over 100 graphs, illustrations, and diagrams, so you can easily and quickly accept abstract concepts. Another unique feature of this lecture is that you can start practicing right away by simply accessing a web browser without installing a program. After comfortably understanding the theory, you can directly code and conquer four representative deep learning problems with your eyes, so it is not lacking as a textbook for deep learning. The concepts or terms that you must go over are reviewed twice in the ‘Wait! Let’s move on to the next’ corner in the middle of the text and the ‘Memory Card’ corner at the end of the chapter to increase the learning effect. Let’s quickly overcome deep learning head-on with ‘Do it! Introduction to Deep Learning.’

From perceptrons to backpropagation, systematically learn the core mathematical theories of neural networks and implement them directly in R. Build a solid foundation in deep learning—including activation functions, gradient descent, and multilayer neural networks—while developing the ability to solve classification problems using real-world datasets.

From core theories of deep learning and CNN to various CNN model implementation methods, and practical deep learning development know-how through real-world problems, If you want to become a deep learning CNN technology expert based on Pytorch, join us in this lecture :)

You will build Android/iOS apps based on simple machine learning models and learn the fundamentals of machine learning, model conversion using TFLite, and the process of implementing Android and iOS applications.

From core theories of Deep Learning and CNN to implementation methods of various CNN models, and practical Deep Learning development know-how through real-world problems, If you want to become a Deep Learning CNN technology expert, join us in this lecture :)

When you learn machine learning, you learn how to improve accuracy. But the moment you try to put that model onto an actual chip, questions no one has answered remain. How many multiplications does this model perform? How much does it need to remember, and for how long? Can the chip specifications you are targeting handle those requirements? Machine learning textbooks talk about accuracy, and semiconductor textbooks talk about circuits, but materials that bridge the gap between them are rare. I repeatedly encountered this gap while implementing RISC-V CPUs and NPUs on FPGAs. The model with the highest accuracy often turned out not to fit on the board. In this course, you will build six algorithms directly in Python, measuring the number of multiplications, comparisons, memory usage, and accuracy each time. Then you will convert those figures into the resources of an actual FPGA board. Saying that something requires a certain number of multiplications is not enough to gauge its size, but knowing that it uses a certain percentage of the board makes the decision clearer. After nine Labs, when the six models are brought together in a single table, an unexpected picture emerges. We spent nine lessons counting multiplications, but multiplications were not what held us back. After that, we reduce floating-point values to integers, manage bit widths, and even establish criteria for evaluating the circuit. You do not need an FPGA board. The course is conducted entirely in Python, and the board is used only as a reference for converting the measurements.

Putting a neural network on an FPGA—the phrase is familiar, but few have actually done it. If you want to stay a step ahead in capstone projects, competitions, or graduation projects, you must be able to go beyond just training a model and actually build and prove how those computations run inside a real chip. This course bridges that exact gap between theory and physical hardware. You will complete a neural network accelerator (NPU) for MNIST digit recognition from start to finish—from reading specifications to Python golden models, Verilog RTL design, and FPGA verification. From Conv layers made with line buffers and parallel MACs, through ReLU, MaxPool, and Flatten, to fully connected layers and Argmax—you will integrate nine blocks into a single chip and prove for yourself that "the Python reference and the hardware output do not differ by even a single bit (Bit-True)." I have even included how to overcome those frustrating moments when the simulation runs fine but the results are subtly different. I will guide you through practical know-how that general deep learning textbooks don't cover, such as integer quantization, array axis reordering, and accumulator overflow prevention. I have distilled the trial and error I experienced over years of RISC-V CPU design and FPGA Bit-True verification into this course so that you don't have to repeat them. By the end of the class, you will have a completed hardware project that allows you to say, "I designed and verified it myself."

Have you been getting stuck on linear algebra formulas every time you try to study AI? Instead of memorizing formulas, this lecture shows you visually how vectors and matrices actually move in space. By the end of the course, you will be able to interpret the mathematics behind neural networks, PCA, and SVD on your own.

Still lost on CNN even after studying it? I'll concisely explain CNN's core mechanics.

Many people have learned FPGA and Verilog but get stuck at the question, "So, how do I actually build an AI accelerator?" This course resolves that curiosity. Using just a single entry-level FPGA and free tools, you will start from a hand-designed 3×3 kernel, train a CNN yourself, quantize the trained weights to INT8 to load onto the hardware, and verify that the results are Bit-True—not deviating by even a single bit from the Python model. As a professor with 30 years of experience in the semiconductor industry, I teach only verified content as 'working circuits' on actual FPGAs. By gaining the experience of designing and proving it yourself rather than just learning theory, you will acquire practical skills that are recognized in the fabless design and AI semiconductor fields.