Video yükleniyor...

Video Yüklenemedi

Ana Sayfaya Dön

[LSTM] by Hand ✍️ LSTMs have been the most effective architecture to process long sequences of data, until our world was taken over by the Transformers. LSTMs belong to the broader family of recurrent neural network (RNNs) that process data sequentially in a recurrent manner. Transformers, on the other...

ProfTomYeh's profile picture

Tom Yeh

64,300 subscribers

72,966 görüntüleme • 2 yıl önce •via X (Twitter)

EğitimHaberler & PolitikaBilim & Teknoloji
LIVE

Anya Rossi• Live Now

Private livecam show

0 Yorum

Yorum bulunmuyor

Orijinal gönderinin yorumları burada görünecek

Benzer Videolar

[Graph Convolutional Network] by hand ✍️ Graph Convolutional Networks (GCNs), introduced by Thomas Kipf and Max Welling in 2017, have emerged as a powerful tool in the analysis and interpretation of data structured as graphs. This exercise demonstrates how GCN works in a simple application: binary classification. -- Goal -- Predict if a node in a graph is X. -- Architecture -- 🟪 Graph Convolutional Network (GCN) 1. GCN1(4,3) 2. GCN2(3,3) 🟦 Fully Connected Network (FCN) 1. Linear1(3,5) 2. ReLU 3. Linear2(5,1) 4. Sigmoid Simplications: • Adjacent matrices are not normalized. • ReLU is applied to messages directly. -- Walkthrough -- [1] Given ↳ A graph with five nodes A, B, C, D, E [2] 🟩 Adjacency Matrix: Neighbors ↳ Add 1 for each edge to neighbors ↳ Repeat in both directions (e.g., A->C, C->A) ↳ Repeat for both GCN layers [3] 🟩 Adjacency Matrix: Self ↳ Add 1's for each self loop ↳ Equivalent to adding the identity matrix ↳ Repeat for both GCN layers [4] 🟪 GCN1: Messages ↳ Multiply the node embeddings 🟨 with weights and biases ↳ Apply ReLU (negatives → 0) ↳ The result is one message per node [5] 🟪 GCN1: Pooling ↳ Multiply the messages with the adjacent matrix ↳ The purpose is the pool messages from each node's neighbors as well as from the node itself. ↳ The result is a new feature per node [6] 🟪 GCN1: Visualize ↳ For node 1, visualize how messages are pooled to obtain a new feature for better understanding ↳ [3,0,1] + [1,0,0] = [4,0,1] [7] 🟪 GCN2: Messages ↳ Multiply the node features with weights and biases ↳ Apply ReLU (negatives → 0) ↳ The result is one message per node [8] 🟪 GCN2: Pooling ↳ Multiply the messages with the adjacent matrix ↳ The result is a new feature per node [9] 🟪 GCN2: Visualize ↳ For node 3, visualize how messages are pooled to obtain a new feature for better understanding ↳ [1,2,4] + [1,3,5] + [0,0,1] = [2,5,10] [10] 🟦 FCN: Linear 1 + ReLU ↳ Multiply node features with weights and biases ↳ Apply ReLU (negatives → 0) ↳ The result is a new feature per node ↳ Unlike in GCN layers, no messages from other nodes are included. [11] 🟦 FCN: Linear 2 ↳ Multiply node features with weights and biases [12] 🟦 FCN: Sigmoid ↳ Apply the Sigmoid activation function ↳ The purpose is to obtain a probability value for each node ↳ One way to calculate Sigmoid by hand ✍️ is to use the approximation below: • >= 3 → 1 • 0 → 0.5 • <= -3 → 0 -- Outputs -- A: 0 (Very unlikely) B: 1 (Very likely) C: 1 (Very likely) D: 1 (Very likely) E: 0.5 (Neutral)
0:12

[Graph Convolutional Network] by hand ✍️ Graph Convolutional Networks (GCNs), introduced by Thomas Kipf and Max Welling in 2017, have emerged as a powerful tool in the analysis and interpretation of data structured as graphs. This exercise demonstrates how GCN works in a simple application: binary classification. -- Goal -- Predict if a node in a graph is X. -- Architecture -- 🟪 Graph Convolutional Network (GCN) 1. GCN1(4,3) 2. GCN2(3,3) 🟦 Fully Connected Network (FCN) 1. Linear1(3,5) 2. ReLU 3. Linear2(5,1) 4. Sigmoid Simplications: • Adjacent matrices are not normalized. • ReLU is applied to messages directly. -- Walkthrough -- [1] Given ↳ A graph with five nodes A, B, C, D, E [2] 🟩 Adjacency Matrix: Neighbors ↳ Add 1 for each edge to neighbors ↳ Repeat in both directions (e.g., A->C, C->A) ↳ Repeat for both GCN layers [3] 🟩 Adjacency Matrix: Self ↳ Add 1's for each self loop ↳ Equivalent to adding the identity matrix ↳ Repeat for both GCN layers [4] 🟪 GCN1: Messages ↳ Multiply the node embeddings 🟨 with weights and biases ↳ Apply ReLU (negatives → 0) ↳ The result is one message per node [5] 🟪 GCN1: Pooling ↳ Multiply the messages with the adjacent matrix ↳ The purpose is the pool messages from each node's neighbors as well as from the node itself. ↳ The result is a new feature per node [6] 🟪 GCN1: Visualize ↳ For node 1, visualize how messages are pooled to obtain a new feature for better understanding ↳ [3,0,1] + [1,0,0] = [4,0,1] [7] 🟪 GCN2: Messages ↳ Multiply the node features with weights and biases ↳ Apply ReLU (negatives → 0) ↳ The result is one message per node [8] 🟪 GCN2: Pooling ↳ Multiply the messages with the adjacent matrix ↳ The result is a new feature per node [9] 🟪 GCN2: Visualize ↳ For node 3, visualize how messages are pooled to obtain a new feature for better understanding ↳ [1,2,4] + [1,3,5] + [0,0,1] = [2,5,10] [10] 🟦 FCN: Linear 1 + ReLU ↳ Multiply node features with weights and biases ↳ Apply ReLU (negatives → 0) ↳ The result is a new feature per node ↳ Unlike in GCN layers, no messages from other nodes are included. [11] 🟦 FCN: Linear 2 ↳ Multiply node features with weights and biases [12] 🟦 FCN: Sigmoid ↳ Apply the Sigmoid activation function ↳ The purpose is to obtain a probability value for each node ↳ One way to calculate Sigmoid by hand ✍️ is to use the approximation below: • >= 3 → 1 • 0 → 0.5 • <= -3 → 0 -- Outputs -- A: 0 (Very unlikely) B: 1 (Very likely) C: 1 (Very likely) D: 1 (Very likely) E: 0.5 (Neutral)

Tom Yeh

46,779 görüntüleme • 1 yıl önce

[VAE] by Hand ✍️ A Variational Auto Encoder (VAE) learns the structure (mean and variance) of hidden features and generates new data from the learned structure. In contrast, GANs only learn to generate new data to fool a discriminator; they may not necessarily know the underlying structure of the data. The International Conference on Learning Representations (ICLR) this year announced its first ever "Test of Time Award" to recognizes the VAE paper, published 10 years ago. This exercise demonstrates how to calculate a VAE by hand. [1] Given: ↳ Three training examples X1, X2, X3 ↳ Copy training examples to the bottom ↳ The purpose is to train the network to reconstruct the training examples. ↳ Since each target is a training example itself, we use the Greek word "auto" which means "self." This crucial step is what makes an autoencoder "auto." [2] Encoder: Layer 1 + ReLU ↳ Multiply inputs with weights and biases ↳ Apply ReLU, crossing out negative values (-1 -> 0) [3] Encoder: Mean and Variance ↳ Multiply features with two sets of weights and biases ↳ 🟩 The first set predicts the means (𝜇) of latent distributions ↳ 🟪 The second set predicts the standard deviation (𝜎) of latent distributions [4] Reparameterization Trick: Random Offset ↳ Sample epsilon ε from the normal distribution with mean = 0 and variance = 1. ↳ The purpose is to randomly pick a offset away from the mean. ↳ Multiply the standard deviation values with epsilon values. ↳ The purpose is to scale the offset by the standard deviation. [5] Reparameterization Trick: Mean + Offset ↳ Add the sampled offset to predicted mean ↳ The result are new parameters or features 🟨 as inputs to the Decoder. [6] Decoder: Layer 1 + ReLU ↳ Multiply input features with weights and biases ↳ Apply ReLU, crossing out negative values. Here, -4 is crossed out. [7] Decoder: Layer 2 ↳ Multiply features with weights and biases ↳ The output is Decoder's attempt to reconstruct the input data X from reparameterized distributions described by 𝜇 and 𝜎. [8]-[10] KL Divergence Loss [8] Loss Gradient: Mean 𝜇 ↳ We want 𝜇 to approach 0. ↳ A lot of math called SGVB simplifies the calculation of loss gradients to simply 𝜇 [9,10] Loss Gradient: Stdev 𝜎 ↳ We want 𝜎 to approach 1. ↳ A lot of math simplifies the calculation to 𝜎 - (1/ 𝜎) [11] Reconstruction Loss ↳ We want the reconstructed data Y (dark 🟧) to be the same as the input data X. ↳ Some math involving Mean Square Error simplifies the calculation to Y - X.
0:11

