In production environments where applications generate vast data, minimizing downtime is critical. However, large-scale log data can overwhelm storage and computational resources, making system stability challenging to maintain. Poor logging practices worsen this by creating excessive, irrelevant, or unstructured logs that hinder efficient application-crash detection and resolution. This is an enterprise-wide issue often leading to resource exhaustion and prolonged downtime.To address this, we propose Log Sculptor, a tool that leverages GenAI (Large Language Models) to proactively analyze, identify, and improve logging practices in code. It provides recommendations for log statement adjustments (rectifications, additions, removals) and can apply these to produce code with optimized logs. Log Sculptor operates on a prompt-based approach.We benchmark Log Sculptor on nine open-source codebases annotated by industry practitioners for logging practices. It achieves results comparable to human experts and suggests further refinements to enhance logging. We analyze the cost-benefit trade-offs, demonstrating the potential of GenAI in transforming logging practices, improving debugging efficiency, reducing downtime, and increasing reliability in production environments.

Hyperspectral images (HSI) have a huge size, which makes their processing through neural networks cumbersome. We propose novel approximate computing techniques that leverage physical properties of the reflectance spectra to accelerate the processing of HSI images. This makes the images interpretable across various applications. We propose three spectral dimensionality reduction techniques. These techniques use spectral clustering methods that rely on reflectance values to capture inherent characteristics from hyperspectral images across diverse domains. We also evaluate existing spatial dimension reduction techniques and a combination of spatial + spectral dimension reduction techniques. We conduct extensive experiments on three real-world open-source datasets, encompassing urban and rural landscapes. Our techniques reduce the training time by up to 8x and inference time by up to 5x, while reducing the model size by up to 3x. Our techniques have a negligible impact on accuracy. By contrast, PCA and MNF techniques incur 3X higher pre-processing latency overheads than our techniques and also degrade the accuracy. Our techniques are promising for addressing the computational challenges of HSI processing.

Quantization is a technique to reduce the size and computation time of machine learning models by reducing the precision of model parameters. However, quantization may reduce the accuracy of the model—popular ML frameworks such as Pytorch and Tensorflow support the quantization process. A quantization process may differ in reducing the number of bits (8, 16, or 32) of model parameters, static, dynamic, and quantization aware training. In this paper, we evaluate the various features of the quantization process supported in Pytorch and Tensorflow on CNN and GNN based Recommendation models. We have compared Pytorch and Tensorflow quantization libraries for the memory efficiency and accuracy of the quantized models. The paper also presents and discusses an additional challenge of quantization in GNN based Recommendation models having embedding layers.

Machine learning, a data-driven approach, is widely used to automate applications. It has been observed that 80% of the time is spent in pre-processing the data to make it available for building machine learning models. Data scientists generally develop and test these pipelines, primarily in python (a popular language for building models) for a small (in thousands) number of records or data points. These pipelines may incur a non-linear increase in execution time when used in production for large-sized data (in 10s of millions to billions of records or data points); these pipelines are not scalable in performance for larger data sizes. We have observed some common performance anti-patterns across many ML pipelines coded by ML practitioners, such as abuse of data frames and nested statements, especially in lambda functions - some of these are not perceivable on small-sized data. Once recognized, these patterns can be replaced by a high-performing piece of code to utilize the underlying hardware optimally. This paper presents a framework, FASCA, to automatically identify the significant performance bottlenecks in an ML/DL pipeline using static and dynamic analysis. FASCA executes the pre-processing pipeline on a fraction of actual data and builds a performance model to identify the top bottleneck components experiencing performance degradation on larger data sizes. Further, the framework generates a high-performing alternative to the bottleneck component using state-of-the-art techniques. We have evaluated and presented the results for the ML pipeline in the Retail domain, where we observed a non-linear degradation in performance with an increase in data size. FASCA recommends and changes a set of bottleneck components to accelerate up to 300% on larger data size (millions of records).

With the advent of big data, training deep learning models quickly has gained prime significance. The faster a model is trained, the more relevant are its predictions in a given context. Deep learning is used for non structured data such as images, videos, sounds, text corpus, all of which represent a huge volume of data and also use complex models. Training these workloads can often take days or even weeks, because of various factors such as size of data, complexity of model, network and the underlying hardware infrastructure. The recognized divide and conquer solution to expedite the training process is to distribute either data or the model. Alas, the challenges of a distributed training setup are well known - creating and maintaining a cluster, enabling data or model parallelism along with uninterrupted communication across the cluster nodes.In this paper, we focus on two lightweight libraries for distributed deep learning, RaySGD and Horovod, which aim to alleviate these challenges by providing support for seamless parallellization. We conduct an in-depth benchmarking exercise to evaluate the performance of both libraries for training time(latency) incurred. Our experiments are conducted on a combination of various parameters such as hardware setup (CPU or GPU based), standard and manually coded models, real world and synthetic datasets. We also vary batch sizes of large workloads and number of worker nodes in a distributed setting. The insights obtained from our experiments act as guidelines for data scientists, facilitating the decision making process when conducting distributed training of big data applications on RaySGD or Horovod.

Recommender systems today face major challenges in keeping up with dynamic customer preferences. Disruptions or sudden changes in the environment affect customer preferences drastically and render historical data ineffective for modeling. With businesses relying heavily on Machine Learning(ML) based recommender systems for catering to customer preferences, the accuracy of timely recommendations gains prime significance.

Usage of an electronic media is increasing day by day and consequently the usage of applications. This fact has resulted in rapid growth of an application's data which may lead to violation of service level agreement (SLA) given to its users. To keep applications SLA compliance, it is necessary to predict the query response time before its deployment. The query response time comprises of two elements, computation time and IO access time. The latter includes time spent in getting data from disk subsystem and database/operating system (OS) cache. Correct prediction of a query performance needs to model cache behavior for growing data size. The complex nature of data storage and data access pattern by queries brings in difficulty to use only mathematical model for cache behavior prediction. In this paper, a Database Buffer Cache Simulator has been proposed, which mimics the behavior of the database buffer cache, which can be used to predict the cache misses for different types of data access by a query. The simulator has been validated using Oracle 11g and TPC-H benchmarks. The simulator is able to predict cache misses with an average error of 2%.

In a production system, increase in data size will increase the execution time of the application's SQL queries and degrade its performance. Tuning SQL queries in production requires additional efforts and cost. Time constraints during application development do not permit testing SQL queries with high data volumes. Having the capability to predict SQL query execution time for large data volumes can alert the developers to tune queries or database design upfront, in such scenarios. Application developers may use 'cost' of SQL query as given by optimizer based relational databases to estimate the SQL query execution time for large data sizes. However, the 'cost' based models may lead to large estimation errors as discussed in this paper. We have presented a modular approach of estimating SQL query execution time for high data volumes using measurements at low data volume. A compound SQL query execution plan is mapped to a sequential execution of a set of elementary steps. The execution time of a SQL query in isolation is predicted as summation of estimated execution time of all its elementary steps. We have built analytical models for estimating execution time of different IO access, DB cache access and SQL operators as function of data size for each such step. The proposed model dynamically adapts itself to the structure of the query execution plans and characteristics of the underlying hardware. We have evaluated the model by generating synthetic queries for all combinations of elementary steps for a range of data sizes. The model has also been validated with TPC-H benchmarks and three real life applications. The proposed model shows an average prediction error to be within 10%.