Search

Cervical cancer is one of the deadliest diseases in women worldwide. It is caused by long-term infection of the skin cells and mucosal cells of the genital area of women. The most disturbing thing about this cancer is the fact that it does not show any symptoms when it occurs. In the diagnosis and prognosis of cervical cancer disease, machine learning has the potential to help detect it at an early stage. In this paper, we analyzed different supervised machine learning techniques to detect cervical cancer at an early stage. To train the machine learning model, a cervical cancer dataset from the UCI repository was used. The different methods were evaluated using this dataset of 858 cervical cancer patients with 36 risk factors and one outcome variable. Six classification algorithms were applied in this study, including an artificial neural network, a Bayesian network, an SVM, a random tree, a logistic tree, and an XG-boost tree. All models were trained with and without a feature selection algorithm to compare the performance and accuracy of the classifiers. Three feature selection algorithms were used, namely (i) relief rank, (ii) wrapper method and (iii) LASSO regression. The maximum accuracy of 94.94% was recorded using XG Boost with complete features. It is also observed that for this dataset, in some cases, the feature selection algorithm performs better. Machine learning has been shown to have advantages over traditional statistical models when it comes to dealing with the complexity of large-scale data and uncovering prognostic features. It offers much potential for clinical use and for improving the treatment of cervical cancer. However, the limitations of prediction studies and models, such as simplified, incomplete information, overfitting, and lack of interpretability, suggest that further efforts are needed to improve the accuracy, reliability, and practicality of clinical outcome prediction. [ABSTRACT FROM AUTHOR]

Cyber-physical systems (CPS) consist of a variety of multicore architectures, including central processing units (CPU) and graphical processing units (GPU). In general, programmers assign sequential programs to the CPU while parallel applications are assigned to the GPU. This article provides a method for mapping an OpenCL application to a heterogeneous multicore architecture using active fuzzy learning to determine the adequacy and processing capabilities of the application. During learning, subsamples are created by developing a machine learning-based device suitability classifier that predicts which processors would have excessive computational compatibility for running OpenCL programs. In addition, this study integrates an active learning model based on entropy with a fuzzification model to find nonoverlapping patterns. To minimize rule generation, the fuzzification-based weighted probabilistic technique is presented. The defuzzification process is optimized by using uncertainty values in conjunction with classification probability. In addition, 20 different features are proposed for extraction using the newly developed LLVM-based static analyzer. The correlation analysis approach is used to determine the optimal subset of features. The synthetic minority oversampling approach with and without feature selection is used to differentiate the class imbalance problem. Instead of manually modifying the machine learning classifier, a tree-based pipeline construction approach is used to determine the optimal classifier and associated hyperparameters. Experiments are then conducted on a set of benchmarks to verify the performance of the designed model. The results show that by increasing the number of training examples and including an entropy uncertainty measure, the proposed model is able to support and improve decision boundaries. We achieved a high F-measure of 0.77 and a ROC of 0.92 by optimizing and reducing the feature subsets. [ABSTRACT FROM AUTHOR]

Massive data parallelism can be achieved by using general-purpose graphics processing units (GPGPU) with the help of the OpenCL framework. When smaller data with higher GPU memory is executed, it results in a low resource utilization ratio and energy inefficiencies. Up until now, there is no existing model to share GPU for further execution. In addition, if the kernel pair requires the same computation resource, then kernel merging also results in a significant increase in execution time. Therefore, optimal device selection, as well as kernel merging, can significantly speed up the execution performance for a batch of jobs. This paper proposes a kernel merging method that leads to high GPU occupancy. As a result, it reduces execution time and increases GPU utilization. Additionally, a machine learning (ML)-based GPU sharing mechanism is presented to select pairs of kernels in OpenCL frameworks. The model first selects suitable architecture for the jobs and then merges GPU kernels for better resource utilization. From all the GPU candidates, the optimal pair of the kernel concerning data size is selected. The experimental results show that the developed model can achieve 0.91 F1-measure for device selection and 0.98 for the scheduling scheme of kernel merging. • A ML-based kernel merging classification model to predict the suitability of OpenCL kernels. • Extraction and selection of significant features to forecast the speedup of the merged kernels. • A better result is obtained by using the 15 mainstream benchmark applications. [ABSTRACT FROM AUTHOR]