Tesla p100 gpu

Since we are able to represent every task as a classification problem, in each task we minimize the categorical cross-entropy loss. All models are trained with Adam³⁸ optimizer that is initialized with the default hyperparameters. Furthermore, we use different batch sizes depending on the number of trainable parameters and the available memory on the GPU cards. As a rule of thumb, we try to pick a batch size that allows us to use as much of the GPU memory as possible. All models are trained on Nvidia Tesla P100 GPUs.

This section includes a comprehensive overview of the proposed DCNN model’s architecture and training method, including the preparation of the dataset and experimental procedures. The suggested model for detecting plant leaf diseases begins with dataset preparation and concludes with model prediction. Python 3.8, TensorFlow Library version 2.10.0, NumPy 1.23.4, matplotlib 3.6.1, and OpenCV 4.6.0 are used to prepare the training dataset and implement the proposed DCNN model, respectively. The simulations, i.e., model development, training, validation, etc., are performed on an HP Z440 workstation consisting of core i7 12 cores of CPU and a DDR4 ram of 48 GB. The proposed scheme also utilized NVidia RTX-3090 Graphical Processor Unit (GPU), which uses the CUDA framework to allow the parallel processing speeds up the proposed model training and testing procedure. The workstation for implementing the proposed DCNN is equipped with a dual Intel Xeon Silver 4310 (12 cores, 24 threads, and 2.10Ghz) processor and six Nvidia Tesla P100 GPUs to expedite the training of deep neural networks. The following sections will explain all the important phases of the proposed plant disease detection framework in detail. The section that follows addresses the specifics of data set preparation and preprocessing.

To determine the accuracy of both single-view and dual-view architectures, both neural networks are trained on the paired synthesized topogram and volumetric CT dataset. For both models, an initial learning rate of 0.0002 on the Adam optimizer is used to minimize the mean-squared-error (MSE) loss function L(Y_pred, Y_truth) via stochastic gradient descent and backpropagation. All training was conducted on two SLI-connected NVIDIA Tesla P100 GPUs, each with 16 GB of VRAM. Model weights are saved locally every 10 epochs, and the training process automatically terminates after convergence. The weights with the lowest average loss are preserved and serialized.

The model was trained on 2.304 × 10⁵ semi-synthetic animals derived from recordings of 12 individuals. The model was trained only once and the same trained model was used throughout this work.
Training is as follows. We performed supervised learning with ground truth matches provided by the semi-synthetically generated data. A cross-entropy loss function was used. If neuron i and neuron j were matched by human, the cross-entropy loss function favors the model to output pi⁢j=1 . If neuron i and neuron j were not matched, the loss function favors the model to output pi⁢j=0 . The model was trained for 12 hr on a 2.40 GHz Intel machine with NVIDIA Tesla P100 GPU.
We trained different models with different hyperparameters and chose the one with best performance. The training curve for each model we trained is shown in Figure 2—figure supplement 1. All the models converged after 12 hr of training. We show the performance of trained models on a held-out validation set consisting of 12,800 semi-synthetic worms in Table 7. We chose the model with 6 layers and 128 dimensional embedding space since it reaches the highest performance and increasing the complexity of the model did not appear to increase the performance dramatically.

We trained a CNN using imbalanced and balanced datasets of 18,884 genes from 14,301 (imbalanced) and 35,362 (balanced) samples. A CNN requires input data in a two-dimensional matrix format, therefore a zero-padding to gene vectors was applied (18,884 increased to 19,044) to reshape them into 138 by 138 square matrices. The CNN included 4 back-to-back convolutional blocks, each consisting of a convolutional layer with a 3 × 3 convolutional kernel, followed by batch normalization and ReLU activation. Max pooling was applied after the second and fourth convolutional blocks to reduce the size of the features vector by half. After the last convolutional block, a 34 × 34 × 256 features vector was produced for each input and then flattened into a 295,936 × 1 embeddings vector. Two fully connected layers were then applied to this embeddings vector to gradually reduce the size to 47 × 1, finally arriving at classification softmax layer (Supplementary Fig. S1b). All ML analyses were performed on Nvidia Tesla P100 GPU with a memory capacity of 16 Gigabytes.