[VAE] by Hand ✍️ A Variational Auto Encoder (VAE) learns the structure (mean and variance) of hidden features and generates new data from the learned structure. In contrast, GANs only learn to generate new data to fool a discriminator; they may not necessarily know the underlying structure of the data. The International Conference on Learning Representations (ICLR) this year announced its first ever "Test of Time Award" to recognizes the VAE paper, published 10 years ago. This exercise demonstrates how to calculate a VAE by hand. [1] Given: ↳ Three training examples X1, X2, X3 ↳ Copy training examples to the bottom ↳ The purpose is to train the network to reconstruct the training examples. ↳ Since each target is a training example itself, we use the Greek word "auto" which means "self." This crucial step is what makes an autoencoder "auto." [2] Encoder: Layer 1 + ReLU ↳ Multiply inputs with weights and biases ↳ Apply ReLU, crossing out negative values (-1 -> 0) [3] Encoder: Mean and Variance ↳ Multiply features with two sets of weights and biases ↳ 🟩 The first set predicts the means (𝜇) of latent distributions ↳ 🟪 The second set predicts the standard deviation (𝜎) of latent distributions [4] Reparameterization Trick: Random Offset ↳ Sample epsilon ε from the normal distribution with mean = 0 and variance = 1. ↳ The purpose is to randomly pick a offset away from the mean. ↳ Multiply the standard deviation values with epsilon values. ↳ The purpose is to scale the offset by the standard deviation. [5] Reparameterization Trick: Mean + Offset ↳ Add the sampled offset to predicted mean ↳ The result are new parameters or features 🟨 as inputs to the Decoder. [6] Decoder: Layer 1 + ReLU ↳ Multiply input features with weights and biases ↳ Apply ReLU, crossing out negative values. Here, -4 is crossed out. [7] Decoder: Layer 2 ↳ Multiply features with weights and biases ↳ The output is Decoder's attempt to reconstruct the input data X from reparameterized distributions described by 𝜇 and 𝜎. [8]-[10] KL Divergence Loss [8] Loss Gradient: Mean 𝜇 ↳ We want 𝜇 to approach 0. ↳ A lot of math called SGVB simplifies the calculation of loss gradients to simply 𝜇 [9,10] Loss Gradient: Stdev 𝜎 ↳ We want 𝜎 to approach 1. ↳ A lot of math simplifies the calculation to 𝜎 - (1/ 𝜎) [11] Reconstruction Loss ↳ We want the reconstructed data Y (dark 🟧) to be the same as the input data X. ↳ Some math involving Mean Square Error simplifies the calculation to Y - X.

Tom Yeh

48,448 görüntüleme • 2 yıl önce

Batch Normalization by hand ✍️ ~ 7 steps walkthrough below Batch normalization is common practice for improving training and achieving faster convergence. It sounds simple. But it is often misunderstood. 🤔 Does batch normalization involve trainable parameters, tunable hyper-parameters, or both? 🤔 Is batch normalization applied to inputs, features, weights, biases, or outputs? 🤔 How is batch normalization different from layer normalization? So I drew and calculated one entirely by hand. Goal: normalize a mini-batch of 4 examples to mean 0 and variance 1, then let the network scale it back. = 1. Given = A mini-batch of 4 training examples, each with 3 features. = 2. Linear layer = Let us multiply by the weights and add the biases. Batch norm sits after this, which answers the second question: what gets normalized is features, not inputs, weights or biases. = 3. ReLU = We apply the activation, and -2 becomes 0. Negative values are suppressed before any statistic is taken. = 4. Batch statistics = Let us compute the sum, mean, variance and standard deviation, one row at a time. A row is a feature and the four columns are the four examples, so every number here measures one feature against the rest of the batch. That is the "batch" in batch normalization, and it is exactly what layer normalization does not do. The statistics are rounded to whole numbers, which is what keeps the rest of the page doable in pen. = 5. Shift to mean 0 = We subtract the mean, in green. The four values in each feature now average to zero. = 6. Scale to variance 1 = Let us divide by the standard deviation, in orange. Each feature now has variance one, whatever scale it arrived at. = 7. Scale and shift = We multiply by a linear transformation and pass the result on. The diagonal and the last column are trainable, so having just forced every feature to mean 0 and variance 1, we hand the network the means to undo it. The outputs: Mean of each feature = [2, 1, 2] Std dev of each feature = [1, 1, 2] To the next layer = [2, -2, 2, 0], [-3, 3, 6, -3], [2, 0, 1, 2] The answers: 🤔 Both. The scale and shift are trainable, the statistics are not. Epsilon and the momentum on the running statistics are the hyper-parameters, and one mini-batch by hand needs neither. 🤔 Features, after the linear layer, not inputs, weights or biases. 🤔 Batch norm measures across the batch, one feature at a time. Layer norm measures across the features, one example at a time. 💾 Save this post!
0:17

Batch Normalization by hand ✍️ ~ 7 steps walkthrough below Batch normalization is common practice for improving training and achieving faster convergence. It sounds simple. But it is often misunderstood. 🤔 Does batch normalization involve trainable parameters, tunable hyper-parameters, or both? 🤔 Is batch normalization applied to inputs, features, weights, biases, or outputs? 🤔 How is batch normalization different from layer normalization? So I drew and calculated one entirely by hand. Goal: normalize a mini-batch of 4 examples to mean 0 and variance 1, then let the network scale it back. = 1. Given = A mini-batch of 4 training examples, each with 3 features. = 2. Linear layer = Let us multiply by the weights and add the biases. Batch norm sits after this, which answers the second question: what gets normalized is features, not inputs, weights or biases. = 3. ReLU = We apply the activation, and -2 becomes 0. Negative values are suppressed before any statistic is taken. = 4. Batch statistics = Let us compute the sum, mean, variance and standard deviation, one row at a time. A row is a feature and the four columns are the four examples, so every number here measures one feature against the rest of the batch. That is the "batch" in batch normalization, and it is exactly what layer normalization does not do. The statistics are rounded to whole numbers, which is what keeps the rest of the page doable in pen. = 5. Shift to mean 0 = We subtract the mean, in green. The four values in each feature now average to zero. = 6. Scale to variance 1 = Let us divide by the standard deviation, in orange. Each feature now has variance one, whatever scale it arrived at. = 7. Scale and shift = We multiply by a linear transformation and pass the result on. The diagonal and the last column are trainable, so having just forced every feature to mean 0 and variance 1, we hand the network the means to undo it. The outputs: Mean of each feature = [2, 1, 2] Std dev of each feature = [1, 1, 2] To the next layer = [2, -2, 2, 0], [-3, 3, 6, -3], [2, 0, 1, 2] The answers: 🤔 Both. The scale and shift are trainable, the statistics are not. Epsilon and the momentum on the running statistics are the hyper-parameters, and one mini-batch by hand needs neither. 🤔 Features, after the linear layer, not inputs, weights or biases. 🤔 Batch norm measures across the batch, one feature at a time. Layer norm measures across the features, one example at a time. 💾 Save this post!

Tom Yeh

20,638 görüntüleme • 23 gün önce

MLP in PyTorch by hand ✍️ ~ 7 steps walkthrough below Goal: fill in every blank in the PyTorch code to build a multi-layer perceptron. 1. Given Let us start with a code template on the left and the network it is supposed to build on the right. Every blank in the code can be worked out from the picture. 2. Linear layer We count: 3 features in, 4 features out. So the weight matrix is 4 by 3. There is an extra column for the biases, which means bias = T. 3. ReLU Let us apply the activation. ReLU crosses out the negatives, so -1 becomes 0. 4. Linear layer The input size is 4, because that is what the previous layer put out. The output size is 2. A 2 by 4 weight matrix, and this time no extra column, so bias = F. 5. ReLU We cross out the negatives again. 6. Linear layer Two features in, five out. A 5 by 2 weight matrix, with a bias column, so bias = T. 7. Sigmoid Let us finish. Sigmoid squashes the raw scores (3, 0, -2, 5, -5) into probabilities between 0 and 1. You have just implemented a three-layer deep neural network by hand. ✍️ == Story == Three years ago I gave this exercise to my students, to connect the code to the math. They found it odd. Every other AI course they were taking lived inside a Jupyter notebook, and here I was handing out paper. Three years later, my colleagues are the ones rushing to move their materials to paper. The exercise has not changed. Paper still asks the one thing a notebook lets you skip: do you actually understand what the code is doing? If you can tell me why the weight matrix is 4 by 3, and why bias is F on the second layer, you understand nn.Linear better than someone who has been copy-pasting it for a year. 💾 Save this post! #AIbyHand #PyTorch #DeepLearning
0:14

MLP in PyTorch by hand ✍️ ~ 7 steps walkthrough below Goal: fill in every blank in the PyTorch code to build a multi-layer perceptron. 1. Given Let us start with a code template on the left and the network it is supposed to build on the right. Every blank in the code can be worked out from the picture. 2. Linear layer We count: 3 features in, 4 features out. So the weight matrix is 4 by 3. There is an extra column for the biases, which means bias = T. 3. ReLU Let us apply the activation. ReLU crosses out the negatives, so -1 becomes 0. 4. Linear layer The input size is 4, because that is what the previous layer put out. The output size is 2. A 2 by 4 weight matrix, and this time no extra column, so bias = F. 5. ReLU We cross out the negatives again. 6. Linear layer Two features in, five out. A 5 by 2 weight matrix, with a bias column, so bias = T. 7. Sigmoid Let us finish. Sigmoid squashes the raw scores (3, 0, -2, 5, -5) into probabilities between 0 and 1. You have just implemented a three-layer deep neural network by hand. ✍️ == Story == Three years ago I gave this exercise to my students, to connect the code to the math. They found it odd. Every other AI course they were taking lived inside a Jupyter notebook, and here I was handing out paper. Three years later, my colleagues are the ones rushing to move their materials to paper. The exercise has not changed. Paper still asks the one thing a notebook lets you skip: do you actually understand what the code is doing? If you can tell me why the weight matrix is 4 by 3, and why bias is F on the second layer, you understand nn.Linear better than someone who has been copy-pasting it for a year. 💾 Save this post! #AIbyHand #PyTorch #DeepLearning

Tom Yeh

13,318 görüntüleme • 1 ay önce

Transformer by hand ✍️ ~ 6 steps walkthrough below Open the hood of a transformer and the parts list is overwhelming: embeddings, positional encoding, attention weighting, self-attention, cross-attention, multi-head attention, layer norm, skip connections, softmax, linear, Nx, shifted right, query, key, value, masking. Which of those actually make the car run? Two of them. Attention weighting and the feed-forward network. Everything else is an enhancement to make it run faster and longer, which is how we got from a car to a truck, and to the word "large" in large language model. So I drew and calculated those two parts entirely by hand. Goal: push five features through one transformer block, filling in every cell yourself. 1. Given Five positions of input features, arriving from the previous block. 2. Attention matrix Let us feed all five features to a query-key module (QK) and read back an attention weight matrix, A. The details of that module are a post of their own. 3. Attention weighting We multiply the input features by A to get the attention weighted features, Z. Still five positions. The effect is to combine features *across positions*, horizontally: X1 becomes X1 + X2, X2 becomes X2 + X3, and so on. 4. First layer Let us feed all five weighted features into the first layer of the FFN. Multiply by the weights and biases. This time the combining happens *across feature dimensions*, vertically, and each feature grows from 3 numbers to 4. Note that every position goes through the same weight matrix. That is what "position-wise" means. 5. ReLU We cross out the negatives. They become zeros. 6. Second layer Let us bring it back down: 4 dimensions to 3. The output feeds the next block, which has a completely separate set of parameters, and the whole thing runs again. You have just calculated a transformer block by hand. ✍️ The takeaway: the two parts are doing two different jobs, and neither one alone is enough. Attention mixes *across positions*, so a feature can see its neighbours. The FFN mixes *across feature dimensions*, so each position can think about itself. Horizontal, then vertical. Then that pattern repeats N times, each block with its own separate set of weights. That is the Nx from the list up top, and that is what makes the transformer run. 💾 Save this post! #AIbyHand #Transformers #DeepLearning
0:12

