Geforce gtx 1080 ti gpu

The present study used three ML frameworks for estimating evaporation. These models are Extreme Gradient Boosting (XGB)⁴³ , ElasticNet Linear Regression (ElasticNet LR)⁵⁰ , and Long Short-Term Memory (LSTM)^{45 (link)}. The training and testing for the machine learning models were carried out by using the TensorFlow framework on an NVIDIA GeForce GTX 1080 Ti GPU.

The National Institutes of Health (NIH) pancreas segmentation dataset¹⁷, ¹⁸ contains 82 contrast‐enhanced abdominal CT volumes, and it is the most recognized public dataset for pancreas segmentation. Each CT scan has a resolution of 512×512×L, and L varies from patient to patient within the range of 181–466. In this work, the CT scans are resized to [208, 208] based on the approximate range of the pancreas label in the scans to ensure that each slice contains complete pancreas areas. Meanwhile, the CT volumes are randomly split into four folds, where three folds are used for training and the remaining one is used for testing, that is, 4‐fold cross‐validation. Metrics dice similarity coefficient (DSC) and Jaccard are used to evaluate the similarity between the obtained prediction maps and their corresponding ground truths. Besides, average symmetric surface distance (ASD) and root‐mean‐squared error (RMSE) are used to determine whether the pancreas edge is well segmented compared with the edge of the ground truths. Our algorithm is implemented by PyTorch environment,¹⁹ and the ADAU‐Net processing is conducted on one NVIDIA GeForce GTX 1080Ti GPU with 11 GB memory. In the experiment, Adam optimizer is used with the learning rate of 0.0001, and the momentum of 0.9 and 0.99. The networks are optimized from scratch with a batch size of 1.

The computer hardware included an Intel Core i5-8300H CPU @ 2.30 GHz and an NVIDIA GeForce GTX 1080 Ti GPU. The model was trained on a single GPU using Python 3.8 and CUDA 10.2, with an initial learning rate of 0.01. The maximum number of training iterations was set to 50, with a momentum of 0.937. The batch size was set to 48. The performance of the model was evaluated using precision (P), recall (R), average precision (AP), and mean average precision (mAP). The definitions of these metrics are as follows: $$\mathrm{P}=\frac{\mathrm{T}\mathrm{P}}{\mathrm{T}\mathrm{P}+\mathrm{F}\mathrm{P}}\times 100\mathrm{\%}$$
$$\mathrm{R}=\frac{\mathrm{T}\mathrm{P}}{\mathrm{T}\mathrm{P}+\mathrm{F}\mathrm{N}}\times 100\mathrm{\%}$$
$$\mathrm{A}\mathrm{P}={\int }_0^1\mathrm{P}\left(\mathrm{R}\right)\mathrm{d}\mathrm{R}\times 100\mathrm{\%}$$
$$\mathrm{m}\mathrm{A}\mathrm{P}=\frac{{\sum }_{\mathrm{n}=1}^2\mathrm{A}{\mathrm{P}}_{\mathrm{n}}}{2}\times 100\mathrm{\%}$$
where TP, FP, and FN represent true positive, false positive, and false negative, respectively, with n representing the nth sample. In addition, to evaluate the computational capability and inference speed of the model, the number of parameters (Params), floating-point operations per second (FLOPs), and frames per second (FPS) were used as evaluation indicators.

We implemented and trained EDRnet using TensorFlow, version 1.13.1 for graphics processing unit (GPU), and Keras, version 2.2.4 for GPU. NumPy, version 1.16.4; Pandas, version: 0.25.3; Matplotlib, version 3.1.2; and scikit-learn, version 0.22.1, were used to build the model and analyze the results. We trained the models with the Adam optimizer and a binary cross-entropy cost function in equation 9 with a learning rate of 0.0001 and a batch size of 64 on the NVIDIA GeForce GTX 1080 Ti GPU as
where y_i is the label (ie, 1 for deceased and 0 for survived) and p(y_i) is the predicted probability of each patient being deceased for the batch size N number of patients.

In our experiments, an Adam optimizing function was used for training the entire network of the default setting parameters. The default learning rate was initially set at 0.0004 with a decreasing step 0.0001, whereas the validation accuracy did not increase after more than 10 epochs. The learning-rate threshold was set to 0.0001. A cross-entropy loss function was used to train the model. Weight constraint of dropout (p = 0.5) used to avoid overfitting were applied to the output filters before advancing to the next BGRU layer. The algorithm was enforced to complete when validation accuracy stopped increasing. When the model had iterated about 130 epochs, it converged and predictive performance stabilized. Our model was implemented in Keras, which is a publicly available deep-learning software. Weights in the CRRNN were initialized using default values, and the entire network was trained on a single NVIDIA GeForce GTX 1080 Ti GPU with 12GB memory.

We implemented our proposed model using the TensorFlow package (version 1.14.0), which provides a Python (version 3.6.8; Python Software Foundation) application programming interface for tensor manipulation. We also used Keras (version 2.2.4) as the official front end of TensorFlow. We trained the models with the Adam optimizer with a learning rate of 0.0001, a batch size of 16, and the loss functions of binary cross-entropy and dice loss [17 (link)] on the GeForce GTX 1080 Ti GPU (NVIDIA Corporation).
For the performance evaluation, 5-fold cross-validation was performed to confirm its generalization ability. The augmented training data set (n=48,874) was randomly shuffled and divided into five equal groups in a stratified manner. Subsequently, four groups were selected for training the model, and the remaining group was used for validation. This process was repeated five times by shifting the internal validation group. Then, we averaged the mean validation costs of the five internal validation groups according to each epoch and found the optimal epoch that provides the lowest validation cost. The testing data set was evaluated only after the model was completely trained using the training and validation data set.