正在加载视频...

视频加载失败

➡️ Machine Learning from Scratch, part 38: cross entropy. Softmax (part 37) turns the raw scores of a network into one probability per class. Cross entropy is the loss function that scores how wrong those probabilities are, with one number. It looks only at the probability of the right...

0 条评论

暂无评论

原始帖子的评论将显示在这里

相关视频

➡️ Machine Learning from Scratch, part 37: softmax. Every neuron first adds up its inputs times their weights, then an activation function reshapes the result. Without activation functions, any number of layers would act like one single linear layer. Softmax is the special activation at the very end of a network that sorts things into classes. The last layer has one output neuron per class, and each one gives a raw score that can be any number, even negative. Softmax looks at all of them at once: it raises e to the power of each score, then divides by the sum. Now every output lies between 0 and 1, all outputs add up to exactly 1, and the class with the highest one is the prediction. Unlike an S curve on each neuron, softmax couples the whole layer: if one score rises, the other probabilities fall. Our own run, nothing downloaded. softmax.py (16 lines of numpy) makes 300 points in three classes and trains a small network with 2 inputs, 4 hidden neurons and 3 output neurons on 200 of them. On the 100 new points it gets 90 right. For the point (-1, 0) it says 95% class 1, 1% class 2 and 4% class 3. Honest notes: these percentages are the model's own confidence. On the test points our model is 94.9% sure on average but right only 90% of the time, so it is a bit too confident, which is common for neural networks. Our learning rate sits close to the edge of stability, so a tiny change in the start can move the last digit (we show our exact run). The 3D hills are the real probabilities of our trained network over the input plane. #machinelearning #coding #softmax #neuralnetwork #deeplearning

MachineLearningToGo

16,500 次观看 • 1 个月前

➡️ Machine Learning from Scratch, part 35: supervised vs unsupervised learning. In supervised learning every training example comes with the right answer, a label. The model guesses, a loss function measures how wrong the guess was, and training makes that error smaller step by step. In unsupervised learning there are no labels. The model still has a goal, but it is measured on the data itself. k-means is the classic example: place a few group centers, give every point to its nearest center, add up the squared distances, move each center to the middle of its points and repeat. That total never gets larger, and after a few rounds the groups stop changing. Our own run, nothing downloaded. learn.py (16 lines of numpy) makes 300 points in 2D from 3 true groups and learns them both ways. With labels (a nearest-middle classifier trained on 200 points) it gets 100 of 100 new points right. Without labels, k-means brings the total squared distance down from 2927 to 741, and its groups match the true ones for 298 of 300 points. Honest notes: our three groups are made up and well separated on purpose, so both methods do very well; real data is messier. The 298 counts each found group as the true group most of its points belong to (here that is a clean one-to-one match). k-means starts from far-apart points, because a random start can get stuck in a worse grouping. The algorithm cannot know what a group means, so a person still has to name it. #machinelearning #ai #supervisedlearning #coding #python

MachineLearningToGo

26,000 次观看 • 1 个月前

➡️ Part 9 of learning ML code from scratch Six weights, one wrong answer, and not one of them knows it was at fault. Backpropagation is how they find out. Two questions guide the video: what even is backpropagation, and why do models need it? Step 1, the forward pass. Two numbers go into a tiny network, run through a hidden layer, and one number comes out. Ours says 0.700. We wanted 1.0, so square the difference and the loss is 0.09. That single number is how wrong the model is. Step 2, the question. Six weights produced that answer together. Which of them is to blame, and by how much? Step 3, the one idea. Change a single weight by a tiny amount and watch the error move. How much the error changes per unit of weight is the gradient of that weight. In the video you can see it happen: the weight wobbles and the error bar answers. Step 4, the shortcut. Every weight running into the same neuron starts from one shared number, the blame of that neuron. Multiply that blame by the value each weight carried and you have its gradient. One blame, computed once, and every weight into that neuron gets its own gradient from it. That is why backpropagation is fast enough to train anything at all. Step 5, backwards. The blame starts at the output and every layer hands its share to the layer in front of it, back through the same network the data came forward through. It goes layer by layer, and inside one layer every neuron is done together. Step 6, the update. The optimizer moves every weight against its own gradient, the whole weight matrix in one go, so no weight waits for its turn. All six gradients here are negative, so all six weights go up. After one step the answer reads 0.769. After sixty it reads 0.968 and the error is down to 0.001. The honest part: every gradient in the video was checked against the measured change of the error. Move that one weight, see what the error does, divide. Backprop and the measurement agree to nine decimal places, otherwise nothing would have rendered. #machinelearning #backpropagation #neuralnetworks #python #coding

MachineLearningToGo

212,200 次观看 • 1 个月前