Transformer by hand ✍️ ~ 6 steps walkthrough below Open the hood of a transformer and the parts list is overwhelming: embeddings, positional encoding, attention weighting, self-attention, cross-attention, multi-head attention, layer norm, skip connections, softmax, linear, Nx, shifted right, query, key, value, masking. Which of those actually make the car run? Two of them. Attention weighting and the feed-forward network. Everything else is an enhancement to make it run faster and longer, which is how we got from a car to a truck, and to the word "large" in large language model. So I drew and calculated those two parts entirely by hand. Goal: push five features through one transformer block, filling in every cell yourself. 1. Given Five positions of input features, arriving from the previous block. 2. Attention matrix Let us feed all five features to a query-key module (QK) and read back an attention weight matrix, A. The details of that module are a post of their own. 3. Attention weighting We multiply the input features by A to get the attention weighted features, Z. Still five positions. The effect is to combine features *across positions*, horizontally: X1 becomes X1 + X2, X2 becomes X2 + X3, and so on. 4. First layer Let us feed all five weighted features into the first layer of the FFN. Multiply by the weights and biases. This time the combining happens *across feature dimensions*, vertically, and each feature grows from 3 numbers to 4. Note that every position goes through the same weight matrix. That is what "position-wise" means. 5. ReLU We cross out the negatives. They become zeros. 6. Second layer Let us bring it back down: 4 dimensions to 3. The output feeds the next block, which has a completely separate set of parameters, and the whole thing runs again. You have just calculated a transformer block by hand. ✍️ The takeaway: the two parts are doing two different jobs, and neither one alone is enough. Attention mixes *across positions*, so a feature can see its neighbours. The FFN mixes *across feature dimensions*, so each position can think about itself. Horizontal, then vertical. Then that pattern repeats N times, each block with its own separate set of weights. That is the Nx from the list up top, and that is what makes the transformer run. 💾 Save this post! #AIbyHand #Transformers #DeepLearning

Tom Yeh

25,944 görüntüleme • 27 gün önce

[Backpropagation] by Hand✍️ [1] Forward Pass ↳ Given a multi layer perceptron (3 levels), an input vector X, predictions Y^{Pred} = [0.5, 0.5, 0], and ground truth label Y^{Target} = [0, 1, 0]. [2] Backpropagation ↳ Insert cells to hold our calculations. [3] Layer 3 - Softmax (blue) ↳ Calculate ∂L / ∂z3 directly using the simple equation: Y^{Pred} - Y^{Target} = [0.5, -0.5, 0]. ↳ This simple equation is the benefit of using Softmax and Cross Entropy Loss together. [4] Layer 3 - Weights (orange) & Biases (black) ↳ Calculate ∂L / ∂W3 and ∂L / ∂b3 by multiplying ∂L / ∂z3 and [ a2 | 1 ]. [5] Layer 2 - Activations (green) ↳ Calculate ∂L / ∂a2 by multiplying ∂L / ∂z3 and W3. [6] Layer 2 - ReLU (blue) ↳ Calculate ∂L / ∂z2 by multiplying ∂L / ∂a2 with 1 for positive values and 0 otherwise. [7] Layer 2 - Weights (orange) & Biases (black) ↳ Calculate ∂L / ∂W2 and ∂L / ∂b2 by multiplying ∂L / ∂z2 and [ a1 | 1 ]. [8] Layer 1 - Activations (green) ↳ Calculate ∂L / ∂a1 by multiplying ∂L / ∂z2 and W2. [9] Layer 1 - ReLU (blue) ↳ Calculate ∂L / ∂z1 by multiplying ∂L / ∂a1 with 1 for positive values and 0 otherwise. [10] Layer 1 - Weights (orange) & Biases (black) ↳ Calculate ∂L / ∂W1 and ∂L / ∂b1 by multiplying ∂L / ∂z1 and [ x | 1 ]. [11] Gradient Descent ↳ Update weights and biases (typically a learning rate is applied here). 💡 Matrix Multiplication is All You Need: Just like in the forward pass, backpropagation is all about matrix multiplications. You can definitely do everything by hand as I demonstrated in this exercise, albeit slow and imperfect. This is why GPU's ability to multiply matrices efficiently plays such an important role in the deep learning evolution. This is why NVIDIA is now close to $1 trillion in valuation. 💡Exploding Gradients: We can already see the gradients are getting larger as we back-propagate up, even in this simple 3-layer network. This motivates using methods like skip connections to handle exploding (or diminishing) gradients as in the ResNet. I did the calculations entirely by hand. Please let me know if you spot any error or have any questions!
0:11

[Backpropagation] by Hand✍️ [1] Forward Pass ↳ Given a multi layer perceptron (3 levels), an input vector X, predictions Y^{Pred} = [0.5, 0.5, 0], and ground truth label Y^{Target} = [0, 1, 0]. [2] Backpropagation ↳ Insert cells to hold our calculations. [3] Layer 3 - Softmax (blue) ↳ Calculate ∂L / ∂z3 directly using the simple equation: Y^{Pred} - Y^{Target} = [0.5, -0.5, 0]. ↳ This simple equation is the benefit of using Softmax and Cross Entropy Loss together. [4] Layer 3 - Weights (orange) & Biases (black) ↳ Calculate ∂L / ∂W3 and ∂L / ∂b3 by multiplying ∂L / ∂z3 and [ a2 | 1 ]. [5] Layer 2 - Activations (green) ↳ Calculate ∂L / ∂a2 by multiplying ∂L / ∂z3 and W3. [6] Layer 2 - ReLU (blue) ↳ Calculate ∂L / ∂z2 by multiplying ∂L / ∂a2 with 1 for positive values and 0 otherwise. [7] Layer 2 - Weights (orange) & Biases (black) ↳ Calculate ∂L / ∂W2 and ∂L / ∂b2 by multiplying ∂L / ∂z2 and [ a1 | 1 ]. [8] Layer 1 - Activations (green) ↳ Calculate ∂L / ∂a1 by multiplying ∂L / ∂z2 and W2. [9] Layer 1 - ReLU (blue) ↳ Calculate ∂L / ∂z1 by multiplying ∂L / ∂a1 with 1 for positive values and 0 otherwise. [10] Layer 1 - Weights (orange) & Biases (black) ↳ Calculate ∂L / ∂W1 and ∂L / ∂b1 by multiplying ∂L / ∂z1 and [ x | 1 ]. [11] Gradient Descent ↳ Update weights and biases (typically a learning rate is applied here). 💡 Matrix Multiplication is All You Need: Just like in the forward pass, backpropagation is all about matrix multiplications. You can definitely do everything by hand as I demonstrated in this exercise, albeit slow and imperfect. This is why GPU's ability to multiply matrices efficiently plays such an important role in the deep learning evolution. This is why NVIDIA is now close to $1 trillion in valuation. 💡Exploding Gradients: We can already see the gradients are getting larger as we back-propagate up, even in this simple 3-layer network. This motivates using methods like skip connections to handle exploding (or diminishing) gradients as in the ResNet. I did the calculations entirely by hand. Please let me know if you spot any error or have any questions!

Tom Yeh

64,645 görüntüleme • 2 yıl önce

