Autogenerated Advertisements (AGAs) can be a concern for consumers if they suspect that Artificial Intelligence (AI) was involved. Consumers may have an opposing stance against AI, leading companies to miss profit opportunities and reputation loss. Hence, companies need ways of managing consumers’ con-cerns. As a part of designing such advices we explore consumers’ discernment ability (DA) of AGAs. A quantitative survey was used to explore consumers’ DA of AGAs. In order to do this, we administered questionnaires to 233 re-spondents. A statistical analysis including Z-tests, of these responses suggests that consumers can hardly pick out AGAs. This indicates that consumers may be guessing and thus do not possess any significant DA of our AGAs.

Artificial Intelligence (AI) and Machine Learning (ML) are shaping marketing activities through digital innovations. Competition is a familiar concept for any digital retailer, and the digital transformation provides hopes for gaining a competitive edge over competitors. Those who do not adopt digital innovations risk getting outcompeted by those who do. This study aims to identify AI mar-keting (AIM) adoptions used for ad optimization with Reinforcement Learning (RL). A scoped literature review is used to find ad optimization adoptions re-search trends with RL in AIM. Scoping this is important both to research and practice as it provides spots for novel adaptations and directions of research of digital ad optimization with RL. The results of the review provide several differ-ent adoptions of ad optimization with RL in AIM. In short, the major category is Ad Relevance Optimization that takes several different forms depending on the purpose of the adoption. The underlying found themes of adoptions are Ad Attractiveness, Edge Ad, Sequential Ad and Ad Criteria Optimization. In conclusion, AIM adoptions with RL is scarce, and recommendations for future research are suggested based on the findings of the review.

Marketers need new ways of generating campaigns artificially for their marketing activities. Many marketers assume proprietary systems are individualized enough. This article investigates an order of models used to measure how reliably a system can generate campaigns artificially while producing a campaign classification and generation models that are integrated into an intelligent marketing system. The order is between a Classification Model (CM) and a Generation Model (GM). The order also functions as an iterative model improvement process for developing the models by evaluating the models' accuracy distributions. The CM received a mean accuracy of 100%. The GM received 98.9% mean accuracy and a reproducibility score of 96.2%, implying the vast potential for increased resource savings, marketing precision, and less consumer annoyance. The conclusion is that the developed system can reliantly construct campaigns.

This study presents a novel taxonomy of short message service campaigns, for the purpose of building an intelligent marketing system. The main issue of mass marketing is that one size does not fit everybody. In other words, it is challenging to meet different consumer needs. With the help of artificial intelligence, marketers can be supported to overcome some of these challenges. This study uses a mixed methods approach where design science and grounded theory is used to produce a short message service campaign taxonomy for a future intelligent marketing system. Data collection consisted of 386 previously active campaigns used over 33 months to build the taxonomy. An experimental study was conducted to test the effectiveness of the proposed taxonomy. The experiments involved automatic generation of campaign messages. The validity of these campaign messages, and hence the proposed taxonomy, was ascertained by analysing the messages within a business context. The study concludes that the system, intertwined with the taxonomy, performs comparably to a regular campaign. Another proof of concept is that the business context deemed the generated campaign texts to be both semantically and syntactically similar to run them in active campaigns as experiments.

Being able to accurately predict several attributes related to size is vital for services supporting online fitting. In this paper, we investigate a data-driven approach, while comparing two different supervised modeling techniques for predictive regression; standard multiple linear regression and neural networks. Using a fairly large, publicly available, data set of high quality, the main results are somewhat discouraging. Specifically, it is questionable whether key attributes like sleeve length, neck size, waist and chest can be modeled accurately enough using easily accessible input variables as sex, weight and height. This is despite the fact that several services online offer exactly this functionality. For this specific task, the results show that standard linear regression was as accurate as the potentially more powerful neural networks. Most importantly, comparing the predictions to reasonable levels for acceptable errors, it was found that an overwhelming majority of all instances had at least one attribute with an unacceptably high prediction error. In fact, if requiring that all variables are predicted with an acceptable accuracy, less than 5% of all instances met that criterion. Specifically, for females, the success rate was as low as 1.8%.

