Apprendimento automatico e Reti Neurali - pagina 17

[MetaQuotes]

PyTorch for Deep Learning & Machine Learning – Full Course (parts 10-14)

PyTorch for Deep Learning & Machine Learning – Full Course

Part 10

• 09:00:00 In this section, the video focuses on creating a custom dataset using the scikit-learn library. The make circles dataset is imported and 1000 samples are created with some added noise for randomness. The length of X and Y are printed, which indicate that there are 1000 samples of features and labels. The first five samples of X and Y are then printed, showcasing that the data is already numerical and only has two classes: zero and one for binary classification. A pandas data frame is then created, with the features labeled as X1 and X2, and random sampling is discussed as a potentially helpful approach for exploring large datasets.
  
  
• 09:05:00 In this section of the course, the instructor explains the toy dataset that will be used to practice building a neural network in PyTorch for binary classification. The dataset was generated using scikit-learn and consists of two circles with different colors representing the two classes of the binary classification problem. The instructor shows how data visualization can help to understand the dataset and prepare for building a neural network. The input and output shapes of the problem are also discussed, as well as how to split the dataset into training and test sets, which will be covered in the next section of the course.
  
  
• 09:10:00 In this section, the instructor discusses the importance of checking input and output shapes in machine learning, as they are common sources of errors. They demonstrate how to view the input and output shapes of a dataset using NumPy arrays and convert the data into PyTorch tensors. The process of converting data into tensors and splitting it into train and test sets is a crucial step in machine learning, even for toy datasets like the one used in this example. The instructor shows how to import PyTorch and ensure the version being used is 1.10, how to convert NumPy arrays to PyTorch tensors, and how to create train and test sets for the data.
  
  
• 09:15:00 In this section, the instructor demonstrates how to convert data from NumPy arrays into PyTorch's default type of float 32 using the command "torch.float". Failure to do so may result in errors later on. The instructor then shows how to split data into training and test sets using random split, which is done using scikit-learn's "train_test_split" function. The code example shows the order in which features and labels should appear while passing them into the function. The instructor also explains the use of the "test_size" parameter, where the value given is the percentage of data to be used as test data, and the "random_state" parameter that acts like a random seed.
  
  
• 09:20:00 In this section, the video covers splitting the data into training and testing sets by using the Scikit-learn library in PyTorch. The torch dot manual seed is set to make sure that the same random splits are used, ensuring they are the same as the ones you want to compare. By using the length of the train and test sets, the video explains that they have 800 and 200 samples, respectively, making up the data set that they will be working with. The next step is to create and pick a model to classify the red and blue dots. To accomplish this, they set up an agnostic code including the device such that it runs on an accelerator, construct the model, define loss, and use PyTorch to create a training and test loop that will be explored further in the next section.
  
  
• 09:25:00 In this section, we learn how to set up a GPU for PyTorch and create a device-agnostic code to ensure that the code will run on a CPU without any issues. We then move on to construct a model by subclassing an nn.Module and follow four main steps. Firstly, we create a model that subclasses an nn.Module. Secondly, we create two Linear Layers capable of handling the shapes of our data. Thirdly, we define a forward method that outlines the forward pass of the model. Fourthly, we instantiate the instance of our model class and send it to the target device. We learn that our model will be used to separate red and blue circles using a neural network.
  
  
• 09:30:00 In this section of the course, the instructor discusses how to define a neural network layer that is capable of handling input features. He goes on to explain that the number of features required for each layer depends on the data set being used. In this example, where X has two features, the first layer is defined as an "n-linear" with n features equal to two, while the second layer is defined with five features to help the model learn more patterns. The instructor also explains that the in-features of the second layer should match the out-features of the previous layer to avoid shape mismatch errors. Finally, he defines a Ford method that outlines the Ford pass and returns self layer two (which takes in self layer one and X as inputs).
  
  
• 09:35:00 In this section, the instructor explains how to instantiate an instance of the model class and send it to the target device. He shows how to create a simple multi-layer neural network, which he then demonstrates on the TensorFlow playground using two input features and passing them to a hidden layer with five neurons, which feeds into another layer that has one output feature. He fits the network to some data, and the test loss is approximately 50%, which means if the model was just randomly guessing, it would get a loss of about 0.5, because there are only two classes.
  
  
• 09:40:00 In this section of the video, the instructor uses a whiteboard tool called Fig Jam to visually represent a neural network for a binary classification problem. The instructor explains that in a binary classification problem, randomly guessing will get you around 50% accuracy. The neural network is constructed using inputs, hidden units, and an output layer, and the instructor emphasizes that the shape of the layers must match. The TensorFlow playground is suggested as a fun way to explore and challenge oneself in building a neural network on this type of data. Later on, the instructor discusses replicating the previously created neural network with even less code using two linear layers capable of handling the input features and upscaling them to improve the network's learning.
  
  
• 09:45:00 In this section, the instructor demonstrates how to replicate a neural network model using nn.Sequential in PyTorch. By using nn.Sequential, the code for the model can be simplified, as most of the code is implemented behind the scenes. The instructor explains that using nn.Sequential for simple, straightforward operations can be more efficient than subclassing, as demonstrated in a previous section of the video. However, subclassing allows for more complex operations, such as building more complex forward passes. This section highlights the flexibility of PyTorch and the different ways to make a model. The instructor also demonstrates passing data through the model and analyzing the state dictionary.
  
  
• 09:50:00 In this section, the instructor demonstrates how PyTorch automatically creates weight and bias parameters behind the scenes while implementing a two-layer neural network. The instructor highlights the fact that the model is instantiated with random numbers and that PyTorch will change these values slightly during the backpropagation and gradient descent process to better fit or represent the data. The instructor also shows the potential complexity of having many layers with numerous features and how keeping track of these values by hand can become verbose. Finally, the instructor goes on to make predictions using the untrained model and highlights the importance of troubleshooting and visualizing the data.
  
  
• 09:55:00 In this section, the video explains how to pick a loss function and optimizer after creating a model for deep learning. The type of loss function and optimizer needed usually depends on the nature of the dataset being worked on. For regression problems, the mean absolute error or mean squared error might be appropriate. Meanwhile, for classification issues, binary cross-entropy or categorical cross-entropy could be chosen. The video concludes by noting that the loss function helps to measure how accurate a model's predictions are.

Part 11

• 10:00:00 In this section of the video course, the instructor provides an overview of various loss functions and optimizers commonly used in PyTorch for neural network classification. The instructor explains binary cross entropy loss, cross entropy loss, mean absolute error, and mean squared error, and which ones are typically used for regression versus classification tasks. For binary classification tasks, the code examples provided include torch.nn BCE loss with logits and BCE loss. The video also covers the concept of logit in deep learning and explores two commonly used optimizers, SGD and Adam. The instructor notes that while there may be other optimizers available, sticking with these two can still achieve good results on many problems.
  
  
• 10:05:00 In this section of the video, the speaker sets up the loss function and optimizer in PyTorch for deep learning and machine learning. The loss function is called BCE with logits loss, which has the sigmoid activation function built in. The speaker explains that if one wants to learn more about activation functions in neural networks, there are online resources available. The optimizer chosen is stochastic gradient descent (SGD), with a learning rate of 0.1, and the parameters are set to update the model parameters with respect to the loss. Finally, the speaker creates an evaluation metric.
  
  
• 10:10:00 In this section, the instructor discusses the importance of accuracy as an evaluation metric and demonstrates how to create an accuracy function using pytorch. The accuracy function compares the predictions to the ground truth labels and returns the percentage of correct predictions out of the total number of samples. The instructor also provides an overview of the steps involved in a pytorch training loop, including the forward pass, loss calculation, optimizer zero grad, back propagation, and gradient descent. The steps are listed out and the importance of each step is discussed.
  
  
• 10:15:00 In this section, the instructor explains how to go from raw logits to prediction probabilities to prediction labels. Raw outputs of the model are referred to as logits, which can be converted into prediction probabilities by passing them to an activation function such as sigmoid for binary classification and softmax for multi-class classification. Prediction probabilities can then be converted to prediction labels by either rounding them for binary classification or taking the argmax for multi-class classification. The instructor also explains the concept of an activation function as something separate from a layer and shows how data passed through a linear layer applies a linear transformation to the incoming data through a dot product and bias term.
  
  
• 10:20:00 In this section of the video, the instructor explains how to use the sigmoid activation function to turn the raw output of a model, called logits, into prediction probabilities that can be used for binary classification. The instructor demonstrates how to use the sigmoid function on the model logits to create predprobs, which can then be passed to a torch dot round function to obtain prediction labels. These prediction labels are used to determine which class an input belongs to, using a decision boundary often set at 0.5. The instructor also emphasizes the importance of performing this step on the raw logits to ensure the prediction probabilities are in the same format as the test data.
  
  
• 10:25:00 In this section, the video discusses the process of turning raw logits from the model into prediction probabilities using an activation function and then converting them into prediction labels. The steps are demonstrated through a fair bit of code, where y-pred is created from y-pred probes using the full step, including predictions, logits to pred probes to pred labels. The model's predictions are compared to test labels, and the same format is created using the squeeze function. The next step is to build a training and testing loop, which involves doing a forward pass, calculating the loss and optimizing the gradients. The video encourages the viewer to attempt this on their own before proceeding to the next video for further instructions.
  
  
• 10:30:00 In this section, the instructor sets a manual seed for reproducibility, specifically a CUDA random seed for operations on a CUDA device. They then move on to putting the data on the target device and building the training and evaluation loop. The instructor highlights a little tidbit in the forward pass where raw logits are outputted and must be passed through torch.round and torch.sigmoid to convert them into prediction probabilities and labels. Lastly, they calculate the loss and accuracy, noting that although calculating accuracy is not necessary, it can be useful to visualize different metrics while the model is training.
  
  
• 10:35:00 In this section, the video discusses the difference between BCE loss and BCE with logits loss in PyTorch. The BCE with logits loss expects logits as input and combines a sigmoid layer and BCE loss, making it more numerically stable. On the other hand, the BCE loss expects prediction probabilities as input, so torch sigmoid needs to be called on the logits to convert them to probabilities. The video also outlines the steps for the PyTorch optimization loop, including zeroing the gradients, performing backpropagation, and updating the parameters to reduce the gradients. Likewise, when testing or making predictions, the model should be put in inference mode, and the test logits should be processed by calling the sigmoid function to acquire prediction probabilities.
  
  
• 10:40:00 In this section, the instructor discusses how to calculate test loss and accuracy for the classification model. To calculate the test loss, the instructor uses BCE with logits loss function and compares it to Y test labels. To calculate the test accuracy, the instructor uses the accuracy function on Y true and Y pred variables. The order of variables is reversed for the accuracy function, as the instructor based it off scikit-learn's metrics package. Finally, the instructor prints the epoch number, training loss and accuracy, and test loss and accuracy at every 10th epoch. The instructor encourages the users to run this mammoth code and fix any errors that arise.
  
  
• 10:45:00 In this section, the instructor discusses the results of the model training from the previous section, which did not show any significant improvement in accuracy. The instructor suggests that an ideal accuracy for the model should be 100 and a loss value should be zero. However, the current model's accuracy is below 50%, which is equivalent to randomly guessing. To determine the reason for the poor performance, the instructor suggests visualizing the predictions made by the model. The instructor imports a function called "plot decision boundary" from a helper function file to be used in this visualization process. The instructor also recommends a resource, madewithml.com, for those interested in learning more about machine learning foundations and ml ops.
  
  
• 10:50:00 In this section, the instructor explains how to download helper functions from the PyTorch learn repository in a programmatic way using Python's "pathlib" and "request" modules. The instructor shows the process of checking if the path of helper functions already exists, and if it does not exist, a request is made to download the helper function as a file called "helper_functions.py". The instructor demonstrates the successful import of methods "plot_predictions" and "plot_decision_boundary" from the downloaded helper function, which will be used later in the course. Finally, the instructor performs a test to visualize the helper function using the "plot_decision_boundary" function, which successfully plots a decision boundary for the training set.
  
  
• 10:55:00 In this section of the video, the presenter discusses the limitations of a linear model in separating circular data with straight lines, as shown in a visualization of the model's decision boundary. The solution to improving the model's accuracy is to add more layers, i.e., increase the depth of the neural network, which allows for more chances to learn about patterns in the data. Other ways to improve a model's performance include increasing the amount of training data and adjusting hyperparameters such as learning rate and batch size. Importing and using helper functions from external Python scripts is also mentioned as a common practice.

Part 12

• 11:00:00 In this section, the instructor discusses ways to improve a model: adding more hidden units, fitting for longer, changing activation functions, adjusting the learning rate, and changing the loss function. The instructor points out that increasing the number of parameters in a model can potentially help represent the data better, but too many parameters may make the model too complex for a simple dataset. The instructor also illustrates how experimentation can help improve the model by changing its structure and hyperparameters. Finally, the instructor shows graphical examples of how adding layers, increasing the number of hidden units, adding activation functions, and changing the optimization function can potentially improve the model.
  
  
• 11:05:00 In this section, the instructor discusses how to improve a model from a model perspective. He explains the concept of hyper parameters, which are values that machine learning engineers and data scientists can change to improve the model's results. The instructor demonstrates how to change the hyper parameters of a model, such as the number of hidden units, the number of layers, and the number of epochs. He also highlights the importance of testing these changes one at a time to identify which one offers the improvement or degradation. Finally, he explains the difference between parameters and hyper parameters and why it's important to make this distinction.
  
  
• 11:10:00 In this section, the instructor creates a three-layered model with more hidden units to see if training this model for longer yields better results. The forward method is overridden to pass data through each layer, with an extra hidden unit and an extra layer overall. The method that leverages speed-ups is also demonstrated to perform all operations at once. An instance of the three-layered model is created and sent to the target device, followed by the creations of a loss function and an optimizer, and a training and evaluation loop for model one.
  
  
• 11:15:00 In this section, the video continues from the previous one in which the nn.module was subclassed to create a new model, Circle Model V1, with more hidden units and an extra layer. Now, the next step in the workflow is to select a loss function, and the video uses nn.BCEWithLogitsLoss() as before, with the same optimizer, torch.optin.SGD(). The video sets the learning rate to 0.1, the number of epochs to 1000, and puts data on the target device (CPU or GPU). The video also demonstrates a loop through the epochs and passes the training data through the model with the new architecture, calculates the loss, and updates the parameters using torch's autograd.
  
  
• 11:20:00 In this section of the video, the instructor goes over the steps for evaluating the model's accuracy and loss. The loss function takes in the predicted label values and compares them to the actual label values. The accuracy function is used to determine how accurate the model's predictions are. The optimizer is used to adjust the model's parameters to create a better representation of the data. Testing is done by calling the model's eval() method and turning on the inference mode. Logits are created by passing input data to the model, and then the torch.round() and torch.sigmoid() functions are used to convert them to predictions. The loss and accuracy are calculated for the test data and printed out every 100 epochs during training of the model.
  
  
• 11:25:00 In this section of the PyTorch for Deep Learning & Machine Learning course, the instructor discusses troubleshooting techniques for when a model is not working, such as testing out a smaller problem to see if the model can learn anything at all. He suggests replicating the data set from a previous section where a linear model was able to fit a straight line and using it to see if the current model can learn anything, as it is currently only guessing and unable to draw a straight line to separate the circular data. The instructor also mentions that some methods to improve a model include changing the hyperparameters, such as the number of layers and hidden units, and changing the activation and loss functions.
  
  
• 11:30:00 In this section, the instructor creates a data set using linear regression formula to see if the model works on any kind of problem. The data set is called x regression and contains 100 samples of one x-value per y-value. The instructor then creates training and test splits for the data and checks their lengths. Finally, the plot predictions function from the helper functions file is used to visually inspect the data.
  
  
• 11:35:00 In this section, the presenter discusses a side project to see if their model can fit a straight line data set before attempting to fit a non-straight line data set. They adjust Model 1 to fit the new data set by changing the number of input features from two to one to match the data, while keeping the output features at 10 to give the model as many parameters as possible. They also create Model 2 using NN dot sequential, which passes data through layers, and set up a loss and optimizer function.
  
  
• 11:40:00 In this section, the instructor introduces the L1 loss function to optimize a regression problem and uses the SGD optimizer with a learning rate of 0.1 to optimize the model's parameters. After loading the dataset and putting it on the target device, the model is trained for a thousand epochs with a loop. In each epoch, the forward pass is performed, the loss is calculated, and the parameters are updated using backward and step functions. The training progress is printed out with the epoch, loss, and test loss every 100 epochs. The loss goes down as the model is optimized.
  
  
• 11:45:00 In this section of the video, the instructor recaps the previous section where they created a straight line data set and trained a model to fit it. They confirm that the model is learning something and suggest that learners play around with different values of the learning rate to experiment with machine learning models. The instructor then goes on to explain how to turn on evaluation mode and make predictions, which are also known as inference. They also teach how to use the plot predictions function and encounter an error due to the data not being on the same device as the model, which they solve by calling dot CPU on their tensor inputs.
  
  
• 11:50:00 In this section, the instructor introduces the importance of nonlinearity in machine learning and deep learning models. Linear functions alone cannot capture the complex patterns in data that require nonlinear functions like curves to represent them accurately. Neural networks are built by combining linear functions with nonlinear functions, or activations, to model complex data patterns. The instructor hints at upcoming videos that will cover nonlinear activations and their role in deep learning models.
  
  
• 11:55:00 In this section, the instructor discusses the power of nonlinearity in machine learning and neural networks. Nonlinearity is essential in machine learning because the data is not always comprised of straight lines. The instructor then demonstrates how to create and plot nonlinear data using the make circles function, and convert data to tenses and train and test splits using PyTorch and the train test split function from sklearn.

Part 13

• 12:00:00 In this section, the instructor in a PyTorch for Deep Learning & Machine Learning course introduces nonlinearity, which is a crucial component of building a model. The instructor challenges the viewer to find a specific nonlinear function in the TorchNN module, which can include pooling layers, padding layers, and activation functions to perform some mathematical operation on an input. Examples of nonlinear activations such as n dot sigmoid and n dot relu are provided. The instructor then demonstrates how to build a classification model using nonlinearity with PyTorch. Nonlinearity means that the graph is not a straight line, whereas linear means the opposite.
  
  
• 12:05:00 In this section of the PyTorch for Deep Learning & Machine Learning course, the instructor introduces the concept of nonlinear data and how neural networks and machine learning models can work with numbers in hundreds of dimensions, making it easier for them to handle nonlinear data. A new neural network, circle model V2, is created using classes with a constructor and several layers that perform linear operations with the addition of a nonlinear activation function called "relu". This function turns negative inputs of the model to zero while leaving the positives as they are. The new model is then passed through the sigmoid function to determine the output.
  
  
• 12:10:00 In this section, the instructor challenges viewers to recreate a neural network model in the TensorFlow Playground with two hidden layers and five neurons, using the Rectified Linear Unit (ReLU) activation function instead of the linear activation function, which they've been using. The instructor explains that the ReLU activation function is a popular and effective nonlinear activation function necessary for modeling nonlinear data, which neural networks are designed to do. The instructor demonstrates the effect of changing the learning rate on the training loss and encourages viewers to experiment with different learning rates to observe the effect on the loss curve.
  
  
• 12:15:00 In this section, the instructor discusses building an optimizer and a loss function for a binary classification problem using PyTorch. They set the model's non-linear activation function to ReLU and create random seeds for CUDA. They then loop through 1000 epochs to train the model, and calculate the loss and accuracy using the BCE with logits loss function and an accuracy function respectively. The instructor encourages thinking about how to functionalize the training code and suggests that this section is to build experience and momentum towards working on real-world PyTorch projects.
  
  
• 12:20:00 In this section, the instructor explains the process of optimizing the model with the backpropagation method in PyTorch. Before performing backpropagation, the optimizer's gradients are zeroed so that it can start from a clean slate. After executing loss.backward(), the optimizer's step method is called to perform gradient descent on the model parameters. The instructor also demonstrates how to debug the model's parameters and explains that the ReLU activation function does not have any parameters, which makes it effective. Finally, the instructor prints out the training and test loss, accuracy, and epoch to track the progress of the model's learning.
  
  
• 12:25:00 In this section, the instructor troubleshoots a shape issue in the PyTorch code and fixes it by using the squeeze function to remove an extra dimension in the test logits dot shape. They then discuss the power of non-linearity and how the addition of relu layers improved the performance of the model, allowing it to potentially draw a line to separate the circles in the dataset. The instructor also emphasizes the importance of visualization in evaluating the model and making predictions, and they challenge the viewers to plot the decision boundaries.
  
  
• 12:30:00 In this section, the instructor demonstrates using the plot decision boundary function to visualize the performance of a nonlinear model compared to a linear model. The nonlinear model is shown to have better accuracy than the linear one, but the instructor challenges the viewer to improve upon the accuracy even more. The instructor then moves on to discuss how neural networks use linear and nonlinear functions as tools for discovering patterns in data, leading into a demonstration of how to create tensors and use nonlinear activation functions in PyTorch.
  
  
• 12:35:00 In this section, the instructor explains how to create custom activation functions in PyTorch by replicating the popular ReLU and Sigmoid functions. The instructor first sets a data type of torch float 32 and visualizes a straight line plotted using the negative 10 to 10 values on the x-axis. The ReLU function is then created using the torch.relu and nn.relu functions by taking an input tensor and returning the maximum of zero and x. Similarly, the Sigmoid function is created by taking an input tensor and returning one divided by one plus the exponential of negative x. The instructor demonstrates the effectiveness of the custom ReLU and Sigmoid functions by plotting them and comparing them to the PyTorch built-in functions.
  
  
• 12:40:00 In this section of the PyTorch course, the instructor explains the importance of combining linear and nonlinear functions to find patterns in data in order to fit a data set. The idea behind neural networks is to stack layers of these functions to create a model. While it is possible to build these layers from scratch, Pytorch offers pre-built layers that have been error-tested and compute as fast as possible behind the scenes while also allowing for the use of GPUs. The instructor also discusses the difference between binary classification, which involves two possible outcomes, and multi-class classification, which involves more than two possible outcomes. Finally, the section concludes by reiterating the importance of nonlinearity in neural networks and the instructor issues a challenge to improve upon their previous binary classification model.
  
  
• 12:45:00 In this section, the course instructor introduces multi-class classification and the differences between it and binary classification. The softmax activation function is used instead of sigmoid and cross entropy instead of binary cross entropy. The instructor then proceeds to create a 20 multi-class data set using the make blobs function from scikit-learn.datasets to generate four classes with two features each. The center standard deviation is adjusted to give the clusters some randomness and shake them up a bit, thereby making it a little bit harder for the model.
  
  
• 12:50:00 In this section, the transcript excerpt discusses how to prepare data for a multi-class classification model using PyTorch. They turn the data into tensors and use the train test split function from scikit-learn to split the data into training and test sets. They also visualize the data using plot.figure and set the random seed to ensure reproducibility. After creating the multi-class classification dataset, they consider whether non-linearity is needed to separate the data and then proceed to build a model for the data.
  
  
• 12:55:00 In this section, the instructor discusses how to set up a multi-class classification model using PyTorch. He explains the process step-by-step, starting with defining the input layer shape and determining the number of neurons per hidden layer. The instructor then explains how to set the output layer shape, which requires one output feature per class. To create the model, the instructor creates a class called "blob model" that inherits from nn.module and sets some parameters for the model. Finally, the instructor demonstrates how to initialize the multi-class classification model with input features and output features.

Part 14

