torch does not have built-in functionality to do wavelet analysis. But we can efficiently implement what we need, making use of the Fast Fourier Transform (FFT). This post is a very first introduction to wavelets, suitable for readers that have not encountered it before. At the same time, it provides useful starter code, showing an (extensible) way to perform wavelet analysis in torch. It is an excerpt from the corresponding chapter in the forthcoming book, Deep Learning and Scientific Computing with R torch, to be published by CRC Press
About the Fourier Transform, it has been said that it is one of the greatest wonders of the universe. At the same time, it can be realized in a mere half-dozen lines of code. Even if in the end, you’re just going to call torch’s built-in functions directly, it helps to understand, and be able to reproduce in code, the ideas that underlie the magic. This post is an excerpt from the forthcoming book, Deep Learning and Scientific Computing with R torch, to be published by CRC Press
Get to know torch’s linalg module, all while learning about different ways to do least-squares regression from scratch. This post is a condensed version of the corresponding chapter in the forthcoming book, Deep Learning and Scientific Computing with R torch, to be published by CRC Press
The next release of ggplot2 will contain a number of internal improvements and fixes long-time inconsistencies. One of these are the conflation of point size and linewidth into the same aesthetic. This post will go into detail with how you can make your extension package work well with the new linewidth aesthetic
lintr 3.0.0 is a major release featuring a more consistent API for using linter and dozens of new linters included
We have updated our GitHub Actions at r-lib/actions. Consider upgrading to the new v2 version, for faster and more reliable GHA jobs
roxygen2 7.2.0 brings improvements to NAMESPACE generation, better multiparameter argument inheritance, and improved warnings
Support for case weights is now available across many tidymodels packages
The graphics engine in R is continually improving, and the ragg and svglite graphic devices follow along in supporting them. This blog post outlines what is now possible, and what might come in the future
rlang 1.0.0 is near and introduces a new style of error display. Feedback welcome!
pkgdown 2.0.0 includes a major refresh of the default template (now using bootstrap 5), many new ways to customise your site, improvements to code styling, and much, much, more
cli 3.1.0 introduces customizable color palettes plus it comes with a number of other smaller improvements
We are working on extending support for survival analysis in tidymodels. We are looking for early adopters to try out the new package called censored and give feedback
testthat 3.1.0 brings improvements to snapshot testing and one breaking change
Geometric deep learning is a “program” that aspires to situate deep learning architectures and techniques in a framework of mathematical priors. The priors, such as various types of invariance, first arise in some physical domain. A neural network that well matches the domain will preserve as many invariances as possible. In this post, we present a very conceptual, high-level overview, and highlight a few applications
waldo 0.3.0 improves the display of data frame differences, and gives the objects being compared the ability to control the detail of their comparisons
Worked solutions to all 284 exercises in the second edition of Advanced R, covering foundations, functional programming, object-oriented programming, metaprogramming, and performance
Building Software that Makes Research Possible
The topic of AI fairness metrics is as important to society as it is confusing. Confusing it is due to a number of reasons: terminological proliferation, abundance of formulae, and last not least the impression that everyone else seems to know what they’re talking about. This text hopes to counteract some of that confusion by starting from a common-sense approach of contrasting two basic positions: On the one hand, the assumption that dataset features may be taken as reflecting the underlying concepts ML practitioners are interested in; on the other, that there inevitably is a gap between concept and measurement, a gap that may be bigger or smaller depending on what is being measured. In contrasting these fundamental views, we bring together concepts from ML, legal science, and political philosophy
How can ggplot2 break with no breaking changes? This short post goes into detail with how and why the latest ggplot2 release disrupted some users workflow
This major release of vdiffr includes an updated SVG engine and integrates with the snapshot management mechanism of testthat 3
reprex is now much easier to use on RStudio Server and RStudio Cloud
Frustrations and possible solutions for online course development
The lifecycle package documentation received a major overhaul based on what I learned preparing for my rstudio::global keynote
ragg has taken a major leap forward in text-rendering capabilities with the latest releases of systemfonts, textshaping, and ragg itself. This post will go into detail with what is now possible and how it compares to the build in devices
We’ve never blogged about reprex before, so the release of v1.0.0 seems like a good occasion for it
This is a big release aimed at improving usability, especially around Git and GitHub functionality
testhat 3.0.0 brings a raft of major improvements including snapshot testing and parallel testing. It also includes a new “edition” that allows you opt-in to a set of substantial improvements that are not backward compatible
waldo is a new package that makes it easier to see the differences between a pair of complex R objects
This release mostly contains bug fixes and minor improvements, but it now uses the downlit and ragg packages for syntax highlighting and graphical output, respectively
For data science teams to be successful, they need to embrace both R and Python. The ease of interoperability gives the user the flexibility to fill in any tool gaps for their own needs
How can the seemingly iterative process of weighted sampling without replacement be transformed into something highly parallelizable? Turns out a well-known technique based on exponential variates accomplishes exactly that
A preview of a research project studying how and how well data scientists find errors
dplyr 1.0.0 is scheduled for release on May 15. This blog post talks about what package maintainers can do to prepare
Kullback-Leibler divergence is not just used to train variational autoencoders or Bayesian networks (and not just a hard-to-pronounce thing). It is a fundamental concept in information theory, put to use in a vast range of applications. Most interestingly, it’s not always about constraint, regularization or compression. Quite on the contrary, sometimes it is about novelty, discovery and surprise
Broadcasting, as done by Python’s scientific computing library NumPy, involves dynamically extending shapes so that arrays of different sizes may be passed to operations that expect conformity - such as adding or multiplying elementwise. In NumPy, the way broadcasting works is specified exactly; the same rules apply to TensorFlow operations. For anyone who finds herself, occasionally, consulting Python code, this post strives to explain
reticulate 1.14: automatic Python environment configuration for R packages that use Python
Introducing renv: isolated, portable, reproducible R project environments to replace Packrat
TensorFlow Probability, and its R wrapper tfprobability, provide Markov Chain Monte Carlo (MCMC) methods that were used in a number of recent posts on this blog. These posts were directed to users already comfortable with the method, and terminology, per se, which readers mainly interested in deep learning won’t necessarily be. Here we try to make up leeway, introducing Hamitonian Monte Carlo (HMC) as well as a few often-heard “buzzwords” accompanying it, always striving to keep in mind what it is all “for”
Have you ever wondered why you can call TensorFlow - mostly known as a Python framework - from R? If not - that’s how it should be, as the R packages keras and tensorflow aim to make this process as transparent as possible to the user. But for them to be those helpful genies, someone else first has to tame the Python
As of today, there is no mainstream road to obtaining uncertainty estimates from neural networks. All that can be said is that, normally, approaches tend to be Bayesian in spirit, involving some way of putting a prior over model weights. This holds true as well for the method presented in this post: We show how to use tfprobability, the R interface to TensorFlow Probability, to add uncertainty estimates to a Keras model in an elegant and conceptually plausible way
Learn how R works under the hood, from names and values, functions, and environments to functional programming, object-oriented programming with S3, S4, and R6, metaprogramming, and performance
Normalizing flows are one of the lesser known, yet fascinating and successful architectures in unsupervised deep learning. In this post we provide a basic introduction to flows using tfprobability, an R wrapper to TensorFlow Probability. Upcoming posts will build on this, using more complex flows on more complex data
Which versions of R do tidyverse packages support?
Not everybody who wants to get into deep learning has a strong background in math or programming. This post elaborates on a concepts-driven, abstraction-based way to learn what it’s all about
Sometimes, deep learning is seen - and welcomed - as a way to avoid laborious preprocessing of data. However, there are cases where preprocessing of sorts does not only help improve prediction, but constitutes a fascinating topic in itself. One such case is audio classification. In this post, we build on a previous post on this blog, this time focusing on explaining some of the non-deep learning background. We then link the concepts explained to updated for near-future releases TensorFlow code
Why do we use the activations we use, and how do they relate to the cost functions they tend to co-appear with? In this post we provide a conceptual introduction
Contributing code to open source projects can be intimidating. These projects are often widely used and have well known maintainers. Contributing code and having it accepted seems an almost insurmountable task. However if you follow a few simple strategies you can have your code accepted into even the most popular projects in the tidyverse
roxygen2 6.0.0 introduces markdown syntax for documentation and improved inheritance with @inherit tags
testthat 1.0.0 adds pipe support, new expectations, consistent side-effect testing, and C++ unit testing with Catch
Improved R support on Travis-CI with container-based infrastructure, package caching, and multiple R versions
memoise 1.0.0 caches function results with better printing, argument forwarding, and time-based invalidation
devtools 1.10.0 improves Windows RTools detection, adds use_news_md() and use_mit_license(), with lazy GitHub installs
RcppParallel provides portable parallel C++ algorithms using Intel TBB or TinyThread, achieving 200-300x speedups
roxygen2 5.0.0 adds RoxygenNote for version tracking, easier package documentation, and support for documenting re-exported functions
testthat 0.11.0 adds expect_silent() for checking no output/warnings, skip_on_os() and skip_on_appveyor(), plus random encouragement
devtools 1.9.1 adds remote dependencies via DESCRIPTION’s Remotes field, improved GitHub integration, and better revdep_check()
testthat 0.10.0 improves R CMD check output, adds skip_if_not_installed(), and soft-deprecates expect_that() style
devtools 1.8 adds use_git(), use_test(), dr_devtools(), and better dependency management with package_deps()
devtools 1.6 improves install_github(), adds session_info(), and introduces use_data(), use_testthat(), use_travis() helpers
Try adjusting your filters or search query.