Vector Database by Hand ✍️ Vector databases are revolutionizing how we search and analyze complex data. They have become the backbone of Retrieval Augmented Generation (#RAG). How do vector databases work? [1] Given ↳ A dataset of three sentences, each has 3 words (or tokens) ↳ In practice, a dataset may contain millions or billions of sentences. The max number of tokens may be tens of thousands (e.g., 32,768 mistral-7b). Process "how are you" [2] 🟨 Word Embeddings ↳ For each word, look up corresponding word embedding vector from a table of 22 vectors, where 22 is the vocabulary size. ↳ In practice, the vocabulary size can be tens of thousands. The word embedding dimensions are in the thousands (e.g., 1024, 4096) [3] 🟩 Encoding ↳ Feed the sequence of word embeddings to an encoder to obtain a sequence of feature vectors, one per word. ↳ Here, the encoder is a simple one layer perceptron (linear layer + ReLU) ↳ In practice, the encoder is a transformer or one of its many variants. [4] 🟩 Mean Pooling ↳ Merge the sequence of feature vectors into a single vector using "mean pooling" which is to average across the columns. ↳ The result is a single vector. We often call it "text embeddings" or "sentence embeddings." ↳ Other pooling techniques are possible, such as CLS. But mean pooling is the most common. [5] 🟦 Indexing ↳ Reduce the dimensions of the text embedding vector by a projection matrix. The reduction rate is 50% (4->2). ↳ In practice, the values in this projection matrix is much more random. ↳ The purpose is similar to that of hashing, which is to obtain a short representation to allow faster comparison and retrieval. ↳ The resulting dimension-reduced index vector is saved in the vector storage. [6] Process "who are you" ↳ Repeat [2]-[5] [7] Process "who am I" ↳ Repeat [2]-[5] Now we have indexed our dataset in the vector database. [8] 🟥 Query: "am I you" ↳ Repeat [2]-[5] ↳ The result is a 2-d query vector. [9] 🟥 Dot Products ↳ Take dot product between the query vector and database vectors. They are all 2-d. ↳ The purpose is to use dot product to estimate similarity. ↳ By transposing the query vector, this step becomes a matrix multiplication. [10] 🟥 Nearest Neighbor ↳ Find the largest dot product by linear scan. ↳ The sentence with the highest dot product is "who am I" ↳ In practice, because scanning billions of vectors is slow, we use an Approximate Nearest Neighbor (ANN) algorithm like the Hierarchical Navigable Small Worlds (HNSW).
0:17

Vector Database by Hand ✍️ Vector databases are revolutionizing how we search and analyze complex data. They have become the backbone of Retrieval Augmented Generation (#RAG). How do vector databases work? [1] Given ↳ A dataset of three sentences, each has 3 words (or tokens) ↳ In practice, a dataset may contain millions or billions of sentences. The max number of tokens may be tens of thousands (e.g., 32,768 mistral-7b). Process "how are you" [2] 🟨 Word Embeddings ↳ For each word, look up corresponding word embedding vector from a table of 22 vectors, where 22 is the vocabulary size. ↳ In practice, the vocabulary size can be tens of thousands. The word embedding dimensions are in the thousands (e.g., 1024, 4096) [3] 🟩 Encoding ↳ Feed the sequence of word embeddings to an encoder to obtain a sequence of feature vectors, one per word. ↳ Here, the encoder is a simple one layer perceptron (linear layer + ReLU) ↳ In practice, the encoder is a transformer or one of its many variants. [4] 🟩 Mean Pooling ↳ Merge the sequence of feature vectors into a single vector using "mean pooling" which is to average across the columns. ↳ The result is a single vector. We often call it "text embeddings" or "sentence embeddings." ↳ Other pooling techniques are possible, such as CLS. But mean pooling is the most common. [5] 🟦 Indexing ↳ Reduce the dimensions of the text embedding vector by a projection matrix. The reduction rate is 50% (4->2). ↳ In practice, the values in this projection matrix is much more random. ↳ The purpose is similar to that of hashing, which is to obtain a short representation to allow faster comparison and retrieval. ↳ The resulting dimension-reduced index vector is saved in the vector storage. [6] Process "who are you" ↳ Repeat [2]-[5] [7] Process "who am I" ↳ Repeat [2]-[5] Now we have indexed our dataset in the vector database. [8] 🟥 Query: "am I you" ↳ Repeat [2]-[5] ↳ The result is a 2-d query vector. [9] 🟥 Dot Products ↳ Take dot product between the query vector and database vectors. They are all 2-d. ↳ The purpose is to use dot product to estimate similarity. ↳ By transposing the query vector, this step becomes a matrix multiplication. [10] 🟥 Nearest Neighbor ↳ Find the largest dot product by linear scan. ↳ The sentence with the highest dot product is "who am I" ↳ In practice, because scanning billions of vectors is slow, we use an Approximate Nearest Neighbor (ANN) algorithm like the Hierarchical Navigable Small Worlds (HNSW).

Tom Yeh

192,022 görüntüleme • 2 yıl önce

[Discrete Fourier Transform] by Hand ✍️ In signal processing, the Discrete Fourier Transform (DFT) is no doubt the most important method. But the math involved is extremely complex, literally, involving a summation over a complex number term e^(-iwt). I developed this exercise to demonstrate that underneath such complexity, DFT is just a series of matrix multiplications you can calculate by hand. ✍️ Once you see that, it should not surprise you that a deep neural network, which is also a series of matrix multiplications, with activation functions in-between, can learn to perform DFT to process and analyze signals so effectively. How does DFT work? [1] Given ↳ Signals A, B, and C in the 🟧 frequency domain: ◦ A = cos(w) + 2cos(2w) ◦ B = cos(w) + cos(3w) + cos(4w) ◦ C = -cos(2w) + cos(3w) ◦ Each signal is a weighed sum of four cosine waves at frequencies 1w, 2w, 3w, and 4w. ◦ We will apply Inverse DFT to convert the signals to time domain representations, and then demonstrate DFT can convert back to their original frequency domain representations. ↳ Signal X in the 🟩 time domain. X is sampled at 10 time points 1t, 2t, …, 10t: ◦ X = [-2.5, -1.8, 3, -0.7, -1.0, -0.7, 3, -1.8, -2.5, 5] ◦ Suppose X is also a weighted sum of the same four cosine waves, but we don’t already know their weights. We will apply DFT to discover them. [2] 🟧 Frequency Matrix (F) ↳ Write the coefficients of A, B, C as a matrix F. Each signal is a row. Each frequency is a column. ↳ A → [1, 2, 0, 0] ↳ B → [1, 0, 1, 1] ↳ C → [0, 1-, 1, 0] [3] Cosine → Discrete ↳ Sample from the continuous cosine waves at discrete time points 1t, 2t, 3t, to 10t. [4] Cosine Matrix (W) ↳ Write the samples as a matrix, Each frequency is a row. Each time point is a column. [5] Inverse DFT: 🟧 Frequency → 🟩 Time ↳ Multiply the frequency matrix F and the cosine matrix W. ↳ The meaning of this multiplication is to linearly combine the four cosine waves (rows in W) into time-domain signals (rows in T) using the weights specified in F. ↳ The result is matrix T, which are signals A, B, C converted to the time domain. Each signal is a row. Each time point is a column. [6] Transpose ↳ Transpose T, converting each signal’s time domain representation from a row to a column. [7] DFT: 🟩 Time → 🟧 Frequency ↳ Multiply the cosine matrix W with the transpose of matrix T. ↳ The purpose of this multiplication is to take a dot-product between each time-domain signal (columns in the transpose of T) and each cosine wave (rows in W), which has the effect of projecting the signal onto a cosine wave to determine how much they are correlated. Zero means not correlated at all. ↳ The result is an intermediate version of the “recovered” frequency matrix where each column corresponds to a signal and each row corresponds to a frequency. ↳ Compared to the original frequency matrix F, this intermediate matrix has non-zero weights in the correct places, but scaled up by a factor of 5 (n/2, n=10). For example, signal A, originally [1,2,0,0], is recovered at [5,10,0,0]. [8] Scale ↳ Multiply each value by 2/n = 1/5 to scale down the intermediate matrix to match the magnitude of the original frequency matrix F. [9] Transpose ↳ Transpose the recovered frequency matrix back to the same orientation of the original frequency matrix F. ↳ Like magic 🪄, the result is identical to the original F, which means DFT successfully recovered the frequency components of signals A, B, C. [10] Apply DFT to X: 🟩 Time → 🟧 Frequency ↳ Now that we have some confidence in DFT’s ability to recover frequency components, we apply DFT to X’s time-domain representation by multiplying W with X. ↳ The result is the an intermediate matrix. [11] Scale ↳ Similarly, we scale down by a factor of 5 to obtain the recovered frequency components of X (a column). [12] Transpose ↳ Similarly, we transpose the recovered column to row to match the orientation of the frequency matrix. ↳ Using the coefficients [0,0,3,2], we can write the equation of X as 3cos(3w) + 2cos(4w). Notes: I hope this by hand exercise helps you understand the essence of DFT. But there is more technical details, such as: • Sine: The complete DFT math also includes sine waves that follow a similar calculation process. • Phase: Here, we assume all the cosine waves are aligned at the origin, namely, phase is 0. If a phase p is added, for example, cos(w+p), we will need to calculate the sine component and use their ratio to figure out what p is. • Magnitude: If phase is not zero, the magnitude will need to be calculated by combining both cosine and sine terms.
0:12

[Discrete Fourier Transform] by Hand ✍️ In signal processing, the Discrete Fourier Transform (DFT) is no doubt the most important method. But the math involved is extremely complex, literally, involving a summation over a complex number term e^(-iwt). I developed this exercise to demonstrate that underneath such complexity, DFT is just a series of matrix multiplications you can calculate by hand. ✍️ Once you see that, it should not surprise you that a deep neural network, which is also a series of matrix multiplications, with activation functions in-between, can learn to perform DFT to process and analyze signals so effectively. How does DFT work? [1] Given ↳ Signals A, B, and C in the 🟧 frequency domain: ◦ A = cos(w) + 2cos(2w) ◦ B = cos(w) + cos(3w) + cos(4w) ◦ C = -cos(2w) + cos(3w) ◦ Each signal is a weighed sum of four cosine waves at frequencies 1w, 2w, 3w, and 4w. ◦ We will apply Inverse DFT to convert the signals to time domain representations, and then demonstrate DFT can convert back to their original frequency domain representations. ↳ Signal X in the 🟩 time domain. X is sampled at 10 time points 1t, 2t, …, 10t: ◦ X = [-2.5, -1.8, 3, -0.7, -1.0, -0.7, 3, -1.8, -2.5, 5] ◦ Suppose X is also a weighted sum of the same four cosine waves, but we don’t already know their weights. We will apply DFT to discover them. [2] 🟧 Frequency Matrix (F) ↳ Write the coefficients of A, B, C as a matrix F. Each signal is a row. Each frequency is a column. ↳ A → [1, 2, 0, 0] ↳ B → [1, 0, 1, 1] ↳ C → [0, 1-, 1, 0] [3] Cosine → Discrete ↳ Sample from the continuous cosine waves at discrete time points 1t, 2t, 3t, to 10t. [4] Cosine Matrix (W) ↳ Write the samples as a matrix, Each frequency is a row. Each time point is a column. [5] Inverse DFT: 🟧 Frequency → 🟩 Time ↳ Multiply the frequency matrix F and the cosine matrix W. ↳ The meaning of this multiplication is to linearly combine the four cosine waves (rows in W) into time-domain signals (rows in T) using the weights specified in F. ↳ The result is matrix T, which are signals A, B, C converted to the time domain. Each signal is a row. Each time point is a column. [6] Transpose ↳ Transpose T, converting each signal’s time domain representation from a row to a column. [7] DFT: 🟩 Time → 🟧 Frequency ↳ Multiply the cosine matrix W with the transpose of matrix T. ↳ The purpose of this multiplication is to take a dot-product between each time-domain signal (columns in the transpose of T) and each cosine wave (rows in W), which has the effect of projecting the signal onto a cosine wave to determine how much they are correlated. Zero means not correlated at all. ↳ The result is an intermediate version of the “recovered” frequency matrix where each column corresponds to a signal and each row corresponds to a frequency. ↳ Compared to the original frequency matrix F, this intermediate matrix has non-zero weights in the correct places, but scaled up by a factor of 5 (n/2, n=10). For example, signal A, originally [1,2,0,0], is recovered at [5,10,0,0]. [8] Scale ↳ Multiply each value by 2/n = 1/5 to scale down the intermediate matrix to match the magnitude of the original frequency matrix F. [9] Transpose ↳ Transpose the recovered frequency matrix back to the same orientation of the original frequency matrix F. ↳ Like magic 🪄, the result is identical to the original F, which means DFT successfully recovered the frequency components of signals A, B, C. [10] Apply DFT to X: 🟩 Time → 🟧 Frequency ↳ Now that we have some confidence in DFT’s ability to recover frequency components, we apply DFT to X’s time-domain representation by multiplying W with X. ↳ The result is the an intermediate matrix. [11] Scale ↳ Similarly, we scale down by a factor of 5 to obtain the recovered frequency components of X (a column). [12] Transpose ↳ Similarly, we transpose the recovered column to row to match the orientation of the frequency matrix. ↳ Using the coefficients [0,0,3,2], we can write the equation of X as 3cos(3w) + 2cos(4w). Notes: I hope this by hand exercise helps you understand the essence of DFT. But there is more technical details, such as: • Sine: The complete DFT math also includes sine waves that follow a similar calculation process. • Phase: Here, we assume all the cosine waves are aligned at the origin, namely, phase is 0. If a phase p is added, for example, cos(w+p), we will need to calculate the sine component and use their ratio to figure out what p is. • Magnitude: If phase is not zero, the magnitude will need to be calculated by combining both cosine and sine terms.

Tom Yeh

116,622 görüntüleme • 2 yıl önce

Somewhere between the first click and the latest win, Based became more than just an app. It became a core memory ❣️ Tell us about the best one :) Welcome to Day 4 of Based 7 Days of Xmas 🎄 🎁 Day 4 Challenge 1) Quote tweet this post . 2) Share your favourite Based moment of the year, it could be a feature, a win, a Pal, or a memory that stuck, literally anything as long as it is related to Based. 3) Any forms of content are welcome in your QT (pics, vids, words anything that X allows). Use #BASEDXMAS. ⭐️ Best 3 quality posts will win. 🍀 Blind boxes will also be given out to random participants :) PS. Christmas is getting nearer, the Santa in me is Santa-ing 🧑‍🎄 HOHOHO! TIME TO UPGRADE THE PRESENTS PALS! 🎁 Presents to be won: 🥇: HYPE Card 🥈: 6 Blind Boxes 🥉: 4 Blind Boxes ⏳ 24 hours Merry Day 4 Xmas, Pals 🎄✨ Some moments fade. The Based ones stay. Let's see the ones that did.
0:10