• 13:00:00 In this section, the instructor discusses the creation of a linear layer stack model using PyTorch's nn.Sequential method. To instantiate the model, the number of input features and the number of output classes are accessed to determine the configuration of the hidden layers. The instructor sets up a sequential stack of layers to pass data through each layer one by one. They also provide instructions on adding nonlinearity to the dataset, and then create a forward method to allow the input to go through the specified layers sequentially. Finally, an instance of the blob model is created with the appropriate number of input and output features.
  
  
• 13:05:00 In this section of the video, the instructor creates a multi-class classification model by subclassing an nn.Module and sets up parameters for the class constructor to customize the input and output features. They also explain that the output features parameter lines up with the number of classes in the data. To create a loss function for a multi-class classification model, the instructor searches for and finds cross entropy loss in the torch.nn module, which computes the loss between input and target and is useful when training a classification problem with C classes. The instructor also explains that the weight parameter is useful when dealing with an unbalanced training set.
  
  
• 13:10:00 In this section, the instructor discusses the creation of a loss function and optimizer for multi-class classification. He recommends two common optimizers, SGD and Adam, but chooses to use SGD for this example. He then challenges viewers to do a forward pass with the model created in the previous video and to consider what the raw outputs of a model are. The instructor also reminds viewers to pay attention to device parameters, as a runtime error can occur if tensors are not on the same device. Finally, he turns the model into eval mode and makes some predictions.
  
  
• 13:15:00 In this section, the instructor explains how to convert a model's output logits into prediction probabilities and prediction labels for multi-class classification problems. To do this, the softmax function is used to convert the logits into prediction probabilities, and then the prediction with the highest probability is considered the predicted label. The instructor demonstrates this process using PyTorch code and also notes that the sum of the probabilities for each sample will always be one due to the nature of the softmax function.
  
  
• 13:20:00 In this section, the instructor explains how to go from the raw output of a PyTorch model for a multi-class classification problem to prediction probabilities using the softmax activation function, and then to prediction labels by taking the argmax of the prediction probabilities. This process involves converting the model's raw output into logits, using the softmax function to get the prediction probabilities, and taking the argmax of those probabilities to get the prediction labels. The instructor notes that while the current predictions are random as the model has not been trained yet, these steps will be used in a training loop to train and evaluate the model.
  
  
• 13:25:00 In this section, the instructor begins building a training and testing loop for a multi-class model. First, they set up manual seeds to attempt to get the same output each time, but note that this is not guaranteed. They then set the number of epochs to 100 and put the data onto the target device. The loop through data begins, and for each epoch, the model is trained with a forward pass and logits created from x blob train. The output of the Torch softmax function is used to calculate the loss with cross-entropy loss and accuracy. The optimizer is then zeroed, and back propagation is performed before the optimizer is stepped. The code for testing or inference is also presented, which involves setting the model to evaluation mode.
  
  
• 13:30:00 In this section, the instructor discusses dropout layers, turning off match norm, and the torch inference mode to make predictions faster. They explain that during training, dropout layers randomly drop out some of the neurons to avoid overfitting. The instructor also demonstrates how to calculate test logits and test accuracy by passing in test loss and test labels behind the scenes. They then discuss a pesky data type issue that caused a runtime error and how they resolved it. The instructor emphasizes that troubleshooting code is an essential part of machine learning, and it takes time to identify and resolve errors.
  
  
• 13:35:00 In this section, the narrator encounters various troubleshooting challenges while creating a multi-class classification model. Firstly, he figures out that the error in his code is due to one of the tensors having the wrong data type. Through some research and experimentation, he changes the tensor to a "torch.long tensor," which optimizes computation for cross entropy loss. Later, he encounters another error due to different sizes of his training and test data. By debugging the code on the fly, he identifies the issue and reassigns the data. Despite these challenges, the model's accuracy and loss perform as expected, indicating that the model is working for a multi-class classification dataset.
  
  
• 13:40:00 In this section, the instructor discusses how to evaluate the trained multi-class classification model by making predictions and evaluating them. The instructor explains that predictions are made after setting the model to evaluation mode, passing the test data, and obtaining raw logits as a result. The next step is to convert logits into predictions probabilities by calling torch.softmax on logits. Then, predictions labels are obtained by calling torch.argmax on the prediction probabilities. The instructor emphasizes the importance of visualizing the predictions by plotting them and comparing them with the actual data.
  
  
• 13:45:00 In this section, the instructor evaluates the multi-class classification model visually and explores the linear and non-linear functions used to separate the data. The instructor also mentions that most data requires both linear and non-linear functions for classification, and PyTorch makes it easy to add these functions to models. Additionally, the section covers the importance of evaluating models and introduces precision and recall as important metrics when dealing with classes with different amounts of values.
  
  
• 13:50:00 In this section, the instructor discusses various classification evaluation methods, including accuracy, precision, recall, F1 score, confusion matrix, and classification report. The instructor explains that while accuracy is the default metric for classification problems, it may not be the best for imbalanced datasets. For imbalanced data sets, precision and recall should be used. The precision is determined by the true positive over true positive plus false positive, while the recall is determined by the true positive over true positive plus false negative. The instructor also notes the trade-off between precision and recall, where increasing one metric would lower the other. The use of torchmetrics and scikit-learn libraries for classification metrics is also discussed.
  
  
• 13:55:00 In this section, the instructor shows how to import and use pre-built metrics functions in PyTorch using the torchmetrics package. They demonstrate how to install torchmetrics, import the accuracy metric, and use it to calculate the accuracy of a multi-class model. However, they also caution that when using torchmetrics, the metrics must be on the same device as the data, using device-agnostic code. The instructor provides a link to the torchmetrics module and extracurricular articles for further exploration. They also introduce exercises and solutions for practicing the code covered in the previous sections.

[MetaQuotes]

PyTorch per Deep Learning e Machine Learning – Corso completo (descrizione delle parti 15-19)

PyTorch per Deep Learning e Machine Learning - Corso completo

Parte 15

• 14:00:00 In questa sezione, l'istruttore consiglia gli spettatori su dove ottenere assistenza per il codice di visione artificiale PyTorch, incluso seguire il codice, utilizzare la funzione doc string di Google Colab, cercare il codice su Stack Overflow o nella documentazione di PyTorch e porre domande nella scheda Discussioni del repository di deep learning PyTorch. La sezione copre anche esempi di problemi di visione artificiale, come i problemi di classificazione binaria o multiclasse, in cui un modello di apprendimento automatico apprende schemi da diversi esempi di immagini per determinare se un'immagine è una bistecca o una pizza o per classificare le immagini in più categorie .
  
  
• 14:05:00 In questa sezione, il relatore discute diverse applicazioni della visione artificiale utilizzando l'apprendimento automatico, come la classificazione multiclasse per i problemi di immagine, il rilevamento di oggetti e la segmentazione delle immagini. Il relatore fornisce un esempio di Nutrify, che utilizza l'apprendimento automatico per classificare fino a 100 alimenti diversi da un'immagine caricata. L'oratore discute anche di come Tesla utilizzi la visione artificiale per pianificare i movimenti delle sue auto a guida autonoma utilizzando lo spazio vettoriale tridimensionale e l'apprendimento automatico. Il relatore osserva che Tesla usa PyTorch, che è lo stesso codice che viene insegnato nel corso.
  
  
• 14:10:00 In questa sezione del video, l'istruttore illustra l'utilizzo di PyTorch per creare un modello di visione artificiale per la classificazione di immagini multiclasse. Utilizzando l'esempio di Nutrify, una tecnologia di riconoscimento fotografico per il cibo, l'istruttore spiega gli input e gli output tipici per un problema di visione artificiale. Gli input includono un tensore che rappresenta i canali di altezza, larghezza e colore di un'immagine. L'istruttore menziona anche che gli algoritmi esistenti potrebbero già esistere per i comuni problemi di visione artificiale, ma se necessario è possibile crearne uno. L'output desiderato per l'esempio Nutrify è di tre output, uno per ogni classe alimentare.
  
  
• 14:15:00 In questa sezione, il video spiega come i modelli di machine learning possono essere utilizzati per la classificazione delle immagini, utilizzando PyTorch e le reti neurali convoluzionali (CNN) per rappresentare le informazioni numericamente e addestrare il modello a riconoscere i modelli nei dati. L'esempio fornito è la previsione dei tipi di cibo in un'immagine, come sushi, bistecche e pizza, con l'uso di PyTorch per codificare le informazioni e CNN per riconoscere i modelli nelle immagini. Il video sottolinea che le forme di input e output varieranno in base al problema da risolvere e che le CNN sono in genere la scelta migliore per i dati delle immagini, sebbene possano essere utilizzati altri modelli. Infine, il video introduce un problema relativo alle immagini in scala di grigi di articoli di moda che verranno utilizzate per dimostrare ulteriormente gli stessi principi appresi in questa sezione.
  
  
• 14:20:00 In questa sezione, l'istruttore discute la rappresentazione dei dati immagine in PyTorch e altre librerie di deep learning. Queste librerie spesso si aspettano che i canali di colore siano gli ultimi, ma PyTorch per impostazione predefinita rappresenta prima i dati dell'immagine con i canali di colore. Il video spiega l'importanza di allineare le forme di input e output di un modello per un determinato problema. L'istruttore fornisce una panoramica del flusso di lavoro PyTorch per la creazione di modelli, inclusa la preparazione dei dati utilizzando trasformazioni e caricatori di dati, la creazione o la selezione di un modello pre-addestrato, la selezione di un ottimizzatore e una funzione di perdita, la valutazione del modello utilizzando le metriche e la sperimentazione per migliorare il modello. La sezione successiva discute l'architettura di una rete neurale convoluzionale (CNN).
  
  
• 14:25:00 In questa sezione, l'istruttore discute l'architettura di una tipica rete neurale convoluzionale (CNN). I dati di input passano attraverso vari livelli, inclusi i livelli convoluzionali, di attivazione e di raggruppamento, fino a quando non vengono convertiti in una forma di output che può essere convertita in nomi di classe. L'istruttore sottolinea che ci sono modi quasi illimitati per impilare una CNN e dimostra un modo per farlo attraverso le diapositive. Tuttavia, il modo migliore per imparare è codificarlo e l'istruttore indirizza gli utenti a un taccuino Google Colab dove possono esercitarsi a costruire una CNN utilizzando PyTorch e la libreria TorchVision. L'istruttore fornisce anche risorse aggiuntive, tra cui un taccuino di riferimento e una sezione di visione artificiale PyTorch in LearnPyTorch.io.
  
  
• 14:30:00 In questa sezione del video, l'istruttore introduce le diverse librerie PyTorch per diversi domini, evidenziando la forza di PyTorch nella visione artificiale. La libreria principale per la visione artificiale è la visione artificiale, che contiene set di dati, modelli pre-addestrati per la visione artificiale e trasformazioni per la manipolazione dei dati visivi in numeri utilizzabili dai modelli di apprendimento automatico. L'istruttore dimostra l'importazione di PyTorch, NN e la visione della torcia e illustra il modulo di trasformazione, che contiene trasformazioni di immagini comuni e può essere addestrato insieme utilizzando la composizione. La funzione to_tensor viene introdotta come trasformazione principale per trasformare i dati dell'immagine in formato tensore.
  
  
• 14:35:00 In questa sezione del corso PyTorch for Deep Learning & Machine Learning, l'istruttore copre le librerie fondamentali di visione artificiale in PyTorch, tra cui TorchVision, i moduli derivanti da TorchVision e TorchUtils.data.dataset, che è il set di dati di base classe per PyTorch. L'istruttore discute anche l'importanza dell'utilizzo di Matplotlib per la visualizzazione e la necessità di convertire le immagini in tensori da utilizzare con i modelli. L'istruttore introduce quindi il set di dati FashionMNIST, che è una versione del database MNIST originale, con immagini in scala di grigi di capi di abbigliamento. Questo set di dati verrà utilizzato per dimostrare le tecniche di visione artificiale. L'istruttore spiega che mentre i seri ricercatori di machine learning considerano MNIST un uso eccessivo e non rappresentativo delle moderne attività di visione artificiale, FashionMNIST è un utile set di dati con cui iniziare.
  
  
• 14:40:00 In questa sezione, l'istruttore spiega come scaricare e utilizzare i set di dati dalla libreria TorchVision. Citano vari set di dati di classificazione delle immagini come Caltech101, CIFAR-100 e CIFAR-10 e come scaricarli utilizzando il modulo torchvision.datasets. L'istruttore passa quindi a dimostrare come scaricare e utilizzare il set di dati Fashion-MNIST, spiegando i vari parametri e le trasformazioni che possono essere applicati al set di dati. Forniscono anche codice di esempio per scaricare i set di dati di addestramento e test.
  
  
• 14:45:00 In questa sezione, l'istruttore spiega come utilizzare i set di dati torchvision.dataset di PyTorch per scaricare set di dati di visione artificiale di esempio, in particolare il set di dati FashionMNIST. Possiamo memorizzare i dati in una variabile chiamata "data" e utilizzare torchvision.transforms per convertire i dati dell'immagine in tensori. L'istruttore dimostra anche come controllare la lunghezza dei set di dati di addestramento e test, visualizzare l'immagine e l'etichetta di un esempio di addestramento e ottenere maggiori informazioni sui nomi delle classi attraverso l'uso di attributi come ".classes" e ".class_to_idx". Infine, spiegano che un'etichetta non ha una forma perché è solo un numero intero.
  
  
• 14:50:00 In questa sezione, l'istruttore discute le forme di input e output del set di dati Fashion MNIST, che comprende immagini in scala di grigi di diversi tipi di abbigliamento. La forma di input delle immagini è in formato NCHW, dove la dimensione del batch è impostata su "none" e la forma di output è 10. Per comprendere meglio i dati, l'istruttore utilizza Matplotlib per visualizzare un'immagine e la sua forma, ma incontra un errore perché il formato dei dati non corrisponde al formato previsto. La sezione sottolinea l'importanza di comprendere le forme e la formattazione di input e output quando si lavora con modelli di machine learning.
  
  
• 14:55:00 In questa sezione, il video esplora come tracciare e visualizzare i dati delle immagini utilizzando PyTorch e Matplotlib. L'istruttore mostra come tracciare una singola immagine e rimuovere le dimensioni extra usando image.squeeze(). Successivamente, tracciano un set di 16 immagini casuali dal set di dati utilizzando un seme casuale fisso e la funzione di sottotrama di Matplotlib. L'istruttore mostra anche come utilizzare la proprietà o il parametro cmap per modificare la mappa dei colori del grafico in scala di grigi. Discutono quindi dell'importanza di esplorare visivamente un set di dati per ottenere una migliore comprensione dei dati e identificare potenziali problemi, come le somiglianze tra pullover e magliette nel set di dati.

Parte 16

• 15:00:00 In questa sezione, l'istruttore spiega l'importanza di preparare i dati per un modello di visione artificiale e come farlo utilizzando set di dati PyTorch e caricatori di dati. Discute anche della potenziale necessità di non linearità nella modellazione delle 60.000 immagini di abbigliamento da classificare in 10 classi diverse e di come la suddivisione del set di dati in batch più piccoli possa migliorare l'efficienza computazionale. L'obiettivo di questa preparazione è creare un iterabile Python che possa essere utilizzato dal modello per identificare modelli nei dati.
  
  
• 15:05:00 In questa sezione, l'istruttore spiega il concetto di mini batch e il motivo per cui è comunemente utilizzato nell'apprendimento approfondito, iniziando con la scomposizione di un set di dati di 60.000 immagini in batch di 32. I due motivi principali per utilizzare i mini batch sono rendere la rete neurale più efficiente dal punto di vista computazionale evitando i limiti di memoria della GPU e per dare alla rete maggiori possibilità di aggiornare i suoi gradienti per epoca. I dati vengono raggruppati utilizzando il caricatore di dati da torch.utils.data passandogli un set di dati, definendo la dimensione del batch e impostando shuffle su true per evitare che la rete memorizzi l'ordine dei dati. L'istruttore fornisce il codice per creare caricatori di dati di addestramento e test, che verranno utilizzati nel ciclo di addestramento.
  
  
• 15:10:00 In questa sezione viene sottolineata l'importanza dei mini-batch nei problemi di deep learning e viene spiegato il processo di creazione di caricatori di dati di train e test utilizzando PyTorch. L'iperparametro della dimensione del batch è impostato su 32 e i set di dati vengono trasformati in iterabili. I set di dati di train e test vengono caricati utilizzando DataLoader, con la dimensione del batch impostata su 32 per i dati di train e i dati di test e shuffle impostata su True per i dati di train e False per i dati di test. Vengono esplorati gli attributi del caricatore di dati del treno, come la dimensione del batch e il set di dati. La lunghezza di entrambi i caricatori di dati di treno e di prova viene stampata per determinare il numero di batch in ciascuno.
  
  
• 15:15:00 In questa sezione, l'istruttore spiega come visualizzare batch di immagini utilizzando PyTorch. L'estratto della trascrizione mostra come viene determinata la lunghezza del caricatore di dati del treno, in base alla dimensione del batch e al numero di campioni di addestramento. Quindi, l'istruttore mostra come visualizzare una singola immagine da un batch utilizzando la casualità e controlla la dimensione dell'immagine e l'etichetta associate a quel campione. L'istruttore sottolinea che queste forme di input e output varieranno a seconda del problema specifico, ma la premessa di base rimane la stessa: i dati vengono trasformati in batch per passarli a un modello.
  
  
• 15:20:00 In questa sezione, l'istruttore video spiega come visualizzare le immagini in un batch e trasformare i dati in caricatori di dati. Hanno anche introdotto il concetto di modello di base, che viene utilizzato come punto di partenza ed è un modello semplice che può essere migliorato in seguito attraverso la sperimentazione. L'istruttore introduce quindi un nuovo livello, "appiattisci", che appiattisce una gamma continua di attenuazioni in un tensore da utilizzare con sequenziale e mostra come utilizzarlo come modello autonomo.
  
  
• 15:25:00 In questa sezione, apprendiamo l'appiattimento e come viene utilizzato per trasformare dati multidimensionali in un singolo vettore. Dopo aver stampato le forme prima e dopo l'appiattimento, vediamo che l'output è ora un vettore unidimensionale con una lunghezza di 1784. Vediamo anche che questo processo è simile alla codifica delle informazioni nelle telecamere di Tesla per l'uso nei modelli di deep learning. Vediamo quindi come verranno utilizzati i dati appiattiti nel livello lineare del nostro modello PyTorch. Il modello è definito utilizzando nn.Sequential e include uno strato appiattito e due strati lineari. Le forme di input e output sono definite e vediamo che le caratteristiche esterne del primo strato lineare corrispondono alle caratteristiche interne del secondo strato lineare.
  
  
• 15:30:00 In questa sezione, l'istruttore spiega come creare un semplice modello di rete neurale utilizzando PyTorch. Il modello è costituito da uno strato appiattito seguito da due strati lineari, senza non linearità. Viene definito il metodo forward del modello, che accetta un input, lo passa attraverso lo strato appiattito, quindi attraverso i due strati lineari e restituisce l'output. L'istruttore imposta quindi un'istanza del modello ed esegue un passaggio fittizio in avanti per assicurarsi che il modello funzioni come previsto. Inoltre, spiegano anche la forma di input e output di ogni strato e come sono disposti per ottenere la forma di output desiderata. Infine, dimostrano l'importanza dell'utilizzo del livello appiattito e perché è necessario combinare l'output del livello precedente in un singolo vettore.
  
  
• 15:35:00 In questa sezione, l'istruttore esamina il video precedente in cui ha creato il modello zero per un problema di visione artificiale e ha ribadito l'importanza di garantire che le forme di input e output siano allineate con dove devono essere. Spiegano inoltre che i pesi e le matrici di bias rappresentano caratteristiche diverse nelle immagini, che il modello apprenderà attraverso il deep learning e il machine learning. Andando avanti, discutono la selezione di una funzione di perdita, un ottimizzatore e una metrica di valutazione per il modello, scegliendo rispettivamente la perdita di entropia incrociata, l'ottimizzatore di discesa del gradiente stocastico e la metrica di valutazione dell'accuratezza. Forniscono inoltre un riferimento a una risorsa PyTorch online per le metriche di valutazione della classificazione.
  
  
• 15:40:00 In questa sezione, l'istruttore video discute il concetto di utilizzo delle funzioni di supporto nei progetti di machine learning Python. Fornisce un codice di esempio per l'importazione di uno script Python contenente funzioni comuni, inclusa una funzione di supporto chiamata accuratezza. La funzione di precisione calcola la metrica di precisione e l'istruttore dimostra che può essere importata correttamente verificando la presenza di una stringa di documenti. Spiega anche che l'utilizzo delle funzioni di supporto nei progetti Python può far risparmiare molto tempo e fatica, soprattutto quando si ha a che fare con funzionalità comuni che non devono essere riscritte ogni volta. Infine, imposta una funzione di perdita uguale a nn perdita di entropia incrociata di punti e un ottimizzatore per addestrare il modello.
  
  
• 15:45:00 In questa sezione, l'istruttore imposta l'ottimizzatore per la discesa del gradiente stocastico e imposta un tasso di apprendimento relativamente alto di 0,1 per il semplice set di dati di immagini 28x28. Discutono quindi dell'importanza di tenere traccia delle prestazioni di un modello e del suo tempo di esecuzione, poiché spesso esiste un compromesso tra i due. Procedono dimostrando come creare una funzione per cronometrare l'addestramento del modello utilizzando il modulo time in Python e passando il torch.device per confrontare la velocità con cui il modello viene eseguito su dispositivi diversi.
  
  
• 15:50:00 In questa sezione, l'istruttore discute l'importanza delle funzioni di temporizzazione per misurare il tempo impiegato da un modello per l'addestramento. Dimostra come creare un timer utilizzando il modulo "timer" di Python e mostra come incorporarlo nel processo di formazione. L'istruttore spiega anche come utilizzare la funzione di riconnessione di Google Colab e fornisce un promemoria sull'utilizzo dei caricatori di dati per suddividere i dati in batch per l'addestramento. Quindi delinea i passaggi coinvolti nella creazione di un ciclo di addestramento e nell'addestramento di un modello su batch di dati, sottolineando la necessità di scorrere epoche e batch, eseguire passaggi di addestramento e calcolare la perdita di treno per batch. Infine, afferma che il modello sarà valutato nella stessa fase della formazione.
  
  
• 15:55:00 In questa sezione, l'istruttore inizia la fase di test importando TQDM per una barra di avanzamento che indicherà quante epoche ha attraversato il ciclo di addestramento. TQDM è una barra di avanzamento Python che ha un basso sovraccarico ed è un software open source. Poiché TQDM è così popolare, è integrato in Google CoLab. L'istruttore imposta il seme e avvia il timer prima di impostare il numero di epoche su tre per un tempo di addestramento più rapido per eseguire più esperimenti. Creano un ciclo di addestramento e test, istanziano la perdita di treno e calcolano la perdita di addestramento per epoca. I dati vengono raggruppati in batch e viene aggiunto un ciclo per scorrere i dati del batch di addestramento.

Parte 17

