Search

Production imaging pipelines commonly operate using fixed-point arithmetic, and within these pipelines a core primitive is convolution by small filters - taking; convex combinations of fixed-point values in order to resample, interpolate, or denoise. We describe a new way to compute unbiased convex combinations of fixed-point values using sequences of averaging instructions, which exist on all popular CPU and DSP architectures but are seldom used. For a variety of popular kernels, our averaging; trees have higher performance and higher quality than existing standard practice.

Over the last decade, automatic differentiation (AD) has profoundly impacted graphics and vision applications --- both broadly via deep learning and specifically for inverse rendering. Traditional AD methods ignore gradients at discontinuities, instead treating functions as continuous. Rendering algorithms intrinsically rely on discontinuities, crucial at object silhouettes and in general for any branching operation. Researchers have proposed fully- automatic differentiation approaches for handling discontinuities by restricting to affine functions, or semi- automatic processes restricted either to invertible functions or to specialized applications like vector graphics. This paper describes a compiler-based approach to extend reverse mode AD so as to accept arbitrary programs involving discontinuities. Our novel gradient rules generalize differentiation to work correctly, assuming there is a single discontinuity in a local neighborhood, by approximating the prefiltered gradient over a box kernel oriented along a 1D sampling axis. We describe when such approximation rules are first-order correct, and show that this correctness criterion applies to a relatively broad class of functions. Moreover, we show that the method is effective in practice for arbitrary programs, including features for which we cannot prove correctness. We evaluate this approach on procedural shader programs, where the task is to optimize unknown parameters in order to match a target image, and our method outperforms baselines in terms of both convergence and efficiency. Our compiler outputs gradient programs in TensorFlow, PyTorch (for quick prototypes) and Halide with an optional auto-scheduler (for efficiency). The compiler also outputs GLSL that renders the target image, allowing users to interactively modify and animate the shader, which would otherwise be cumbersome in other representations such as triangle meshes or vector art.

PurposeTo provide insights into the role of formal and informal accounts in preventing the liquidation of a professional football club and in post-crisis rebuilding.Design/methodology/approachThis case study, framed as a conflict arena, covers an eight-year period of a high-profile struggle over the future of a professional football club. It uses a mixed methods design, including direct engagement with key actors involved in administration proceedings and transformation to a hybrid supporter-owned organisation.FindingsOur findings suggest that within the arena:• formal accounting and governance were of limited use in managing the complex network of relationships and preventing the abuse of power or existential crises. • informal accounting helped mobilise critical resources and maintain supporters’ emotional investment during periods of conflict. • informal accounts enabled both resistance and coalition-building in response to perceived abuse of power. • informal accounts were used by the Club as part of its legitimation activities.Originality/valueThis study provides theoretical and empirical insights into an unfolding crisis with evidence gathered directly from actors involved in the process. The conceptual framework developed in this paper creates new visibilities and possibilities for developing more effective accounting practices in settings that enable continuing emotional investment from supporters.

We present a method to automatically synthesize efficient, high-quality demosaicking algorithms, across a range of computational budgets, given a loss function and training data. It performs a multi-objective, discrete-continuous optimization which simultaneously solves for the program structure and parameters that best tradeoff computational cost and image quality. We design the method to exploit domain-specific structure for search efficiency. We apply it to several tasks, including demosaicking both Bayer and Fuji X-Trans color filter patterns, as well as joint demosaicking and super-resolution. In a few days on 8 GPUs, it produces a family of algorithms that significantly improves image quality relative to the prior state-of-the-art across a range of computational budgets from 10 s to 1000 s of operations per pixel (1 dB–3 dB higher quality at the same cost, or 8.5–200× higher throughput at same or better quality). The resulting programs combine features of both classical and deep learning-based demosaicking algorithms into more efficient hybrid combinations, which are bandwidth-efficient and vectorizable by construction. Finally, our method automatically schedules and compiles all generated programs into optimized SIMD code for modern processors.