➡️ Machine Learning from Scratch, part 47: the Hopfield network. In 1982 the physicist John Hopfield described a network that works as a memory, and 42 years later this work was part of the Nobel Prize in Physics. Each neuron is one pixel that is either on or off, and every neuron is connected to every other neuron, so 100 pixels need 4,950 connections. There are no layers: signals go back and forth until the network settles. Each neuron takes a weighted sum of its inputs and switches on if the sum is positive, off if it is negative. Storing a picture is simple: for every pair of pixels with the same colour the connection gets stronger, otherwise weaker. Every stored picture becomes a valley in the energy landscape, and no switch can ever raise the energy, so a noisy picture rolls downhill into the nearest stored memory. The code (hopfield.py, 16 lines of numpy, pictures in pics.txt) stores three 10 x 10 pictures, a heart, a house and a smiley, and flips 30 of the 100 pixels in each. After a single pass over all neurons all three come back exactly; the energy of the heart falls from -6.90 to -48.90, the energy of the stored heart. With 100 neurons and random patterns (10 flipped pixels, 20 runs) it recalls 5 patterns every time, 10 patterns in 94.5 % of the cases, 14 in 68 %, 20 in about one in four (24 %) and 30 in 1 %. Honest notes: the weights are kept as whole numbers (100 times the Hebb weight), so a sum of exactly zero switches the neuron on, as the rule says. The landscape in the video is a picture of the idea; the valley floors and the height of the rolling ball are the real energies from the run. #machinelearning #ai #coding #neuralnetworks #nobelprize

MachineLearningToGo

12,000 次观看 • 17 天前

➡️ Machine Learning from Scratch, part 15: a recommender, the kind of algorithm that picks what your feed shows you. Our app is simulated: 300 people and 60 videos. Every person has a hidden taste, every video has a hidden style, and each person has watched only about 12 of the 60 videos. All the algorithm ever sees is who liked which of the videos they watched. How it learns: every person gets two numbers, and every video gets two numbers. Think of them as arrows on a map. For every video a person has seen, the two arrows turn into a chance of a like with the sigmoid from part 2. The algorithm compares that chance with what really happened and nudges both arrows a little. That is gradient descent from part 8, and the whole method is called matrix factorisation. The results, all measured on the videos nobody showed it: After 25 rounds it guesses 85.0% of the hidden likes right. After 3000 rounds it gets 87.8% right. The best any method could do here is 91.1%, because some likes are just random. For every person it recommends the three unseen videos with the strongest match, and 98% of them are videos the person really likes. A random unseen video gets a like 51% of the time. The first person on the list watched only 5 videos. From those five it guessed the other 55 and got 51 of them right. We ran the same program on 20 different simulated apps, and it always landed between 84 and 88%. Real apps use hundreds of numbers for every person and every video, plus signals like watch time and skips. The core idea stays the same: learn numbers for people and for videos, and match them. #machinelearning #ai #recommendersystem #python #coding

MachineLearningToGo

89,100 次观看 • 1 个月前

➡️ Machine Learning from Scratch, part 31: the transformer. A transformer turns every token into a list of numbers, adds its position, and then lets every token look at the others. That step is called attention: each token has a query (what am I looking for), a key (what do I contain) and a value (what I pass on). The better a query matches a key, the more of that value flows in. Real transformers repeat this in many layers with several attention heads each. The design comes from the 2017 Google paper "Attention Is All You Need" by Ashish Vaswani and colleagues, first used for translation. A large language model is a transformer trained to predict the next token, again and again, on a huge amount of text. Our own run, nothing downloaded. attention.py is one self-attention layer in 16 lines of numpy. Every word gets a query, a key and a value of 8 numbers, starting random, trained from scratch with hand-written backpropagation on 192 made-up sentences like "the dog ate the carrot because it was hungry". The task: find out which pet "it" means. On 64 new test sentences "it" puts 99.95 percent of its attention on the right word on average (the lowest single sentence gets 99.9 percent; the program prints this as 100%). Before training it was 10 percent, spread evenly. The cat sentence from the video is one of the test sentences. Honest notes: our task is easy on purpose. Every sentence has exactly one pet, so "it" only has to learn to look for pets, and it learns that within the first pass. Real sentences with two candidates need more context, which is what many layers are for. Our small version has no positions, no scaling, no mask, one head, and only "it" asks a question. Every word of the test sentences also appears in training; the combinations are new. The 3D space in the video shows the real keys of our model, projected to three axes (two of them stretched so you can see them). The stacked layers are a sketch. #machinelearning #ai #transformer #python #llm

MachineLearningToGo

81,200 次观看 • 1 个月前