• 16:00:00 In questa sezione, l'istruttore imposta il ciclo di addestramento per la rete neurale. Il modello viene messo in modalità di addestramento e viene eseguito il passaggio in avanti per calcolare la perdita. I valori di perdita di addestramento vengono accumulati ogni batch e l'ottimizzatore viene aggiornato una volta per batch anziché una volta per epoca. L'istruttore stampa anche i campioni esaminati e la perdita di allenamento media per lotto per epoca a scopo di monitoraggio. Questo ciclo continuerà fino a quando tutti i batch non saranno stati elaborati nel caricatore dati del treno.
  
  
• 16:05:00 In questa sezione, l'istruttore esamina il codice per il ciclo di test in PyTorch, che prevede l'impostazione di una variabile di perdita di test e l'utilizzo di un passaggio in avanti per valutare i modelli appresi sui dati di addestramento. Anche l'accuratezza per il test viene calcolata utilizzando la funzione di accuratezza scaricata e i valori di perdita e accuratezza del test vengono accumulati per batch e quindi divisi per il numero di batch per trovare la media per epoca. Questi valori vengono quindi stampati per tenere traccia dell'avanzamento del modello.
  
  
• 16:10:00 In questa sezione, l'istruttore discute i passaggi finali dell'impostazione del ciclo di addestramento, che include la stampa della perdita del treno, della perdita del test e dell'accuratezza del test, nonché il calcolo del tempo di addestramento. Forniscono anche suggerimenti per la risoluzione dei problemi per potenziali errori che possono verificarsi durante la codifica in PyTorch. Concludono dimostrando come eseguire il codice e mostrano la barra di avanzamento del ciclo di addestramento.
  
  
• 16:15:00 In questa sezione, l'istruttore discute i risultati del ciclo di allenamento e introduce l'idea dell'accuratezza della linea di base e del tempo di allenamento. Sottolinea che i numeri possono variare leggermente a causa della casualità intrinseca dell'apprendimento automatico e dell'hardware utilizzato. L'istruttore passa quindi alla valutazione del modello creando una funzione per costruire più modelli e confrontare i risultati in seguito. La funzione accetta un modello, un caricatore di dati, una funzione di perdita e una funzione di accuratezza e restituisce un dizionario contenente i risultati della previsione del modello sul caricatore di dati. Spiega che la funzione è simile al ciclo di test ma è progettata per essere utilizzata con più modelli e caricatori di dati. L'istruttore menziona inoltre che le sezioni seguenti riguarderanno la creazione di previsioni e la valutazione del modello sulla GPU e sulla rete neurale convoluzionale.
  
  
• 16:20:00 In questa sezione, il creatore del video mostra come rendere generalizzabile la funzione di perdita e accuratezza in modo che possa essere utilizzata con qualsiasi caricatore di modelli e dati. Dimostrano come accumulare i valori di perdita e accuratezza per batch, ridimensionarli per trovare la perdita/accuratezza media per batch e restituire i risultati in un formato dizionario. Mostrano inoltre come creare una nuova funzione per calcolare i risultati del modello sul set di dati di test, utilizzando le funzioni definite in precedenza. Infine, utilizzano una barra di avanzamento per tenere traccia delle prestazioni del modello sul set di dati di test.
  
  
• 16:25:00 In questa sezione del corso PyTorch per Deep Learning e Machine Learning, l'istruttore illustra come impostare codice indipendente dal dispositivo per addestrare modelli su CPU e GPU. Dimostrano il controllo della disponibilità di CUDA e il passaggio alla GPU per sfruttarne la potenza di elaborazione. L'istruttore consiglia inoltre di iniziare con set di dati e modelli più piccoli prima di aumentare la complessità e le dimensioni. Infine, propongono di creare un nuovo modello per il set di dati e testarne le prestazioni con e senza non linearità durante l'esecuzione sulla GPU.
  
  
• 16:30:00 In questa sezione, l'istruttore introduce il concetto di non linearità nelle reti neurali e incoraggia gli spettatori a sperimentare la creazione di un modello con funzioni non lineari. Vengono discussi i vantaggi della non linearità per la modellazione di dati non lineari e l'istruttore spiega come implementare una rete neurale con livelli sia lineari che non lineari utilizzando PyTorch. Esaminano il codice passo dopo passo e sottolineano l'importanza della sperimentazione per trovare il modello migliore per un determinato set di dati.
  
  
• 16:35:00 In questa sezione, l'istruttore discute la personalizzazione delle reti neurali con funzioni lineari e non lineari e dimostra l'aggiunta di due funzioni di attivazione ReLU a una rete precedentemente definita. Il metodo forward viene quindi sovrascritto per consentire all'input di passare attraverso lo stack di livelli e il modello viene istanziato sul dispositivo. Il video passa quindi alla creazione di una funzione di perdita, di un ottimizzatore e di metriche di valutazione per il nuovo modello, che ha aggiunto livelli non lineari, sottolineando l'importanza di eseguire esperimenti per capire come le diverse funzioni possono influenzare le reti neurali.
  
  
• 16:40:00 In questa sezione, il relatore discute la creazione di funzioni di supporto e il funzionamento dei cicli di addestramento e valutazione in PyTorch. Menzionano l'importazione della funzione di precisione e l'impostazione di una funzione di perdita e dell'ottimizzatore. Il passaggio successivo consiste nel creare cicli di addestramento e valutazione come funzioni in modo che possano essere richiamati ripetutamente senza il rischio di errori. L'oratore illustra il processo di creazione di una funzione del passo del treno, che richiede un modello, un caricatore di dati, una funzione di perdita, un ottimizzatore e, facoltativamente, una funzione di precisione e un dispositivo di destinazione come input. La funzione train step passa attraverso un caricatore di dati, esegue un passaggio in avanti, calcola la perdita, esegue la retropropagazione e aggiorna i parametri del modello con l'ottimizzatore.
  
  
• 16:45:00 In questa sezione, il presentatore spiega come eseguire una fase di addestramento in PyTorch. Iniziano definendo gli input della funzione, inclusi un modello, un caricatore di dati, una funzione di perdita, un ottimizzatore e un dispositivo. Quindi, passano attraverso ogni riga della funzione, iniziando con un ciclo attraverso il caricatore di dati e inserendo i dati sul dispositivo di destinazione. Aggiungono anche una funzione di precisione per accumulare il punteggio di precisione per batch. Infine, al termine della fase di addestramento, calcolano la perdita media e la precisione per lotto e stampano i risultati. Nel complesso, questa sezione fornisce una spiegazione chiara e concisa su come utilizzare PyTorch per il deep learning e il machine learning.
  
  
• 16:50:00 In questa sezione, il trainer funzionalizza il ciclo di test creando una funzione della fase di test che accetta come input un modello, un caricatore di dati, una funzione di perdita, una funzione di precisione e un dispositivo. Il trainer dimostra come impostare un test di perdita e accuratezza e mettere il modello in modalità di valutazione prima di eseguire il ciclo del caricatore di dati ed eseguire un passaggio in avanti. Il trainer spiega anche l'importanza dell'utilizzo del gestore di contesto della modalità di inferenza e della creazione di codice indipendente dal dispositivo. Il test pred viene calcolato passando in X e la perdita e l'accuratezza del test vengono accumulate per batch utilizzando le rispettive funzioni. Infine, il trainer converte i logit di output in etichette di previsione prendendo argmax.
  
  
• 16:55:00 In questa sezione del corso completo di PyTorch, l'istruttore mostra come creare una funzione di test step e un ciclo di ottimizzazione e valutazione utilizzando le funzioni train step e test step. Le nuove funzioni vengono utilizzate per addestrare un modello e valutarne l'accuratezza per tre epoche. L'istruttore mostra anche come misurare il tempo necessario al modello per funzionare sulla GPU rispetto alla CPU.

Parte 18

• 17:00:00 In questa sezione, l'istruttore ci guida attraverso l'impostazione della fase di test per il nostro modello di deep learning e la creazione di un timer per misurare il tempo di addestramento. Il codice è semplice ed efficiente in quanto è progettato per essere riutilizzabile in progetti futuri. Inoltre, eseguiamo il secondo esperimento di modellazione e confrontiamo i risultati con il primo modello, che utilizzava strati non lineari. Sebbene il secondo modello fosse leggermente più veloce in termini di tempo di addestramento, non ha prodotto risultati migliori del precedente, il che significa che i tuoi numeri potrebbero non essere gli stessi dell'istruttore ma dovrebbero essere abbastanza simili nella direzione. Infine, l'istruttore spiega che il nostro modello non è troppo complesso e il nostro set di dati non è molto grande, quindi questo potrebbe spiegare perché i tempi di addestramento della CPU e della GPU non sono molto diversi.
  
  
• 17:05:00 In questa sezione, l'istruttore spiega che a volte un modello si allena più velocemente su una CPU che su una GPU. I due motivi principali di ciò sono che l'overhead per la copia di dati/modello da e verso la GPU supera i vantaggi di calcolo offerti dalla GPU e che l'hardware utilizzato ha una CPU migliore in termini di capacità di calcolo rispetto alla GPU. Tuttavia, l'istruttore osserva che questo è meno comune e, in generale, una GPU moderna è più veloce nel calcolare algoritmi di deep learning rispetto a una CPU generale. Successivamente, l'istruttore condivide una risorsa che parla di come accelerare il deep learning ottimizzando, tra le altre cose, la larghezza di banda e i costi generali. Infine, l'istruttore crea un dizionario dei risultati per il modello uno per confrontare i risultati della modellazione in un secondo momento.
  
  
• 17:10:00 In questa sezione, l'istruttore discute un errore comune che può verificarsi nei modelli di deep learning per quanto riguarda le mancate corrispondenze del dispositivo tra dati e modello. Spiega che l'errore si è verificato perché i dati e il modello si trovavano su dispositivi diversi e suggerisce una soluzione rendendo il codice indipendente dal dispositivo. Avverte inoltre che è sempre meglio creare codice indipendente dal dispositivo. Infine, l'istruttore introduce il prossimo esperimento di modellazione, che prevede la costruzione di una rete neurale convoluzionale (CNN) e spiega l'architettura di una tipica CNN.
  
  
• 17:15:00 In questa sezione, l'istruttore spiega i diversi tipi di strati in una semplice rete neurale convoluzionale (CNN). La CNN inizia con un input, preelaborato in un tensore in rosso, verde e blu per un'immagine. L'input passa quindi attraverso una combinazione di livelli convoluzionali, livelli relu e livelli di pooling. Al modello di deep learning possono essere aggiunti più livelli per trovare più modelli nei dati, con ogni livello che esegue una diversa combinazione di operazioni matematiche sui dati. L'istruttore dimostra la CNN utilizzando il sito Web esplicativo della CNN, in cui l'input di diverse immagini passa attraverso diversi livelli, con l'output finale che è la classe con il valore più alto.
  
  
• 17:20:00 In questa sezione, l'istruttore spiega come funzionano le reti neurali convoluzionali e la bellezza del deep learning. Ogni livello della rete è progettato per apprendere diverse funzionalità dei dati, con la rete stessa che trova il modo migliore per apprendere tali funzionalità. L'istruttore introduce quindi il sito Web esplicativo della CNN come risorsa per saperne di più sulle reti neurali convoluzionali, ma incoraggia anche
  studenti a partecipare alla replica della rete neurale nel codice PyTorch. L'istruttore procede quindi alla costruzione di una minuscola rete neurale convoluzionale VGG in PyTorch e spiega che gli autori di documenti di ricerca possono nominare nuove architetture modello per renderlo più facile per riferimenti futuri. Il codice viene inizializzato con forma di input, unità nascoste e forma di output, che sono parametri tipici nella creazione di un modello PyTorch.
  
  
• 17:25:00 In questa sezione, l'istruttore spiega come creare una rete neurale utilizzando i blocchi in PyTorch, che sono spesso indicati come blocchi convoluzionali. Questi blocchi sono costituiti da più livelli e un'architettura complessiva è composta da più blocchi. L'istruttore mostra come creare blocchi convoluzionali scrivendo due esempi di livelli con iperparametri come canali di ingresso e uscita, dimensioni del kernel, passo e riempimento. L'istruttore fornisce anche risorse interattive per consentire agli studenti di comprendere le basi degli iperparametri e li incoraggia a esaminarli.
  
  
• 17:30:00 In questa sezione, l'istruttore esamina il codice per la creazione di un modello di deep learning utilizzando PyTorch, concentrandosi in particolare sui livelli di blocchi convoluzionali. Il modello acquisisce i dati dell'immagine 2D e i livelli vengono utilizzati per apprendere una rappresentazione compressa dei dati di input, con il pooling massimo utilizzato per acquisire il valore massimo dei dati di input. Il codice viene suddiviso in due blocchi, quindi viene aggiunto un livello di output. Gli input del livello finale vengono appiattiti prima di passare attraverso l'ultimo livello lineare per creare l'output finale.
  
  
• 17:35:00 In questa sezione, l'istruttore costruisce il livello di classificazione per una rete neurale convoluzionale (CNN) chiamata tiny VGG, che ha due livelli che fungono da estrattori di caratteristiche e un livello finale che classifica queste caratteristiche in classi target. L'istruttore codifica il livello del classificatore utilizzando sequenziale e passa in un livello appiattito per appiattire l'output dei due livelli precedenti in un singolo vettore di caratteristiche. Il vettore di feature viene quindi passato a un layer nn.linear, che calcola le feature in base al numero di unità nascoste e le feature out in base alla lunghezza delle classi. Infine, l'istruttore imposta il metodo in avanti e stampa la forma del punto X per tenere traccia dei cambiamenti di forma di ogni livello. L'istruttore stabilisce la forma di input per il modello CNN, che ha un solo canale di colore per le immagini in bianco e nero, imposta il valore delle unità nascoste per ogni livello e termina istanziando il modello.
  
  
• 17:40:00 In questa sezione del video, l'istruttore esamina il codice scritto nella sezione precedente per creare una rete neurale convoluzionale utilizzando PyTorch. Identificano e correggono alcuni errori di battitura nel codice e spiegano che il livello maxpool2d non ha parametri apprendibili. Quindi introducono il livello conv2d e spiegano che il suo tensore del peso e il valore di polarizzazione manipolano l'input per produrre l'output. Mostrano come riprodurre il primo livello del sito Web esplicativo della CNN utilizzando un input fittizio in PyTorch e forniscono un collegamento alla documentazione di PyTorch per ulteriori letture. Dimostrano anche come creare immagini batch utilizzando prima lo stile PyTorch con canali di colore.
  
  
• 17:45:00 In questa sezione, il video tutorial esplora la composizione di un modello PyTorch e il funzionamento pratico delle convoluzioni. L'istruttore spiega come il modello, composto da numeri casuali, regola questi livelli per rappresentare al meglio i dati utilizzando i livelli comp2d. Dopo aver passato alcuni dati casuali attraverso uno di questi livelli, il tutorial approfondisce la dimensione del kernel e come determina l'operazione eseguita dalla convoluzione. L'istruttore elabora lo scopo di uno strato convoluzionale, che è garantire che questo kernel sia in grado di eseguire correttamente l'operazione per fornire il giusto output.
  
  
• 17:50:00 In questa sezione, l'istruttore spiega gli effetti della modifica dei valori di passo e imbottitura in uno strato convoluzionale in PyTorch. Un valore di stride di 1 significa che la convoluzione salta su un pixel alla volta, mentre un valore di stride di 2 salta su due pixel alla volta, determinando una diminuzione della dimensione dell'output. Nel frattempo, l'aggiunta di riempimento ai bordi dell'immagine consente al kernel di operare sulle informazioni dell'immagine ai bordi. L'istruttore osserva inoltre che quando non si è sicuri di quali valori impostare per i diversi parametri, è normale copiare i valori esistenti e regolarli secondo necessità. La sezione si conclude con una dimostrazione di come aggiungere una dimensione batch a un'immagine di prova e passarla attraverso uno strato convoluzionale in PyTorch.
  
  
• 17:55:00 In questa sezione, il video illustra i livelli di pooling convoluzionale e massimo in PyTorch per il deep learning e il machine learning. Il video mostra come utilizzare PyTorch per creare livelli convoluzionali passando un'immagine di prova attraverso un livello convoluzionale per produrre un output. Giocando con i valori di dimensione del kernel, stride e padding, gli utenti possono osservare come cambia la dimensione dell'output. Il video copre anche il livello di pool massimo e mostra come creare un livello di pool massimo di esempio con una dimensione del kernel di due.

Parte 19

• 18:00:00 In questa sezione, l'istruttore dimostra come passare i dati attraverso un livello convoluzionale e un livello di pool massimo in PyTorch. Iniziano passando prima l'immagine di prova attraverso il livello conv e poi stampando la forma. Quindi passano l'output del livello conv attraverso il livello max pool e stampano nuovamente la forma risultante. L'istruttore spiega che il livello massimo del pool prende il massimo di un certo intervallo di tensore interno e riduce la dimensione dell'output del livello convoluzionale. Dimostrano anche come cambieranno le forme se i valori dei layer e dei parametri vengono alterati.
  
  
• 18:05:00 In questa sezione, l'istruttore spiega il concetto di Max Pooling nelle reti neurali convoluzionali (CNN). L'obiettivo è comprimere i dati di input in un vettore di caratteristiche più piccolo che può essere utilizzato per previsioni future. Il pool massimo comporta l'assunzione del valore massimo di una determinata sezione di dati di input per determinare la funzionalità più importante in quella regione. L'istruttore dimostra gli effetti della variazione della dimensione del kernel per il pool massimo e come influisce sullo spazio delle funzionalità. Forniscono anche un esempio visivo utilizzando un tensore casuale più piccolo per mostrare il processo di max pooling. Nel complesso, il max pooling è una tecnica utile per ridurre la dimensionalità dei dati pur mantenendo caratteristiche importanti per le previsioni.
  
  
• 18:10:00 In questa sezione del corso, l'istruttore discute lo scopo del max pool layer in una rete neurale convoluzionale, che consiste nel comprimere le caratteristiche apprese dallo strato convoluzionale in uno spazio più piccolo, portando infine a una rappresentazione compressa dei dati di input che possono essere utilizzati per fare previsioni. L'istruttore sfida anche gli spettatori a creare un tensore fittizio e a farlo passare attraverso la minuscola rete VGG che hanno costruito nei video precedenti per vedere cosa succede alla forma del tensore fittizio mentre si muove attraverso i blocchi convoluzionali. Infine, l'istruttore spiega che lo scopo di replicare un modello da qualche altra parte e passare i dati attraverso di esso è una pratica comune nel deep learning.
  
  
• 18:15:00 In questa sezione, l'istruttore fornisce un esempio di passaggio in avanti in PyTorch e dimostra come gestire gli errori di mancata corrispondenza della forma. Usano un'immagine creata in precedenza dal set di dati Fashion MNIST e creano un tensore della stessa forma dell'immagine. Tuttavia, ricevono un errore dovuto al fatto che il tensore ha una dimensione extra per la dimensione del batch. Per risolvere questo problema, sbloccano il tensore alla dimensione zero per aggiungere la dimensione batch. Garantiscono inoltre che il tensore si trovi sullo stesso dispositivo del modello e dimostrano come risolvere i problemi e trovare le forme necessarie per i diversi livelli del modello. La sezione si conclude con l'istruttore che ricrea il modello utilizzando le informazioni raccolte sulle forme.
  
  
• 18:20:00 In questa sezione del video, l'istruttore mostra un trucco per eseguire il debug delle forme dei livelli in un modello di rete neurale. Passando i dati fittizi attraverso il modello e stampando le forme dell'output su ciascun livello, l'istruttore è in grado di determinare dove si verificano le discrepanze di forma e identificare i problemi con il livello di classificazione. L'istruttore mostra quindi come calcolare manualmente le forme di input e output dei livelli convoluzionali, ma afferma anche i vantaggi dell'utilizzo del codice per eseguire questi calcoli. Infine, l'istruttore utilizza il trucco per assicurarsi che il modello sia compatibile con le regole di moltiplicazione di matrici e per confermare che il modello possa elaborare i dati con la forma desiderata.
  
  
• 18:25:00 In questa sezione, l'istruttore discute le forme di input e output di ogni livello nel modello che ha creato. Passano un tensore casuale attraverso il modello e ottengono una forma di output di uno e dieci, poiché hanno dieci classi nel loro set di dati. Quindi passano alla creazione di una funzione di perdita e di un ottimizzatore per il loro secondo modello e spiegano come addestreranno la loro prima rete neurale convoluzionale (CNN). Importano una funzione di precisione, impostano una funzione di perdita di entropia incrociata e mantengono l'ottimizzatore lo stesso di prima, torch.opt in SGD. Quindi dimostrano come utilizzare le loro funzioni train step e test step per addestrare il modello due, che tratteranno in dettaglio nel prossimo video. Infine, impostano la funzionalità di addestramento e test eseguendo la fase di addestramento con il modello e provando ad apprendere su un caricatore di dati.
  
  
• 18:30:00 In questa sezione, il video si concentra sull'addestramento di una rete neurale convoluzionale e misura il tempo necessario per addestrarlo utilizzando TQDM per misurare i progressi. Impostano la funzione di precisione, la funzione di perdita, l'ottimizzatore, il caricatore dei dati del treno e il caricatore dei dati di prova. Misurano anche l'ora di fine per sapere quanto tempo ha impiegato l'esecuzione del codice. Avevano un problema di codice con una stampa, ma lo hanno risolto e hanno addestrato con successo la loro prima CNN, ottenendo una precisione del test dell'88,5% in circa 42 secondi. Il video consiglia di essere consapevoli del fatto che un modello con prestazioni migliori richiede generalmente più tempo per l'addestramento.
  
  
• 18:35:00 In questa sezione, l'istruttore discute l'importanza di confrontare i risultati e il tempo di addestramento tra diversi modelli negli esperimenti di machine learning. Introducono tre dizionari dei risultati del modello e creano un frame di dati utilizzando i panda per confrontare l'accuratezza, la perdita e il tempo di addestramento di ciascun modello. Scoprono che la rete neurale convoluzionale (Modello 2) ha superato gli altri modelli con una precisione dell'88% e incoraggia gli spettatori a sperimentare diverse architetture di modello, iperparametri e tempi di addestramento per ottenere risultati migliori. L'istruttore sottolinea l'importanza di considerare il compromesso tra prestazioni del modello e velocità nelle applicazioni pratiche.
  
  
• 18:40:00 In questa sezione, l'istruttore discute confrontando i risultati dei tre esperimenti condotti nella sezione precedente utilizzando un data frame e un grafico. Il tempo di addestramento e la precisione vengono confrontati per ciascun modello e l'istruttore nota che il tempo di addestramento varierà a seconda dell'hardware utilizzato. Il modello con le migliori prestazioni è stata la rete neurale convoluzionale, ma ha avuto il tempo di addestramento più lungo. L'istruttore suggerisce di provare a fare previsioni su campioni casuali dal set di dati del test utilizzando il modello con le migliori prestazioni.
  
  
• 18:45:00 In questa sezione, l'istruttore spiega come creare una funzione chiamata "fare previsioni" per valutare un modello di machine learning addestrato. La funzione include un modello di tipo torcia e modulo terminale, alcuni dati e un tipo di dispositivo. L'obiettivo è prelevare campioni casuali dal set di dati di test, fare previsioni su di essi utilizzando il modello e visualizzare le previsioni. La funzione prepara il campione sbloccandolo e passandolo al dispositivo di destinazione. Quindi esegue un passaggio in avanti sul modello per ottenere i logit grezzi e applica la funzione di attivazione softmax per ottenere la probabilità di previsione. Infine, le probabilità di previsione vengono trasformate in etichette di previsione e l'elenco delle probabilità di previsione relative a campioni particolari viene impilato per trasformare l'elenco in un tensore. La sezione termina con una dimostrazione della funzione in azione utilizzando campioni di prova.
  
  
• 18:50:00 In questa sezione, l'istruttore spiega come campionare dati di test in modo casuale e creare etichette di test per valutare le previsioni del modello. I dati di test non sono ancora stati convertiti in un caricatore di dati e il codice campiona nove campioni di dati di test casuali. L'istruttore sottolinea l'importanza di fare previsioni su campioni di dati di test casuali anche dopo aver addestrato il modello per comprenderne le prestazioni. L'istruttore discute anche come convertire le probabilità di previsione in etichette di previsione utilizzando argmax per prendere l'indice del valore più alto nelle probabilità.
  
  
• 18:55:00 In questa sezione, l'istruttore scrive il codice per tracciare le previsioni e le immagini per campioni casuali. Il codice crea una figura Matplotlib con tre righe e tre colonne ed enumera ogni campione nei campioni di prova. Per ogni campione viene creata una sottotrama e viene tracciata l'immagine di destinazione. Anche l'etichetta di previsione e l'etichetta di verità vengono trovate e convertite in forma di testo utilizzando i nomi delle classi e gli indici delle classi pred e delle etichette di test. Infine, viene creato un titolo per la trama e il colore del testo del titolo viene cambiato in verde se l'etichetta di previsione è uguale all'etichetta di verità e in rosso se non sono uguali.

[MetaQuotes]

PyTorch per Deep Learning e Machine Learning – Corso completo (descrizione delle parti 20-22)

PyTorch per Deep Learning e Machine Learning - Corso completo

Parte 20

