A quick introduction to deep learning, NLP, and LLMs
February 16, 2024
Old concept … new computing power
The concept is everything but new: Arthur Samuel came up with it in 1949 and built a self-learning Checkers-playing program in 1959
Machine learning consists of feeding vast amounts of data to algorithms to strengthen pathways, so the excitement for the approach became somewhat dormant due to the lack of computing power and the lack of training data at the time
The advent of powerful computers, GPUs, and massive amounts of data have brought the old concept to the forefront
Decide on an architecture
The architecture won’t change during training
The type of architecture you choose (e.g. CNN, Transformer) depends on the type of data you have (e.g. vision, textual). The depth and breadth of your network depend on the amount of data and computing resource you have
Set some initial parameters
You can initialize them randomly or get much better ones through transfer learning
While the parameters are also part of the model, those will change during training
Get some labelled data
When we say that we need a lot of data for machine learning, we mean “lots of labelled data” as this is what gets used for training models
Make sure to keep some data for testing
Those data won’t be used for training the model. Often people keep around 20% of their data for testing
Pass data and parameters through the architecture
The train data are the inputs and the process of calculating the outputs is the forward pass
The outputs of the model are predictions
Compare those predictions to the train labels
Since our data was labelled, we know what the true outputs are
Calculate train loss
The deviation of our predictions from the true outputs gives us a measure of training loss
Adjust parameters
The parameters get automatically adjusted to reduce the training loss through the mechanism of backpropagation. This is the actual training part
This process is repeated many times. Training models is pretty much a giant for loop
From model to program
Remember that the model architecture is fixed, but that the parameters change at each iteration of the training process
While the labelled data are key to training, what we are really interested in is the combination of architecture + final parameters
When the training is over, the parameters become fixed. Which means that our model now behaves like a classic program
Evaluate the model
We can now use the testing set (which was never used to train the model) to evaluate our model: if we pass the test inputs through our program, we get some predictions that we can compare to the test labels (which are the true outputs)
This gives us the test loss: a measure of how well our model performs
Use the model
Now that we have a program, we can use it on unlabelled inputs to get what people ultimately want: unknown outputs
This is when we put our model to actual use to solve some problem
While biological neurons are connected in extremely intricate patterns, artificial ones follow a layered structure. Another difference in complexity is in the number of units: the human brain has 65–90 billion neurons. ANN have much fewer units
The information in biological neurons is an all-or-nothing electrochemical pulse or action potential. Greater stimuli don’t produce stronger signals but increase firing frequency. In contrast, artificial neurons pass the computation of their inputs through an activation function and the output can take any of the values possible with that function
Fully connected neural networks
Each neuron receives inputs from every neuron of the previous layer and passes its output to every neuron of the next layer
Convolutional neural networks
Convolutional neural networks (CNN) are used for spatially structured data (e.g. images)
Images have huge input sizes and would require a very large number of neurons in a fully connected neural net. In convolutional layers, neurons receive input from a subarea (called local receptive field) of the previous layer. This greatly reduces the number of parameters. Optionally, pooling (combining the outputs of neurons in a subarea) reduces the data dimensions
Recurrent neural networks
From fdeloche, Wikipedia
Recurrent neural networks (RNN) such as Long Short-Term Memory (LSTM) are used for chain structured data (e.g. text)
They are not feedforward networks (i.e. networks for which the information moves only in the forward direction without any loop)
The last one is particularly problematic whenever the model outputs the next round of data based on interactions of the current round of data with the real world
Solution: ensure there are human circuit breakers and oversight
Python
IDE
Getting help