Somewhere between the first click and the latest win, Based became more than just an app. It became a core memory ❣️ Tell us about the best one :) Welcome to Day 4 of Based 7 Days of Xmas 🎄 🎁 Day 4 Challenge 1) Quote tweet this post . 2) Share your favourite Based moment of the year, it could be a feature, a win, a Pal, or a memory that stuck, literally anything as long as it is related to Based. 3) Any forms of content are welcome in your QT (pics, vids, words anything that X allows). Use #BASEDXMAS. ⭐️ Best 3 quality posts will win. 🍀 Blind boxes will also be given out to random participants :) PS. Christmas is getting nearer, the Santa in me is Santa-ing 🧑‍🎄 HOHOHO! TIME TO UPGRADE THE PRESENTS PALS! 🎁 Presents to be won: 🥇: HYPE Card 🥈: 6 Blind Boxes 🥉: 4 Blind Boxes ⏳ 24 hours Merry Day 4 Xmas, Pals 🎄✨ Some moments fade. The Based ones stay. Let's see the ones that did.

BasedPals

12,363 görüntüleme • 7 ay önce

Researchers made KMeans 200x faster. And the new technique also beats approaches like cuML and FAISS. Flash-KMeans is an IO-aware implementation of exact KMeans that redesigns the algorithm around modern GPU bottlenecks. By attacking the memory bottlenecks directly, Flash-KMeans achieves: - 33x speedup over cuML - 200x speedup over FAISS This speedup comes from how it moves through GPU memory. Standard KMeans runs in two steps, and both are bottlenecked by reads and writes to GPU memory: 1) The first step matches every point to its nearest centroid. Standard KMeans computes the full point-to-centroid distance matrix, writes it out to GPU memory, then reads it back to find each nearest centroid. That write-then-read round trip is the bottleneck. Flash-KMeans combines the distance calculation with the nearest-centroid step, so the result is computed on-chip and the full matrix is never written out. 2) The second step recomputes each centroid by averaging the points assigned to it. Standard KMeans has thousands of threads writing into the same centroid slots at once, so they stall waiting for their turn. Flash-KMeans sorts points by cluster first, turning scattered writes into sequential reductions that read and write memory in one efficient pass. Using these two optimizations at the million-scale, Flash-KMeans completes a standard KMeans iteration in a few milliseconds. The video below depicts this in action. Several reasons why this is important: KMeans has always been an offline primitive. Something you run once to preprocess data and move on. These speedups make the approach viable in several runtime-critical systems. ↳ Vector indices like FAISS use KMeans to build search indices. Faster KMeans means you can re-index dynamically as data changes. ↳ LLM quantization methods need KMeans to find optimal weight codebooks, per layer, repeatedly. What takes hours could now take minutes. ↳ MoE models need fast token routing at inference time. Flash-KMeans makes it viable to run this inside the inference loop, not just in preprocessing. I have shared the paper in the replies. That said, memory is the real constraint Flash-KMeans solves, and the problem is not just limited to clustering. The vectors a RAG system stores after indexing create similar bottlenecks. I wrote a detailed walkthrough recently on cutting this vector memory by 32x with binary quantization, querying 36M+ vectors in a few milliseconds. Read it below.
0:12

Researchers made KMeans 200x faster. And the new technique also beats approaches like cuML and FAISS. Flash-KMeans is an IO-aware implementation of exact KMeans that redesigns the algorithm around modern GPU bottlenecks. By attacking the memory bottlenecks directly, Flash-KMeans achieves: - 33x speedup over cuML - 200x speedup over FAISS This speedup comes from how it moves through GPU memory. Standard KMeans runs in two steps, and both are bottlenecked by reads and writes to GPU memory: 1) The first step matches every point to its nearest centroid. Standard KMeans computes the full point-to-centroid distance matrix, writes it out to GPU memory, then reads it back to find each nearest centroid. That write-then-read round trip is the bottleneck. Flash-KMeans combines the distance calculation with the nearest-centroid step, so the result is computed on-chip and the full matrix is never written out. 2) The second step recomputes each centroid by averaging the points assigned to it. Standard KMeans has thousands of threads writing into the same centroid slots at once, so they stall waiting for their turn. Flash-KMeans sorts points by cluster first, turning scattered writes into sequential reductions that read and write memory in one efficient pass. Using these two optimizations at the million-scale, Flash-KMeans completes a standard KMeans iteration in a few milliseconds. The video below depicts this in action. Several reasons why this is important: KMeans has always been an offline primitive. Something you run once to preprocess data and move on. These speedups make the approach viable in several runtime-critical systems. ↳ Vector indices like FAISS use KMeans to build search indices. Faster KMeans means you can re-index dynamically as data changes. ↳ LLM quantization methods need KMeans to find optimal weight codebooks, per layer, repeatedly. What takes hours could now take minutes. ↳ MoE models need fast token routing at inference time. Flash-KMeans makes it viable to run this inside the inference loop, not just in preprocessing. I have shared the paper in the replies. That said, memory is the real constraint Flash-KMeans solves, and the problem is not just limited to clustering. The vectors a RAG system stores after indexing create similar bottlenecks. I wrote a detailed walkthrough recently on cutting this vector memory by 32x with binary quantization, querying 36M+ vectors in a few milliseconds. Read it below.

Avi Chawla

89,234 görüntüleme • 1 ay önce

ReLU vs Leaky ReLU 👉 = ReLU = ReLU is the default activation in modern deep learning — cheap to compute, and stable enough to train networks hundreds of layers deep. To see what it does, picture five boba tea shops on the same block — 𝚊, 𝚋, 𝚌, 𝚍, 𝚎 — each running their own books. Each value is a shop's monthly profit — receipts minus rent, ingredients, and wages. When profit is positive, the shop stays open and the owner pockets every dollar. When profit turns negative, the shop runs out of cash and shutters — the lights go off, the books are wiped to zero. ReLU is exactly that rule, applied one shop at a time. Read the diagram left to right. The first column is the raw value x — each shop's profit at month's end. The second column is the gate: 1 if the shop is open (x > 0), 0 if it has shuttered. The last column is the ReLU output: open shops pass their profit through untouched, while shuttered ones are zeroed out. Five rows means five parallel shops on the same block, each evaluated independently. That's why ReLU is called an element-wise activation: every neuron decides its own fate. = LeakyRelu = Plain ReLU wipes negative values to zero — clean, but a shop that shutters can never recover, since both its output and its gradient stay pinned at zero. This is the dying ReLU problem, and in deep networks it can quietly kill a meaningful fraction of the units. Leaky ReLU is the one-line fix: instead of shuttering, the shop files for Chapter 11 protection and keeps the lights on at reduced capacity. Its debt is restructured down to a fraction α (typically 0.1) — the rest is forgiven, and the shop is wounded, not killed. A small negative signal still flows through, so the gradient survives, and the shop can crawl back to life if a TikTok goes viral. Read the diagram left to right. The first column is the raw value x — each shop's profit at month's end. The second column is the leakage α — the fraction of the loss held over after restructuring (default 0.1, editable). The third column is the gate: 1 for shops still in the black, α for those operating under bankruptcy protection. The last column is the Leaky ReLU output: y = x · gate. Profitable shops pass through untouched; struggling ones shrink by a factor of α but still carry a sign. Five rows means five parallel shops, each evaluated independently. Like ReLU, this is an element-wise activation: every neuron's fate is decided on its own merits. #aibyhahd
0:18

ReLU vs Leaky ReLU 👉 = ReLU = ReLU is the default activation in modern deep learning — cheap to compute, and stable enough to train networks hundreds of layers deep. To see what it does, picture five boba tea shops on the same block — 𝚊, 𝚋, 𝚌, 𝚍, 𝚎 — each running their own books. Each value is a shop's monthly profit — receipts minus rent, ingredients, and wages. When profit is positive, the shop stays open and the owner pockets every dollar. When profit turns negative, the shop runs out of cash and shutters — the lights go off, the books are wiped to zero. ReLU is exactly that rule, applied one shop at a time. Read the diagram left to right. The first column is the raw value x — each shop's profit at month's end. The second column is the gate: 1 if the shop is open (x > 0), 0 if it has shuttered. The last column is the ReLU output: open shops pass their profit through untouched, while shuttered ones are zeroed out. Five rows means five parallel shops on the same block, each evaluated independently. That's why ReLU is called an element-wise activation: every neuron decides its own fate. = LeakyRelu = Plain ReLU wipes negative values to zero — clean, but a shop that shutters can never recover, since both its output and its gradient stay pinned at zero. This is the dying ReLU problem, and in deep networks it can quietly kill a meaningful fraction of the units. Leaky ReLU is the one-line fix: instead of shuttering, the shop files for Chapter 11 protection and keeps the lights on at reduced capacity. Its debt is restructured down to a fraction α (typically 0.1) — the rest is forgiven, and the shop is wounded, not killed. A small negative signal still flows through, so the gradient survives, and the shop can crawl back to life if a TikTok goes viral. Read the diagram left to right. The first column is the raw value x — each shop's profit at month's end. The second column is the leakage α — the fraction of the loss held over after restructuring (default 0.1, editable). The third column is the gate: 1 for shops still in the black, α for those operating under bankruptcy protection. The last column is the Leaky ReLU output: y = x · gate. Profitable shops pass through untouched; struggling ones shrink by a factor of α but still carry a sign. Five rows means five parallel shops, each evaluated independently. Like ReLU, this is an element-wise activation: every neuron's fate is decided on its own merits. #aibyhahd