• 19:00:00 In questa sezione, il relatore discute l'importanza di visualizzare le previsioni del modello di apprendimento automatico e mostra come tracciare le previsioni di una rete neurale convoluzionale (CNN) addestrata su campioni selezionati casualmente da un set di dati di test. Il presentatore dimostra come tracciare le immagini con le loro etichette previste e vere e cambiare il colore del testo del titolo a seconda che la previsione sia corretta o meno. Analizzando le previsioni, il relatore mostra le potenziali confusioni tra le classi di etichette e suggerisce che la visualizzazione delle previsioni può fornire spunti per migliorare le etichette o il modello stesso. Il relatore introduce quindi il concetto di matrice di confusione come un altro modo di valutare le prestazioni del modello confrontando le etichette previste e vere di un ampio insieme di campioni di test.
  
  
• 19:05:00 In questa sezione, l'istruttore discute come valutare un modello di classificazione multiclasse utilizzando la matrice di confusione in PyTorch. La matrice di confusione è una rappresentazione visiva che mostra le prestazioni del modello su diverse classi. L'istruttore spiega come utilizzare le metriche della torcia per le metriche di valutazione e mostra come accedere alle metriche di valutazione della matrice di confusione. Inoltre, ML extend viene utilizzato per tracciare la matrice di confusione. È importante sottolineare che l'istruttore spiega che Google Colab non dispone della versione richiesta di ML extend e che è necessaria la versione 0.19.0 per garantire la corretta installazione del pacchetto. Infine, il video mostra come effettuare previsioni nel set di dati di test e come impostare il modello in modalità di valutazione con la modalità di inferenza della torcia come gestore di contesto.
  
  
• 19:10:00 In questa sezione, l'istruttore dimostra come iterare attraverso il caricatore di dati di test per fare previsioni utilizzando PyTorch. Le previsioni vengono aggiunte a un elenco e quindi concatenate in un tensore utilizzando torch.cat. Il tensore risultante ha una previsione per campione di prova. L'istruttore installa anche le metriche della torcia e mostra come utilizzare un ciclo try and accept per importarlo. Infine, la versione richiesta di ML extend viene verificata utilizzando un'istruzione assert da utilizzare nella funzione di matrice di confusione del grafico.
  
  
• 19:15:00 In questa sezione, l'istruttore spiega come installare e aggiornare i pacchetti in Google Colab utilizzando l'esempio dell'installazione delle metriche della torcia e dell'aggiornamento dell'estensione ML alla versione 0.19.0 o successiva. L'istruttore esamina il codice e spiega come verificare se l'installazione è andata a buon fine e cosa fare se si verificano errori durante il processo, incluso come riavviare il runtime se necessario. Una volta completata l'installazione, l'istruttore passa a spiegare come creare una matrice di confusione con le previsioni effettuate sull'intero set di dati del test nel video precedente.
  
  
• 19:20:00 In questa sezione, l'istruttore spiega come creare e tracciare una matrice di confusione per valutare le prestazioni di un modello di deep learning. Innanzitutto, vengono importate la classe della matrice di confusione dalle metriche della torcia e la funzione della matrice di confusione del grafico da ML extend. Quindi, viene impostata un'istanza di matrice di confusione passando il numero di classi come lunghezza dell'elenco dei nomi delle classi. Il tensore della matrice di confusione viene creato passando le previsioni e gli obiettivi nel set di dati di test. Infine, la matrice di confusione viene tracciata utilizzando la funzione matrice di confusione del grafico passando il tensore della matrice di confusione e l'elenco dei nomi delle classi, creando una diagonale visivamente piacevole che mostra le previsioni corrette e le potenziali aree in cui il modello sta commettendo errori.
  
  
• 19:25:00 In questa sezione, l'istruttore spiega l'importanza dell'utilizzo di una matrice di confusione per valutare visivamente le previsioni di un modello di classificazione, specialmente quando gli errori commessi dal modello sono significativi, come confondere due classi di dati dall'aspetto simile come camicie e cappotti. L'utilizzo di una matrice di confusione è un modo efficace per valutare le prestazioni di un modello e può aiutare a identificare eventuali problemi con le etichette esistenti. Parla anche dell'importanza di salvare e caricare un modello addestrato, soprattutto quando le prestazioni del modello sono soddisfacenti. Salvando il modello in un file, può essere utilizzato altrove o ricaricato per assicurarsi che sia stato salvato correttamente. L'istruttore illustra come creare un percorso di directory del modello e un percorso di salvataggio del modello, quindi mostra come salvare lo stato del modello dict utilizzando il metodo torch.save.
  
  
• 19:30:00 In questa sezione, l'istruttore dimostra come salvare e caricare un modello PyTorch. Viene salvato il dizionario di stato, che rappresenta tutti i parametri appresi del modello dopo che è stato addestrato. Per caricare il modello salvato, viene creata una nuova istanza con gli stessi parametri di quella originale. È importante impostare il modello caricato con gli stessi parametri dell'originale per evitare un errore di mancata corrispondenza della forma. Il modello caricato viene quindi valutato per garantire che produca risultati simili a quelli del modello originale. L'istruttore sottolinea l'importanza di valutare un modello dopo averlo salvato e caricato per assicurarsi che sia stato salvato correttamente.
  
  
• 19:35:00 In questa sezione, vediamo che il modello caricato produce gli stessi risultati del modello addestrato in precedenza prima che fosse salvato, e possiamo usare torch.is_close per verificare a livello di codice se i risultati del modello sono vicini tra loro. Il livello di tolleranza assoluto può essere regolato per garantire che i risultati siano sufficientemente simili e, in caso di discrepanze, si consiglia di controllare se il modello viene salvato correttamente e se sono impostati semi casuali. Viene anche discusso il flusso di lavoro per un problema di visione artificiale, dall'utilizzo di materiali di riferimento e librerie come torchvision alla valutazione del modello e alla sperimentazione di modelli di rete neurale non lineare e convoluzionale per trovare quello migliore.
  
  
• 19:40:00 In questa sezione di "PyTorch for Deep Learning & Machine Learning", l'istruttore incoraggia gli spettatori a mettere in pratica ciò che hanno appreso finora visitando il sito Web learn pytorch.io e completando gli esercizi forniti. Gli esercizi si concentrano sulla pratica del codice e dei concetti trattati nelle sezioni precedenti, e c'è anche un curriculum extra disponibile per coloro che vogliono immergersi più a fondo nella visione artificiale. Inoltre, la sezione copre l'argomento dei set di dati personalizzati di pytorch e offre risorse per ottenere aiuto se necessario, come la documentazione di pytorch e lo stack overflow.
  
  
• 19:45:00 In questa sezione del corso PyTorch, viene discusso come lavorare con set di dati personalizzati, nonché le diverse librerie di domini come visione della torcia, testo della torcia, audio della torcia e registrazione della torcia. Le librerie di domini contengono funzioni di caricamento dei dati per diverse fonti di dati e sono dotate di set di dati integrati come set di dati di visione della torcia per set di dati di visione predefiniti come Fashion MNIST e quelli personalizzati. Ogni libreria di dominio ha anche un modulo "set di dati" che aiuta gli utenti a lavorare con diversi set di dati in diversi domini e, a seconda del dominio in cui si sta lavorando, come visione, testo, audio, raccomandazione, si consiglia di esaminare la sua libreria personalizzata in PyTorch.
  
  
• 19:50:00 In questa sezione, l'istruttore spiega come caricare set di dati personalizzati in PyTorch da utilizzare nella creazione di un modello di visione artificiale. Il modello che costruiranno si chiama food vision mini, che classificherà le immagini di pizza, sushi e bistecche. L'istruttore copre vari passaggi coinvolti nell'addestramento di un modello, come la scelta di una funzione di perdita e di un ottimizzatore, la creazione di un ciclo di addestramento e la valutazione del modello. Spiegano anche come trasformare i dati per l'utilizzo con un modello e confrontare i modelli con e senza aumento dei dati. Infine, mostrano come fare previsioni su dati personalizzati e forniscono una risorsa per accedere al taccuino video nel repository di deep learning PyTorch.
  
  
• 19:55:00 In questa sezione, l'istruttore discute il processo per inserire i propri dati in PyTorch tramite set di dati personalizzati. Sottolineano l'importanza di utilizzare le librerie di dominio per le funzioni di caricamento dei dati e le funzioni di caricamento dei dati personalizzabili e forniscono esempi di queste librerie per varie categorie come visione, testo, audio e raccomandazione. L'istruttore dimostra anche come importare le librerie necessarie e impostare il codice indipendente dal dispositivo per le migliori pratiche con PyTorch. Mostrano come controllare i dispositivi CUDA disponibili e come modificare il tipo di runtime per utilizzare le GPU per un'elaborazione più rapida. Infine, l'istruttore suggerisce di ottenere dati con cui lavorare nel prossimo video.

Parte 21

• 20:00:00 In questa sezione del corso, l'istruttore introduce il set di dati Food 101, che include 101 diverse categorie di alimenti con 101.000 immagini. Tuttavia, per esercitarsi nell'uso di PyTorch, l'istruttore ha creato un sottoinsieme più piccolo di questo set di dati che include tre categorie di alimenti e solo il 10% delle immagini. Questo set di dati più piccolo ha 750 immagini di addestramento, 250 immagini di test e circa 75 immagini di addestramento e 25 immagini di test per classe. Iniziando con questo set di dati più piccolo, l'obiettivo è accelerare la sperimentazione e ridurre il tempo necessario per addestrare i modelli. L'istruttore fornisce un taccuino su come creare questo set di dati personalizzato e incoraggia gli studenti a iniziare in piccolo e aggiornare se necessario.
  
  
• 20:05:00 In questa sezione, l'istruttore spiega il processo di download e preparazione di un set di dati di immagini per PyTorch. Il set di dati include immagini di pizza, bistecche e sushi, archiviate in una cartella denominata dati. L'istruttore utilizza la libreria delle richieste Python per scaricare i dati, quindi li decomprime nella cartella dei dati. Lo scopo di questa sezione è dimostrare come caricare i dati dell'immagine in PyTorch, che possono essere applicati a qualsiasi progetto simile. L'istruttore sottolinea l'importanza di disporre di una directory separata per i dati, che può trovarsi su un computer locale o nel cloud.
  
  
• 20:10:00 In questa sezione, l'istruttore illustra come utilizzare la libreria Python, zipfile, per estrarre dati da un file zip. Usano l'esempio dell'estrazione di un file zip contenente immagini di pizza, bistecca e sushi per un problema di visione artificiale con apprendimento automatico. L'istruttore dimostra come estrarre il contenuto del file zip in un percorso di file specifico utilizzando il metodo zipfile.extractall(). Risolvono anche un errore nel codice derivante dalla copia dell'indirizzo di collegamento errato da GitHub, sottolineando l'importanza di garantire che venga utilizzato il collegamento corretto per scaricare i set di dati. Nel complesso, il processo mostrato può essere utilizzato per scaricare ed estrarre qualsiasi set di dati personalizzato da utilizzare in PyTorch. Il prossimo video esplorerà ulteriormente i dati.
  
  
• 20:15:00 In questa sezione, l'istruttore discute l'importanza di diventare tutt'uno con i dati attraverso la preparazione e l'esplorazione dei dati. Condivide una citazione inventata dalla funzione di perdita di Abraham, sottolineando la necessità di dedicare molto tempo alla preparazione del set di dati. L'istruttore passa quindi attraverso ciascuna directory dei dati di esempio scaricati, che si trova in un formato di classificazione delle immagini standard. Utilizza la funzione OS dot walk per generare un albero di directory per ciascuna directory, visualizzando informazioni sulle directory e le immagini presenti in ciascuna di esse. Infine, l'istruttore imposta le parti di addestramento e test e dimostra la loro configurazione standard di classificazione delle immagini.
  
  
• 20:20:00 In questa sezione, l'istruttore spiega la struttura dei dati di classificazione delle immagini standard in cui una cartella complessiva del set di dati contiene cartelle di addestramento e test con sottodirectory denominate classi che contengono le rispettive immagini. L'istruttore osserva che esistono modalità standardizzate di memorizzazione di tipi specifici di dati come riferimento per i formati dei dati. Per preparare i dati immagine da utilizzare con PyTorch, viene scritto il codice per convertire i dati in tensori. L'istruttore evidenzia il formato dei dati necessario per classificare le immagini di cani e gatti, dove le directory delle immagini di addestramento e test contengono le rispettive cartelle di classe. L'istruttore menziona anche i piani per visualizzare un'immagine e un codice per ottenere ciò che comporta l'ottenimento di tutti i percorsi dell'immagine, la scelta di un percorso dell'immagine casuale, l'ottenimento del nome della classe dell'immagine utilizzando il modulo Pathlib.
  
  
• 20:25:00 In questa sezione, l'istruttore spiega come aprire e manipolare le immagini utilizzando la libreria di immagini Python chiamata Pillow. Innanzitutto, generano un elenco di tutti i percorsi delle immagini all'interno di una cartella specifica e utilizzano la libreria casuale di Python per selezionare casualmente un'immagine da questo elenco. Quindi aprono e visualizzano l'immagine mentre ne estraggono anche i metadati. Inoltre, l'istruttore fornisce una panoramica delle funzionalità della libreria Torch Vision, inclusi i metodi per il caricamento e l'elaborazione delle immagini.
  
  
• 20:30:00 In questa sezione, l'istruttore dimostra come lavorare con le immagini utilizzando la libreria PIL e come aprire e analizzare i metadati delle immagini. La classe dell'immagine è il nome della directory in cui sono archiviati i dati dell'immagine e i metadati vengono ottenuti utilizzando la funzione Print. L'istruttore mostra quindi alcune immagini di cibo casuali dal set di dati, tra cui pizza, sushi e bistecca, e spiega l'importanza di visualizzare le immagini in modo casuale per acquisire familiarità con il set di dati. L'istruttore offre una piccola sfida per gli spettatori, ovvero visualizzare un'immagine utilizzando Matplotlib per la sezione successiva.
  
  
• 20:35:00 In questa sezione, l'istruttore mostra come tracciare immagini e dati con matplotlib e trasformare le immagini in array utilizzando il metodo NumPy NP. Viene sottolineata l'importanza di comprendere la forma dei dati per evitare problemi di mancata corrispondenza della forma. Il formato predefinito per la libreria di pillole e matplotlib è l'ultimo formato dei canali di colore, ma PyTorch utilizza per impostazione predefinita il primo formato dei canali di colore. L'istruttore mostra anche come visualizzare immagini diverse e acquisire familiarità con i dati e come trasformare i dati convertendoli in tensori PyTorch da utilizzare con PyTorch.
  
  
• 20:40:00 In questa sezione, l'istruttore discute il processo di trasformazione dei dati target in tensori PyTorch e la creazione di set di dati PyTorch e caricatori di dati. Utilizzando la documentazione PyTorch, l'istruttore mostra come creare set di dati con il modulo cartella immagini e introduce il parametro transform che consente l'applicazione di trasformazioni specifiche sui dati. L'istruttore mostra quindi come creare una trasformazione per i dati dell'immagine che ridimensiona le immagini a 64x64 e le capovolge in modo casuale sul piano orizzontale per aumentare artificialmente la diversità del set di dati. Questo viene fatto usando il metodo transforms.compose che accetta un elenco di trasformazioni come argomento.
  
  
• 20:45:00 In questa sezione, l'istruttore spiega come trasformare un'immagine in un tensore della torcia utilizzando il modulo di trasformazione in PyTorch. Questo viene fatto con la funzione "transforms.ToTensor()", che converte un'immagine PIL o un array NumPy da un'altezza con canali di colore nell'intervallo da 0 a 255 in un tensore di torcia galleggiante di forma canali di colore larghezza altezza nell'intervallo da 0 a 1. L'istruttore suggerisce di provare a passare i dati attraverso questa trasformazione e mostra come modificare la forma dell'immagine utilizzando la funzione "transforms.Resize()". La sezione si conclude con una discussione delle varie trasformazioni disponibili nella libreria torchvision, comprese le trasformazioni di aumento dei dati, e un'anteprima del codice di visualizzazione in arrivo per esplorare le immagini trasformate.
  
  
• 20:50:00 In questa sezione, l'istruttore dimostra come campionare in modo casuale le immagini da un percorso, caricarle e trasformarle, quindi confrontare le versioni originali e trasformate utilizzando PyTorch. Il codice usa la funzione seme casuale per impostare il seme per la funzione casuale e campiona casualmente k immagini dall'elenco dei percorsi immagine. L'istruttore utilizza quindi la libreria matplotlib per creare una sottotrama con una riga e n colonne per tracciare le immagini originali e trasformate fianco a fianco. L'immagine trasformata deve avere la sua forma modificata per adattarsi al formato preferito dei canali di colore della libreria matplotlib per ultimo. Infine, il codice imposta il titolo delle immagini originali e trasformate e imposta il super titolo al nome della classe dell'immagine.
  
  
• 20:55:00 In questa sezione del video, l'istruttore dimostra come utilizzare le trasformazioni per manipolare i dati delle immagini per i modelli di deep learning utilizzando PyTorch. L'istruttore imposta la trasformazione in modo che sia uguale alla trasformazione dei dati, il che significa che l'immagine verrà ridimensionata, capovolta orizzontalmente in modo casuale e convertita in un tensore. Mostrano anche come utilizzare la funzione permuta per riorganizzare la forma dei dati scambiando l'ordine degli assi. Le immagini vengono quindi tracciate per mostrare le versioni originale e trasformata fianco a fianco, con le immagini trasformate in formato tensoriale, ideale per l'uso con modelli di deep learning. L'istruttore avvisa che la dimensione dell'immagine è un iperparametro che può essere regolato e incoraggia gli spettatori a esplorare l'ampia gamma di trasformazioni disponibili in PyTorch.

Parte 22

• 21:00:00 In questa sezione, l'istruttore spiega come caricare i dati immagine utilizzando l'opzione cartella immagini. Usano il modulo dei set di dati della visione della torcia per mostrare come caricare i dati nel formato generico di classificazione delle immagini. Viene dimostrata la funzione dei set di dati predefiniti, la cartella delle immagini, che può quindi essere utilizzata per caricare tutte le immagini personalizzate in tensori con l'aiuto delle trasformazioni. L'istruttore mostra quindi come trasformare il set di dati di addestramento e creare un set di dati di test, anch'esso trasformato nello stesso modo del set di dati di addestramento. Infine, stampano i set di dati creati.
  
  
• 21:05:00 In questa sezione, l'istruttore spiega come utilizzare la funzione di cartella delle immagini in PyTorch per caricare le immagini in tensori e trasformarle utilizzando una pipeline, che può quindi essere utilizzata con un modello PyTorch. Dimostrano come accedere e utilizzare vari attributi forniti con il caricatore di dati predefinito, come ottenere i nomi delle classi come elenco o dizionario e controllare la lunghezza del set di dati. Inoltre, mostrano come visualizzare campioni ed etichette dal set di dati di addestramento utilizzando l'indicizzazione.
  
  
• 21:10:00 In questa sezione del corso, l'istruttore dimostra come convertire un set di dati immagine in formato tensoriale, che è il formato dati predefinito per PyTorch. Usano un esempio di un'immagine di pizza e mostrano come ottenere l'etichetta associata e convertirla in formato numerico. Quindi stampano alcune informazioni importanti sui dati del tensore, come il tipo e la forma dei dati, che saranno utili per la risoluzione dei problemi in seguito. Infine, tracciano l'immagine usando matplotlib e impostano il titolo sul nome della classe, che in questo caso è pizza. Incoraggiano gli studenti a provarlo con immagini diverse ed esplorare diverse trasformazioni.
  
  
• 21:15:00 In questa sezione del video, l'istruttore discute il processo di conversione delle immagini caricate in caricatori di dati in PyTorch. Un caricatore di dati può aiutare a trasformare i set di dati in iterabili, consentendo agli utenti di personalizzare le dimensioni del batch e visualizzare un numero specifico di immagini alla volta. Questo è importante perché se tutte le immagini sono state caricate contemporaneamente, c'è il rischio di esaurire la memoria. Pertanto, la suddivisione in batch delle immagini aiuta a sfruttare tutta la memoria disponibile. L'istruttore prosegue fornendo una guida passo passo per creare un caricatore di dati del treno e introduce anche il concetto del numero di parametri di lavoro, che decide quanti core della CPU vengono utilizzati per caricare i dati.
  
  
• 21:20:00 In questa sezione, l'istruttore discute come creare e personalizzare caricatori di dati per l'addestramento e il test dei dati in PyTorch. Mostra come inizializzare i set di dati e personalizzare gli iperparametri per i caricatori di dati, come la dimensione del batch e il numero di lavoratori. L'istruttore mostra anche come scorrere i caricatori e ottenere informazioni sulla forma delle immagini e delle etichette. La sezione si conclude con un riepilogo del processo di caricamento e una raccomandazione per costruire una rete neurale convoluzionale per identificare i modelli nei tensori dell'immagine.
  
  
• 21:25:00 In questa sezione, l'istruttore discute il processo di creazione di una classe di caricamento dei dati personalizzata per caricare i dati dell'immagine nel formato Tensor. L'obiettivo è replicare la funzionalità della cartella immagini tramite questa classe personalizzata, poiché è una buona pratica e potrebbe essere necessaria nei casi in cui non esiste una funzione predefinita. L'istruttore elenca i passaggi necessari alla classe personalizzata per caricare le immagini, ottenere i nomi delle classi come elenco e ottenere le classi come dizionario dal set di dati. Vengono discussi anche i pro ei contro della creazione di un set di dati personalizzato, inclusa la flessibilità di creare un set di dati da quasi tutto, ma anche il potenziale di errori e problemi di prestazioni. L'istruttore quindi importa i moduli necessari per creare la classe personalizzata, incluso il sistema operativo e il percorso lib per lavorare con il file system.
  
  
• 21:30:00 In questa sezione, stiamo imparando come creare un set di dati personalizzato in PyTorch e ci concentriamo sulla scrittura di una funzione per ottenere i nomi delle classi dalla directory di destinazione. Il set di dati personalizzato verrà utilizzato per caricare le immagini da un file, ottenere i nomi delle classi dal set di dati e ottenere le classi come dizionario dal set di dati. La funzione utilizzerà lo scanner del sistema operativo per attraversare la directory di destinazione e ottenere i nomi delle classi e genererà un errore se i nomi delle classi non vengono trovati, indicando un problema con la struttura della directory. Successivamente creeremo una sottoclasse di torch.utils.data.Dataset per creare un set di dati personalizzato.
  
  
• 21:35:00 In questa sezione del video, l'istruttore dimostra come creare una funzione chiamata "find_classes" che accetta una directory come stringa e restituisce un elenco di nomi di classe e un dizionario che associa i nomi di classe a numeri interi. La funzione utilizza lo scanner del sistema operativo per eseguire la scansione della directory di destinazione e ottenere i nomi delle classi. L'istruttore mostra anche come generare un errore se non è possibile trovare i nomi delle classi. La funzione può essere utilizzata per qualsiasi directory specificata e replica la funzionalità eseguita in precedenza per la directory di addestramento.
  
  
• 21:40:00 In questa sezione del video, l'istruttore spiega come creare un set di dati personalizzato creando sottoclassi torch.utils.data.dataset. Il set di dati dovrebbe rappresentare una mappa dalle chiavi ai campioni di dati, dove le chiavi si riferiscono a obiettivi o etichette, e i campioni di dati in questo caso sono immagini di cibo. La sottoclasse dovrebbe sovrascrivere il metodo get item, che recupera un campione di dati per una data chiave e facoltativamente sovrascrivere il metodo len per restituire la dimensione del set di dati. L'istruttore illustra i passaggi per creare il set di dati personalizzato e spiega come utilizzare la funzione helper che abbiamo creato nella sezione precedente per mappare i nomi delle classi ai numeri interi.
  
  
• 21:45:00 In questa sezione, l'istruttore spiega come creare un set di dati personalizzato in PyTorch. Per fare ciò, dobbiamo creare una sottoclasse della classe torch.utils.data.Dataset e inizializzare il nostro set di dati personalizzato passando la directory di destinazione (dove risiedono i dati) e la trasformazione (per eseguire qualsiasi trasformazione dei dati). Inoltre, dobbiamo creare diversi attributi come percorsi, trasformazioni, classi e classi per l'ID X. Inoltre, dobbiamo creare una funzione per caricare immagini, sovrascrivere il metodo LAN per restituire la lunghezza del nostro set di dati e get item metodo per restituire un dato campione quando viene passato un indice. Infine, scriviamo un set di dati personalizzato implementando pathlib e passando le directory di destinazione come le directory test o train.
  
  
• 21:50:00 In questa sezione, l'istruttore spiega i diversi passaggi coinvolti nella creazione di una classe di set di dati PyTorch personalizzata. Il primo passaggio consiste nell'ottenere tutti i percorsi dell'immagine che seguono la convenzione del nome file corretta. Il passaggio successivo consiste nel creare un set di trasformazioni dell'immagine, che possono essere facoltative. Viene creata anche una funzione per caricare le immagini, che accetta un indice e restituisce un'immagine. L'istruttore mostra quindi come eseguire l'override del metodo "len" per restituire il numero totale di campioni nel set di dati, che è facoltativo. Infine, il metodo "get item" viene sovrascritto in modo che restituisca un particolare campione se passato un indice.
  
  
• 21:55:00 In questa sezione impareremo a sottoclassare torch.utils.data.Dataset per personalizzare il modo in cui i dati vengono caricati in PyTorch. La classe viene inizializzata con una directory radice e un dizionario che mappa i nomi delle classi agli indici. Il metodo __len__ restituisce la lunghezza del set di dati mentre __getitem__ consente l'indicizzazione nel set di dati per restituire una tupla di un'immagine del tensore della torcia e l'etichetta intera corrispondente. La classe ha anche un parametro transform facoltativo per applicare le trasformazioni all'immagine prima di restituire la tupla. I vantaggi della sottoclasse torch.utils.data.Dataset sono le capacità di personalizzazione che offre, ma richiede la scrittura di quantità significative di codice che possono essere soggette a errori.

