“The first duty in life is to be as artificial as possible. What the second duty is no one has as yet discovered.” Oscar Wilde
This post reports on the creation of a python package for the game of nim. The package contains a function that finds the perfect move in a given position and informs on whether the position is winning. In the package we make use of Charles Leonard Bouton’s solution of the game of Nim. We use the so-called normal variant, where the player with the last move wins.
The creation of the package is preparatory work for the reinforcement learning of the game of nim.
The code is available on github.
So now we’re ready to deploy our own custom R Shiny server with caching.
We had previously already discussed the pros and cons of
See this https://arthought.com/r-shiny-stock-analysis. Then we had opted for option 2, mainly to avoid complexity. We chose the free plan option, however there is a fairly tight limit on the number of hours the free-plan shinyapps.io based apps will run. On the other hand, the non-free shinyapps.io pricing options, while very practical, might be a stretch for some people’s budget, the starter package is currently at 9$/month.
Therefore in this post we deploy a server on digital ocean on the smallest droplet, which currently is at 5$/month. This is a link to the digital ocean pricing options.
We want to achieve the same functionality as the already mentioned predecessor post, namely plotting various analyses of a DAX-stock vs the DAX index itself.
In order for this to work as smoothly as possible we make use of caching, as discussed previously.
The app code can be found on github.
The other part of this post concerns how to spin up the docker based RShiny server, the necessary files are also on github.
Continue reading “R shiny custom docker server with caching”
In the previous post we looked at a simple data caching example which we used to explore the workings of the R-package DataCache.
In this post we continue with this exploration. Instead of just using system time as the datafeed we now use a more real world example of financial data. This is again in preparation for running a custom Shiny server.
This is in preparation for running a custom Shiny server. We want to accelerate the server by using caching. In the this post we take a look at a candidate caching package.
In this post we’ll explore a the package DataCache. It is a very useful package, however, I found that for some reason the provided weather data example was not working. So I wanted to simulate a datafeed using a scheduler, preferably within R. There is a scheduler package for R tcltk2. It worked for me from the command line, however when running this in RStudio or Rscript there is a small complication, which we will cover further below.
The data function here outputs the system time, using Sys.time(). When it is cached it uses a previous version of the cached time, therefore it is is smaller than the current Sys.time(). In general
Current time >=Cached time .
Let’s look at the output first:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
No cached data found. Loading intial data... [1] "Current:2017-12-22 14:58:09.2|Cached:2017-12-22 14:58:09.2" [1] "Current:2017-12-22 14:58:09.5|Cached:2017-12-22 14:58:09.2" [1] "Current:2017-12-22 14:58:09.7|Cached:2017-12-22 14:58:09.2" [1] "Current:2017-12-22 14:58:09.9|Cached:2017-12-22 14:58:09.2" [1] "Current:2017-12-22 14:58:10.1|Cached:2017-12-22 14:58:09.2" Loading more recent data, returning lastest available. [1] "Current:2017-12-22 14:58:10.3|Cached:2017-12-22 14:58:09.2" [1] "Current:2017-12-22 14:58:10.5|Cached:2017-12-22 14:58:10.3" [1] "Current:2017-12-22 14:58:10.7|Cached:2017-12-22 14:58:10.3" [1] "Current:2017-12-22 14:58:10.9|Cached:2017-12-22 14:58:10.3" [1] "Current:2017-12-22 14:58:11.1|Cached:2017-12-22 14:58:10.3" Loading more recent data, returning lastest available. [1] "Current:2017-12-22 14:58:11.3|Cached:2017-12-22 14:58:10.3" [1] "Current:2017-12-22 14:58:11.5|Cached:2017-12-22 14:58:11.3" [1] "Current:2017-12-22 14:58:11.7|Cached:2017-12-22 14:58:11.3" [1] "Current:2017-12-22 14:58:11.9|Cached:2017-12-22 14:58:11.3" [1] "Current:2017-12-22 14:58:12.1|Cached:2017-12-22 14:58:11.3" Loading more recent data, returning lastest available. [1] "Current:2017-12-22 14:58:12.4|Cached:2017-12-22 14:58:11.3" [1] "Current:2017-12-22 14:58:12.6|Cached:2017-12-22 14:58:12.4" [1] "Current:2017-12-22 14:58:12.8|Cached:2017-12-22 14:58:12.4" [1] "Current:2017-12-22 14:58:13.0|Cached:2017-12-22 14:58:12.4" [1] "Current:2017-12-22 14:58:13.2|Cached:2017-12-22 14:58:12.4" |
So we can see that it works. Basically, the scheduler does a cycle ~ every 200ms, whereas the Cached time is only updated every second, which implies that the update happens after 5 = 1000ms/200ms cycles.
Let’s discuss the code. We have three parts:
The Game of Nim is a simple two player game. The rules of the game are indeed very simple, however, to play it well is difficult for the uninitiated.
This post we deploy our own R-shiny app.
The source code is on github.
Continue reading “R shiny stock analysis”
Recap:
I this addendum post we’ll take a look at the package code in gym_drifty_walk.
There are excellent articles about how to create a python package, I have no intention to duplicate those, I recommend python-packaging. One warning: the packaging article is written for python 2, so be aware of that.
There are things missing in this (like e.g. tests) that you would typically add. We choose to use the most basic approach that works, which we believe lowers the barrier to comprehension.
The most basic steps you need are these:
|
1 2 3 4 5 6 7 8 9 |
gym_drifty_walk/ ├── gym_drifty_walk │ ├── envs │ │ ├── drifty_walk_env.py │ │ └── __init__.py │ └── __init__.py ├── LICENSE.md ├── README.md └── setup.py |
Recap: Previously we constructed a very simple class to emulate the type of environment which is provided by OpenAI. Then we simulated two windy walks and used the result of these walks to produce some plots.
Now we want to produce the same results again but via a different and more interesting route. This time we want a windy walk model that is implemented as an extension to OpenAI.
In [22]:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
import numpy as np class env(): def __init__(self): # the walk starts at 0 self.state = 0 return None def reset(self): # the walk again restarts at 0 self.state = 0 return None def step(self, action): IntendedStepSize = action # IntendedStepSize is step the walker wants to take # on average we allow him to achieve that (so it's the average step size) # ... however we subject the walker to a random influence, the influence of the wind # represented by np.random.normal() windInfluence = np.random.normal() # the change in the walker's position is the sum of the # his IntendedStepSize and the windInfluence exerted by the environment self.state += IntendedStepSize + windInfluence return None |
|
1 2 3 4 5 6 7 8 9 10 11 12 |
## do walk with small IntendedStepSize: 0.1 # set random seed, for reproducibility np.random.seed(166) test = env() Walk1 = [] for i in range(50): test.step(0.1) Walk1.append(test.state) |
|
1 2 3 4 5 6 7 |
# import matplotlib for plotting import matplotlib.style as style import matplotlib.pyplot as plt style.use('ggplot') plt.plot(Walk1) |
|
1 2 3 4 5 6 7 8 9 10 11 12 |
## do walk with small IntendedStepSize: 1 # set random seed, for reproducibility np.random.seed(167) test.reset() Walk2 = [] for i in range(50): test.step(1) Walk2.append(test.state) |
|
1 2 3 4 5 6 7 8 9 10 |
# import matplotlib for plotting import matplotlib.style as style import matplotlib.pyplot as plt style.use('ggplot') plt.plot(Walk1, label='Walk1, IntendedStepSize 0.1') plt.plot(Walk2, label='Walk2, IntendedStepSize 1') plt.legend(loc='best') plt.show() |