Tom Yeh

32,561 görüntüleme • 3 ay önce

THIS IS WHY THE SOUTHERN LEBANESE ARE ANGRY 🇱🇧🇮🇱 The Full 14 Articles Lebanon Signed Read Like a SURRENDER, Not a Treaty Al-Jadeed obtained the complete Trilateral Framework signed in Washington, the document no government released in public. The clauses, in plain language: 1) DISARM FIRST (Art. 4): Lebanon commits to the "complete and verified disarmament" of every non-state armed group on its soil, Hezbollah unnamed but unmistakable, before anything is given back. 2) WITHDRAWAL IS THE REWARD (Art. 2, 5): The IDF only "progressively redeploys" out of two pilot zones, governed by a Security Annex that DOESN'T EVEN EXIST YET, and Israel's "no territorial ambitions" pledge is conditioned entirely on a disarmament IT ALONE gets to certify as complete. 3) SOVEREIGNTY ON PAPER (Art. 6): Lebanon holds the "exclusive sovereign authority" over war and peace, a clause built to outlaw the resistance by name without naming it. 4) AID ON A LEASH (Art. 9, 11): U.S. money to the Lebanese army is "strictly conditioned on verifiable milestones" and oversight. Beirut also pledges to choke off all funds to non-state groups, then keep reconstruction money out of their hands entirely. 5) RECONSTRUCTION, SEPARATELY GATED (Art. 10): Washington will "rally partners" to rebuild Lebanon, but on a SEPARATE track from the conditioned aid, leverage held in reserve. 6) THE TELL (Art. 14): The whole framework closes with both governments expressing "deep appreciation for the vision and leadership of President Donald J. Trump."
0:16

THIS IS WHY THE SOUTHERN LEBANESE ARE ANGRY 🇱🇧🇮🇱 The Full 14 Articles Lebanon Signed Read Like a SURRENDER, Not a Treaty Al-Jadeed obtained the complete Trilateral Framework signed in Washington, the document no government released in public. The clauses, in plain language: 1) DISARM FIRST (Art. 4): Lebanon commits to the "complete and verified disarmament" of every non-state armed group on its soil, Hezbollah unnamed but unmistakable, before anything is given back. 2) WITHDRAWAL IS THE REWARD (Art. 2, 5): The IDF only "progressively redeploys" out of two pilot zones, governed by a Security Annex that DOESN'T EVEN EXIST YET, and Israel's "no territorial ambitions" pledge is conditioned entirely on a disarmament IT ALONE gets to certify as complete. 3) SOVEREIGNTY ON PAPER (Art. 6): Lebanon holds the "exclusive sovereign authority" over war and peace, a clause built to outlaw the resistance by name without naming it. 4) AID ON A LEASH (Art. 9, 11): U.S. money to the Lebanese army is "strictly conditioned on verifiable milestones" and oversight. Beirut also pledges to choke off all funds to non-state groups, then keep reconstruction money out of their hands entirely. 5) RECONSTRUCTION, SEPARATELY GATED (Art. 10): Washington will "rally partners" to rebuild Lebanon, but on a SEPARATE track from the conditioned aid, leverage held in reserve. 6) THE TELL (Art. 14): The whole framework closes with both governments expressing "deep appreciation for the vision and leadership of President Donald J. Trump."

Ryan Rozbiani

61,924 görüntüleme • 1 ay önce

After Season 1 of the #ZamaCreatorProgram ended, the Now @zama project entered Season 2 and quickly attracted strong attention from the community. At first, I was quite worried about having to compete with large accounts that had a huge number of followers. However, after carefully studying the project’s documentation, I realized that Zama has designed mechanisms to ensure fairness among accounts, regardless of whether they have many or few followers. That’s why I want to share this with everyone. Below is the concrete proof : Score calculation a) Definitions •ER% = (likes + retweets + quotes) ÷ impressions. •SF = log10(smart_followers + 1), max 3. •IMP = √impressions. •ENG = likes + 3×retweets + qW×quotes, where qW = 4–6 (depending on SRM). •SRM (Scale Rate Multiplier) = min(1, impressions ÷ 100k). •QE (reach efficiency) = log(1 + impressions/followers) × SRM, max 2. •Clamp = caps actual engagement so it doesn’t exceed the ER limit. b) E.g Input: 20k impressions, 300 like, 50 RT, 30 quote, 5k followers, 800 smart followers. Output: •ER% ≈ 1.9% •SRM = 0.2; qW = 4.4 •ENG = 582 •IMP ≈ 141.42 •SF ≈ 2.90 •QE ≈ 0.322 •ER_cap = 1.8% → Clamp ≈ 0.619
0:17

After Season 1 of the #ZamaCreatorProgram ended, the Now @zama project entered Season 2 and quickly attracted strong attention from the community. At first, I was quite worried about having to compete with large accounts that had a huge number of followers. However, after carefully studying the project’s documentation, I realized that Zama has designed mechanisms to ensure fairness among accounts, regardless of whether they have many or few followers. That’s why I want to share this with everyone. Below is the concrete proof : Score calculation a) Definitions •ER% = (likes + retweets + quotes) ÷ impressions. •SF = log10(smart_followers + 1), max 3. •IMP = √impressions. •ENG = likes + 3×retweets + qW×quotes, where qW = 4–6 (depending on SRM). •SRM (Scale Rate Multiplier) = min(1, impressions ÷ 100k). •QE (reach efficiency) = log(1 + impressions/followers) × SRM, max 2. •Clamp = caps actual engagement so it doesn’t exceed the ER limit. b) E.g Input: 20k impressions, 300 like, 50 RT, 30 quote, 5k followers, 800 smart followers. Output: •ER% ≈ 1.9% •SRM = 0.2; qW = 4.4 •ENG = 582 •IMP ≈ 141.42 •SF ≈ 2.90 •QE ≈ 0.322 •ER_cap = 1.8% → Clamp ≈ 0.619

KenDi99999.ETH Ⓜ️Ⓜ️T 🟨

28,316 görüntüleme • 11 ay önce

Full Fine-tuning vs. Freezing Layers. Interact 👉 and == Full Fine-tuning == A real network has many — three layers in this example, billions of parameters in a production model. What does fine-tuning look like when you update all of them? That’s full fine-tuning: continue training every weight in the pretrained network on your new task. Every layer’s W gets its own ΔW. Nothing is frozen — every parameter is in play. Think of an MLP as a chain of prerequisites leading to an advanced course. Layer 1 might be Linear Algebra, layer 2 Probability, layer 3 Advanced Machine Learning — each one building on what came before. Fine-tuning is what happens during graduate study: the foundations are already there from undergrad, so you’re not re-learning. Full fine-tuning is reviewing every prerequisite to see what new topics have appeared and what discoveries the field has made since the last time you sat through them. Effective — but exhausting. This diagram shows the same three-layer MLP twice, side by side. On the left, the pretrained network runs on input X: three weight matrices W₁, W₂, W₃, each followed by a ReLU activation. Full fine-tuning gives the model the most freedom to specialize. Every parameter can move — and every parameter that can move must be stored. But not every prerequisite needs revisiting. The further you go back in the chain, the less the material has changed since pretraining — the linear-algebra basics under your computer-vision course are largely the same as they ever were. The next page does exactly that: freeze the prerequisites that haven’t moved, and only refresh the advanced one closest to your specialization. == Freezing Layers == Full fine-tuning reviewed every prerequisite — Linear Algebra, Probability, Advanced ML — to refresh each subject with the latest topics. Effective, but exhausting. Then you realize something. The prerequisites haven’t actually changed that much. Linear Algebra is still Linear Algebra; the matrix decompositions you learned still hold. Probability is still Probability; the distributions and Bayes’ rule haven’t moved. Almost all the new material — the new ideas, the recent discoveries — lives in the advanced layer at the top. That’s freezing layers: keep the prerequisite layers fixed at their pretrained state, and only update the advanced one. In the diagram below, W1​ and W2​ — the foundational prerequisites — stay frozen. Only W3​ — the layer closest to your task-specific output — gets a ΔW.
0:16

Full Fine-tuning vs. Freezing Layers. Interact 👉 and == Full Fine-tuning == A real network has many — three layers in this example, billions of parameters in a production model. What does fine-tuning look like when you update all of them? That’s full fine-tuning: continue training every weight in the pretrained network on your new task. Every layer’s W gets its own ΔW. Nothing is frozen — every parameter is in play. Think of an MLP as a chain of prerequisites leading to an advanced course. Layer 1 might be Linear Algebra, layer 2 Probability, layer 3 Advanced Machine Learning — each one building on what came before. Fine-tuning is what happens during graduate study: the foundations are already there from undergrad, so you’re not re-learning. Full fine-tuning is reviewing every prerequisite to see what new topics have appeared and what discoveries the field has made since the last time you sat through them. Effective — but exhausting. This diagram shows the same three-layer MLP twice, side by side. On the left, the pretrained network runs on input X: three weight matrices W₁, W₂, W₃, each followed by a ReLU activation. Full fine-tuning gives the model the most freedom to specialize. Every parameter can move — and every parameter that can move must be stored. But not every prerequisite needs revisiting. The further you go back in the chain, the less the material has changed since pretraining — the linear-algebra basics under your computer-vision course are largely the same as they ever were. The next page does exactly that: freeze the prerequisites that haven’t moved, and only refresh the advanced one closest to your specialization. == Freezing Layers == Full fine-tuning reviewed every prerequisite — Linear Algebra, Probability, Advanced ML — to refresh each subject with the latest topics. Effective, but exhausting. Then you realize something. The prerequisites haven’t actually changed that much. Linear Algebra is still Linear Algebra; the matrix decompositions you learned still hold. Probability is still Probability; the distributions and Bayes’ rule haven’t moved. Almost all the new material — the new ideas, the recent discoveries — lives in the advanced layer at the top. That’s freezing layers: keep the prerequisite layers fixed at their pretrained state, and only update the advanced one. In the diagram below, W1​ and W2​ — the foundational prerequisites — stay frozen. Only W3​ — the layer closest to your task-specific output — gets a ΔW.

Tom Yeh

27,587 görüntüleme • 3 ay önce