[MetaQuotes]

PyTorch per Deep Learning e Machine Learning – Corso completo (descrizione delle parti 23-26)

PyTorch per Deep Learning e Machine Learning - Corso completo

Parte 23

• 22:00:00 In questa sezione, l'istruttore mostra come creare un set di dati personalizzato in PyTorch utilizzando il modulo Torchvision. Creano una trasformazione per convertire le immagini JPEG grezze in tensori e impostano il treno e testano la composizione delle trasformazioni. Quindi testano la classe della cartella di immagini personalizzata e vedono se funziona sul proprio set di dati personalizzato. Controllano gli attributi di lunghezza e classe per assicurarsi che funzioni correttamente. Infine, ispezionano i dati del treno personalizzati e testano i dati personalizzati per verificare che tutto funzioni come previsto.
  
  
• 22:05:00 In questa sezione del corso completo PyTorch per Deep Learning e Machine Learning, l'istruttore mostra come verificare l'uguaglianza tra il set di dati della cartella di immagini originale e il set di dati personalizzato che ha creato nella sezione precedente confrontando la classe con l'ID X di entrambi i set di dati. Afferma che possiamo replicare la funzionalità principale della classe del set di dati della cartella di immagini creando la nostra funzione di caricamento del set di dati personalizzata, e i risultati di ciò sono che PyTorch fornisce una classe del set di dati di base da cui ereditare e fintanto che sovrascriviamo la terra e ottenere i metodi degli elementi e restituire una sorta di valori, possiamo creare la nostra funzione di caricamento del set di dati. L'istruttore procede spiegando come creare una funzione per visualizzare immagini casuali dalla classe personalizzata di dati addestrati per visualizzare i nostri dati.
  
  
• 22:10:00 In questa sezione, l'istruttore illustra i passaggi per la creazione di una funzione chiamata "visualizza immagini casuali" che accetta un "set di dati", "classi" e "n" come parametri. La funzione visualizza n numero di immagini selezionate casualmente dal set di dati e ne stampa la forma se "visualizza forma" è impostato su vero. L'istruttore esamina anche i dettagli dell'implementazione come la regolazione del display se n è maggiore di 10 e l'impostazione del seme casuale per la riproducibilità. Inoltre, la funzione scorre le immagini o gli indici di esempio casuali e li traccia con Matplotlib.
  
  
• 22:15:00 In questa sezione, l'istruttore continua a costruire il proprio modello di deep learning in PyTorch impostando la trama e assicurandosi che le dimensioni delle proprie immagini siano allineate con matplotlib. Regolano le dimensioni del loro tensore per la stampa, aggiungono una sottotrama alla loro trama matplotlib e regolano il titolo della trama in base alla variabile delle classi, un elenco di classi. Quindi creano una funzione per visualizzare immagini casuali dalla cartella delle immagini, sia per la cartella delle immagini pytorch integrata che per il set di dati personalizzato creato dall'istruttore. Infine, regolano il seme e tracciano le immagini per vedere come ha senso il loro codice per regolare la trama.
  
  
• 22:20:00 In questa sezione della trascrizione, l'istruttore mostra come trasformare un set di dati di immagini caricate personalizzate in caricatori di dati, che è un passaggio necessario per raggruppare le immagini e utilizzarle con un modello. Utilizzando torchvision.datasets.ImageFolder e torchvision.transforms, il set di dati personalizzato viene trasformato in un formato tensore. Il passaggio successivo consiste nel trasformare il set di dati in un caricatore di dati utilizzando torch.utils.data.DataLoader. L'istruttore imposta la dimensione del batch su 32 e il numero di worker su 0 sia per Train Data Loader Custom che per Test Data Loader Custom. La differenza tra loro è che i dati del treno verranno mescolati mentre i dati del test non verranno mescolati.
  
  
• 22:25:00 In questa sezione, il video illustra i caricatori di dati personalizzati e la trasformazione dei dati in PyTorch. L'istruttore azzera prima il conteggio della CPU OOS e imposta i lavoratori intorpiditi su zero per garantire che la formazione si svolga senza intoppi. Dopo aver impostato il caricatore di dati personalizzato, utilizza la funzione di stampa per verificare la forma dell'immagine e le dimensioni del batch, impostate su 32 dalla trasformazione precedentemente impostata. L'istruttore spiega anche come l'aumento dei dati può aumentare artificialmente la diversità del set di dati di addestramento e dimostra i vari modi in cui i dati possono essere trasformati utilizzando il modulo di trasformazione della visione della torcia, tra cui ridimensionamento, ritaglio centrale, scala di grigi, trasformazioni casuali e aumento casuale .
  
  
• 22:30:00 ha appreso dell'aumento dei dati, che è il processo di aggiunta artificiale di diversità ai dati di addestramento applicando varie trasformazioni di immagini. Questo aiuta a rendere il modello più generalizzabile ai dati invisibili. Esistono molti tipi diversi di aumento dei dati come ritaglio, sostituzione, taglio e altro. PyTorch ha un pacchetto di visione della torcia che include primitive o funzioni che possono aiutare ad addestrare i modelli a funzionare bene. Utilizzando l'aumento dei dati e altri miglioramenti, PyTorch è stato in grado di addestrare modelli all'avanguardia con elevata precisione, come il modello ResNet 50.
  
  
• 22:35:00 In questa sezione, l'istruttore discute i modi per migliorare l'accuratezza del modello, come l'ottimizzazione del tasso di apprendimento, l'addestramento più a lungo e l'utilizzo di diverse tecniche di aumento. L'istruttore si concentra sulla banale tecnica di aumento, che sfrutta il potere della casualità per cambiare le immagini in vari modi utilizzando un numero di bin di grandezza. L'istruttore dimostra come implementare banali aumenti utilizzando la libreria di trasformazioni visive della torcia PyTorch e fornisce un collegamento al documento per coloro che sono interessati a saperne di più. Inoltre, l'istruttore consiglia di provare diverse tecniche ed esperimenti di aumento per vedere cosa funziona meglio per i singoli problemi. Infine, l'istruttore mostra come testare la pipeline di aumento ottenendo tutti i percorsi delle immagini e globbando tutti i file e le cartelle che corrispondono a uno schema specifico.
  
  
• 22:40:00 In questa sezione, il video dimostra l'uso del banale aumento, una tecnica di aumento dei dati, nella trasformazione delle immagini per aggiungere artificialmente diversità a un set di dati di addestramento. Il potere della casualità viene sfruttato selezionando tra diversi tipi di aumento e applicandoli con diversi livelli di intensità. Questa sezione mostra come l'aumento banale viene applicato a immagini trasformate in modo casuale e i risultati vengono visualizzati. L'obiettivo è consentire al modello di apprendimento automatico di apprendere i modelli delle immagini manipolate ed essere in grado di identificarle di conseguenza. La sezione successiva si concentra sulla costruzione del primo modello di visione artificiale senza aumento dei dati utilizzando la minuscola architettura VGG.
  
  
• 22:45:00 In questa sezione, il relatore passa attraverso il processo di creazione delle trasformazioni e caricamento dei dati per un modello PyTorch. L'obiettivo è caricare le immagini dalla cartella dei dati, in questo caso pizza, bistecca e sushi, e trasformarle in tensori. Le trasformazioni includono il ridimensionamento delle immagini a 64x64 e la loro conversione in tensori in modo che i valori siano compresi tra 0 e 1. Il presentatore spiega anche come creare caricatori di dati e regolare la dimensione del batch e il numero di core della CPU dedicati al caricamento dei dati. La dimensione del batch utilizzata in questo esempio è 32.
  
  
• 22:50:00 In questa sezione, l'istruttore spiega come caricare e trasformare i dati utilizzando DataLoader di PyTorch. Il processo prevede la creazione di una trasformazione e quindi il caricamento e la trasformazione dei dati contemporaneamente utilizzando la funzione DataLoader. L'istruttore fornisce anche un semplice codice per costruire da zero l'architettura Tiny VGG, che include la creazione del primo blocco COM costituito da livelli come COM, ReLU, MaxPool e ComToD. Il modello viene inizializzato con la forma di input, le unità nascoste e i parametri della forma di output. L'istruttore incoraggia gli studenti a sperimentare valori diversi per gli iperparametri come la dimensione del kernel e il passo.
  
  
• 22:55:00 In questa sezione, vediamo la creazione di una rete neurale convoluzionale utilizzando PyTorch. Iniziamo definendo i blocchi convoluzionali e i livelli massimi di pooling per la rete. Quindi, replichiamo lo stesso blocco per crearne un altro e cambiamo la forma di input in modo che corrisponda alla forma di output. Successivamente, creiamo un livello di classificazione per trasformare l'output dei blocchi convoluzionali in un vettore di caratteristiche e passarlo attraverso un livello lineare per produrre dieci classi. Infine, sovrascriviamo il metodo forward per passare i dati attraverso i blocchi convoluzionali e stamparne la forma ad ogni passaggio. Il metodo forward potrebbe anche essere riscritto per includere la fusione degli operatori, che accelera il calcolo della GPU.

Parte 24

• 23:00:00 In questa sezione, l'istruttore discute il concetto di fusione degli operatori, che è l'ottimizzazione più importante nei compilatori di deep learning. Creano anche un modello utilizzando la minuscola architettura VGG per le immagini a colori RGB e ne controllano le forme di input e output. L'istruttore sottolinea l'importanza di utilizzare la fusione degli operatori per accelerare il calcolo di grandi reti neurali evitando il trasporto tra memoria e calcolo. Suggeriscono inoltre di passare dati fittizi attraverso il modello per risolverlo e assicurarsi che il metodo di inoltro funzioni correttamente. Infine, viene visualizzato un messaggio di errore quando si tenta di passare il batch di immagini al modello a causa di una mancata corrispondenza nei tipi di input.
  
  
• 23:05:00 In questa sezione, l'istruttore sta risolvendo un errore di forma per il modello. Spiegano che le regole di moltiplicazione delle matrici devono essere soddisfatte quando si passano tensori attraverso strati lineari. L'istruttore esamina le forme della matrice e determina che 10, che rappresenta il numero di unità nascoste, sta causando un problema se moltiplicato per 2560. Usano la forma di output del livello precedente per determinare che 10 deve essere moltiplicato per 16x16 per ottenere 2560. Dopo aver corretto questo e verificando che le forme del modello siano allineate con l'output dell'esplicatore della CNN, passano a un'ulteriore risoluzione dei problemi e alla fine scoprono che la rimozione del riempimento dagli strati convoluzionali allineerà le forme con l'output dell'esplicatore della CNN.
  
  
• 23:10:00 In questa sezione, l'istruttore introduce Torch Info, un pacchetto che consente agli utenti di stampare un riepilogo dei loro modelli PyTorch. Innanzitutto, l'istruttore commenta le dichiarazioni di stampa dal metodo forward e installa Torch Info in Google CoLab utilizzando il comando pip install. L'istruttore quindi importa il riepilogo da Torch Info e lo utilizza per passare il modello e una dimensione di input per ottenere le forme dei dati che scorrono attraverso il modello. L'istruttore mostra come Torch Info stampa un riepilogo del modello, inclusi i livelli e le forme corrispondenti.
  
  
• 23:15:00 In questa sezione, il relatore discute il pacchetto informazioni torcia, che viene utilizzato per dare un'idea delle forme di input e output di ogni strato in un modello PyTorch. Spiegano che il pacchetto fornisce anche informazioni sul numero di parametri in ogni livello, che possono essere utili per determinare le dimensioni del modello e i vincoli di archiviazione per le applicazioni future. Il relatore osserva che man mano che un modello diventa più grande e ha più livelli, avrà più parametri, con conseguente dimensione di input maggiore e dimensione totale stimata. Nella sezione successiva, il relatore passa all'addestramento di un set di dati personalizzato e crea due funzioni, fase di addestramento e fase di test, che sono generiche e possono essere utilizzate con quasi tutti i caricatori di modelli e dati. La funzione train step accetta un modello, un caricatore di dati, una funzione di perdita e un ottimizzatore e mette il modello in modalità train durante l'impostazione delle metriche di valutazione.
  
  
• 23:20:00 In questa sezione, il relatore discute l'impostazione dei valori di train loss e train precision per una funzione train loop in PyTorch. I dati vengono trasmessi in loop utilizzando il caricatore di dati e, per ogni batch, viene eseguito il passaggio in avanti per fare previsioni e calcolare la perdita. L'ottimizzatore viene quindi utilizzato per eseguire la backpropagation e fare un passo. Una volta completato il giro del treno, la precisione viene calcolata ottenendo la classe prevista e confrontandola con le etichette corrette. Questa operazione viene eseguita al di fuori del ciclo batch, in cui la perdita di treno e la precisione del treno vengono regolate per ottenere la media per epoca in tutti i batch. L'oratore quindi sfida gli spettatori a scrivere una funzione di ciclo di prova.
  
  
• 23:25:00 In questa sezione, l'istruttore passa attraverso il processo di creazione di una fase di test per valutare le prestazioni di un modello di deep learning PyTorch su un set di dati. Il passaggio prevede l'impostazione del modello in modalità di valutazione, il ciclo dei batch del set di dati, l'invio dei dati al dispositivo di destinazione, l'esecuzione di un passaggio in avanti, il calcolo della perdita e dell'accuratezza per batch, l'accumulo della perdita e dell'accuratezza e la regolazione delle metriche per ottenere i valori medi. L'istruttore suggerisce quindi di creare una funzione di addestramento per rendere funzionale il processo di addestramento del modello, che verrà trattato nella sezione successiva.
  
  
• 23:30:00 In questa sezione, l'istruttore illustra il processo di creazione di una funzione train che combini le funzioni train step e test step. L'idea è creare una funzione per chiamare entrambe queste funzioni per addestrare e valutare un modello con una sola chiamata di funzione. La funzione train accetta una gamma di parametri del modello, tra cui ottimizzatore, caricatori di dati, funzione di perdita e altri. L'istruttore crea quindi un dizionario vuoto per tenere traccia delle prestazioni del modello durante l'addestramento, inclusi l'addestramento e la perdita e la precisione del test. Quindi passano in rassegna le epoche, chiamando TQDM per ottenere una barra di avanzamento mentre il modello è in fase di addestramento. La funzione train è uno strumento utile per non dover riscrivere il codice quando si addestrano più modelli e si sfrutta il codice esistente.
  
  
• 23:35:00 In questa sezione, l'istruttore spiega la funzione train che tiene traccia dell'addestramento e del test utilizzando rispettivamente le funzioni train e test step. La funzione verrà eseguita per un numero specificato di epoche e, per ogni epoca, stamperà il treno e verificherà la perdita e l'accuratezza utilizzando un'istruzione di stampa di fantasia. I risultati verranno memorizzati nel dizionario dei risultati per essere successivamente utilizzati per l'analisi. La funzione train sfrutterà la funzione train step e la funzione test step per aggiornare il modello e testarlo rispettivamente. La funzione restituirà i risultati dell'epoca.
  
  
• 23:40:00 In questa sezione, l'istruttore esamina i progressi compiuti nel flusso di lavoro PyTorch, che include la preparazione dei dati, la creazione e la selezione di un modello, la creazione di un ciclo di addestramento e ora la sfida per creare una funzione di perdita e un ottimizzatore. Passando alla sezione 7.7, l'istruttore illustra come addestrare e valutare il modello zero, il modello di base, sul proprio set di dati personalizzato. Impostano i semi casuali per la riproducibilità, istanziano il minuscolo modello VGG con una forma di input di tre per le immagini a colori, impostano il numero di unità nascoste e la forma di output in modo che corrisponda al numero di classi nel loro set di dati di addestramento. Selezionano anche la funzione di perdita di entropia incrociata per la classificazione multiclasse e provano l'ottimizzatore Adam con un tasso di apprendimento di 0,001.
  
  
• 23:45:00 In questa sezione, l'istruttore mostra come cronometrare il processo di formazione di un modello di deep learning. Prima importano la classe timer predefinita da time, quindi avviano il timer prima di addestrare il modello zero utilizzando la funzione train da un video precedente. Quindi impostano i dati del treno per addestrare il caricatore di dati semplice ei dati di test per testare il caricatore di dati semplice, nonché l'ottimizzatore su FriendlyAtomOptimizer e la funzione di perdita sulla perdita di entropia n incrociata. Il modello viene addestrato per cinque epoche e il timer termina per visualizzare il tempo totale di addestramento. L'istruttore mostra quindi i risultati di accuratezza del modello sui set di addestramento e test, che sono rispettivamente di circa il 40% e il 50%. Suggeriscono di provare diversi metodi per migliorare il modello, come l'aggiunta di più livelli o unità nascoste, l'adattamento più lungo, la modifica delle funzioni di attivazione e la regolazione del tasso di apprendimento.
  
  
• 23:50:00 In questa sezione, l'istruttore spiega come tracciare le curve di perdita per tracciare l'andamento del modello nel tempo. Una curva di perdita è un modo per tenere traccia dei progressi di un modello nel tempo visualizzando il valore di perdita a sinistra e i passaggi sull'asse inferiore. Tracciando il treno e testando i valori di perdita e accuratezza del nostro dizionario dei risultati utilizzando matplotlib, possiamo vedere come si sta comportando il nostro modello e valutarlo. L'istruttore scrive una funzione chiamata "def plot loss curves" che accetta un dizionario dei risultati contenente i valori di perdita e precisione come una stringa e un elenco di float.
  
  
• 23:55:00 In questa sezione, l'istruttore mostra come creare curve di perdita sia per i dati di addestramento che di test utilizzando le epoche come metrica del tempo. La trama è composta da due sottotrame, una per la perdita e un'altra per la precisione, con etichette e titoli per ciascuna di esse. La tendenza ideale per una curva di perdita è che la perdita diminuisca nel tempo e la precisione aumenti. L'istruttore incoraggia lo spettatore a sperimentare epoche aggiuntive per vedere se la perdita raggiunge il valore ottimale. Il prossimo video coprirà diverse forme di curve di perdita e l'istruttore consiglia una guida sull'interpretazione delle curve di perdita.

Parte 25