We present a new algorithm to quickly generate high-performance GPU implementations of complex imaging and vision pipelines, directly from high-level Halide algorithm code. It is fully automatic, requiring no schedule templates or hand-optimized kernels. We address the scalability challenge of extending search-based automatic scheduling to map large real-world programs to the deep hierarchies of memory and parallelism on GPU architectures in reasonable compile time. We achieve this using (1) a two-phase search algorithm that first ‘freezes’ decisions for the lowest cost sections of a program, allowing relatively more time to be spent on the important stages, (2) a hierarchical sampling strategy that groups schedules based on their structural similarity, then samples representatives to be evaluated, allowing us to explore a large space with few samples, and (3) memoization of repeated partial schedules, amortizing their cost over all their occurrences. We guide the process with an efficient cost model combining machine learning, program analysis, and GPU architecture knowledge. We evaluate our method’s performance on a diverse suite of real-world imaging and vision pipelines. Our scalability optimizations lead to average compile time speedups of 49x (up to 530x). We find schedules that are on average 1.7x faster than existing automatic solutions (up to 5x), and competitive with what the best human experts were able to achieve in an active effort to beat our automatic results.

Median filters are a widely-used tool in graphics, imaging, machine learning, visual effects, and even audio processing. Currently, very-small-support median filters are performed using sorting networks, and large-support median filters are handled by O (1) histogram-based methods. However, the constant factor on these O (1) algorithms is large, and they scale poorly to data types above 8-bit integers. On the other hand, good sorting networks have not been described above the 7 X 7 case, leaving us with no fast way to compute integer median filters of modest size, and no fast way to compute floating point median filters for any size above 7 X 7. This paper describes new sorting networks that efficiently compute median filters of arbitrary size. The key idea is that these networks can be factored to exploit the separability of the sorting problem - they share common work across scanlines, and within small tiles of output. We also describe new ways to run sorting networks efficiently, using a sorting-specific instruction set, compiler, and interpreter. The speed-up over prior work is more than an order of magnitude for a wide range of data types and filter sizes. For 8-bit integers, we describe the fastest median filters for all sizes up to 25 X 25 on CPU, and up to 33 X 33 on GPU. For higher-precision types, we describe the fastest median filters at all sizes tested on both CPU and GPU.

This book presents a critical assessment of evaluation theory and practice in sport and leisure. It considers established and emerging forms of evaluation; examines typologies, issues, contexts and processes, and asks how evaluation practice can be improved in the future.

Background: Pancreatic ductal adenocarcinoma (PDAC) due to its unique genetic makeup and immunosuppressive tumor microenvironment (TME) produce a lack of response to current therapies. Macrophages, constitute a large innate immune subset and play a vital role in establishing an immune-suppressive microenvironment. Previously, we have identified Cyclic AMP Response Element Binding protein 1 (CREB) as a tumor cell-intrinsic oncogenic factor that promotes disease aggressiveness, poor survival, and immune suppression. Based on these, we sought to determine CREB mediated mechanisms of tumor-macrophage cross talk in driving immunosuppressive phenotype in PDAC. Methods: We have generated a genetically engineered mouse model (GEMM) of pancreas-specific CREB deletion (CREBfl/fl) in LSL-KrasG12D/+; Trp53 R172H/+; Pdx1Cre/+ (KPC) mice. CRISPR/CAS9-based genomic editing was utilized to ablate CREB (CREBKO) in KPC tumor cells. RNA-sequencing analysis was performed in KPC CREBKO tumor cells. ChIP-qPCR analysis was performed in KPC tumor cells. Orthotopic tumor implantation of these cells was performed in the pancreata of mice. Immunophenotyping was accomplished to assess changes in the immune subsets with CREB deletion in vivo. Additionally, these tissues were also processed for single-cell RNA (scRNA) transcriptomics analysis to evaluate the impact of CREB deletion on different cellular constituents within the TME. Results: CREB deletion in the KPC GEMM led to a significant reduction in the primary tumor burden, liver metastases, and improved overall survival compared to wild-type KPC. In assessing the immune repercussions of CREB deletion, we observed a decreased infiltration of tumor-promoting CD11b+ F4/80+ CD206+ tumor-associated macrophages (TAMs) and a concomitant increase in the antigen-presenting M1-like macrophages (F4/80+MHC-IIhighCD86high). Additionally, scRNA sequencing analysis within the macrophage compartment in CREBKO tumors revealed significant enrichment of M1 hallmark signaling pathways. Further, CREB ablation in these tumors facilitated increased infiltration of activated effector memory CD8+ T cells and resulted in enhanced adaptive immune response. RNA transcriptomic-based analysis of CREBKO tumor cells revealed downregulation of Leukemia inhibitory factor (LIF) as of the top targets. Mechanistically, ChIP qPCR analysis after CREB1 pulldown confirmed its occupancy on LIF promoter region. Further, on exploring the role of CREB regulated LIF on immune subsets, incubation of macrophages with CREBWT conditioned media in the presence of LIF neutralizing antibody or blocking its receptor (LIFR) decreases polarization of macrophages towards M2 like phenotype. Conclusion: These findings broaden our understanding of the tumor cell-intrinsic role of CREB in fostering immunosuppressive profile via LIF by promoting skewness of TAMs towards M2 like state in PDAC. Citation Format: Siddharth Mehra, Vanessa Garrido, Samara Singh, Iago De Castro Silva, Zhiqun Zhou, Supriya Srinivasan, Luis Alberto Nivelo, Anna Bianchi, Andrew Adams, Haleh Amirian, Lluis Morey, Ban Yuguang, Alejandro Villarino, Jashodeep Datta, Nipun Merchant, Nagaraj Nagathihalli. Tumor cell-macrophage crosstalk drives immune suppression in pancreatic cancer [abstract]. In: Proceedings of the American Association for Cancer Research Annual Meeting 2023; Part 1 (Regular and Invited Abstracts); 2023 Apr 14-19; Orlando, FL. Philadelphia (PA): AACR; Cancer Res 2023;83(7_Suppl):Abstract nr 653.

