| doInstall <- TRUE # Change to FALSE if you don't want packages installed. | |
| toInstall <- c("ggplot2", "proxy") | |
| if(doInstall){install.packages(toInstall, repos = "http://cran.r-project.org")} | |
| lapply(toInstall, library, character.only = TRUE) | |
| nIncrements <- 36 | |
| eachIncrement <- seq(0, 1, len = nIncrements) | |
| colorSweep <- expand.grid(eachIncrement, eachIncrement, eachIncrement) | |
| moduloRemainder <- with(colorSweep, Var1*(nIncrements-1)) %% | |
| floor(sqrt(nIncrements)) |
| g_LastCtrlKeyDownTime := 0 | |
| g_AbortSendEsc := false | |
| g_ControlRepeatDetected := false | |
| *CapsLock:: | |
| if (g_ControlRepeatDetected) | |
| { | |
| return | |
| } |
MIT License
Copyright (c) [year] [fullname]
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
2017-08-03: Since I wrote this in 2014, the universe, specifically Kirill Müller (https://github.com/krlmlr), has provided better solutions to this problem. I now recommend that you use one of these two packages:
I love these packages so much I wrote an ode to here.
I use these packages now instead of what I describe below. I'll leave this gist up for historical interest. 😆
The standard way of understanding the HTTP protocol is via the request reply pattern. Each HTTP transaction consists of a finitely bounded HTTP request and a finitely bounded HTTP response.
However it's also possible for both parts of an HTTP 1.1 transaction to stream their possibly infinitely bounded data. The advantages is that the sender can send data that is beyond the sender's memory limit, and the receiver can act on
| from datetime import datetime, timedelta | |
| import functools | |
| def timed_cache(**timedelta_kwargs): | |
| def _wrapper(f): | |
| update_delta = timedelta(**timedelta_kwargs) | |
| next_update = datetime.utcnow() + update_delta | |
| # Apply @lru_cache to f with no cache size limit |
| Moved to: | |
| https://github.com/cra0zy/code-nautilus | |
| since people want to add features to it and no notification arrive from comments on gist. |
Install native ARM R: https://cloud.r-project.org/
Install RStudio (probably preview) which is not native as of today: https://www.rstudio.com/products/rstudio/download/preview/
This blog post is helpful for getting Tensorflow working, but it is older, before the ARM version of R and the RStudio version that supports it was available.
This other blog post has specific steps outlined, but some of it has also been superseded.
Non-Uniform Memory Access (NUMA) is one of the computer memory design methods used in multiprocessor systems, and the time to access the memory varies depending on the relative position between the memory and the processor. In the NUMA architecture, when a processor accesses its local memory, it is faster than when it accesses the remote memory. Remote memory refers to memory that is connected to another processor, and local memory refers to memory that is connected to its own processor. In other words, it is a technology to increase memory access efficiency while using multiple processors on one motherboard. When a specific processor runs out of memory, it monopolizes the bus by itself, so other processors have to play. , and designate 'access only here', and call it a NUMA node.
lspci | grep -i nvidia
01:00.0 VGA compatible controller: NVIDIA Corporation TU106 [GeForce RTX 2060 12GB] (rev a1)
| ## Setup | |
| Sys.setenv(CUDA_VISIBLE_DEVICES='') | |
| options(tensorflow.extract.warn_tensors_passed_asis = FALSE) | |
| library(dplyr, warn.conflicts = FALSE) | |
| library(purrr) | |
| library(glue) | |
| library(envir) | |
| library(tensorflow) |