• 24:00:00 In questa sezione del corso PyTorch per Deep Learning e Machine Learning, l'istruttore discute le curve di perdita e la loro importanza nella valutazione delle prestazioni di un modello nel tempo. Una curva di perdita dovrebbe mostrare una tendenza alla diminuzione della perdita nel tempo e all'aumento della precisione. Esistono diverse forme di curve di perdita e una curva di perdita ideale mostra che la perdita di allenamento e di test diminuisce a un ritmo simile. L'underfitting si verifica quando la perdita del modello potrebbe essere inferiore, mentre l'overfitting si verifica quando il modello apprende troppo bene i dati di addestramento, portando a una perdita di addestramento inferiore rispetto alla perdita di test. L'istruttore fornisce curriculum extra dalla guida alla curva di perdita di Google e discute i metodi per affrontare l'overfitting, come le tecniche di regolarizzazione e la riduzione della complessità del modello.
  
  
• 24:05:00 alcuni modi per ridurre l'overfitting nel tuo modello di deep learning che sono stati discussi in questa sezione. Ottenere più dati attraverso l'aumento dei dati o una migliore qualità dei dati può aiutare il tuo modello ad apprendere modelli più generalizzabili. Anche l'utilizzo del transfer learning prendendo modelli appresi da modelli pre-addestrati e applicandoli al proprio set di dati può essere efficace. Anche semplificare il modello riducendo il numero di livelli o unità nascoste può essere d'aiuto. Il decadimento del tasso di apprendimento può aiutare riducendo il tasso di apprendimento nel tempo e l'arresto anticipato può interrompere il processo di addestramento prima che si verifichi l'overfitting.
  
  
• 24:10:00 In questa sezione, viene discusso il concetto di arresto anticipato come metodo per gestire l'overfitting nell'apprendimento automatico. Prima che l'errore di test inizi ad aumentare, l'errore di test del modello viene tracciato e il modello viene interrotto dall'addestramento o i pesi/modelli vengono salvati dove la perdita del modello era minima. Vengono inoltre esplorati diversi metodi per affrontare l'underfitting, come l'aggiunta di più livelli/unità al modello, la modifica del tasso di apprendimento, l'addestramento più a lungo e l'utilizzo dell'apprendimento di trasferimento. Viene sottolineato l'equilibrio tra overfitting e underfitting e viene evidenziata l'importanza di valutare le prestazioni di un modello nel tempo utilizzando le curve di perdita. Infine, vengono discussi i modi per prevenire l'eccessiva regolarizzazione del modello e finire con l'underfitting, e viene sottolineato l'obiettivo di raggiungere un giusto equilibrio tra underfitting e overfitting.
  
  
• 24:15:00 In questa sezione del video su PyTorch per il deep learning e il machine learning, l'istruttore discute il concetto di overfitting e underfitting nei modelli, insieme ai modi per gestirli. L'aumento dei dati è uno dei metodi introdotti per affrontare l'overfitting, in cui le immagini vengono manipolate per aumentare la diversità del set di dati di addestramento. L'istruttore passa quindi a dimostrare come creare una trasformazione con l'aumento dei dati e caricare i dati utilizzando tali trasformazioni per creare e testare set di dati e caricatori di dati. Il video sottolinea l'importanza di provare diversi modelli con varie modifiche e trasformazioni per trovare la soluzione migliore per un particolare problema.
  
  
• 24:20:00 In questa sezione del video, l'istruttore illustra il processo di creazione di un set di dati e di un caricatore di dati utilizzando le trasformazioni PyTorch e la classe ImageFolder. Forniscono esempi di codice e incoraggiano gli spettatori a provarlo da soli, se lo desiderano. Il set di dati viene creato da immagini di pizza, bistecche e sushi sia per le cartelle di formazione che per quelle di test. L'istruttore discute anche dell'importanza di essere chiari con i nomi delle variabili quando si lavora con nomi simili in tutto il taccuino. Hanno impostato i caricatori di dati sia per i set di dati di addestramento che per quelli di test, con il set di dati di addestramento aumentato con la banale funzione augment wide. L'istruttore suggerisce quindi agli spettatori di costruire e addestrare il modello uno utilizzando la minuscola classe VGG e la funzione train.
  
  
• 24:25:00 In questa sezione del corso completo su PyTorch, l'istruttore guida lo spettatore attraverso il processo di creazione e addestramento di un nuovo modello utilizzando la stessa architettura di prima, ma con dati di addestramento aumentati. L'obiettivo è confrontare le prestazioni di questo modello con il modello di base senza aumento dei dati. L'istruttore utilizza la classe precedentemente creata per il minuscolo modello VGG e imposta un seme manuale per la riproducibilità. Quindi definiscono la funzione di perdita e l'ottimizzatore, impostano gli iperparametri e avviano il timer. Infine, l'istruttore esegue il training del modello chiamando la funzione train precedentemente creata, passando il modello ei caricatori di dati e valutando i risultati.
  
  
• 24:30:00 In questa sezione, l'istruttore continua l'addestramento del secondo modello con l'aumento dei dati e mostra che non ha funzionato bene come il primo modello senza l'aumento dei dati a causa del fatto che la perdita stava già diminuendo e lì non era molto esagerato. L'istruttore introduce quindi una funzione per tracciare le curve di perdita e la utilizza per valutare le prestazioni del secondo modello. La curva di perdita mostra che il modello è underfitting e possibilmente overfitting, indicato dalla maggiore perdita di test rispetto alla perdita di addestramento. L'istruttore pone quindi la domanda su cosa si può fare per affrontare sia l'underfitting che l'overfitting nel modello, suggerendo opzioni come ottenere più dati, semplificare il modello, utilizzare il transfer learning o aggiungere più livelli.
  
  
• 24:35:00 In questa sezione, l'istruttore discute l'importanza di confrontare i risultati del modello e fornisce alcuni strumenti, come PyTorch più TensorBoard e pesi e distorsioni, per tenere traccia di diversi esperimenti. Tuttavia, sottolinea che per ora questo corso si concentrerà solo su PyTorch puro. L'istruttore quindi imposta un grafico per confrontare i risultati del modello fianco a fianco, utilizzando frame di dati per ciascuno dei risultati del modello. Suggerisce anche di provare un esperimento per addestrare il modello zero per una durata maggiore per vedere se migliora. In definitiva, il confronto visivo tra diversi esperimenti e le relative metriche è fondamentale per migliorare i modelli.
  
  
• 24:40:00 In questa sezione, l'istruttore utilizza le sottotrame per confrontare diverse metriche su due modelli sperimentati. Iniziano creando un intervallo per il numero di epoche e quindi creano un grafico per la perdita del treno utilizzando PLT.subplot() e PLT.plot(). Fanno lo stesso per la perdita e l'accuratezza del test sia per i dati di addestramento che per quelli di test. L'istruttore sottolinea che il modello uno, che ha implementato l'aumento dei dati, sembra essere sovradimensionato in questa fase, mentre il modello zero sta ottenendo risultati migliori in termini di perdita. L'istruttore suggerisce che se avessero più modelli da confrontare, potrebbero potenzialmente trasformarlo in una funzione, ma osserva anche che strumenti come TensorBoard, pesi e pregiudizi e MLflow possono aiutare a dare un senso a questi grafici quando vengono condotti numerosi esperimenti.
  
  
• 24:45:00 In questa sezione, il relatore discute l'importanza di valutare i modelli in base al loro rendimento sul set di dati di test anziché solo sul set di dati di addestramento. Suggeriscono che mentre le metriche sul set di dati di addestramento sono buone, l'obiettivo finale è che il modello funzioni bene su dati invisibili. Il relatore consiglia di addestrare i modelli più a lungo e possibilmente di aggiungere più unità nascoste a ogni livello per ottenere risultati migliori. Passano quindi a dimostrare come fare previsioni su immagini personalizzate che non si trovano nel set di dati di addestramento o test, utilizzando come esempio un'app di riconoscimento alimentare. Spiegano il flusso di lavoro per scaricare un'immagine personalizzata e fare una previsione utilizzando un modello PyTorch addestrato, ma avvertono che il modello corrente potrebbe non avere grandi prestazioni.
  
  
• 24:50:00 In questa sezione, l'istruttore mostra come scaricare un'immagine personalizzata di una pizza e prepararla per la previsione utilizzando il modello addestrato. L'immagine viene scaricata utilizzando un URL GitHub non elaborato e salvata nella cartella dei dati. L'istruttore osserva che l'immagine personalizzata deve essere nello stesso formato dei dati utilizzati per addestrare il modello, in particolare la forma Tensor con tipo di dati torcia galleggiante 32 e una forma di 64 per 64 per tre. Dimostrano come caricare l'immagine in PyTorch utilizzando il pacchetto di visione della torcia e la funzione read_image, che legge un JPEG o PNG in un tensore tridimensionale RGB o in scala di grigi.
  
  
• 24:55:00 In questa sezione, l'istruttore dimostra come leggere un'immagine personalizzata in PyTorch utilizzando torch vision.io e convertirla in un tensore. Mostra anche come ottenere metadati sull'immagine, come la sua forma e il tipo di dati. L'istruttore osserva che prima di passare l'immagine attraverso un modello, potrebbe essere necessario ridimensionarla, convertirla in float32 e inserirla nel dispositivo giusto. Nella sezione successiva, intende dimostrare come effettuare una previsione sull'immagine personalizzata utilizzando un modello PyTorch.

Parte 26

• 25:00:00 In questa sezione, l'istruttore discute l'importanza dei tipi di dati e delle forme nell'apprendimento profondo e come correggere gli errori ad essi correlati. L'istruttore tenta di fare una previsione su un'immagine, ma si imbatte in errori perché i dati personalizzati non sono dello stesso tipo di dati su cui il modello è stato originariamente addestrato. Mostrano come correggere l'errore ricreando il tensore dell'immagine personalizzata e convertendolo in torcia galleggiante 32. L'istruttore affronta quindi un altro problema con la forma dell'immagine personalizzata e mostra come risolverlo creando una pipeline di trasformazione per ridimensionare l'immagine a la stessa dimensione su cui è stato addestrato il modello.
  
  
• 25:05:00 In questa sezione, l'istruttore mostra come utilizzare il pacchetto transforms di PyTorch per trasformare un'immagine di input e prepararla per l'utilizzo da parte di un modello di deep learning. Dimostrano come applicare una pipeline di trasformazione a un'immagine personalizzata, che comporta la compressione e la pixelizzazione dell'immagine. L'istruttore osserva che ciò potrebbe potenzialmente influire sulla precisione del modello e consiglia di sperimentare immagini di dimensioni maggiori per migliorare le prestazioni. Discutono inoltre dell'importanza di garantire che le dimensioni del tensore siano allineate ai requisiti del modello, inclusa l'aggiunta di una dimensione batch a un'immagine personalizzata prima di passarla attraverso il modello per l'inferenza.
  
  
• 25:10:00 In questa sezione del video, il presentatore mostra come fare previsioni su dati immagine personalizzati utilizzando un modello PyTorch. Sottolineano l'importanza di formattare correttamente i dati e di garantire che abbiano lo stesso tipo di dati, forma e dispositivo su cui il modello è stato addestrato per evitare errori. Il presentatore mostra anche come convertire gli output grezzi del modello, o logit, in probabilità di previsione utilizzando la funzione softmax. Sebbene il modello utilizzato nell'esempio non funzioni bene, viene illustrato il processo di previsione sui dati personalizzati.
  
  
• 25:15:00 In questa sezione del video, l'istruttore mostra come utilizzare il processo di previsione dell'immagine personalizzata. Questa funzione accetta come input un modello PyTorch, un percorso immagine, un elenco di nomi di classe, una trasformazione e un dispositivo. Carica l'immagine utilizzando TorchVision, la formatta, ottiene le etichette di previsione e traccia l'immagine con la sua previsione come titolo. L'istruttore sfida gli spettatori a provare a creare questa funzione da soli e quindi passa attraverso una possibile implementazione nel video. La funzione non è completamente implementata in questa sezione e continuerà nel prossimo video.
  
  
• 25:20:00 In questa sezione, vediamo come fare una previsione su dati personalizzati utilizzando PyTorch. Innanzitutto, dobbiamo ridimensionare i dati dell'immagine in modo che siano compresi tra 0 e 1 in modo che il nostro modello possa elaborarli correttamente. Quindi, controlliamo se sono necessarie trasformazioni e passiamo l'immagine attraverso di esse se lo sono. Successivamente, ci assicuriamo che il modello sia sul dispositivo corretto e lo mettiamo in modalità di inferenza. Aggiungiamo anche una dimensione extra all'immagine per riflettere la dimensione del batch di 1 su cui il nostro modello prevederà. Quindi facciamo una previsione, convertiamo i logit grezzi in probabilità di previsione utilizzando softmax, quindi li convertiamo in etichette di previsione utilizzando argmax. Infine, creiamo un grafico dell'immagine accanto alla sua previsione e probabilità di previsione. Se viene fornito un elenco di nomi di classe, la funzione replicherà i nomi di classe per ogni previsione nel grafico.
  
  
• 25:25:00 In questa sezione, l'istruttore spiega come creare una funzione in grado di acquisire immagini e visualizzare la classe prevista utilizzando un modello PyTorch preaddestrato. La funzione può contenere un elenco di nomi di classe per l'etichettatura e visualizza anche la probabilità di previsione. L'istruttore dimostra quindi l'utilizzo di questa funzione su immagini personalizzate e un modello preaddestrato, spiegando l'importanza di inserire il risultato nella CPU per la compatibilità con matplotlib. Nonostante le scarse prestazioni del modello, l'istruttore sottolinea il potere di visualizzare i risultati.
  
  
• 25:30:00 In questa sezione, l'istruttore riassume i punti principali della sezione precedente, che spiegava come prevedere dati personalizzati con PyTorch. I punti principali da ricordare sono che i dati devono essere preelaborati per corrispondere al formato previsto del modello, inclusi il tipo di dati corretto, il dispositivo corretto e la forma corretta. PyTorch ha molte funzioni integrate per la gestione di diversi tipi di dati e gli utenti possono scrivere le proprie classi di set di dati personalizzate, se necessario. Inoltre, l'istruttore sottolinea l'importanza di bilanciare overfitting e underfitting durante la formazione dei modelli e menziona diverse risorse per l'ulteriore apprendimento e pratica, inclusi esercizi e materiali extracurriculari.
  
  
• 25:35:00 In questa sezione, l'istruttore incoraggia gli studenti a passare prima attraverso il modello di esercizi sui set di dati personalizzati PyTorch e provare a compilare tutto il codice da soli. Nel caso in cui si blocchino, possono fare riferimento alle soluzioni di esempio fornite dall'istruttore. Le soluzioni offerte sono solo un modo di fare le cose e gli utenti sono liberi di farvi riferimento e confrontarle con la loro implementazione. Le soluzioni e gli errori riscontrati durante il processo possono essere visualizzati anche nelle procedure dettagliate dal vivo disponibili su YouTube. L'istruttore ricorda agli utenti che hanno coperto molti esercizi e possono controllare gli esercizi e le soluzioni extra nel repository di deep learning PyTorch. L'istruttore conclude menzionando che ci sono altri cinque capitoli disponibili su learnpytorch.io, che gli studenti possono esplorare per saperne di più sul trasferimento dell'apprendimento, sul tracciamento dell'esperimento del modello pytorch, sulla replica della carta pytorch e sulla distribuzione del modello pytorch.

[MetaQuotes]

No Black Box Machine Learning Course - Impara senza biblioteche

No Black Box Machine Learning Course - Impara senza biblioteche

00:00:00 - 01:00:00 In questo video di YouTube, l'istruttore presenta un corso di machine learning No Black Box che insegna come codificare in machine learning senza fare affidamento sulle librerie. Il corso copre argomenti relativi alla creazione di un'app Web che riconosce i disegni, inclusa la raccolta di dati, l'estrazione e la visualizzazione delle caratteristiche e l'implementazione di classificatori come il vicino più vicino e il vicino più vicino K. L'istruttore sottolinea l'importanza della comprensione dei dati nell'apprendimento automatico e suggerisce risorse per coloro che hanno bisogno di rispolverare la matematica delle scuole superiori e l'esperienza di programmazione. Il video mostra il processo di creazione di una pagina Web che funge da creatore di dati utilizzando JavaScript senza librerie esterne. Il presentatore include anche istruzioni su come creare un pulsante Annulla e un campo di immissione del nome, archiviare i disegni in un oggetto dati e salvare i percorsi sul computer dell'utente. Infine, il video mostra come creare un generatore di set di dati in node.js e generare i dati associati a ciascun campione utilizzando JavaScript.

01:00:00 - 02:00:00 In questo video di YouTube, l'istruttore insegna agli spettatori come creare un set di dati di machine learning ed estrarre funzionalità senza utilizzare le librerie. Dimostrano come archiviare il set di dati in una cartella in grado di comunicare tra gli script dei nodi e le app Web e creare un'app visualizzatore di dati. L'istruttore mostra anche come visualizzare i dati raccolti utilizzando i grafici di Google e come identificare ed enfatizzare gli elementi selezionati nel grafico e nell'elenco. Nel complesso, il video fornisce una guida completa per gli studenti per creare set di dati di machine learning ed estrarre funzionalità utilizzando solo JavaScript. 02:00:00 - 03:00:00 Il video "No Black Box Machine Learning Course – Learn Without Libraries" mostra come classificare i disegni in base alle loro caratteristiche senza utilizzare le librerie di machine learning. Il creatore del video sottolinea l'importanza di disporre di un sistema rapido e reattivo per l'ispezione dei dati per evitare errori manuali. Dimostrano come aggiungere funzionalità al grafico, come nascondere lo sfondo e come visualizzare le etichette previste sullo schermo utilizzando contenitori dinamici con HTML e CSS. Il video copre anche le tecniche di ridimensionamento dei dati come la normalizzazione e la standardizzazione. Infine, il video mostra come implementare il classificatore K dei vicini più vicini e contare il numero di ciascuna etichetta all'interno dei K vicini più vicini.

03:00:00 - 03:50:00 Il video di YouTube "No Black Box Machine Learning Course - Learn Without Libraries" copre vari argomenti relativi alla classificazione K-nearest neighbor senza utilizzare librerie di machine learning come JavaScript e Python. Il video spiega come suddividere i set di dati in set di addestramento e test, gestire separatamente i campioni di addestramento e test e normalizzare i dati. L'istruttore discute anche l'importanza dei limiti decisionali nella comprensione del funzionamento di un classificatore, dimostra come implementare un classificatore K-nearest neighbor (KNN) in JavaScript e generare un grafico basato su pixel senza utilizzare le librerie di machine learning. Infine, il video si conclude con un invito agli spettatori a esplorare le funzionalità aggiuntive di Python e riflettere su ciò che hanno appreso finora.

Parte 1

• 00:00:00 In questa sezione, il relatore introduce il corso di apprendimento automatico senza scatola nera che si concentra sulla programmazione senza fare affidamento sulle librerie. Il corso copre vari argomenti per la creazione di un'app Web che riconosce i disegni, inclusa la raccolta di dati, l'estrazione e la visualizzazione delle caratteristiche e l'implementazione di classificatori come il vicino più vicino e il vicino più vicino K. Il relatore sottolinea l'importanza della comprensione dei dati nell'apprendimento automatico e offre agli studenti una breve pausa per concentrarsi sui compiti, suggerendo anche risorse per rispolverare la matematica delle scuole superiori e l'esperienza di programmazione. Il corso passa quindi alla fase due in cui verranno trattati metodi più avanzati come le reti neurali. Viene inoltre illustrato un esempio di creazione di un'app di disegno per la raccolta dei dati con funzionalità di annullamento e salvataggio.
  
  
• 00:05:00 In questa sezione del video, l'istruttore illustra il processo di creazione di una pagina Web che verrà utilizzata come creatore di dati per un set di dati. Iniziano creando una nuova cartella chiamata web e all'interno di questa cartella creano il primo file, una pagina web chiamata Creator.html. La pagina include HTML di base, una sezione del titolo e un foglio di stile esterno chiamato Styles.css. Aggiungono anche stili di base per la pagina, inclusa la famiglia di caratteri e il colore di sfondo. L'istruttore passa quindi all'implementazione dello sketchpad utilizzando un file JavaScript esterno chiamato sketchpad.js e definisce il costruttore della classe sketchpad per contenere l'elemento canvas.
  
  
• 00:10:00 In questa sezione, l'istruttore configura un canvas utilizzando JavaScript e aggiunge un listener di eventi "onmousedown" per rilevare le azioni del mouse. Ottengono le coordinate del mouse ottenendo il rettangolo dell'area di delimitazione della tela e sottraendo rispettivamente i lati sinistro e superiore. Dopo aver arrotondato le coordinate a numeri interi, l'istruttore crea un array di percorsi che contiene le coordinate del mouse quando si fa clic sull'area di disegno. Impostano anche "drawing" su false e "path" su empty. Viene aggiunto un altro listener di eventi per "onmousemove" per continuare ad aggiungere altri punti all'array del percorso man mano che il mouse viene spostato.
  
  
• 00:15:00 In questa sezione, il relatore spiega come implementare gli eventi del mouse per disegnare su una tela utilizzando JavaScript, senza l'uso di librerie. Utilizzando i listener di eventi per "onMouseMove" e "onMouseUp", il codice tiene traccia dei movimenti del mouse e aggiunge la posizione a un percorso se l'utente sta disegnando. Inoltre, viene creata una nuova funzione "ottieni mouse" per aggiungere la posizione all'area di disegno. Infine, il relatore mostra come creare un oggetto di utilità "disegna" per cancellare e disegnare il percorso sulla tela.
  
  
• 00:20:00 In questa sezione, l'istruttore video continua a creare un programma di disegno senza librerie esterne affrontando alcuni problemi con le linee disegnate, come l'aspetto degli angoli e le estremità delle linee rette. Quindi procedono a creare una funzione per disegnare più percorsi e incorporarla nel programma. L'istruttore riscontra alcuni problemi durante l'esecuzione del programma su un dispositivo mobile a causa del viewport e lo risolve utilizzando un meta tag nella sezione head del file HTML.
  
  
• 00:25:00 In questa sezione, il tutorial si concentra su come adattare la tela a schermi più piccoli come quelli dei dispositivi mobili aggiungendo comandi specifici al meta tag viewport nel codice HTML. Tuttavia, i listener di eventi per il tocco sono diversi da quelli per il mouse e richiedono una modifica del blocco per schizzi con i listener di eventi per il tocco. Per migliorare ulteriormente la tela, viene creato un pulsante Annulla, ma solo quando ci sono percorsi da annullare. Il pulsante è disabilitato quando la tela è vuota.
  
  
• 00:30:00 In questa sezione, il video spiega come migliorare l'aspetto del pulsante modificando lo stile nel file CSS. Il narratore aggiunge un effetto al passaggio del mouse e imposta gli stili per lo stato disabilitato. Successivamente, impareremo come creare un campo di input per consentire agli utenti di inserire il proprio nome e un pulsante per passare al disegno successivo. Il video spiega anche come raccogliere i dati da questi campi e memorizzarli in un oggetto con tre campi: studente, sessione e disegni. Infine, il narratore inizia a implementare la funzione di avvio che verrà utilizzata per avviare il processo di disegno.
  
  
• 00:35:00 In questa sezione del video, il presentatore mostra come implementare un'app di disegno utilizzando JavaScript senza utilizzare alcuna libreria. Iniziano definendo un indice per le etichette delle cose che vogliono disegnare, come un'auto, un pesce, una casa, ecc. Aggiungono anche un campo per le istruzioni e modificano il pulsante di avvio per passare a "successivo" dopo il primo disegno . Quindi implementano una funzione per il pulsante "successivo", che aumenta l'indice, ottiene l'etichetta successiva e aggiorna le istruzioni. Memorizzano inoltre i disegni in un oggetto dati per l'etichetta specifica e aggiungono un metodo pubblico per reimpostare il blocco degli schizzi. Il relatore testa l'app e mostra che l'oggetto dati sta raccogliendo i disegni.
  
  
• 00:40:00 In questa sezione l'istruttore spiega come salvare in locale sul proprio computer i percorsi tracciati dagli utenti. Creano un elemento "a" con l'attributo href impostato su "data plain text" e codificano il componente URI utilizzando la versione stringata dei dati. I dati raccolti vengono salvati come stringa JSON in un file con un nome univoco generato da un timestamp. Infine, viene attivata l'azione di download per scaricare il file. L'istruttore aggiunge anche istruzioni su cosa fare con il file scaricato e afferma che questo avrà più senso dopo la lezione successiva.
  
  
• 00:45:00 In questa sezione, l'istruttore mostra come risolvere un potenziale problema con il blocco per schizzi aggiungendo un listener di eventi sul documento anziché sull'area di disegno. Chiede inoltre agli spettatori di aiutare a testare il sistema su diversi dispositivi e segnalare eventuali problemi o proporre soluzioni. L'istruttore spiega quindi come elaborare i dati raccolti in una forma più gestibile utilizzando node.js e mostra come navigare nella directory del progetto e creare una nuova cartella per l'archiviazione dei dati. Infine, crea una cartella "grezza" in cui incolla tutti i dati raccolti da quasi 500 consegne degli studenti, ciascuna contenente otto diversi disegni, e spiega come elaborerà questi file per creare un set di dati in cui ogni campione è un disegno.
  
  
• 00:50:00 +Alt+M e il file Json verrà formattato correttamente. In questa sezione, l'istruttore spiega come creerà un generatore di set di dati in nodejs per elaborare i campioni e visualizzarli utilizzando due cartelle separate: una per le rappresentazioni Json e l'altra per le immagini. Lo script leggerà i nomi dei file dalla directory dei dati grezzi, ne estrarrà il contenuto e memorizzerà le informazioni su ciascun campione come ID, etichetta, nome dello studente e ID dello studente, sessione e disegno. Infine, la sezione mostra brevemente come eseguire e testare il codice, con conseguente creazione di un file Json di esempio nella directory designata.
  
  
• 00:55:00 In questa sezione, il relatore spiega come generare i dati associati a ciascun campione utilizzando JavaScript. Ciò comporta la scrittura di file in una directory Json e la stringatura del disegno di ciascuna etichetta specifica. Il relatore mostra quindi come generare una rappresentazione dell'immagine di ciascun disegno utilizzando una tela e la funzione "disegna percorsi" da una directory comune. Per fare ciò, il relatore esporta l'oggetto 'draw' dal file 'draw.js' da utilizzare nel generatore di set di dati e installa la libreria canvas utilizzando il gestore di pacchetti del nodo.

Parte 2