We show how an exploratory tool for association rule mining can be used for efficient multi-objective optimization of marketing campaigns for companies within the fashion retail industry. We have earlier designed and implemented a novel digital tool for mining of association rules from given basket data. The tool supports efficient finding of frequent itemsets over multiple hierarchies and interactive visualization of corresponding association rules together with numerical attributes. Normally when optimizing a marketing campaign, factors that cause an increased level of activation among the recipients could in fact reduce the profit, i.e., these factors need to be balanced, rather than optimized individually. Using the tool we can identify important factors that influence the search for an optimal campaign in respect to both activation and profit. We show empirical results from a real-world case-study using campaign data from a well-established company within the fashion retail industry, demonstrating how activation and profit can be simultaneously targeted, using computer-generated algorithms as well as human-controlled visualization.

Successful use of probabilistic classification requires well-calibrated probability estimates, i.e., the predicted class probabilities must correspond to the true probabilities. The standard solution is to employ an additional step, transforming the outputs from a classifier into probability estimates. In this paper, Venn predictors are compared to Platt scaling and isotonic regression, for the purpose of producing well-calibrated probabilistic predictions from decision trees. The empirical investigation, using 22 publicly available datasets, showed that the probability estimates from the Venn predictor were extremely well-calibrated. In fact, in a direct comparison using the accepted reliability metric, the Venn predictor estimates were the most exact on every data set.

special session Information

We are witnessing the beginning of a seismic shift in retail due to digitalization. However, what is meant by digitalization is less clear. Sometimes it is understood as means for automatization and sometimes it is regarded as equal to e-commerce. Sometimes digitalization is considered being both automatization and e-commerce trough new technology. In recent years there has been an increase in Internet and mobile devise usage within the retail sector and e-commerce is growing, encompassing both large and small retailers. Digital tools such as, new applications are developing rapidly in order to search for information about products based on price, health, environmental and ethical considerations, and also to facilitate payments. Also the fixed store settings are changing due to digitalization and at an overall level; digitalization will lead to existing business models being reviewed, challenged and ultimately changed. More specifically, digitalization has consequences for all parts of the physical stores including customer interface, knowledge creation, sustainability performance and logistics. As with all major shifts, digitalization comprises both opportunities and challenges for retail firms and employees, and these needs to be empirically studied and systematically analysed. The Swedish Institute for Innovative Retailing at University of Borås is a research centre with the aim of identifying and analysing emerging trends that digitalization brings for the retail industry.

We present two new parallel implementations of the ensemble learning methods Random Forests (RF) and Extremely Randomized Trees (ERT), called gpuRF and gpuERT, for emerging many-core platforms, e.g., contemporary graphics cards suitable for general-purpose computing (GPGPU). RF and ERT are two ensemble methods for generating predictive models that are of high importance within machine learning. They operate by constructing a multitude of decision trees at training time and outputting a prediction by comparing the outputs of the individual trees. Thanks to the inherent parallelism of the task, an obvious platform for its computation is to employ contemporary GPUs with a large number of processing cores. Previous parallel algorithms for RF in the literature are either designed for traditional multi-core CPU platforms or early history GPUs with simpler architecture and relatively few cores. For ERT, only briefly sketched parallelization attempts exist in the literature. The new parallel algorithms are designed for contemporary GPUs with a large number of cores and take into account aspects of the newer hardware architectures, such as memory hierarchy and thread scheduling. They are implemented using the C/C++ language and the CUDA interface to attain the best possible performance on NVidia-based GPUs. An experimental study comparing the most important previous solutions for CPU and GPU platforms to the novel implementations shows significant advantages in the aspect of efficiency for the latter, often with several orders of magnitude.

Mark-split is a garbage collection algorithm that combines advantages of both the mark-sweep and the copying collection algorithms. In this paper, we present a parallel mark-split garbage collector (GC). Our parallel design introduces and makes use of an efficient concurrency control mechanism for handling the list of free memory intervals. This mechanism is based on a lock-free skip-list design which supports an extended set of operations. Beside basic operations, it can perform a composite one that can search and remove and also insert two elements atomically. We have implemented the parallel mark-split GC in OpenJDK’s HotSpot virtual machine. We experimentally evaluate our collector and compare it with the default concurrent mark-sweep GC in HotSpot, using the DaCapo benchmarks, on two contemporary multiprocessor systems; one has 12 Intel Nehalem cores with HyperThreading and the other has 48 AMD Bulldozer cores. The evaluation shows that our parallel mark-split keeps the characteristics of the sequential mark-split, that it performs better than the concurrent mark-sweep in applications that have low live/garbage ratio, and have live objects locating contiguously, therefore being marked consecutively. Our parallel mark-split performs significantly better than a trivial parallelization based on locks in terms of both collection time and scalability.