Halide is a domain-specific language for high-performance image processing and tensor computations, widely adopted in industry. Internally, the Halide compiler relies on a term rewriting system to prove properties of code required for efficient and correct compilation. This rewrite system is a collection of handwritten transformation rules that incrementally rewrite expressions into simpler forms; the system requires high performance in both time and memory usage to keep compile times low, while operating over the undecidable theory of integers. In this work, we apply formal techniques to prove the correctness of existing rewrite rules and provide a guarantee of termination. Then, we build an automatic program synthesis system in order to craft new, provably correct rules from failure cases where the compiler was unable to prove properties. We identify and fix 4 incorrect rules as well as 8 rules which could give rise to infinite rewriting loops. We demonstrate that the synthesizer can produce better rules than hand-authored ones in five bug fixes, and describe four cases in which it has served as an assistant to a human compiler engineer. We further show that it can proactively improve weaknesses in the compiler by synthesizing a large number of rules without human supervision and showing that the enhanced ruleset lowers peak memory usage of compiled code without appreciably increasing compilation times.

Deep learning frameworks automate the deployment, distribution, synchronization, memory allocation, and hardware acceleration of models represented as graphs of computational operators. These operators wrap high-performance libraries such as cuDNN or NNPACK. When the computation does not match any predefined library call, custom operators must be implemented, often at high engineering cost and performance penalty, limiting the pace of innovation. To address this productivity gap, we propose and evaluate: (1) a domain-specific language with a tensor notation close to the mathematics of deep learning; (2) a Just-In-Time optimizing compiler based on the polyhedral framework; (3) carefully coordinated linear optimization and evolutionary algorithms to synthesize high-performance CUDA kernels; (4) the transparent integration of our flow into PyTorch and Caffe2, providing the fully automatic synthesis of high-performance GPU kernels from simple tensor algebra. The performance is comparable to, and often exceeds the performance of, highly tuned libraries.

In this paper, the authors examine the impacts of natural fractures on the distribution of slurry in a well with a permanent fiber installation and drill bit geomechanics data. Additionally, they propose a framework for further investigation of natural fractures on slurry distribution. As part of the Marcellus Shale Energy and Environmental Laboratory (MSEEL), the operator monitored the drilling of a horizontal Marcellus Formation well with drill bit geomechanics, and subsequent stimulation phase with a DAS/DTS permanent fiber installation. Prior to the completion, the authors used an analytical model to examine the theoretical distribution of slurry between perforation clusters from a geomechanics framework. A perforation placement scheme was then developed to minimize the stress difference between clusters and to segment stages by the intensity of natural fractures while conforming to standard operating procedures for the operator's other completions. The operator initially began completing the well with the geomechanics-informed perforation placement plan while monitoring the treatment distribution with DAS/DTS in real time. The operator observed several anomalous stages with treating pressures high enough to cause operational concerns. The operator, fiber provider, and drill bit geomechanics provider reviewed the anomalous stages’ treatment data, DAS/DTS data, and geomechanics data and developed a working hypothesis. They believed that perforation clusters placed in naturally fractured rock were preferentially taking the treatment slurry. This phenomenon appeared to cause other clusters within the stage to sand-off or become dormant prematurely, resulting in elevated friction pressure. This working hypothesis was used to predict upcoming stages within the well that would be difficult to treat. Another perforation placement plan was developed for the second half of the well to avoid perforating natural fractures as an attempt to mitigate operational issues due to natural fracture dominated distribution. Over the past several years, the industry's growing understanding of geomechanical and well construction variability has created new limited-entry design considerations to optimize completion economics and reduce the variability in cluster slurry volumes. Completion engineers working in naturally fractured fields, such as the Marcellus, should consider the impact the natural fractures have on slurry distribution when optimizing their limited-entry designs and stage plan.