• 01:00:00 In questa sezione, l'istruttore mostra come creare una tela e usarla per disegnare percorsi sulla tela, quindi memorizzarla come immagine. Puliscono anche la tela prima di disegnare nuovi percorsi. Dopo aver generato i file di immagine, l'istruttore risolve un problema nell'app di disegno causato dal modulo non definito in draw JS. Usano una struttura che verrà utilizzata durante tutto il corso, separando le costanti in un altro file e richiedendolo. L'istruttore aggiunge un indicatore di avanzamento in un nuovo file chiamato utils creando l'oggetto utils e aggiungendo la funzione chiamata print progress. Usano il processo STD out per ottenere l'output standard, calcolano la percentuale utilizzando la funzione per la formattazione di una percentuale e la scrivono nell'output standard per mostrare l'indicatore di avanzamento.
  
  
• 01:05:00 In questa sezione, il creatore del video spiega come archiviare il set di dati generato in modo che il browser possa leggerlo. Crea una cartella chiamata "JS_objects" che conterrà i file che possono comunicare tra gli script del nodo e le app web. Viene creato un file JavaScript "campioni" che inizializzerà un oggetto JavaScript all'interno della cartella JS_objects. Il creatore del video afferma inoltre che creerà un'app visualizzatore per il set di dati e crea un file HTML chiamato "viewer.html" con codice HTML di base. La sezione head del file include un meta tag per supportare i caratteri UTF e un titolo per la pagina. La sezione body include un tag H1 con il titolo "Data Viewer" e un div con ID "container" per contenere il set di dati. Il file JavaScript "campioni" è incluso nel file HTML.
  
  
• 01:10:00 In questa sezione, l'istruttore sta lavorando alla creazione di una tabella con campioni raggruppati per ID studente. Per fare ciò, implementano una funzione "raggruppa per" nel file utils.js, che raggruppa un array in base a una determinata chiave. Quindi registrano i gruppi nella console per verificare se funziona. Successivamente, creano una funzione chiamata "crea riga" in un file display.js separato, che accetta un contenitore, il nome di uno studente e campioni come parametri e crea una riga con il nome a sinistra e campioni a destra. Creano un ciclo per scorrere ogni ID studente, chiamano la funzione "crea riga" e passano i parametri necessari per visualizzare i dati in un formato tabella.
  
  
• 01:15:00 In questa sezione, l'istruttore mostra come creare dinamicamente una riga di immagini con etichette e allinearle correttamente con i CSS. Iniziano scorrendo una serie di campioni di immagini, creando un elemento immagine e assegnando gli attributi sorgente e stile. Le immagini vengono quindi aggiunte a una riga mentre un'etichetta div viene creata e aggiunta a un contenitore di esempio. Il contenitore di esempio viene quindi racchiuso in un div, a cui vengono assegnati un ID e una classe. L'istruttore quindi perfeziona il CSS per centrare le etichette e le immagini e aggiungere puntini di sospensione a nomi più lunghi. Infine, aggiungono uno sfondo bianco ai disegni di esempio creando un div e aggiungendolo dopo l'etichetta.
  
  
• 01:20:00 In questa sezione, il creatore del video modifica la visualizzazione dei campioni di immagini raccolti nell'app Web. La modifica comporta la creazione di un contenitore di esempio con uno sfondo bianco, un testo allineato al centro, un angolo arrotondato e un margine di un pixel. La miniatura è impostata su 100 e l'etichetta di riga ha una proprietà che occupa il 20 percento dello spazio, mentre gli otto campioni rimanenti occupano ciascuno il dieci percento dello spazio. La struttura del display risultante è ordinata, ma alcune immagini non si adattano perfettamente, il che non è un grosso problema perché è pensato per le applicazioni desktop. Inoltre, il creatore aggiunge un filtro di sfocatura ad alcuni disegni realizzati da utenti contrassegnati utilizzando i propri ID. Alcuni dei disegni raccolti sono impressionanti, mentre altri contengono interpretazioni errate che rendono i dati più impegnativi.
  
  
• 01:25:00 In questa sezione, lo YouTuber dà un'occhiata ad alcuni disegni nel set di dati e commenta la loro qualità, notando che alcuni sono molto dettagliati e devono aver impiegato molto tempo per essere creati. Dicono anche che il loro set di dati è diverso dal set di dati Quick Draw, poiché hanno un pulsante Annulla e nessun limite di tempo, il che significa che i loro disegni dovrebbero essere in media di qualità migliore. Infine, fanno un commento disinvolto sull'organizzazione e lo stile della pagina.
  
  
• 01:30:00 In questa sezione, l'istruttore spiega come estrarre le funzionalità dai campioni senza utilizzare alcuna libreria. Le funzioni per l'estrazione del conteggio dei percorsi e dei punti sono implementate in un file denominato features.js e aggiunte a un oggetto denominato features. Quindi, nel file feature extractor.js, gli esempi vengono letti e le funzionalità vengono estratte eseguendo un ciclo di tutti gli esempi e ottenendo il conteggio dei percorsi e dei punti per ciascuno di essi. Questi valori di funzionalità vengono quindi combinati in un array e scritti in un nuovo file. Infine, i nomi delle funzionalità e gli esempi vengono combinati in un altro file denominato features.json. Quando si esegue lo script di estrazione delle funzionalità, il registro dice "estrazione delle funzionalità" e alla fine "fatto". Le caratteristiche risultanti nella directory del set di dati possono quindi essere esaminate.
  
  
• 01:35:00 In questa sezione, il creatore del video spiega come utilizzare un oggetto JavaScript per contenere dati aggiuntivi che non sono già contenuti in un file di caratteristiche. L'oggetto può essere salvato in un file JavaScript separato e utilizzato per estrarre tutti i dati necessari per un'applicazione web. Il creatore mostra anche come visualizzare i dati utilizzando i grafici di Google, in cui è possibile definire in un oggetto opzioni come larghezza, altezza, titoli degli assi e il pacchetto grafico principale. Viene creata una tabella di dati con due colonne per i valori delle caratteristiche e i nomi corrispondenti.
  
  
• 01:40:00 In questa sezione, il video mostra come creare un grafico a dispersione con Google Visualization, consentendo agli utenti di esaminare più da vicino diverse caratteristiche dei dati utilizzando le azioni di Explorer per ingrandire e ridurre. Il video mostra anche come utilizzare colori diversi per ogni classe e implementare la trasparenza per una migliore visualizzazione della densità in diverse parti utilizzando una versione diversa della libreria di grafici di Google chiamata grafici dei materiali.
  
  
• 01:45:00 In questa sezione, il creatore del video mostra come creare un grafico a dispersione utilizzando i grafici di Google e quindi creare un nuovo grafico con il proprio codice JavaScript. Il creatore semplifica le opzioni per il grafico e modifica la combinazione di colori per utilizzare invece gli emoji, il che consente un riconoscimento più semplice dei punti dati senza la necessità di etichette o legende. Anche la trasparenza del grafico viene regolata per consentire una migliore visibilità dei dati fittamente tracciati.
  
  
• 01:50:00 In questa sezione, l'istruttore aggiunge una funzione di callback al grafico per identificare qualsiasi elemento selezionato nella tabella sottostante. La nuova funzione si chiama "handle click", che aggiunge una classe "enfatizza" all'elemento selezionato e utilizza "scorri in vista" e "centro blocco" per garantire che venga fatto scorrere automaticamente al centro della pagina. L'istruttore modifica quindi il layout della pagina in modo che il grafico si trovi sul lato destro della pagina, con gli altri contenuti sul lato sinistro. Il grafico è inoltre fissato in posizione in modo che non si sposti quando l'utente scorre.
  
  
• 01:55:00 In questa sezione del video, il presentatore mostra come selezionare gli elementi dal grafico e dall'elenco e come deselezionarli. Specificano un parametro per impostare se deve verificarsi lo scorrimento e aggiungono codice per gestire l'errore che si verifica quando si tenta di non selezionare nulla. Inoltre, il relatore aggiunge la possibilità di enfatizzare un elemento attraverso una classe, rimuovendo la classe se è già enfatizzata. Infine, testano la funzionalità del grafico e regolano le dimensioni del grafico.

Parte 3

• 02:00:00 In questa sezione, l'oratore dimostra l'uso di un blocco per schizzi come input per disegnare qualcosa da classificare. Preparano un contenitore per esso, aggiungono stili e fissano la sua posizione a una certa distanza dalla destra e dalla parte superiore dello schermo. Gli danno anche un margine per una chiara visibilità e un pulsante Annulla al centro. Quindi aggiungono un pannello di controllo e un pulsante per attivare o disattivare l'input visibile o meno che funziona correttamente durante il test. Il relatore sottolinea l'importanza di disporre di un sistema veloce e reattivo durante l'ispezione dei dati per evitare errori manuali che possono portare a errori.
  
  
• 02:05:00 In questa sezione, l'istruttore video mostra come aggiungere un pannello di controllo al grafico e come nascondere lo sfondo quando è presente l'input. Dimostrano una soluzione per nascondere lo sfondo nell'HTML del visualizzatore rendendo trasparente il contorno della tela del blocco schizzi. Mostrano anche come visualizzare le caratteristiche sul grafico immediatamente quando qualcosa viene disegnato sullo sketchpad aggiungendo una funzione di callback di aggiornamento che estrae le caratteristiche allo stesso modo dell'estrattore di caratteristiche. L'istruttore incontra un problema con oggetti in conflitto chiamati funzionalità, ma lo risolve rinominandoli in funzionalità funzioni ovunque.
  
  
• 02:10:00 In questa sezione, l'oratore mostra un punto dinamico che può essere aggiunto al grafico, che si sposta mentre si disegna. Ciò si ottiene impostando un attributo su un valore e ridisegnandolo. Il punto dinamico viene aggiunto alla classe del grafico e disegnato prima della visualizzazione degli assi. Trascinando, il punto si sposta in aree diverse e, se disegnato con un punto bianco trasparente su sfondo nero, è molto più visibile. Il valore deve essere grande, poiché il grafico può essere ingrandito e il punto rimane visibile senza oltrepassare i bordi.
  
  
• 02:15:00 In questa sezione, l'istruttore dimostra come attivare un metodo di aggiornamento in sketchpad.js, che funziona nascondendo l'input dinamico e mostrando i dati quando viene premuto l'input di commutazione. Con il metodo di aggiornamento del trigger, l'istruttore applica le funzioni get width e height feature nelle Common feature functions per calcolare la larghezza e l'altezza del disegno, che vengono utilizzate per estrarre nuove feature nell'estrattore di feature nodo. L'istruttore suggerisce di ristrutturare l'HTML in modo che la stessa risorsa venga utilizzata per l'estrazione e la visualizzazione dei dati.
  
  
• 02:20:00 In questa sezione, il creatore del video mostra come rimuovere il codice non necessario e sostituirlo con nuove funzioni, ottenendo un processo di creazione di punti più generalizzato e multidimensionale. Dopo aver rigenerato le feature e aver aggiornato i nomi delle feature, si osservano alcuni punti campione problematici, che è un problema comune quando si lavora con i dati. Il creatore osserva che sono da aspettarsi valori anomali e incoerenze nei dati e invita gli spettatori ad aiutare a identificare la causa del problema.
  
  
• 02:25:00 In questa sezione, l'istruttore spiega come classificare un disegno in base alle sue caratteristiche senza utilizzare librerie di machine learning. Estraggono le caratteristiche dall'input e guardano i punti vicini per classificare l'input. Per trovare il punto più vicino, l'istruttore copia la funzione di avvicinamento dal grafico math.js e la incolla nel proprio codice. Quindi chiamano la funzione per identificare l'etichetta per il disegno e registrano il risultato.
  
  
• 02:30:00 In questa sezione, il creatore del video aggiunge la funzionalità per visualizzare l'etichetta prevista sullo schermo utilizzando contenitori dinamici con HTML e CSS. L'etichetta prevista viene visualizzata in un contenitore bianco con un testo concatenato che indica se l'oggetto è un'auto o meno. Il creatore sperimenta il disegno di diversi oggetti come orologi e matite per testare le capacità predittive del programma. Il creatore del video quindi aggiorna il grafico utilizzando punti dinamici con etichette e immagini e disegna linee che collegano i campioni più vicini.
  
  
• 02:35:00 In questa sezione, il relatore discute l'importanza di non schiacciare o allungare i dati nei grafici quando si lavora su progetti di machine learning. Dimostrano come le proporzioni di un grafico possono influenzare il modo in cui i dati vengono interpretati, portando a confusione ed errori. Per risolvere questo problema, il relatore calcola un delta per i valori massimi x e y e regola il grafico di conseguenza. Sebbene ciò crei uno spazio vuoto, consente una corretta visualizzazione dei dati e risultati accurati di machine learning.
  
  
• 02:40:00 In questa sezione della trascrizione, il creatore del video sottolinea l'importanza del ridimensionamento dei dati nell'apprendimento automatico per garantire che tutte le funzionalità abbiano lo stesso significato nella classificazione. Il creatore dimostra come i dati possono essere schiacciati e allungati durante l'estrazione delle funzionalità, con conseguente disparità di trattamento di determinate funzionalità. Per livellare il campo di gioco, il creatore introduce la normalizzazione, una tecnica comune per rimappare i valori delle caratteristiche in un intervallo compreso tra 0 e 1. Il video mostra l'implementazione di una nuova funzione chiamata "normalizza punti" nella sezione "utilità" per ottenere questo risultato rimappatura.
  
  
• 02:45:00 In questa sezione, il tutorial video mostra come normalizzare i dati modificando i valori in modo che siano compresi tra 0 e 1. La funzione viene inizializzata per essere sufficientemente generale e vengono calcolati i valori minimo e massimo per ciascuna caratteristica. I punti vengono modificati per essere compresi tra 0 e 1 sottraendo il valore minimo e dividendo per la differenza. La funzione lerp inversa viene utilizzata per convertire il valore dato in una percentuale per normalizzare le caratteristiche estratte dal disegno. I valori min-max vengono restituiti dalla funzione e scritti in uno dei file oggetto JavaScript per comunicare con l'interfaccia. Infine, i dati vengono generati e i valori min-max vengono inclusi nei file oggetto JavaScript.
  
  
• 02:50:00 In questa sezione, il relatore spiega come normalizzare i punti prima di tentare di classificarli utilizzando la funzione Utils normalize points. Per fare ciò, i dati grezzi della feature vengono caricati e passati come input alla funzione. Inoltre, è possibile passare un valore min-max per supportare la normalizzazione senza doverli calcolare. Viene inoltre dimostrato come la normalizzazione sia sensibile ai punti anomali e come gestirli, ad esempio rilevandoli e rimuovendoli automaticamente o utilizzando la standardizzazione come un diverso ridimensionamento dei dati.
  
  
• 02:55:00 In questa sezione, l'istruttore discute la tecnica della standardizzazione, che prevede il calcolo della media e della deviazione standard di ciascuna caratteristica e la rimappatura sottraendo la media e dividendo per la deviazione standard. Questa tecnica è meno sensibile ai valori anomali e può funzionare meglio in alcuni casi. L'istruttore introduce anche il classificatore K dei vicini più vicini, in cui la classe è determinata in base alla maggioranza dei K dei vicini più vicini. Il codice viene aggiornato per consentire la ricerca di K vicini più vicini e l'istruttore dimostra come contare il numero di ciascuna etichetta all'interno dei K vicini più vicini.

Parte 4

• 03:00:00 In questa sezione, l'istruttore spiega il processo per capire la maggior parte di una serie di campioni in base alle loro etichette. Ciò comporta il conteggio delle occorrenze di ciascuna etichetta nei campioni e l'impostazione dell'etichetta di maggioranza come quella con il conteggio più alto. L'istruttore aggiorna il codice per restituire tutti i campioni più vicini e tracciare delle linee nel grafico, anziché solo quello più vicino. Quindi dimostrano il funzionamento del classificatore su vari set di dati e incoraggiano gli spettatori a condividere le proprie implementazioni di altre varianti dei classificatori del vicino più vicino. Infine, l'istruttore sottolinea la necessità di suddividere i dati in set di addestramento e test per valutare obiettivamente le prestazioni del classificatore.
  
  
• 03:05:00 In questa sezione, il video mostra come suddividere un set di dati in set di addestramento e test, scriverli in file e definire costanti per tali suddivisioni nel codice utilizzando JavaScript. Il set di addestramento è impostato per essere il 50% del numero di campioni e il video avverte dell'errore di testare i dati di addestramento. Per testare, il codice scorre tutti i campioni di test e memorizza il valore dell'etichetta in un attributo chiamato Verità fingendo di non conoscere l'etichetta a scopo di test.
  
  
• 03:10:00 In questa sezione, il video illustra come gestire separatamente i campioni di addestramento e test e come normalizzare correttamente i dati. Il relatore spiega che è importante normalizzare i dati solo con il set di addestramento poiché non abbiamo idea di quale sarà il set di test. Descrivono inoltre come classificare correttamente utilizzando solo le informazioni dai dati di addestramento e dimostrano come gestire i punti dati sconosciuti utilizzando la funzione di classificazione.
  
  
• 03:15:00 In questa sezione, il creatore del video aggiunge un attributo corretto a un'etichetta di prova e confronta questa etichetta con il valore di verità precedente per determinarne l'accuratezza. Viene inoltre aggiunto un sottotitolo per chiarire dove inizia il set di test. Il creatore aggiunge quindi un campo di statistiche per calcolare e visualizzare l'accuratezza del classificatore K dei vicini più vicini, che è impostato su 10 vicini più vicini, con una precisione del 39,62%. Modificando il parametro in un vicino più vicino, la precisione è in realtà molto peggiore, dimostrando che considerare più vicini era una buona idea.
  
  
• 03:20:00 In questa sezione, l'istruttore esegue il refactoring del codice e discute l'importanza dei limiti decisionali nella comprensione del funzionamento di un classificatore. Creano un nuovo file chiamato "run evaluation" e caricano le costanti e le utilità necessarie. L'istruttore spiega come creare un classificatore e come ottenere campioni di addestramento e test per calcolare l'accuratezza di un classificatore. Introducono anche limiti decisionali, che forniscono preziose informazioni su come un classificatore determina la classificazione di un punto dati. L'istruttore afferma che i limiti decisionali sono più utili del semplice conteggio delle diverse caratteristiche di un punto dati.
  
  
• 03:25:00 In questa sezione, il relatore spiega come implementare un classificatore K-nearest neighbor (KNN) in JavaScript. Il codice inizia con la previsione delle etichette per ogni punto campione di test utilizzando il metodo KNN e calcolando l'accuratezza controllando il conteggio delle previsioni corrette. Il file KN.js viene creato per definire la classe che accetta campioni di addestramento e K per archiviare e prevedere un determinato punto. Il codice della classe per la classificazione viene copiato dall'HTML del visualizzatore a KN.js e modificato per adattarsi alla nuova classe. Lo script di valutazione dell'esecuzione viene aggiornato per utilizzare il classificatore KNN invece del vecchio metodo di classificazione. Con il refactoring in questo modo, il codice diventa più gestibile e si possono evitare errori stupidi.
  
  
• 03:30:00 In questa sezione, l'istruttore dimostra come generare un grafico basato su pixel senza utilizzare librerie di machine learning normalizzando i valori dei pixel e codificandoli con colori in base ai valori previsti. Il grafico viene quindi salvato come immagine PNG e impostato come sfondo di un grafico. L'istruttore mostra come implementare questa nuova funzionalità nel file chart.js prendendo la coordinata in alto a sinistra in base ai dati, ottenendo il valore in pixel dai limiti dei dati ai limiti dei pixel e dividendolo in base a come è stato eseguito il ridimensionamento utilizzando la trasformazione.
  
  
• 03:35:00 In questa sezione del video, il presentatore discute l'immagine generata nella sezione precedente e commenta la sua bassa risoluzione e l'effetto levigante. Introducono quindi un'immagine a risoluzione più elevata, che non richiede più la visualizzazione dei dati. Spiegano che le regioni colorate ci parlano delle diverse etichette e di quanto sia interessante osservare le diverse regioni apparire. Sfidano quindi gli spettatori a calcolare l'accuratezza per tutti i possibili valori di K e creare un grafico a linee per determinare il miglior valore e anche per generare un grafico del confine decisionale ad alta risoluzione per il miglior valore.
  
  
• 03:40:00 In questa sezione, lo YouTuber spiega come preparare i dati per Python scrivendo una funzione per convertire i dati di esempio in formato CSV utilizzando JavaScript. Creano una funzione chiamata toCSV che converte i dati di esempio con intestazioni e nomi di funzionalità in formato CSV, che è comunemente usato in Python. Emettono il CSV con i nomi delle funzionalità e le etichette sia per i dati di addestramento che di test, quindi passano all'implementazione Python del vicino più vicino K utilizzando le librerie. Aprono il file CSV di addestramento, leggono le righe e analizzano i dati come un array di righe rappresentato come una stringa, con il carattere di nuova riga.
  
  
• 03:45:00 In questa sezione, l'istruttore spiega come preparare i dati per la classificazione K dei vicini più vicini senza l'uso di librerie. I dati vengono letti da un file CSV e archiviati in due array vuoti in Python: X per i valori delle caratteristiche e Y per le etichette. L'istruttore esegue un ciclo per popolare gli array, convertire i valori delle caratteristiche in float e rimappare le etichette in numeri. La rimappatura si ottiene utilizzando un dizionario Python. I dati vengono quindi adattati a un oggetto classificatore KNN con parametri impostati per emulare l'app Web, inclusi 250 vicini, algoritmo di forza bruta e pesi uniformi. L'istruttore termina evidenziando l'importanza dell'indentazione in Python ed estraendo i dati della funzione di lettura da un file come funzione.
  
  
• 03:50:00 In questa sezione, il relatore mostra come passare i dati al modello e verificarne l'accuratezza utilizzando la funzione punteggio. Incoraggiano inoltre gli spettatori a esplorare funzionalità aggiuntive di Python, come l'installazione di matplotlib per visualizzare i valori delle funzionalità e i limiti decisionali. Il video si conclude con un invito agli spettatori a riflettere su ciò che hanno appreso finora e prepararsi per la fase successiva del corso.

[MetaQuotes]

MIT 6.034 "Intelligenza Artificiale". Autunno 2010. Conferenza 1. Introduzione e scopo

1. Introduzione e scopo

Questo video è un'introduzione al corso MIT 6.034 "Artificial Intelligence" Il professore spiega la definizione di intelligenza artificiale e la sua importanza, e passa a discutere i modelli di pensiero e le rappresentazioni che sono importanti per comprendere l'argomento. Infine, il video fornisce una breve panoramica del corso, incluso come viene calcolato il voto e cosa comporteranno il quiz e la finale.

• 00:00:00 In questo video, un professore discute la definizione di intelligenza artificiale e la sua importanza. Continua dicendo che chiunque segua il corso diventerà più intelligente. Il professore discute anche i modelli di pensiero e come sono importanti per avere una buona comprensione della materia. Infine, parla dell'importanza delle rappresentazioni per realizzare buoni modelli.
  
  
• 00:05:00 In questo video il professore spiega come funzionano i giroscopi e come rappresentare un problema in termini di grafico. Quindi spiega come risolvere il problema dell'oca e del grano del contadino Fox, che è un esempio che molte persone potrebbero conoscere fin dall'infanzia.
  
  
• 00:10:00 Il video introduce il concetto di intelligenza artificiale e le sue varie componenti, compresi i test generati dall'intelligenza artificiale. Il video prosegue poi discutendo il principio di Rumpelstiltskin, che afferma che una volta che puoi dare un nome a qualcosa, puoi ottenere potere su di esso.
  
  
• 00:15:00 Questo video introduce il concetto di idee semplici, che sono potenti e possono essere semplici o complesse. Il video prosegue poi discutendo la definizione e gli esempi di idee semplici. Il punto principale del video è che le idee semplici sono importanti per costruire programmi più intelligenti e che scienziati e ingegneri hanno motivazioni diverse per studiarle.
  
  
• 00:20:00 Questo video racconta la storia dell'intelligenza artificiale, a partire dal lavoro svolto da Ada Lovelace più di un secolo fa. L'era moderna dell'IA è iniziata con l'articolo scritto da Marvin Minsky nel 1960. Tra un giorno, la discussione sull'intelligenza artificiale sarà inclusa nel corso.
  
  
• 00:25:00 L'"età del bulldozer" si riferisce all'età in cui le persone iniziarono a vedere di avere accesso a una potenza di calcolo illimitata e iniziarono a sviluppare sistemi esperti basati su regole.
  
  
• 00:30:00 Il video discute la storia dell'evoluzione umana e l'idea del liceo, ovvero che gli esseri umani si sono evoluti attraverso un miglioramento graduale e continuo. Prosegue discutendo di come i cambiamenti accidentali che hanno portato all'evoluzione umana siano stati prodotti evolutivi accidentali e ipotizzando quali potrebbero essere questi cambiamenti.
  
  
• 00:35:00 Questo video fornisce una breve introduzione alle idee di Noam Chomsky sullo sviluppo dell'intelligenza umana. I punti principali sottolineati sono che la lingua è al centro dell'intelligenza umana e che lo scopo principale del corso è aiutare gli studenti a sviluppare abilità nell'area. Il video menziona anche l'importanza delle recitazioni e dei tutorial, che sono aspetti chiave del corso.
  
  
• 00:40:00 Questo video fornisce una breve panoramica del corso del MIT, inclusa la sua correlazione tra frequenza alle lezioni e voti. Il video fornisce quindi un riepilogo di come il corso calcola il voto di uno studente, che include la presa in considerazione delle prestazioni dello studente nei quiz e nella finale. Infine, il video avverte gli studenti di non tentare di sostenere tutti gli esami finali, poiché ci sarebbe troppa pressione e minori opportunità di miglioramento.
  
  
• 00:45:00 Il video introduce il quiz e la finale e spiega come funzionerà il quiz e il formato dell'esame finale. Il video spiega anche come gli studenti potranno contattare l'istruttore e programmare i tutorial.