This brief announcement provides a high level overview of a parallel mark-split garbage collector. Our parallel design introduces and makes use of an efficient concurrency control mechanism based on a lock-free skip-list design for handling the list of free memory inter- vals. We have implemented the parallel mark-split garbage collector in OpenJDK HotSpot as a parallel and concurrent garbage collector for the old generation. We experimentally evaluate the collector and compare it with the default concurrent mark-sweep garbage collector in OpenJDK HotSpot, using the DaCapo benchmarks.

We present two new parallel implementations of the tree-ensemble algorithms Random Forest (RF) and Extremely randomized trees (ERT) for emerging many-core platforms, e.g., contemporary graphics cards suitable for general-purpose computing (GPGPU). Random Forest and Extremely randomized trees are ensemble learners for classification and regression. They operate by constructing a multitude of decision trees at training time and outputting a prediction by comparing the outputs of the individual trees. Thanks to the inherent parallelism of the task, an obvious platform for its computation is to employ contemporary GPUs with a large number of processing cores. Previous parallel algorithms for Random Forests in the literature are either designed for traditional multi-core CPU platforms or early history GPUs with simpler hardware architecture and relatively few number of cores. The new parallel algorithms are designed for contemporary GPUs with a large number of cores and take into account aspects of the newer hardware architectures as memory hierarchy and thread scheduling. They are implemented using the C/C++ language and the CUDA interface for best possible performance on NVidia-based GPUs. An experimental study comparing with the most important previous solutions for CPU and GPU platforms shows significant improvement for the new implementations, often with several magnitudes.

Garbage collectors are important components of many modern programming languages and runtime systems. Mark-split is a garbage collection algorithm that combines advantages of both mark-sweep and copying collection algorithms. With the switch to multi-core and many-core microprocessors, parallelism becomes a core issue in the design of any algorithm or software system. In this paper, we present a concurrent design of the mark-split garbage collector. Our concurrent design algorithmically introduces and makes use of an efficient concurrency control mechanism for handling the list of free intervals. This mechanism is based on a lock-free skip-list design and supports an extended set of operations that allows, atomically and in a lock-free manner, to search and remove and also to insert two intervals at the same time. We have implemented the concurrent mark-split garbage collector in OpenJDK HotSpot as a garbage collector for the tenured generation. We present experimental evaluation of our concurrent collector and compare it with the default concurrent marks-sweep garbage collector present in OpenJDK HotSpot, using the Dacapo benchmarks. The evaluation shows that our concurrent mark-split performs better than the concurrent mark-sweep garbage collector in some applications.

A lock-free bag data structure supporting unordered buffering is presented in this paper. The algorithm supports multiple producers and multiple consumers, as well as dynamic collection sizes. To handle concurrency efficiently, the algorithm was designed to thrive for disjoint-access-parallelism for the supported semantics. Therefore, the algorithm exploits a distributed design combined with novel techniques for handling concurrent modifications of linked lists using double marks, detection of total emptiness, and efficient memory management with hazard pointer handover. Experiments on a 24-way multi-core platform show significantly better performance for the new algorithm compared to previous algorithms of relevance.

We present a new algorithm for implementing a multi-word compare-and-swap functionality supporting the Read and CASN operations. The algorithm is wait-free under reasonable assumptions on execution history and benefits from new techniques to resolve conflicts between operations by using greedy helping and grabbing. Although the deterministic scheme for enabling grabbing somewhat sacrifices fairness, the effects are insignificant in practice. Moreover, unlike most of the previous results, the CASN operation does not require the list of addresses to be sorted before the operation is invoked, and the Read operation can read the current value without applying helping when the word to be read is within an ongoing transaction. Experiments using micro-benchmarks varying important parameters in three dimensions have been performed on two multiprocessor platforms. The results show similar performance as the lock-free algorithm by Harris et al. for most scenarios, and significantly better performance on scenarios with very high contention. This is altogether extraordinary good performance considering that the new algorithm is wait-free.