Gradient-based optimization has enabled dramatic advances in computational imaging through techniques like deep learning and nonlinear optimization. These methods require gradients not just of simple mathematical functions, but of general programs which encode complex transformations of images and graphical data. Unfortunately, practitioners have traditionally been limited to either hand-deriving gradients of complex computations, or composing programs from a limited set of coarse-grained operators in deep learning frameworks. At the same time, writing programs with the level of performance needed for imaging and deep learning is prohibitively difficult for most programmers. We extend the image processing language Halide with general reverse-mode automatic differentiation (AD), and the ability to automatically optimize the implementation of gradient computations. This enables automatic computation of the gradients of arbitrary Halide programs, at high performance, with little programmer effort. A key challenge is to structure the gradient code to retain parallelism. We define a simple algorithm to automatically schedule these pipelines, and show how Halide's existing scheduling primitives can express and extend the key AD optimization of "checkpointing." Using this new tool, we show how to easily define new neural network layers which automatically compile to high-performance GPU implementations, and how to solve nonlinear inverse problems from computational imaging. Finally, we show how differentiable programming enables dramatically improving the quality of even traditional, feed-forward image processing algorithms, blurring the distinction between classical and deep methods., National Science Foundation (U.S.) (Grant CCF-1723445)

To determine the protective effects of Pellino-1 against H2O2-induced apoptosis in periodontal ligament stem cells (PDLSC). We demonstrated that H2O2 decreases PDLSC viability by 40 and 50% with the concentrations of 400 and 500 μM, respectively, with an observed downregulation of Pellino-1 mRNA and protein; we further concluded that overexpression of Pellino-1 significantly lowers 8-hydroxy-2′-deoxyguanosine levels by 10% and upregulates superoxide dismutase 1, glutathione peroxidase levels, and catalase mRNA levels by 200, 40, and 250%, respectively. More importantly, we found that overexpression of Pellino-1 inhibited H2O2-induced cellular apoptosis through the activation of the NF-κB signaling pathway. Pellino-1 may be critically important for cell survival in the presence of oxidative elements; activation of the NF-κB signaling cascade was required for the overexpression of Pellino-1 to protect the cells from H2O2-induced apoptosis.

Writing high-performance code on modern machines requires not just locally optimizing inner loops, but globally reorganizing computations to exploit parallelism and locality---doing things such as tiling and blocking whole pipelines to fit in cache. This is especially true for image processing pipelines, where individual stages do much too little work to amortize the cost of loading and storing results to and from off-chip memory. As a result, the performance difference between a naive implementation of a pipeline and one globally optimized for parallelism and locality is often an order of magnitude. However, using existing programming tools, writing high-performance image processing code requires sacrificing simplicity, portability, and modularity. We argue that this is because traditional programming models conflate the computations defining the algorithm with decisions about intermediate storage and the order of computation, which we call the schedule. We propose a new programming language for image processing pipelines, called Halide, that separates the algorithm from its schedule. Programmers can change the schedule to express many possible organizations of a single algorithm. The Halide compiler then synthesizes a globally combined loop nest for an entire algorithm, given a schedule. Halide models a space of schedules which is expressive enough to describe organizations that match or outperform state-of-the-art hand-written implementations of many computational photography and computer vision algorithms. Its model is simple enough to do so often in only a few lines of code, and small changes generate efficient implementations for x86, ARM, Graphics Processors (GPUs), and specialized image processors, all from a single algorithm. Halide has been public and open source for over four years, during which it has been used by hundreds of programmers to deploy code to tens of thousands of servers and hundreds of millions of phones, processing billions of images every day.