[MetaQuotes]

Lezione 2. Ragionamento: alberi degli obiettivi e risoluzione dei problemi

2. Ragionamento: alberi degli obiettivi e risoluzione dei problemi

Questo video illustra come ragionare, alberi degli obiettivi e risolvere i problemi. Introduce una tecnica chiamata "riduzione del problema" e spiega come può essere utilizzata per risolvere problemi di calcolo. Discute anche come utilizzare le trasformazioni euristiche per risolvere i problemi e come la conoscenza può essere utilizzata per risolvere problemi in domini complessi.

• 00:00:00 Il video introduce la riduzione del problema, che è una tecnica di risoluzione dei problemi comune utilizzata dagli studenti nel calcolo. Discute la filosofia educativa alla base della riduzione dei problemi e fornisce un elenco di esempi di riduzione dei problemi.
  
  
• 00:05:00 L'oratore spiega come funziona la risoluzione dei problemi e come diverse trasformazioni possono aiutare a risolvere un problema. Esaminano quattro trasformazioni sicure necessarie per risolvere un problema. Il primo passaggio consiste nell'applicare tutte le trasformazioni sicure, quindi esaminare la tabella per vedere se il problema è stato risolto. Se il problema è stato risolto, l'oratore segnalerà il successo.
  
  
• 00:10:00 Il video discute il concetto di alberi degli obiettivi e risoluzione dei problemi e introduce l'idea delle trasformazioni euristiche. Queste trasformazioni, sebbene non sempre riuscite, possono essere utili in determinate situazioni.
  
  
• 00:15:00 Il video discute varie trasformazioni euristiche che possono essere utilizzate per risolvere i problemi. Una di queste trasformazioni è una famiglia di trasformazioni di cui vi mostrerò solo una. Questa trasformazione va così: se hai l'integrale di una funzione della tangente e X, puoi riscriverlo come integrale di una funzione di Y su 1 più y^2 dy. Questa trasformazione da una forma trigonometrica a una forma polinomiale elimina tutta quella spazzatura trigonometrica con cui non vogliamo avere a che fare. C'è anche una C di cui abbiamo bisogno, e questa sarà la tua giusta reazione istintiva. Vedi qualcosa della forma 1 meno x al quadrato, e cosa fai quando lo vedi? Beh, potresti farlo. Non c'è niente che tu possa fare se Kristen ha qualcosa da suggerire. Dice che a causa di ciò che dov'è il nostro ungherese trasformo il nostro giovane turno, suggerisce di applicare la trasformazione che coinvolge il segno di X persone. Ciò significa che Scilla in realtà non deve più ricordarlo perché andando avanti, non dovrà mai integrare nulla personalmente nella sua vita. Può solo simulare il programma. Questi vanno dalla forma polinomiale alla forma trigonometrica, quindi ne hai tre
  
  
• 00:20:00 Il video discute il ragionamento, gli alberi degli obiettivi e la risoluzione dei problemi. Il presentatore introduce una tecnica di risoluzione dei problemi chiamata "l'albero degli obiettivi". Questo albero mostra come gli obiettivi sono correlati tra loro e può essere utile per prendere decisioni su quale problema risolvere. Il presentatore spiega che questa tecnica è anche nota come "albero di induzione del problema" o "albero degli obiettivi dell'albero".
  
  
• 00:25:00 Questo video introduce il concetto di alberi degli obiettivi e risoluzione dei problemi e mostra come si può misurare la profondità della composizione delle funzioni utilizzando i simboli. Il video mostra quindi come applicare una trasformazione sicura per dividere un integrale in tre parti e come funziona per una particolare funzione razionale.
  
  
• 00:30:00 Il video discute il programma di ragionamento, che risolve i problemi componendo trasformazioni sicure. Mostra come il programma si è fermato prima di una soluzione su un particolare problema ed è tornato a lavorare su un altro problema.
  
  
• 00:35:00 Il video discute il ragionamento alla base del modello di Schlegel dei problemi di calcolo da matricola, che è un modello in cui la conoscenza delle trasformazioni, il funzionamento degli alberi vecchi e le tabelle sono necessarie per risolvere i problemi. Il video menziona anche come la profondità della composizione funzionale, che è una tecnica suggerita da Brett, in realtà non ha importanza perché l'albero non cresce in profondità o in larghezza.
  
  
• 00:40:00 Il video discute come la conoscenza è rappresentata nella risoluzione dei problemi e come certe trasformazioni rendono il problema più semplice. Discute anche come la conoscenza può essere utilizzata per risolvere problemi in domini complessi.
  
  
• 00:45:00 L'oratore mostra un programma che presumibilmente dimostra come i computer possono essere "intelligenti". Tuttavia, l'oratore si rende presto conto che il programma fa la stessa cosa che fa lui, e quindi il computer non è veramente intelligente.

[MetaQuotes]

Lezione 3. Ragionamento: alberi degli obiettivi e sistemi esperti basati su regole

3. Ragionamento: alberi degli obiettivi e sistemi esperti basati su regole

Questo video spiega come funziona un sistema esperto basato su regole. Il sistema è progettato per risolvere problemi difficili da risolvere utilizzando metodi più tradizionali. Il sistema è composto da diverse regole collegate da e cancelli, che consentono al sistema di riconoscere con certezza un animale specifico.

• 00:00:00 Questo video spiega come viene costruito un sistema esperto basato su regole (RBS) e fornisce un esempio di come funziona il sistema. L'RBS è progettato per risolvere problemi difficili da risolvere utilizzando metodi più tradizionali, come le equazioni algebriche.
  
  
• 00:05:00 In questo video, il professor Patrick Winston spiega come funzionano i programmi di ragionamento, o sistemi esperti basati su regole. La struttura del programma è molto semplice, con quattro blocchi che vengono eseguiti in un ciclo iterativo per ottenere il risultato desiderato. Il programma è in grado di risolvere problemi che coinvolgono blocchi semplici perché prende suggerimenti da domande a cui ha risposto in passato e utilizza la ricorsione per ottenere un risultato complesso.
  
  
• 00:10:00 Il video spiega come viene utilizzato un albero degli obiettivi per rispondere a domande su come è stato fatto qualcosa e come un albero e/o può essere utilizzato per farlo. Spiega inoltre che il programma di integrazione può utilizzare gli alberi degli obiettivi per rispondere a domande sul proprio comportamento.
  
  
• 00:15:00 Questo video illustra come il comportamento complesso sia il risultato della complessità dell'ambiente, non della complessità del programma. I sistemi esperti basati su regole sono stati sviluppati alla fine degli anni '60 come un modo per incapsulare la conoscenza in regole semplici e sono ancora in uso oggi.
  
  
• 00:20:00 Questo video di YouTube illustra come utilizzare un sistema esperto basato su regole di forward-chaining (RBSES) per identificare gli animali in un piccolo zoo. L'RBSES è composto da diverse regole collegate da e cancelli, che consentono al sistema di riconoscere con certezza un animale specifico.
  
  
• 00:25:00 Questo video spiega come funziona un sistema esperto basato su regole (RBE), andando a ritroso da un'ipotesi per determinare se un oggetto è un certo tipo di animale.
  
  
• 00:30:00 È stato creato un sistema esperto basato su regole per progettare case simili a quelle progettate dall'architetto portoghese Siza. Il sistema è in grado di tradurre ciò che dice un insaccatore di un negozio di alimentari in una regola se-allora, consentendo a un ingegnere della conoscenza di capirlo.
  
  
• 00:35:00 In questo video, il professor Patrick Winston discute i principi dell'ingegneria della conoscenza, inclusa la necessità di casi specifici e l'uso dell'euristica. Fornisce anche un esempio di come l'euristica numero due, la questione se due oggetti sono uguali o diversi, può essere utilizzata per risolvere i problemi.
  
  
• 00:40:00 Il presentatore discute tre modi in cui l'intelligenza umana può essere migliorata: costruendo sistemi basati su regole, sviluppando programmi orientati agli obiettivi e utilizzando programmi di integrazione. L'euristica numero tre è che quando una regola o un obiettivo non viene seguito, il sistema si romperà, indicando la necessità di ulteriore conoscenza. Il presentatore lo dimostra discutendo un caso in cui un programma ha prescritto un barile di penicillina a un paziente.
  
  
• 00:45:00 Questo video spiega come funziona il ragionamento tramite alberi degli obiettivi e sistemi esperti basati su regole. In entrambi gli esempi, il sistema è in grado di leggere storie e determinare le conseguenze delle azioni.

[MetaQuotes]

Lezione 4. Ricerca: Depth-First, Hill Climbing, Beam

4. Ricerca: Profondità, Arrampicata, Trave

In questo video di YouTube, Patrick Winston illustra diversi algoritmi di ricerca, tra cui le ricerche Depth-first, Hill Climbing, Beam e Best-first. Usando una mappa come esempio, dimostra i vantaggi e i limiti di ciascun algoritmo e come la comprensione di diversi metodi di ricerca può migliorare le capacità di risoluzione dei problemi. Winston discute anche dell'applicazione degli algoritmi di ricerca nei sistemi intelligenti, utilizzando il sistema Genesis per rispondere alle domande sulla storia di Macbeth. Introduce anche il concetto di vittoria di Pirro e come i programmi di ricerca possono scoprire tali situazioni esaminando i grafici e riportando i loro risultati in inglese. Nel complesso, il video fornisce una panoramica completa degli algoritmi di ricerca e del loro utilizzo pratico in scenari reali.

• 00:00:00 In questa sezione, Patrick Winston discute diversi metodi di ricerca e come si collegano alle nostre capacità di risoluzione dei problemi. Dimostra l'importanza di un buon algoritmo di ricerca con l'esempio di trovare il percorso ottimale da un punto all'altro su una mappa. Introduce anche il concetto di una ricerca al British Museum, in cui viene esplorato ogni possibile percorso, ma osserva che questo metodo non è efficiente. Continua a discutere di profondità, scalata in collina e ricerca del raggio e di come possono essere utilizzati in diversi scenari. Sottolinea che la comprensione di diversi algoritmi di ricerca può aiutare a sviluppare l'intuizione sulla risoluzione dei problemi e può anche fornire informazioni su come i nostri cervelli affrontano i problemi.
  
  
• 00:05:00 In questa sezione vengono introdotti i concetti di ricerca Depth-first, Hill Climbing e Beam utilizzando l'esempio di una mappa. L'algoritmo del British Museum viene utilizzato per illustrare come tutti i possibili percorsi possono essere trovati senza mordersi la coda in una mappa. Sebbene la ricerca sia rappresentata attraverso le mappe, è chiaro che non è limitata a esse e riguarda in realtà le scelte che vengono fatte quando si cerca di prendere decisioni. La ricerca in profondità è una delle ricerche mostrate e consiste nell'andare avanti in modo risoluto, scegliere un percorso e tornare indietro quando ci si trova di fronte a un vicolo cieco. Il processo di backtracking viene anche introdotto come un modo per rendere l'algoritmo più efficiente.
  
  
• 00:10:00 In questa sezione, il video illustra due algoritmi di ricerca principali: la ricerca in profondità e la ricerca in ampiezza. La ricerca in profondità è meglio utilizzata in combinazione con la tecnica di backtracking opzionale, in quanto può evitare di perdere un percorso che porta all'obiettivo. La ricerca in ampiezza costruisce un albero livello per livello e completa un percorso che conduce alla meta. Il video quindi testa entrambi gli algoritmi di ricerca su un problema campione, spostando la posizione iniziale e regolando la ricerca di conseguenza. Viene introdotto un diagramma di flusso per dimostrare l'algoritmo per la ricerca, utilizzando una coda per rappresentare i percorsi in esame.
  
  
• 00:15:00 In questa sezione, il relatore spiega come funziona l'algoritmo Depth-first Search. L'algoritmo inizia con l'inizializzazione della coda e l'estensione del primo percorso sulla coda. Dopo aver esteso s, l'oratore ottiene due percorsi, s va in a e s va in b. Per la ricerca Depth-first, i nuovi percorsi estesi vengono inseriti all'inizio della coda in modo che l'algoritmo possa continuare a scendere nell'albero di ricerca. L'oratore spiega anche che la ricerca in ampiezza utilizza lo stesso algoritmo della ricerca in profondità con una riga modificata, che consiste nel mettere i nuovi percorsi in fondo alla coda invece che in primo piano.
  
  
• 00:20:00 In questa sezione, apprendiamo i limiti della ricerca in ampiezza e come migliorarla. L'algoritmo è considerato inefficiente e non può dire se si sta avvicinando o allontanando dall'obiettivo. Inoltre, spesso estende i percorsi che vanno allo stesso nodo più di una volta e dobbiamo evitarlo. Modificando l'algoritmo per non estendere un percorso a meno che un nodo finale non sia stato esteso in precedenza, possiamo evitare di perdere tempo con percorsi duplicati. Utilizzando questo metodo, notiamo un miglioramento significativo dell'efficienza della ricerca e della qualità del percorso.
  
  
• 00:25:00 In questa sezione, il video esplora la ricerca Hill Climbing come approccio più informato per trovare il nodo obiettivo considerando la distanza dal nodo. Simile alla ricerca Depth-first, Hill Climbing elenca le opzioni lessicalmente e rompe i pareggi in base alla vicinanza al nodo obiettivo. Ciò si traduce in un percorso più rettilineo senza backtracking, anche se potrebbe non essere sempre il percorso ottimale. Il video dimostra che Hill Climbing produce meno accodamenti e un percorso più diretto rispetto a Depth-First Search. Il video incoraggia l'uso dell'euristica negli algoritmi di ricerca, se disponibili.
  
  
• 00:30:00 In questa sezione, l'istruttore discute la tecnica della Beam Search, un complemento o un'aggiunta alla ricerca in ampiezza che consente una ricerca informata utilizzando l'euristica. Beam Search imposta un limite al numero di percorsi da considerare a ciascun livello e mantiene solo i primi due percorsi che possono avvicinarsi all'obiettivo sfruttando le informazioni aggiuntive o la misurazione euristica della distanza dall'obiettivo. L'istruttore afferma che Hill Climbing è anche una ricerca informata che aggiunge nuovi percorsi all'inizio della coda considerando la distanza dall'obiettivo, che sono ordinati per mantenere tutto dritto.
  
  
• 00:35:00 In questa sezione, il relatore parla di Beam Search e Best-first Search, due algoritmi di ricerca aggiuntivi che possono essere utilizzati in spazi continui come le montagne. Beam Search comporta la selezione e il mantenimento dei percorsi w best come soluzione, mentre la Best-first Search prevede di lavorare sempre sul nodo foglia più vicino all'obiettivo e può saltare nell'albero di ricerca. L'arrampicata in collina può incontrare problemi in spazi continui, come rimanere bloccati in un massimo locale o non essere in grado di muoversi in una zona pianeggiante. Infine, il relatore illustra un problema aggiuntivo con Hill Climbing in spazi ad alta dimensione, dove può essere presente un ponte tagliente.
  
  
• 00:40:00 In questa sezione, il video discute l'intelligenza di modellazione e la necessità di algoritmi di ricerca nella costruzione di sistemi intelligenti. L'oratore utilizza l'esempio di una mappa topografica per illustrare come possiamo essere ingannati nel pensare di essere in cima, quando in realtà non lo siamo. Da qui il concetto di ricerca, necessario per fare progetti e valutare scelte. L'oratore dimostra quindi l'uso del sistema Genesis per rispondere a domande sulla storia di Macbeth utilizzando un algoritmo di ricerca. Il sistema assorbe informazioni, costruisce un grafico di elaborazione e cerca schemi nella storia relativi alla vendetta e ad altri concetti di livello superiore.
  
  
• 00:45:00 In questa sezione, Patrick Winston discute il concetto di vittoria di Pirro, che è una situazione in cui tutto sembra andare bene all'inizio, ma alla fine porta a conseguenze negative. Dimostra come i programmi di ricerca possono scoprire tali informazioni guardando attraverso i grafici e possono rispondere a domande basate su tali informazioni. I programmi utilizzano una combinazione di affermazioni esplicite e regole if/then per costruire questi grafici e riportare le informazioni in inglese. Winston afferma inoltre che questi programmi possono generare risposte di buon senso e pensieri di livello superiore riferendo sulle ricerche che hanno prodotto le informazioni. Infine, dimostra la capacità del sistema di rispondere a domande sul carattere e le motivazioni di Macbeth utilizzando l'output del linguaggio generato da un sistema parser.

[MetaQuotes]

Lezione 5. Ricerca: Ottimale, Branch and Bound, A*

5. Ricerca: Ottimale, Branch and Bound, A*

Il video discute diversi algoritmi di ricerca per trovare il percorso più breve tra due luoghi, concentrandosi sull'esempio della Route 66 tra Chicago e Los Angeles. Il video introduce il concetto di distanza euristica e fornisce esempi di diversi algoritmi di ricerca, come hill climbing, beam search e branch and bound. Il relatore sottolinea l'importanza di utilizzare euristiche ammissibili e coerenti nell'algoritmo A* per ottimizzare la ricerca. Inoltre, il video rileva l'efficacia dell'utilizzo di un elenco esteso e delle distanze aeree per determinare i limiti inferiori del percorso più breve. In definitiva, il video si conclude con la promessa di discutere ulteriori perfezionamenti dell'algoritmo A* nella prossima lezione.

• 00:00:00 In questa sezione, il professore discute su come trovare il percorso più breve tra due luoghi, concentrandosi sull'esempio della Route 66 tra Chicago e Los Angeles. Cita la creazione del sistema autostradale interstatale da parte del presidente Eisenhower, che voleva replicare la capacità dell'esercito tedesco di spostare rapidamente le truppe nel paese. Il professore introduce poi il concetto di distanza euristica e come può aiutare a trovare il percorso migliore, anche se non sempre è vero. Fornisce anche esempi di diversi algoritmi di ricerca, come l'arrampicata in collina e la ricerca del raggio, che mirano a trovare il percorso migliore essendo vicino alla destinazione.
  
  
• 00:05:00 In questa sezione, il professore discute il concetto di distanza euristica e il principio di problem solving chiedendo a qualcuno che conosce la risposta. Usando l'esempio di trovare il percorso più breve su una mappa, il professore suggerisce di seguire il percorso suggerito da Juana, ma lo verifica controllando che tutti gli altri possibili percorsi finiscano per essere più lunghi del percorso suggerito. Il professore elabora il processo di calcolo della lunghezza del percorso e di scelta del percorso più breve da estendere, finché la lunghezza del percorso non corrisponde a quella suggerita da Juana.
  
  
• 00:10:00 In questa sezione, l'oratore discute su come trovare il percorso più breve senza un oracolo. L'approccio prevede l'estensione del percorso più breve finora fino a raggiungere l'obiettivo. Il relatore fornisce un esempio per illustrare il processo di ricerca del percorso più breve considerando percorsi con lunghezze non negative. L'approccio controlla se parte del lavoro svolto finora è andato sprecato e, in caso contrario, la lunghezza del percorso è la più breve. L'oratore spiega che questo approccio può trovare il percorso più breve, ma potrebbero esserci altri percorsi se esistono lunghezze di lunghezza zero.
  
  
• 00:15:00 In questa sezione del video, l'oratore dimostra l'uso di branch e bound per trovare il percorso più breve su una mappa più complicata. Menzionano la decorazione del diagramma di flusso e spiegano il processo di inizializzazione della coda, test del primo percorso sulla coda ed estensione dei percorsi che non sono vincenti. L'oratore osserva che l'approccio branch and bound mette molti percorsi in coda ed estende molti percorsi che non sono ottimali, ma questo può essere migliorato estendendo solo percorsi che non sono stati estesi in precedenza. Il relatore sottolinea l'importanza di utilizzare solo l'approccio dei percorsi estesi per trovare percorsi ottimali.
  
  
• 00:20:00 In questa sezione viene introdotto il concetto di elenco esteso come miglioramento dell'aggiustamento dell'algoritmo branch-and-bound. L'elenco esteso impedisce all'algoritmo di estendere percorsi che sono già stati estesi e che hanno lunghezze di percorso maggiori rispetto a quelli che hanno già raggiunto lo stesso punto. Mantenendo un elenco esteso, è possibile eliminare vaste aree dell'albero, riducendo il numero di estensioni necessarie per raggiungere una soluzione. Rispetto all'esempio precedente, il nuovo algoritmo richiede solo 38 estensioni invece di 835, con un notevole risparmio di tempo computazionale.
  
  
• 00:25:00 In questa sezione viene introdotto il concetto di utilizzo delle distanze aeree per determinare il limite inferiore per il percorso più breve possibile. La distanza accumulata e la distanza aerea vengono aggiunte per fornire un limite inferiore sul percorso. La simulazione viene quindi dimostrata con la selezione del percorso con la distanza potenziale più breve da S a G. In caso di parità di punteggio, viene scelto il percorso con il valore lessicalmente minimo.
  
  
• 00:30:00 In questa sezione, il relatore discute l'uso dell'euristica per velocizzare gli algoritmi di ricerca dei grafici. L'utilizzo di un'euristica ammissibile è quando è garantito che una stima è inferiore alla distanza effettiva. L'elenco esteso è più utile rispetto all'utilizzo di una di queste euristiche con limite inferiore. Tuttavia, l'efficacia dell'euristica dipende dal problema e, modificando il posizionamento della posizione iniziale, è possibile alterare i risultati della ricerca. In definitiva, è importante notare che l'uso dell'euristica potrebbe non ripetere i movimenti attraverso lo stesso nodo, ma non farà necessariamente qualcosa di essenziale per una ricerca efficiente.
  
  
• 00:35:00 In questa sezione, il video discute A*, un algoritmo di ricerca che combina sia l'euristica ammissibile che l'algoritmo branch and bound. Utilizzando entrambe le tecniche, A* può migliorare notevolmente le proprie prestazioni individuali. L'euristica ammissibile utilizza un obiettivo rigoroso mentre l'algoritmo branch and bound comprende l'esplorazione dello spazio coinvolta. Il video mostra come A* può risolvere i problemi in modo più efficiente quando entrambe le tecniche vengono utilizzate insieme. Tuttavia, il video rileva anche che alcune circostanze possono rendere impossibile l'ammissibilità se la ricerca va oltre le mappe tradizionali. Di conseguenza, la gerarchia ammissibile e l'algoritmo A* potrebbero diventare meno efficaci nel trovare soluzioni ottimali.
  
  
• 00:40:00 In questa sezione, il professore spiega il concetto di euristica ammissibile nell'algoritmo A*. Mostra un esempio di mappa con distanze dispari e spiega come l'uso di un'euristica ammissibile non sempre porti a trovare il percorso più breve. Il professore sottolinea che l'euristica ammissibile funziona solo per le mappe e che per far funzionare l'algoritmo in situazioni che non sono mappe, occorre qualcosa di più forte dell'ammissibilità nell'euristica. Il video si conclude con la promessa di discutere di questo perfezionamento nella prossima conferenza.
  
  
• 00:45:00 In questa sezione, il docente discute i requisiti affinché una funzione euristica funzioni all'interno dell'algoritmo A*. Introduce i concetti di ammissibilità e coerenza, spiegando che una funzione euristica deve essere sia ammissibile che coerente per funzionare in situazioni in cui non è una mappa. Mostra che l'uso di un'euristica ammissibile ma incoerente può causare il fallimento dell'algoritmo, anche in scenari in cui un'euristica coerente avrebbe funzionato. Infine, il docente sottolinea l'importanza di utilizzare ogni vantaggio disponibile per ottimizzare l'algoritmo A*, incluso l'utilizzo di un elenco esteso e di un'appropriata funzione euristica.