A lock-free FIFO queue data structure is presented in this paper. The algorithm supports multiple producers and multiple consumers and weak memory models. It has been designed to be cache-aware and work directly on weak memory models. It utilizes the cache behavior in concert with lazy updates of shared data, and a dynamic lock-free memory management scheme to decrease unnecessary synchronization and increase performance. Experiments on an 8-way multi-core platform show significantly better performance for the new algorithm compared to previous fast lock-free algorithms.

We present a lock-free version of the light-weight userlevel task management library called Wool, in an aim to show that even extremely well tuned, in terms of synchronization,applications can benefit from lock-free programming.Explicit multi-threading is an efficient way to exploit the offered parallelism of multi-core and multi-processor based systems. However, it can sometimes be hard to expressthe inherited parallelism in programs using a limited number of long lived threads. Often it can be more straightforwardto dynamically create a large number of small tasks that in turn automatically execute on the available threads.Wool is a promising and efficient library and framework that allows the programmer to create user tasks in C with a very low overhead. The library automatically executestasks and balances the load evenly on a given number of threads by utilizing work stealing techniques. However, thesynchronization for stealing tasks is based on mutual exclusion which is known to limit parallelism and efficiency. We have designed and implemented a new lock-free algorithmfor synchronization of stealing tasks in Wool. Experiments show similar or significantly improved performance on a setof benchmarks executed on a multi-core platform.

We present an efficient and practical lock-free method for semiautomatic (application-guided) memory reclamation based on reference counting, aimed for use with arbitrary lock-free dynamic data structures. The method guarantees the safety of local as well as global references, supports arbitrary memory reuse, uses atomic primitives that are available in modern computer systems, and provides an upper bound on the amount of memory waiting to be reclaimed. To the best of our knowledge, this is the first lock-free method that provides all of these properties. We provide analytical and experimental study of the method. The experiments conducted have shown that the method can also provide significant performance improvements for lock-free algorithms of dynamic data structures that require strong memory management.

An essential part of programming for multi-core and multi-processor includes ef cient and reliable means for sharing data. Lock-free data structures are known as very suitable for this purpose, although experienced to be very complex to design. In this paper, we present a software library of non-blocking abstract data types that have been designed to facilitate lock-free programming for non-experts. The system provides: i) ef cient implementations of the most commonly used data types in concurrent and sequential software design, ii) a lock-free memory management system, and iii) a run time-system. The library provides clear semantics that are at least as strong as those of corresponding lock-based implementations of the respective data types. Our software library can be used for facilitating lockfree programming; its design enables the programmer to: i) replace lock-based components of sequential or parallel code easily and ef ciently , ii) use well-tuned concurrent algorithms inside a software or hardware transactional system. In the paper we describe the design and functionality of the system. We also provide experimental results that show that the library can considerably improve the performance of software systems.

We present a new algorithm for implementing a multi-word compare-and-swap functionality supporting the Read and CASN operations. The algorithm is wait-free under reasonable assumptions on execution history and benefits from new techniques to resolve conflicts between operations by using greedy helping and grabbing. Although the deterministic scheme for enabling grabbing somewhat sacrifices fairness, the effects are insignificant in practice. Moreover, unlike most of the previous results, the CASN operation does not require the list of addresses to be sorted before calling, and the Read operation can read the current value without applying helping when the word to be read is within an ongoing transaction. Experiments using micro-benchmarks varying important parameters in three dimensions have been performed on two multiprocessor platforms. The results show similar performance as the lock-free algorithm by Harris et al. for most scenarios, and significantly better performance on scenarios with very high contention. This is altogether extraordinary good performance considering that the new algorithm is wait-free.

We present a practical lock-free shared data structure that efficiently implements the operations of a concurrent deque as well as a general doubly linked list. The implementation supports parallelism for disjoint accesses and uses atomic primitives which are available in modern computer systems. Previously known lock-free algorithms of doubly linked lists are either based on non-available atomic synchronization primitives, only implement a subset of the functionality, or are not designed for disjoint accesses. Our algorithm only requires single-word compare-and-swap atomic primitives, supports fully dynamic list sizes, and allows traversal also through deleted nodes and thus avoids unnecessary operation retries. We have performed an empirical study of our new algorithm on two different multiprocessor platforms. Results of the experiments performed under high contention show that the performance of our implementation scales linearly with increasing number of processors. Considering deque implementations and systems with low concurrency, the algorithm by Michael shows the best performance. However, as our algorithm is designed for disjoint accesses, it performs significantly better on systems with high concurrency and non-uniform memory architecture.