➡️ Machine Learning from Scratch, part 48: the Boltzmann machine. In 1985 Hinton, David Ackley and Terrence Sejnowski published how a Boltzmann machine learns, starting from the Hopfield network of part 47. Like the Hopfield network it prefers pictures with low energy, but it also has hidden units next to the visible pixels, and its units switch on by chance: the sigmoid turns the weighted sum into a probability. So the machine never settles and visits low energy pictures more often. We use the restricted version, with connections only between the two layers. The code (boltzmann.py, 16 lines of numpy) trains a restricted Boltzmann machine with 9 visible and 8 hidden units on all 14 bars-and-stripes pictures of 3 x 3 pixels, with contrastive divergence (one dream step per round, 5,000 rounds). Then 1,000 dreams start from pure noise and switch back and forth 100 times: 855 of them became one of the 14 pictures, from 3 times for the empty picture to 142 times for one with two bars. Sources: Nobel Prize in Physics 2024, press release of 8 October 2024 (Hopfield and Hinton, "for foundational discoveries and inventions that enable machine learning with artificial neural networks"); D. H. Ackley, G. E. Hinton, T. J. Sejnowski, "A Learning Algorithm for Boltzmann Machines", Cognitive Science, 1985; G. E. Hinton, "Training Products of Experts by Minimizing Contrastive Divergence", Neural Computation, 2002. Honest notes: the pictures do not come up equally often, because one dream step per round is only a shortcut for the real learning rule. When two of the 14 pictures are left out of training, our small machine does not dream them up; new examples of the same kind come from large machines trained on many examples. #machinelearning #ai #boltzmannmachine #neuralnetworks #nobelprize

MachineLearningToGo

14,700 次观看 • 16 天前

Dropout by hand ✍️ ~ 10 steps walkthrough below Dropout is the simplest trick in deep learning that actually works: during training you randomly switch neurons off, so the network cannot lean on any one of them. It is two lines of code and almost nobody has worked through what those lines do to the numbers. So I drew and calculated one entirely by hand. Goal: train one pass through a small network with two dropout layers, then run inference with dropout switched off. The network: Linear(2,4), ReLU, Dropout(0.5), Linear(4,3), ReLU, Dropout(0.33), Linear(3,2). = 1. Given = A training set of two examples, X1 and X2, and the weight matrices for all three linear layers. = 2. Draw the first random numbers = Let us draw 4 random numbers, one per neuron in the first hidden layer. Above 0.5 we keep (◯), below we drop (╳). Here that gives [◯, ╳, ◯, ╳]. = 3. Build the first dropout matrix = We turn that pattern into a diagonal matrix. The scaling factor is 1/(1-p) = 2, so a kept neuron gets 2 and a dropped one gets 0. Multiplying by it does both jobs at once: it deletes the 2nd and 4th neurons and doubles the two that survive. = 4. Draw the second random numbers = Let us do it again for the 3 neurons in the next layer, this time against p = 0.33. The result is [◯, ◯, ╳]. = 5. Build the second dropout matrix = We set the diagonal to 1.5 where kept and 0 where dropped. Only the 3rd neuron goes. = 6. Feed forward = Let us run the whole thing top to bottom: one matrix multiplication per layer, ReLU setting the negatives to zero, and the two dropout matrices doing their work in between. The outputs Y come out at the bottom. = 7. MSE loss gradients = We compare Y against the targets Y', subtract, and multiply each element by 2. That is the whole gradient of the mean squared error. = 8. Update the weights = Let us push those gradients back through the network and update the weights (marked in light red). = 9. Deactivate dropout = Training is over, so we set both dropout matrices to the identity. Every neuron is back, and nothing is scaled. = 10. Feed forward again = One more pass, this time on unseen data, to make the prediction. You have just trained and run a network with dropout by hand. ✍️ The outputs: Training outputs Y = [-6, 9; 13, 4] Loss gradients = [-4, 4; 6, -2] Inference outputs = [13, 13; 4, 3] 💾 Save this post! #AIbyHand #Dropout #DeepLearning #NeuralNetworks

Tom Yeh

14,442 次观看 • 4 个月前

➡️ Quantitative Finance from Scratch, part 37: Binomial model option pricing The stock moves in steps, and each step goes up or down by a fixed factor that comes from the volatility. In one step of one year, a stock at $100 goes to $122.14 or $81.87, and a call with strike $100 pays $22.14 or nothing. To get one price today, we average the two payoffs with weights that price the stock correctly: on average it must grow like money in the bank at 5 %, which gives 58 % for up and 42 % for down. These weights are the risk neutral probability. They also price the option, because a mix of stock and cash can copy it exactly. 58 % of $22.14, discounted at 5 %, gives $12.16. With many small steps the branches join again, and walking backwards through the tree gives the price, which zigzags toward the Black-Scholes value of $10.45. The code (binomial.py, 16 lines) builds the Cox-Ross-Rubinstein tree for S = K = 100, r = 5 %, volatility 20 %, one year: $12.16 with one step, $9.54 with two, $11.04 with three, $10.25 with ten and $10.45 with 1,000 steps, against Black-Scholes $10.45. With the same numbers, a put is worth $5.57 as a European option and $6.09 as an American option that can be exercised early (1,000 steps). Source: Cox, Ross and Rubinstein, "Option pricing: A simplified approach", Journal of Financial Economics, 1979. Honest notes: the model assumes a constant volatility and interest rate, no fees and trading at every step; real prices do not move in fixed steps. #quantfinance #options #trading #blackscholes #finance Education only, not financial advice.

QuantFinanceToGo

26,700 次观看 • 17 天前