ACCRA, GHANA: In August 2024, the Aye (NBM) cult group recorded one of the most painful BKB cases ever recorded on this platform - a case in Accra, Ghana, where a former Aye number 1 man named Summer or Summerboy (seen in the video) was be@ten to de@th by people he considered friends and fellow Ayes. This story revolves around 3 key individuals: Summer, Update, and Asima - all members of Aye. Summer, originally from Imo state, but raised in Ebonyi state, was an Aye number 1 man while in school at Akanu Ibiam Federal Polytechnic, Unwana, Ebonyi State. Asima (right pic) was his godson (Kson) in Aye. Update is Asima’s younger brother and a childhood friend of Summer. This means Summer was the godfather (LM) to his childhood friend’s elder brother. After Summer graduated and completed his NYSC, he reached out to Update and Asima who lives in Ghana and runs an HK office, seeking to learn how to make money. They agreed and invited Summer to Ghana. When Summer arrived, Asima, Update, and other Ayes in the HK office decided to drill him - a practice just like cult initiation which is meant to toughen up newcomers in the HK. After drilling Summer the first time, they said the drilling was soft and they had to drill him harder the second time. It was during the second drilling that Summer became unc0nscious and was rushed to the hospital, where he d!£d. Summer d!£d on the same day he arrived in Ghana. A godson and a childhood friend, both NBM members, involved in the k**ling of Summer - a friend, a fellow Aye, an Aye godfather, and a former Aye number 1 man. Summer was a very talented musician, and a very peaceful young boy who loved peace and discouraged violence. Summer had supported both Update and Asima in many ways in the past, even supporting them both as a childhood friend and financially, especially when they started a new life in Ghana. Non-cultists (Free Men), there is no true brotherhood in cultism. Reject Aye. Reject Cultism.
0:18

ACCRA, GHANA: In August 2024, the Aye (NBM) cult group recorded one of the most painful BKB cases ever recorded on this platform - a case in Accra, Ghana, where a former Aye number 1 man named Summer or Summerboy (seen in the video) was be@ten to de@th by people he considered friends and fellow Ayes. This story revolves around 3 key individuals: Summer, Update, and Asima - all members of Aye. Summer, originally from Imo state, but raised in Ebonyi state, was an Aye number 1 man while in school at Akanu Ibiam Federal Polytechnic, Unwana, Ebonyi State. Asima (right pic) was his godson (Kson) in Aye. Update is Asima’s younger brother and a childhood friend of Summer. This means Summer was the godfather (LM) to his childhood friend’s elder brother. After Summer graduated and completed his NYSC, he reached out to Update and Asima who lives in Ghana and runs an HK office, seeking to learn how to make money. They agreed and invited Summer to Ghana. When Summer arrived, Asima, Update, and other Ayes in the HK office decided to drill him - a practice just like cult initiation which is meant to toughen up newcomers in the HK. After drilling Summer the first time, they said the drilling was soft and they had to drill him harder the second time. It was during the second drilling that Summer became unc0nscious and was rushed to the hospital, where he d!£d. Summer d!£d on the same day he arrived in Ghana. A godson and a childhood friend, both NBM members, involved in the k**ling of Summer - a friend, a fellow Aye, an Aye godfather, and a former Aye number 1 man. Summer was a very talented musician, and a very peaceful young boy who loved peace and discouraged violence. Summer had supported both Update and Asima in many ways in the past, even supporting them both as a childhood friend and financially, especially when they started a new life in Ghana. Non-cultists (Free Men), there is no true brotherhood in cultism. Reject Aye. Reject Cultism.

Naija Confra

20,349 görüntüleme • 4 ay önce

🔴IMPROVE YOUR SUPER COUNTER🔴 I will refer to you the host as player 1 and friend as player 2 Step 1 - Invite friend to room and create a private match Step 2 - Make DP teams, equip Max health and ki recovery to all your character for this match. Step 3 - To initiate training player 1 should approach player 2 and charge melee attack (smash attack it’s called in game) As demonstrated on this video, also note you have 2 assault vanishing attacks not including lightning attack which would be (O on ps5) per assault combo string. Player 2 can try and super counter that first charged attack and if he fails he’s got another 2 chances at super counter after you follow up the next two vanishing assaults. Step 4 - Flick Up followed by rush attack (⬆️+🟪) so UP first than SQUARE almost simultaneously but fast! on hit. It sounds silly that it has to be on hit but it is literally how it is done so (same time you get hit is the time you input ⬆️+🟪) Step 5 - Never break this rule: you and your friend can only damage each other with successful Super counter. A little tip to reset the vanishing assaults mid vanishing assault combo sequence. - So say player 1 has connected a charged smash and a(1) vanishing assault, And player 2 did not succeed in executing super counters, what should happen next is player 2 should vanish the 2nd Vanishing Assault of player 1 by pressing (🔴) instead of attempting Super Counter (⬆️+🟪), and once player two knocks back player 1 with a successful 🔴 counter player 2 should now press 🔺to do 2 vanishing assault combos, whilst player 1 attempts doing (Super Counter), and if player 1 fails to super counter the first vanishing attack player 1 should press 🔴 on the 2nd attack, now making it so that player 2 has to attempt super counter.. 😭😂💀 I know complicated but it really isn’t. The entire battle can be of you two simply super countering each other! Me and my friend did this for a few hours to build muscle memory and reaction speed because what’ll notice is you have to be fast to react to super counters or else you will take tons of damage. Also I can’t tell you how satisfying it is to perform these. My friend Erci was like: Goku come on man you’re the MC this is cake for you DO IT!! I was like: I am the son of of the prince of all Saiyans you can’t touch me GOKU 😈😂😭 we were talking mad trash to each other. I love this game ❤️ Good luck labbing and see you all tomorrow for a fun dual stream on twitch and YouTube 🔥💪🏾
0:19

🔴IMPROVE YOUR SUPER COUNTER🔴 I will refer to you the host as player 1 and friend as player 2 Step 1 - Invite friend to room and create a private match Step 2 - Make DP teams, equip Max health and ki recovery to all your character for this match. Step 3 - To initiate training player 1 should approach player 2 and charge melee attack (smash attack it’s called in game) As demonstrated on this video, also note you have 2 assault vanishing attacks not including lightning attack which would be (O on ps5) per assault combo string. Player 2 can try and super counter that first charged attack and if he fails he’s got another 2 chances at super counter after you follow up the next two vanishing assaults. Step 4 - Flick Up followed by rush attack (⬆️+🟪) so UP first than SQUARE almost simultaneously but fast! on hit. It sounds silly that it has to be on hit but it is literally how it is done so (same time you get hit is the time you input ⬆️+🟪) Step 5 - Never break this rule: you and your friend can only damage each other with successful Super counter. A little tip to reset the vanishing assaults mid vanishing assault combo sequence. - So say player 1 has connected a charged smash and a(1) vanishing assault, And player 2 did not succeed in executing super counters, what should happen next is player 2 should vanish the 2nd Vanishing Assault of player 1 by pressing (🔴) instead of attempting Super Counter (⬆️+🟪), and once player two knocks back player 1 with a successful 🔴 counter player 2 should now press 🔺to do 2 vanishing assault combos, whilst player 1 attempts doing (Super Counter), and if player 1 fails to super counter the first vanishing attack player 1 should press 🔴 on the 2nd attack, now making it so that player 2 has to attempt super counter.. 😭😂💀 I know complicated but it really isn’t. The entire battle can be of you two simply super countering each other! Me and my friend did this for a few hours to build muscle memory and reaction speed because what’ll notice is you have to be fast to react to super counters or else you will take tons of damage. Also I can’t tell you how satisfying it is to perform these. My friend Erci was like: Goku come on man you’re the MC this is cake for you DO IT!! I was like: I am the son of of the prince of all Saiyans you can’t touch me GOKU 😈😂😭 we were talking mad trash to each other. I love this game ❤️ Good luck labbing and see you all tomorrow for a fun dual stream on twitch and YouTube 🔥💪🏾

GameBreakerGod

181,438 görüntüleme • 1 yıl önce

CHINA'S BIGGEST CHIP IPO EVER DROPS MONDAY. And it's aimed directly at the three companies that control 90% of the world's memory. ChangXin Memory Technologies lists on Shanghai's STAR Market on July 27 at 8.66 yuan a share. About $1.28. They're raising $8.5 billion, close to $9.8 billion if the overallotment gets exercised. That values the company around $85 billion. Largest Chinese semiconductor IPO on record. Biggest chip listing in Asia this year. The demand numbers are wild. More than 9.4 million retail accounts applied. The online tranche was oversubscribed about 244 times. Institutions came in at roughly 570 times. And on Hyperliquid the pre-IPO perp has been trading near $7. Five to six times the issue price. That's people who can't buy A-shares paying whatever it takes for exposure. Now here's why this actually matters. Samsung, SK Hynix and Micron control almost 90% of global DRAM revenue. Samsung 38%, SK Hynix 29%, Micron 22%. For two years they've been starving the market of regular DDR5 while chasing AI memory. That's a big part of why memory prices went through the roof. CXMT is already the fourth largest DRAM maker on earth by capacity. By year end they're on pace to nearly match Micron's wafer output. Every dollar from this IPO goes into more fabs, better DDR5 and LPDDR5X yields, early HBM3 work, and the next process node. In plain English: a state-backed Chinese player is about to push serious volume of cheaper memory into a market that's been kept deliberately tight. The former head of Samsung's chip division already warned that a Chinese capacity surge like this could flip the entire pricing cycle by late 2027. I’ve been in this game for a long time, and every move I make gets posted in The Assembly. We’re a team of 8 analysts and we have one of the BEST track record. You also get access to my full portfolio. I want to keep it exclusive so I will close access shortly. You can join from my bio. A lot of people will regret not joining once we officially stop accepting new members.
0:17

CHINA'S BIGGEST CHIP IPO EVER DROPS MONDAY. And it's aimed directly at the three companies that control 90% of the world's memory. ChangXin Memory Technologies lists on Shanghai's STAR Market on July 27 at 8.66 yuan a share. About $1.28. They're raising $8.5 billion, close to $9.8 billion if the overallotment gets exercised. That values the company around $85 billion. Largest Chinese semiconductor IPO on record. Biggest chip listing in Asia this year. The demand numbers are wild. More than 9.4 million retail accounts applied. The online tranche was oversubscribed about 244 times. Institutions came in at roughly 570 times. And on Hyperliquid the pre-IPO perp has been trading near $7. Five to six times the issue price. That's people who can't buy A-shares paying whatever it takes for exposure. Now here's why this actually matters. Samsung, SK Hynix and Micron control almost 90% of global DRAM revenue. Samsung 38%, SK Hynix 29%, Micron 22%. For two years they've been starving the market of regular DDR5 while chasing AI memory. That's a big part of why memory prices went through the roof. CXMT is already the fourth largest DRAM maker on earth by capacity. By year end they're on pace to nearly match Micron's wafer output. Every dollar from this IPO goes into more fabs, better DDR5 and LPDDR5X yields, early HBM3 work, and the next process node. In plain English: a state-backed Chinese player is about to push serious volume of cheaper memory into a market that's been kept deliberately tight. The former head of Samsung's chip division already warned that a Chinese capacity surge like this could flip the entire pricing cycle by late 2027. I’ve been in this game for a long time, and every move I make gets posted in The Assembly. We’re a team of 8 analysts and we have one of the BEST track record. You also get access to my full portfolio. I want to keep it exclusive so I will close access shortly. You can join from my bio. A lot of people will regret not joining once we officially stop accepting new members.

NoLimit

250,285 görüntüleme • 21 gün önce

1 Neural Network + Obsidian + Karpathy’s 1-file method = the most unhinged second brain build of 2026. It remembers everything you’ve ever done, and it costs $0 on top of what you already pay. The base is Karpathy’s append and review: 1 giant note, new thoughts stack on top, old ones sink, every few days you reread and pull the survivors back up. No folders, no tags, no plugins the rereading IS the system, because review is what turns storage into thinking. The flaw: past 10,000 lines, no human rereads anything. That’s where the neural network takes over. You keep the note in Obsidian 1 vault, everything dumps to the top: ideas, links, meeting fragments, half-thoughts. You never organize, you only dump. It all lives as plain markdown on your own disk, and that detail is the whole trick. Because now you point Claude Code at the vault folder, and it reads every line you’ve ever written. “What did I think about pricing in March.” “Find the 3 ideas I keep circling.” “What did I drop that deserves a second look.” It answers from YOUR notes, with quotes, in 15 seconds. Then once a week, 1 prompt closes the loop: read the last 7 days, surface the 5 entries worth pulling back up, flag anything that contradicts what I wrote a month ago. The model does the sinking and surfacing Karpathy did by hand, and the note stays alive instead of turning into a graveyard. Week 1 feels like nothing. Week 4 you hit the first “I already solved this in January.” Month 3 you consult your past self more than Google. Most second brains die in 11 days under 40 plugins and 200 folders. This one is 1 file and a loop, and it compounds because dumping takes 0 discipline. Notion stores what you thought. This thing argues back.
0:16

1 Neural Network + Obsidian + Karpathy’s 1-file method = the most unhinged second brain build of 2026. It remembers everything you’ve ever done, and it costs $0 on top of what you already pay. The base is Karpathy’s append and review: 1 giant note, new thoughts stack on top, old ones sink, every few days you reread and pull the survivors back up. No folders, no tags, no plugins the rereading IS the system, because review is what turns storage into thinking. The flaw: past 10,000 lines, no human rereads anything. That’s where the neural network takes over. You keep the note in Obsidian 1 vault, everything dumps to the top: ideas, links, meeting fragments, half-thoughts. You never organize, you only dump. It all lives as plain markdown on your own disk, and that detail is the whole trick. Because now you point Claude Code at the vault folder, and it reads every line you’ve ever written. “What did I think about pricing in March.” “Find the 3 ideas I keep circling.” “What did I drop that deserves a second look.” It answers from YOUR notes, with quotes, in 15 seconds. Then once a week, 1 prompt closes the loop: read the last 7 days, surface the 5 entries worth pulling back up, flag anything that contradicts what I wrote a month ago. The model does the sinking and surfacing Karpathy did by hand, and the note stays alive instead of turning into a graveyard. Week 1 feels like nothing. Week 4 you hit the first “I already solved this in January.” Month 3 you consult your past self more than Google. Most second brains die in 11 days under 40 plugins and 200 folders. This one is 1 file and a loop, and it compounds because dumping takes 0 discipline. Notion stores what you thought. This thing argues back.

West Lord

24,679 görüntüleme • 28 gün önce

I'm starting on a new project #buildinpublic 🤠 ✅ ahrefs sub 📚 initial keyword research 🆕 .com domain name But this is different. Why? I'm starting with SEO & marketing, then fleshing out the product afterwards. It's been a busy morning already thanks to Ahrefs. From the learnings of grandmaster sensei — I will be using my other projects for backlinks & focus on SEO instead of adding as an afterthought. The plan: ------------------------- [hacks explained further down] 1. keyword research 2. more keyword research [HACK #1] 3. content plan 4. choose topics, subtopics & post outline using long-tail keywords found in 1. & 2. [HACK #2] 5. landing page, blog & initial marketing 6. barebone MVP 7. blog with content hubs [HACK #3] 8. initial backlinks [HACK #4] 9. marketing & launch 10. talk to users & iterate while SEO is slowly cooking in the background (hopefully by the time the product matures SEO is booming) ... 🔁 continue to fill in posts according to the content plan. then back to 1 & 2. more long-tail posts & create free tools to improve ranking + increase no. of backlinks. Hack #1 --------- Explore keywords for "result intent" SEO. Figure out guides & tutorials for keywords with DR long tail ones. Create structure for internal links, e.g.: /generic-topic-keyword (links to all posts) ➡️/more-specific-subtopic-keyword (links to child posts) ➡️➡️/very-specific-post-1 ➡️➡️/very-specific-post-2 etc. Hack #3 --------- Create hubs for generic keywords with links to subtopics and long-tail posts. The hubs themselves should be somewhat informative but mostly an overview. => My crazy idea: before I have the content, add external links to authoritative sources for each specific post. I'll slowly write my own content to replace those and move the links inside the post. Hack #4 --------- Use my other projects to write posts on the new product and link to it to get a decent domain ranking fast. Launch on PH with a beta, mostly for the good backlink. Add repos with md files to Github, Gitlab, Bitbucket etc. for some easy backlinks. 🤠 Crazy enough to work, right?* *to note: I've validated the idea and am somewhat sure people will pay for it. But, I'd still like to shorten each step to minimize my risk & ship fast. Thinking: 1 week research, 1 week dev, 1 week marketing, 1 week content. What could go wrong? :D
0:13

I'm starting on a new project #buildinpublic 🤠 ✅ ahrefs sub 📚 initial keyword research 🆕 .com domain name But this is different. Why? I'm starting with SEO & marketing, then fleshing out the product afterwards. It's been a busy morning already thanks to Ahrefs. From the learnings of grandmaster sensei — I will be using my other projects for backlinks & focus on SEO instead of adding as an afterthought. The plan: ------------------------- [hacks explained further down] 1. keyword research 2. more keyword research [HACK #1] 3. content plan 4. choose topics, subtopics & post outline using long-tail keywords found in 1. & 2. [HACK #2] 5. landing page, blog & initial marketing 6. barebone MVP 7. blog with content hubs [HACK #3] 8. initial backlinks [HACK #4] 9. marketing & launch 10. talk to users & iterate while SEO is slowly cooking in the background (hopefully by the time the product matures SEO is booming) ... 🔁 continue to fill in posts according to the content plan. then back to 1 & 2. more long-tail posts & create free tools to improve ranking + increase no. of backlinks. Hack #1 --------- Explore keywords for "result intent" SEO. Figure out guides & tutorials for keywords with DR long tail ones. Create structure for internal links, e.g.: /generic-topic-keyword (links to all posts) ➡️/more-specific-subtopic-keyword (links to child posts) ➡️➡️/very-specific-post-1 ➡️➡️/very-specific-post-2 etc. Hack #3 --------- Create hubs for generic keywords with links to subtopics and long-tail posts. The hubs themselves should be somewhat informative but mostly an overview. => My crazy idea: before I have the content, add external links to authoritative sources for each specific post. I'll slowly write my own content to replace those and move the links inside the post. Hack #4 --------- Use my other projects to write posts on the new product and link to it to get a decent domain ranking fast. Launch on PH with a beta, mostly for the good backlink. Add repos with md files to Github, Gitlab, Bitbucket etc. for some easy backlinks. 🤠 Crazy enough to work, right?* *to note: I've validated the idea and am somewhat sure people will pay for it. But, I'd still like to shorten each step to minimize my risk & ship fast. Thinking: 1 week research, 1 week dev, 1 week marketing, 1 week content. What could go wrong? :D

Dan ⚡️

20,654 görüntüleme • 3 yıl önce

Announcing #buildshit! Calling all interaction fanatics, designers and engineers for a fun and light interaction design challenge. The winner takes home $29. Challenge: Create a reveal interaction with two views: 1. The first view should showcase a photograph with the photographer's name and social handle. 2. The second view should present all the metadata and reveal itself through some interaction. Details: 1. Post your work with #buildshit to participate. Use the assets linked below. You may include additional metadata. 2. You have the complete freedom to design any layout and interaction as long as you have the two views and the required assets. 3. The post with the most likes wins (to keep things simple). 4. Tools do not matter. Participate with Code, Figma, Adobe, Jitter, Procreate, Spline, Rive or anything that you are comfortable with. 5. The submissions end on 1 September 2024 at 2:00 PM IST. 6. Do not take the challenge too seriously. This is all about having fun, exploring your creativity and learning from others. Assets: Why? I love thoughtful and delightful interactions. I believe there are always a lot of ways to approach a problem. I am interested in understanding how different people approach the same problem and learning from them. -- Participate for the fun of it, share it with others and let me know if there is something that you'd like to be done differently.
0:10

Announcing #buildshit! Calling all interaction fanatics, designers and engineers for a fun and light interaction design challenge. The winner takes home $29. Challenge: Create a reveal interaction with two views: 1. The first view should showcase a photograph with the photographer's name and social handle. 2. The second view should present all the metadata and reveal itself through some interaction. Details: 1. Post your work with #buildshit to participate. Use the assets linked below. You may include additional metadata. 2. You have the complete freedom to design any layout and interaction as long as you have the two views and the required assets. 3. The post with the most likes wins (to keep things simple). 4. Tools do not matter. Participate with Code, Figma, Adobe, Jitter, Procreate, Spline, Rive or anything that you are comfortable with. 5. The submissions end on 1 September 2024 at 2:00 PM IST. 6. Do not take the challenge too seriously. This is all about having fun, exploring your creativity and learning from others. Assets: Why? I love thoughtful and delightful interactions. I believe there are always a lot of ways to approach a problem. I am interested in understanding how different people approach the same problem and learning from them. -- Participate for the fun of it, share it with others and let me know if there is something that you'd like to be done differently.

Preet

41,517 görüntüleme • 1 yıl önce