--- title: 'Take a Sad Script & Make it Better: Tidymodels Edition' author: Alison Hill date: '2020-02-27' categories: - machine learning - tidymodels tags: - tidymodels summary: Taking a sad script and making it better for model cross-validation. featured: no disable_jquery: no image: caption: Image by [Rachel Martin](https://unsplash.com/photos/PnAc2UaeqII) focal_point: '' preview_only: no projects: - tidyml output: blogdown::html_page: toc: yes number_sections: yes toc_depth: 1 ---
A few years ago, I did a talk called “Take a Sad Plot & Make it Better,” where I showed how I took a single sad plot and tried to make it better. The process of making that plot better taught me a lot about data visualization, and about the ggplot2 package.
Fast-forward to 2019 when I started learning tidymodels, and I have accumulated some pretty sad predictive modeling scripts! And my sad plots are not so lonely anymore. Specifically, my old scripts for doing cross-validation with tidymodels are particularly sad. But, I’ve been able to make them better (one might even call them happy), primarily due to changes in the tune package and the addition of the fit_resamples()
function. The process of making these scripts better taught me a lot about predictive modeling, and about the (evolving) tidymodels ecosystem. So, why write a blog post with outdated code?
Let’s start with some cute penguin art by Rohan Chakravarty…
My objective here is not to provide an introduction to using tidymodels, cross-validation, or to machine learning. If that is what you came for, check out the project button at the top of this post for my workshop materials for learners, and my associated blog post on the RStudio education site.
{{% alert note %}} Bottom line: If you are stumbling upon this blog post in the year 2020 or beyond, know that there is a better way! {{% /alert %}}
I’m not the first person to write sad tidymodels scripts- there are many out in the wild. Here were the blog posts that I found most helpful when trying to solve this particular coding conundrum:
Modelling with Tidymodels and Parsnip: A Tidy Approach to a Classification Problem by Diego Usai
A tutorial on tidy cross-validation with R by Bruno Rodrigues
Modeling with parsnip and tidymodels by Benjamin Sorensen
library(tidyverse)
library(tidymodels)
library(rpart) # for decision tree
library(ranger) # for random forest
I’m going to use data that Allison Horst helped me source on penguins from the Palmer Station (Antarctica) Long Term Ecological Research Network.
“sooo now I’m just looking at penguin pictures” - Allison Horst after slacking me this penguin data
Here are the three dataset sources:
I downloaded and imported these three datasets using R, then did some very light data wrangling and merged them into one called penguins
, which I’ll use now:
penguins <-
read_csv(
here::here("content/post/2020-02-27-better-tidymodels/data/penguins.csv")) %>%
mutate_if(is.character, as.factor)
#> Parsed with column specification:
#> cols(
#> species = col_character(),
#> culmen_length_mm = col_double(),
#> culmen_depth_mm = col_double(),
#> flipper_length_mm = col_double(),
#> body_mass_g = col_double(),
#> sex = col_character()
#> )
glimpse(penguins)
#> Observations: 333
#> Variables: 6
#> $ species <fct> Adelie, Adelie, Adelie, Adelie, Adelie, Adelie, Ade…
#> $ culmen_length_mm <dbl> 39.1, 39.5, 40.3, 36.7, 39.3, 38.9, 39.2, 41.1, 38.…
#> $ culmen_depth_mm <dbl> 18.7, 17.4, 18.0, 19.3, 20.6, 17.8, 19.6, 17.6, 21.…
#> $ flipper_length_mm <dbl> 181, 186, 195, 193, 190, 181, 195, 182, 191, 198, 1…
#> $ body_mass_g <dbl> 3750, 3800, 3250, 3450, 3650, 3625, 4675, 3200, 380…
#> $ sex <fct> MALE, FEMALE, FEMALE, FEMALE, MALE, FEMALE, MALE, F…
This data included structural size measurements of penguins like their bill length, flipper length, and body mass. It also included each penguin’s species and sex. I’m going to use this data to try to predict penguin body mass. Sadly, we only have data for three distinct penguin species:
penguins %>%
count(species)
#> # A tibble: 3 x 2
#> species n
#> <fct> <int>
#> 1 Adelie 146
#> 2 Chinstrap 68
#> 3 Gentoo 119
Here is a lineup:
From: https://www.bas.ac.uk/about/antarctica/wildlife/penguins/
Looks like we have data for 3 of the smaller penguin species (of those pictured here).
First, let’s build a simple linear regression model to predict body mass from flipper length.
ggplot(penguins, aes(x = flipper_length_mm, y = body_mass_g)) +
geom_point(color = "salmon", size = 3, alpha = .9) +
geom_smooth(method = "lm") +
theme_penguin()
Not bad! Looks promising. To actually fit a linear regression model, you might be used to something like this in R:
penguin_mod <- lm(body_mass_g ~ flipper_length_mm, data = penguins)
summary(penguin_mod)
#>
#> Call:
#> lm(formula = body_mass_g ~ flipper_length_mm, data = penguins)
#>
#> Residuals:
#> Min 1Q Median 3Q Max
#> -1057.33 -259.79 -12.24 242.97 1293.89
#>
#> Coefficients:
#> Estimate Std. Error t value Pr(>|t|)
#> (Intercept) -5872.09 310.29 -18.93 <2e-16 ***
#> flipper_length_mm 50.15 1.54 32.56 <2e-16 ***
#> ---
#> Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
#>
#> Residual standard error: 393.3 on 331 degrees of freedom
#> Multiple R-squared: 0.7621, Adjusted R-squared: 0.7614
#> F-statistic: 1060 on 1 and 331 DF, p-value: < 2.2e-16
But we aren’t going to stick with this. We are going to use tidymodels, with the goal of generating accurate predictions for future, yet-to-be-seen penguins.
The code provided in the section below is not particularly sad 🐧. If you are embarking on learning tidymodels, you’ll need to use this same kind of code as the building blocks for any predictive modeling pipeline.
This step is really three, using only the parsnip package:
lm_spec <-
linear_reg() %>% # pick model
set_engine("lm") %>% # set engine
set_mode("regression") # set mode
lm_spec
#> Linear Regression Model Specification (regression)
#>
#> Computational engine: lm
Things that are missing: data (we haven’t touched it yet) and a formula (no data, no variables, no twiddle ~
). This is an abstract model specification. See other possible parsnip models here.
This is where you would normally insert some code for feature engineering using the recipes package. But previously this required functions named prep()
, bake()
, juice()
- so I’m willfully ignoring that for now. There will be no recipes involving penguins.
We’ll use the rsample package to split (ayee! I promise no penguins were hurt in the writing of this blog post) the penguins up into two datasets: training and testing. If you are unfamiliar with this practice, read up on the holdout method.
penguin_split <- initial_split(penguins, strata = species)
penguin_train <- training(penguin_split)
penguin_test <- testing(penguin_split)
Fitting a single model once is…not exactly the hardest part.
This is essentially the workflow from this early blog post.
set.seed(0)
lm_spec %>%
# train: get fitted model
fit(body_mass_g ~ ., data = penguin_train) %>%
# test: get predictions
predict(new_data = penguin_test) %>%
# compare: get metrics
bind_cols(penguin_test) %>%
rmse(truth = body_mass_g, estimate = .pred)
#> # A tibble: 1 x 3
#> .metric .estimator .estimate
#> <chr> <chr> <dbl>
#> 1 rmse standard 297.
If you squint, you might see that I could make this into a function like below:
get_rmse <- function(model_spec, split) {
model_spec %>%
# train: get fitted model
fit(body_mass_g ~ ., data = training(split)) %>%
# test: get predictions
predict(new_data = testing(split)) %>%
# compare: get metrics
bind_cols(testing(split)) %>%
rmse(truth = body_mass_g, estimate = .pred)
}
And I could use it to fit a linear regression model:
set.seed(0)
get_rmse(model_spec = lm_spec, split = penguin_split)
#> # A tibble: 1 x 3
#> .metric .estimator .estimate
#> <chr> <chr> <dbl>
#> 1 rmse standard 297.
I could also build up a tibble that includes the results, if I wanted to save the predicted values, for example:
get_preds <- function(model_spec, split){
# train: get fitted model
fit_model <- model_spec %>%
fit(body_mass_g ~ ., data = training(split))
# test: get predictions
preds <- fit_model %>%
predict(new_data = testing(split)) %>%
bind_cols(testing(split) %>% select(body_mass_g, species))
preds
}
set.seed(0)
penguin_preds <- get_preds(model_spec = lm_spec, split = penguin_split)
Then I can work with the predicted values, like plotting the fitted body mass estimates against the residuals.
ggplot(penguin_preds, aes(x = .pred, y = (.pred - body_mass_g))) +
geom_point(aes(colour = species), size = 3, alpha = .8) +
geom_smooth(method = "lm") +
theme_penguin() +
scico::scale_colour_scico_d(end = .8) +
ggtitle("Residuals vs Fitted")
#> `geom_smooth()` using formula 'y ~ x'
# compare: get metrics
penguin_preds %>%
rmse(truth = body_mass_g, estimate = .pred)
#> # A tibble: 1 x 3
#> .metric .estimator .estimate
#> <chr> <chr> <dbl>
#> 1 rmse standard 297.
Or I could fit a regression tree model with a new model spec:
# regression tree model spec
rt_spec <-
decision_tree() %>%
set_engine("rpart") %>%
set_mode("regression")
# get rmse
set.seed(0)
get_preds(model_spec = rt_spec,
split = penguin_split) %>%
rmse(truth = body_mass_g, estimate = .pred)
#> # A tibble: 1 x 3
#> .metric .estimator .estimate
#> <chr> <chr> <dbl>
#> 1 rmse standard 321.
Or a random forest:
# random forest model spec
rf_spec <-
rand_forest() %>%
set_engine("ranger") %>%
set_mode("regression")
# get rmse
set.seed(0)
get_preds(model_spec = rf_spec,
split = penguin_split) %>%
rmse(truth = body_mass_g, estimate = .pred)
#> # A tibble: 1 x 3
#> .metric .estimator .estimate
#> <chr> <chr> <dbl>
#> 1 rmse standard 299.
But, unfortunately, I shouldn’t be predicting with the test set over and over again like this. It isn’t good practice to predict with the test set > 1 time. What is a good predictive modeler to do? I should be saving (holding out) the test set and use it to generate predictions exactly once, at the very end — after I’ve compared different models, selected my features, and tuned my hyperparameters. How do you do this? You do cross-validation with the training set, and you leave the testing set for the very last fit you do.
Now, for the 😭 part- let’s add cross-validation! To do this, we’ll use a function called rsample::vfold_cv()
.
# add the cv step here
set.seed(0)
penguin_folds <- vfold_cv(data = penguin_train, strata = "species")
penguin_folds
#> # 10-fold cross-validation using stratification
#> # A tibble: 10 x 2
#> splits id
#> <named list> <chr>
#> 1 <split [225/26]> Fold01
#> 2 <split [226/25]> Fold02
#> 3 <split [226/25]> Fold03
#> 4 <split [226/25]> Fold04
#> 5 <split [226/25]> Fold05
#> 6 <split [226/25]> Fold06
#> 7 <split [226/25]> Fold07
#> 8 <split [226/25]> Fold08
#> 9 <split [226/25]> Fold09
#> 10 <split [226/25]> Fold10
The process of training, testing, and computing metrics gets a lot harder when you need to do this across 10 folds, each with a different data split. I eventually worked out three approaches, which I show below. All require some level of comfort with iteration using the purrr package.
This approach is essentially a mega-function, that we then use purrr to map across each fold.
I’m going to change a few things from my previous get_preds()
function:
training(split)
-> analysis(split)
testing(split)
-> assessment(split)
rsample::add_resample_id()
function to keep track of the fold number.To build up this function, my strategy was to figure out how to work with one fold, then I knew I’d be able to use purrr::map_df()
to apply it across multiple folds.
# Figure it out for one fold
get_fold_results <- function(model_spec, split){
# train: get fitted model for each fold
fits <- model_spec %>%
fit(body_mass_g ~ ., data = analysis(split))
# test: get predictions on for each fold
preds <- fits %>%
predict(new_data = assessment(split)) %>%
bind_cols(assessment(split))
# compare: compute metric for each fold
rmse <- assessment(split) %>%
summarize(rmse = rmse_vec(truth = body_mass_g,
estimate = preds$.pred))
rmse %>%
# add fold identifier column
rsample::add_resample_id(split = split) %>%
as_tibble() %>%
# add predictions
mutate(preds = list(preds))
}
I tried this function with a single fold first:
set.seed(0)
get_fold_results(
split = penguin_folds$splits[[1]],
model_spec = rt_spec
)
#> # A tibble: 1 x 3
#> rmse id preds
#> <dbl> <chr> <list>
#> 1 291. Fold01 <tibble [26 × 7]>
Next, I used purrr- but just once. The function get_fold_results
is doing most of the work for us, but I needed purrr to map it across each fold.
set.seed(0)
kfold_results <-
map_df(
penguin_folds$splits,
~get_fold_results(.x, model = rt_spec))
kfold_results
#> # A tibble: 10 x 3
#> rmse id preds
#> <dbl> <chr> <list>
#> 1 291. Fold01 <tibble [26 × 7]>
#> 2 298. Fold02 <tibble [25 × 7]>
#> 3 303. Fold03 <tibble [25 × 7]>
#> 4 359. Fold04 <tibble [25 × 7]>
#> 5 320. Fold05 <tibble [25 × 7]>
#> 6 434. Fold06 <tibble [25 × 7]>
#> 7 320. Fold07 <tibble [25 × 7]>
#> 8 245. Fold08 <tibble [25 × 7]>
#> 9 262. Fold09 <tibble [25 × 7]>
#> 10 343. Fold10 <tibble [25 × 7]>
Here we are still left with 10 RMSE values- one for each of the 10 folds. We don’t care too much about by fold- the power is in the aggregate. Specifically, we mainly care about the central tendency and spread of these RMSE values. Let’s finish by combining (or aggregating) these metrics.
kfold_results %>%
summarize(mean_rmse = mean(rmse), sd_rmse = sd(rmse))
#> # A tibble: 1 x 2
#> mean_rmse sd_rmse
#> <dbl> <dbl>
#> 1 317. 53.4
So, this works. But, can you imagine doing it again? Without errors? Can you imagine teaching it?
This approach is purrr::map()
(and friends) on steriods. We use vanilla map()
, map2()
, and map2_dbl()
here. We also use anonymous functions as a formula, and the pipe operator within those anonymous functions.
set.seed(0)
penguin_res <- penguin_folds %>%
mutate(
# train: get fitted model for each fold
train_set = map(splits, analysis),
fit_models = map(train_set, ~rt_spec %>%
fit(body_mass_g ~ .,
data = .x)),
# test: get predictions for each fold
test_set = map(splits, assessment),
estimates = map2(fit_models,
test_set,
~.x %>%
predict(.y)),
# compare: compute metric for each fold
rmse = map2_dbl(test_set,
estimates,
~rmse_vec(truth = .x$body_mass_g,
estimate = .y$.pred))
)
penguin_res
#> # 10-fold cross-validation using stratification
#> # A tibble: 10 x 7
#> splits id train_set fit_models test_set estimates rmse
#> * <named lis> <chr> <named list> <named lis> <named list> <named list> <dbl>
#> 1 <split [22… Fold01 <tibble [225 … <fit[+]> <tibble [26… <tibble [26… 291.
#> 2 <split [22… Fold02 <tibble [226 … <fit[+]> <tibble [25… <tibble [25… 298.
#> 3 <split [22… Fold03 <tibble [226 … <fit[+]> <tibble [25… <tibble [25… 303.
#> 4 <split [22… Fold04 <tibble [226 … <fit[+]> <tibble [25… <tibble [25… 359.
#> 5 <split [22… Fold05 <tibble [226 … <fit[+]> <tibble [25… <tibble [25… 320.
#> 6 <split [22… Fold06 <tibble [226 … <fit[+]> <tibble [25… <tibble [25… 434.
#> 7 <split [22… Fold07 <tibble [226 … <fit[+]> <tibble [25… <tibble [25… 320.
#> 8 <split [22… Fold08 <tibble [226 … <fit[+]> <tibble [25… <tibble [25… 245.
#> 9 <split [22… Fold09 <tibble [226 … <fit[+]> <tibble [25… <tibble [25… 262.
#> 10 <split [22… Fold10 <tibble [226 … <fit[+]> <tibble [25… <tibble [25… 343.
penguin_res %>%
summarise(mean_rmse = mean(rmse), sd_rmse = sd(rmse))
#> # A tibble: 1 x 2
#> mean_rmse sd_rmse
#> <dbl> <dbl>
#> 1 317. 53.4
Another way I worked out was largely after reviewing Max’s slides from previous workshops. This is basically a mash-up of my previous two approaches, where we write laser-focused functions that each do one thing, then use purrr to apply those functions across the folds. This way is nice(r) for showing in slides as you can incrementally build up the results table. Let’s see this sad script in action…
set.seed(0) # for reproducibility
# train: get fitted model for a split
get_fits <- function(split, model_spec){
model_spec %>%
fit(body_mass_g ~ .,
data = analysis(split))
}
# train: get fitted models across folds
penguin_purrr <- penguin_folds %>%
mutate(rt_fits = map(splits, get_fits, rt_spec))
penguin_purrr
#> # 10-fold cross-validation using stratification
#> # A tibble: 10 x 3
#> splits id rt_fits
#> * <named list> <chr> <named list>
#> 1 <split [225/26]> Fold01 <fit[+]>
#> 2 <split [226/25]> Fold02 <fit[+]>
#> 3 <split [226/25]> Fold03 <fit[+]>
#> 4 <split [226/25]> Fold04 <fit[+]>
#> 5 <split [226/25]> Fold05 <fit[+]>
#> 6 <split [226/25]> Fold06 <fit[+]>
#> 7 <split [226/25]> Fold07 <fit[+]>
#> 8 <split [226/25]> Fold08 <fit[+]>
#> 9 <split [226/25]> Fold09 <fit[+]>
#> 10 <split [226/25]> Fold10 <fit[+]>
# test: get predictions for a split
get_preds <- function(split, fit_df) {
fit_df %>%
predict(new_data = assessment(split)) %>%
bind_cols(assessment(split))
}
# test: get predictions across folds
penguin_purrr <- penguin_purrr %>%
mutate(rt_preds = map2(splits, rt_fits, get_preds))
penguin_purrr
#> # 10-fold cross-validation using stratification
#> # A tibble: 10 x 4
#> splits id rt_fits rt_preds
#> * <named list> <chr> <named list> <named list>
#> 1 <split [225/26]> Fold01 <fit[+]> <tibble [26 × 7]>
#> 2 <split [226/25]> Fold02 <fit[+]> <tibble [25 × 7]>
#> 3 <split [226/25]> Fold03 <fit[+]> <tibble [25 × 7]>
#> 4 <split [226/25]> Fold04 <fit[+]> <tibble [25 × 7]>
#> 5 <split [226/25]> Fold05 <fit[+]> <tibble [25 × 7]>
#> 6 <split [226/25]> Fold06 <fit[+]> <tibble [25 × 7]>
#> 7 <split [226/25]> Fold07 <fit[+]> <tibble [25 × 7]>
#> 8 <split [226/25]> Fold08 <fit[+]> <tibble [25 × 7]>
#> 9 <split [226/25]> Fold09 <fit[+]> <tibble [25 × 7]>
#> 10 <split [226/25]> Fold10 <fit[+]> <tibble [25 × 7]>
# compare: compute metric for a split
get_rmse <- function(pred_df) {
pred_df %>%
rmse(truth = body_mass_g,
estimate = .pred) %>%
pluck(".estimate")
}
# compare: compute metric across folds
penguin_purrr <- penguin_purrr %>%
mutate(rt_rmse = map_dbl(rt_preds, get_rmse))
penguin_purrr
#> # 10-fold cross-validation using stratification
#> # A tibble: 10 x 5
#> splits id rt_fits rt_preds rt_rmse
#> * <named list> <chr> <named list> <named list> <dbl>
#> 1 <split [225/26]> Fold01 <fit[+]> <tibble [26 × 7]> 291.
#> 2 <split [226/25]> Fold02 <fit[+]> <tibble [25 × 7]> 298.
#> 3 <split [226/25]> Fold03 <fit[+]> <tibble [25 × 7]> 303.
#> 4 <split [226/25]> Fold04 <fit[+]> <tibble [25 × 7]> 359.
#> 5 <split [226/25]> Fold05 <fit[+]> <tibble [25 × 7]> 320.
#> 6 <split [226/25]> Fold06 <fit[+]> <tibble [25 × 7]> 434.
#> 7 <split [226/25]> Fold07 <fit[+]> <tibble [25 × 7]> 320.
#> 8 <split [226/25]> Fold08 <fit[+]> <tibble [25 × 7]> 245.
#> 9 <split [226/25]> Fold09 <fit[+]> <tibble [25 × 7]> 262.
#> 10 <split [226/25]> Fold10 <fit[+]> <tibble [25 × 7]> 343.
Finally, summarizing as I did before:
penguin_purrr %>%
summarize(mean_rmse = mean(rt_rmse), sd_rmse = sd(rt_rmse))
#> # A tibble: 1 x 2
#> mean_rmse sd_rmse
#> <dbl> <dbl>
#> 1 317. 53.4
In practice, if you did all these at once instead of incrementally, it would look like:
set.seed(0)
penguin_folds %>%
# train: get fitted model for a split
mutate(rt_fits = map(splits, get_fits, rt_spec)) %>%
# test: get predictions on for each fold
mutate(rt_preds = map2(splits, rt_fits, get_preds)) %>%
# compare: compute metric for each fold
mutate(rt_rmse = map_dbl(rt_preds, get_rmse))
#> # 10-fold cross-validation using stratification
#> # A tibble: 10 x 5
#> splits id rt_fits rt_preds rt_rmse
#> * <named list> <chr> <named list> <named list> <dbl>
#> 1 <split [225/26]> Fold01 <fit[+]> <tibble [26 × 7]> 291.
#> 2 <split [226/25]> Fold02 <fit[+]> <tibble [25 × 7]> 298.
#> 3 <split [226/25]> Fold03 <fit[+]> <tibble [25 × 7]> 303.
#> 4 <split [226/25]> Fold04 <fit[+]> <tibble [25 × 7]> 359.
#> 5 <split [226/25]> Fold05 <fit[+]> <tibble [25 × 7]> 320.
#> 6 <split [226/25]> Fold06 <fit[+]> <tibble [25 × 7]> 434.
#> 7 <split [226/25]> Fold07 <fit[+]> <tibble [25 × 7]> 320.
#> 8 <split [226/25]> Fold08 <fit[+]> <tibble [25 × 7]> 245.
#> 9 <split [226/25]> Fold09 <fit[+]> <tibble [25 × 7]> 262.
#> 10 <split [226/25]> Fold10 <fit[+]> <tibble [25 × 7]> 343.
When you put it like that, it doesn’t look like so much work! But, this way hides how much work it takes to write those 3 custom functions: get_fits()
, get_preds()
, and get_rmse()
. And we still had to use vanilla map()
, map2()
, and map2_dbl()
.
I kept a learning log while working through the all the above code, and I wrote down these notes to myself:
It is very easy to do the wrong thing; it is very hard to do the right thing.
I lost sight many times of what the code I was writing was doing, because I was using up so much cognitive energy on getting the code to just work.
I thought I knew how to use purrr…
If you have made it this far, I’m pretty sure I don’t need to convince you that a better way to do cross-validation using tidymodels would be more pleasant to do more than once.  Luckily, tune::fit_resamples()
came along to take a sad script and make it better:
penguin_party <-
tune::fit_resamples(
body_mass_g ~ .,
model = rt_spec,
resamples = penguin_folds
)
Here is the beautiful output from that function:
penguin_party
#> # 10-fold cross-validation using stratification
#> # A tibble: 10 x 4
#> splits id .metrics .notes
#> * <list> <chr> <list> <list>
#> 1 <split [225/26]> Fold01 <tibble [2 × 3]> <tibble [0 × 1]>
#> 2 <split [226/25]> Fold02 <tibble [2 × 3]> <tibble [0 × 1]>
#> 3 <split [226/25]> Fold03 <tibble [2 × 3]> <tibble [0 × 1]>
#> 4 <split [226/25]> Fold04 <tibble [2 × 3]> <tibble [0 × 1]>
#> 5 <split [226/25]> Fold05 <tibble [2 × 3]> <tibble [0 × 1]>
#> 6 <split [226/25]> Fold06 <tibble [2 × 3]> <tibble [0 × 1]>
#> 7 <split [226/25]> Fold07 <tibble [2 × 3]> <tibble [0 × 1]>
#> 8 <split [226/25]> Fold08 <tibble [2 × 3]> <tibble [0 × 1]>
#> 9 <split [226/25]> Fold09 <tibble [2 × 3]> <tibble [0 × 1]>
#> 10 <split [226/25]> Fold10 <tibble [2 × 3]> <tibble [0 × 1]>
Now, to see all the stuff inside this penguin_party
, we can use tune’s collect_*
functions.
penguin_party %>%
collect_metrics()
#> # A tibble: 2 x 5
#> .metric .estimator mean n std_err
#> <chr> <chr> <dbl> <int> <dbl>
#> 1 rmse standard 317. 10 16.9
#> 2 rsq standard 0.827 10 0.0303
To see the predictions, we need to add use control_resamples()
:
penguin_party <-
tune::fit_resamples(
body_mass_g ~ .,
model = rt_spec,
resamples = penguin_folds,
control = control_resamples(save_pred = TRUE) # add this line
)
Then we collect the predictions.
penguin_party %>%
collect_predictions()
#> # A tibble: 251 x 4
#> id .pred .row body_mass_g
#> <chr> <dbl> <int> <dbl>
#> 1 Fold01 4040. 4 4675
#> 2 Fold01 3428. 11 3800
#> 3 Fold01 3428. 14 3200
#> 4 Fold01 4040. 41 3750
#> 5 Fold01 4040. 54 3900
#> 6 Fold01 3428. 65 3400
#> 7 Fold01 3428. 70 2900
#> 8 Fold01 4040. 71 4100
#> 9 Fold01 3428. 76 2925
#> 10 Fold01 4040. 85 3775
#> # … with 241 more rows
Now, isn’t that better?


JOY - compiled at 16:57:51 on Mar 17 2003 (BDW)
Copyright 2001 by Manfred von Thun
The Joy Programming Language - By Manfred Von Thun
literal
- truth value type
:
-> B
- The logical type, or the type of truth values.
It has just two literals: true and false.
- character type
:
-> C
- The type of characters. Literals are written with a single quote.
Examples: 'A '7 '; and so on. Unix style escapes are allowed.
- integer type
:
-> I
- The type of negative, zero or positive integers.
Literals are written in decimal notation. Examples: -123 0 42.
- set type
:
-> {...}
- The type of sets of small non-negative integers.
The maximum is platform dependent, typically the range is 0..31.
Literals are written inside curly braces.
Examples: {} {0} {1 3 5} {19 18 17}.
- string type
:
-> "..."
- The type of strings of characters. Literals are written inside double quotes.
Examples: "" "A" "hello world" "123".
Unix style escapes are accepted.
- list type
:
-> [...]
- The type of lists of values of any type (including lists),
or the type of quoted programs which may contain operators or combinators.
Literals of this type are written inside square brackets.
Examples: [] [3 512 -7] [john mary] ['A 'C ['B]] [dup *].
- float type
:
-> F
- The type of floating-point numbers.
Literals of this type are written with embedded decimal points (like 1.2)
and optional exponent specifiers (like 1.5E2)
- file type
:
-> FILE:
- The type of references to open I/O streams,
typically but not necessarily files.
The only literals of this type are stdin, stdout, and stderr.
operand
- false
:
-> false
- Pushes the value false.
- true
:
-> true
- Pushes the value true.
- maxint
:
-> maxint
- Pushes largest integer (platform dependent). Typically it is 32 bits.
- setsize
:
-> setsize
- Pushes the maximum number of elements in a set (platform dependent).
Typically it is 32, and set members are in the range 0..31.
- stack
:
.. X Y Z -> .. X Y Z [Z Y X ..]
- Pushes the stack as a list.
- conts
:
-> [[P] [Q] ..]
- Pushes current continuations. Buggy, do not use.
- autoput
:
-> I
- Pushes current value of flag for automatic output, I = 0..2.
- undeferror
:
-> I
- Pushes current value of undefined-is-error flag.
- undefs
:
->
- Push a list of all undefined symbols in the current symbol table.
- echo
:
-> I
- Pushes value of echo flag, I = 0..3.
- clock
:
-> I
- Pushes the integer value of current CPU usage in hundreds of a second.
- time
:
-> I
- Pushes the current time (in seconds since the Epoch).
- rand
:
-> I
- I is a random integer.
- stdin
:
-> S
- Pushes the standard input stream.
- stdout
:
-> S
- Pushes the standard output stream.
- stderr
:
-> S
- Pushes the standard error stream.
operator
- id
:
->
- Identity function, does nothing.
Any program of the form P id Q is equivalent to just P Q.
- dup
:
X -> X X
- Pushes an extra copy of X onto stack.
- swap
:
X Y -> Y X
- Interchanges X and Y on top of the stack.
- rollup
:
X Y Z -> Z X Y
- Moves X and Y up, moves Z down
- rolldown
:
X Y Z -> Y Z X
- Moves Y and Z down, moves X up
- rotate
:
X Y Z -> Z Y X
- Interchanges X and Z
- popd
:
Y Z -> Z
- As if defined by: popd == [pop] dip
- dupd
:
Y Z -> Y Y Z
- As if defined by: dupd == [dup] dip
- swapd
:
X Y Z -> Y X Z
- As if defined by: swapd == [swap] dip
- rollupd
:
X Y Z W -> Z X Y W
- As if defined by: rollupd == [rollup] dip
- rolldownd
:
X Y Z W -> Y Z X W
- As if defined by: rolldownd == [rolldown] dip
- rotated
:
X Y Z W -> Z Y X W
- As if defined by: rotated == [rotate] dip
- pop
:
X ->
- Removes X from top of the stack.
- choice
:
B T F -> X
- If B is true, then X = T else X = F.
- or
:
X Y -> Z
- Z is the union of sets X and Y, logical disjunction for truth values.
- xor
:
X Y -> Z
- Z is the symmetric difference of sets X and Y,
logical exclusive disjunction for truth values.
- and
:
X Y -> Z
- Z is the intersection of sets X and Y, logical conjunction for truth values.
- not
:
X -> Y
- Y is the complement of set X, logical negation for truth values.
- +
:
M I -> N
- Numeric N is the result of adding integer I to numeric M.
Also supports float.
- -
:
M I -> N
- Numeric N is the result of subtracting integer I from numeric M.
Also supports float.
- *
:
I J -> K
- Integer K is the product of integers I and J. Also supports float.
- /
:
I J -> K
- Integer K is the (rounded) ratio of integers I and J. Also supports float.
- rem
:
I J -> K
- Integer K is the remainder of dividing I by J. Also supports float.
- div
:
I J -> K L
- Integers K and L are the quotient and remainder of dividing I by J.
- sign
:
N1 -> N2
- Integer N2 is the sign (-1 or 0 or +1) of integer N1,
or float N2 is the sign (-1.0 or 0.0 or 1.0) of float N1.
- neg
:
I -> J
- Integer J is the negative of integer I. Also supports float.
- ord
:
C -> I
- Integer I is the Ascii value of character C (or logical or integer).
- chr
:
I -> C
- C is the character whose Ascii value is integer I (or logical or character).
- abs
:
N1 -> N2
- Integer N2 is the absolute value (0,1,2..) of integer N1,
or float N2 is the absolute value (0.0 ..) of float N1
- acos
:
F -> G
- G is the arc cosine of F.
- asin
:
F -> G
- G is the arc sine of F.
- atan
:
F -> G
- G is the arc tangent of F.
- atan2
:
F G -> H
- H is the arc tangent of F / G.
- ceil
:
F -> G
- G is the float ceiling of F.
- cos
:
F -> G
- G is the cosine of F.
- cosh
:
F -> G
- G is the hyperbolic cosine of F.
- exp
:
F -> G
- G is e (2.718281828...) raised to the Fth power.
- floor
:
F -> G
- G is the floor of F.
- frexp
:
F -> G I
- G is the mantissa and I is the exponent of F.
Unless F = 0, 0.5 <= abs(G) < 1.0.
- ldexp
:
F I -> G
- G is F times 2 to the Ith power.
- log
:
F -> G
- G is the natural logarithm of F.
- log10
:
F -> G
- G is the common logarithm of F.
- modf
:
F -> G H
- G is the fractional part and H is the integer part
(but expressed as a float) of F.
- pow
:
F G -> H
- H is F raised to the Gth power.
- sin
:
F -> G
- G is the sine of F.
- sinh
:
F -> G
- G is the hyperbolic sine of F.
- sqrt
:
F -> G
- G is the square root of F.
- tan
:
F -> G
- G is the tangent of F.
- tanh
:
F -> G
- G is the hyperbolic tangent of F.
- trunc
:
F -> I
- I is an integer equal to the float F truncated toward zero.
- localtime
:
I -> T
- Converts a time I into a list T representing local time:
[year month day hour minute second isdst yearday weekday].
Month is 1 = January ... 12 = December;
isdst is a Boolean flagging daylight savings/summer time;
weekday is 0 = Monday ... 7 = Sunday.
- gmtime
:
I -> T
- Converts a time I into a list T representing universal time:
[year month day hour minute second isdst yearday weekday].
Month is 1 = January ... 12 = December;
isdst is false; weekday is 0 = Monday ... 7 = Sunday.
- mktime
:
T -> I
- Converts a list T representing local time into a time I.
T is in the format generated by localtime.
- strftime
:
T S1 -> S2
- Formats a list T in the format of localtime or gmtime
using string S1 and pushes the result S2.
- strtol
:
S I -> J
- String S is converted to the integer J using base I.
If I = 0, assumes base 10,
but leading "0" means base 8 and leading "0x" means base 16.
- strtod
:
S -> R
- String S is converted to the float R.
- format
:
N C I J -> S
- S is the formatted version of N in mode C
('d or 'i = decimal, 'o = octal, 'x or
'X = hex with lower or upper case letters)
with maximum width I and minimum width J.
- formatf
:
F C I J -> S
- S is the formatted version of F in mode C
('e or 'E = exponential, 'f = fractional,
'g or G = general with lower or upper case letters)
with maximum width I and precision J.
- srand
:
I ->
- Sets the random integer seed to integer I.
- pred
:
M -> N
- Numeric N is the predecessor of numeric M.
- succ
:
M -> N
- Numeric N is the successor of numeric M.
- max
:
N1 N2 -> N
- N is the maximum of numeric values N1 and N2. Also supports float.
- min
:
N1 N2 -> N
- N is the minimum of numeric values N1 and N2. Also supports float.
- fclose
:
S ->
- Stream S is closed and removed from the stack.
- feof
:
S -> S B
- B is the end-of-file status of stream S.
- ferror
:
S -> S B
- B is the error status of stream S.
- fflush
:
S -> S
- Flush stream S, forcing all buffered output to be written.
- fgetch
:
S -> S C
- C is the next available character from stream S.
- fgets
:
S -> S L
- L is the next available line (as a string) from stream S.
- fopen
:
P M -> S
- The file system object with pathname P is opened with mode M (r, w, a, etc.)
and stream object S is pushed; if the open fails, file:NULL is pushed.
- fread
:
S I -> S L
- I bytes are read from the current position of stream S
and returned as a list of I integers.
- fwrite
:
S L -> S
- A list of integers are written as bytes to the current position of stream S.
- fremove
:
P -> B
- The file system object with pathname P is removed from the file system.
is a boolean indicating success or failure.
- frename
:
P1 P2 -> B
- The file system object with pathname P1 is renamed to P2.
B is a boolean indicating success or failure.
- fput
:
S X -> S
- Writes X to stream S, pops X off stack.
- fputch
:
S C -> S
- The character C is written to the current position of stream S.
- fputchars
:
S "abc.." -> S
- The string abc.. (no quotes) is written to the current position of stream S.
- fputstring
:
S "abc.." -> S
- == fputchars, as a temporary alternative.
- fseek
:
S P W -> S
- Stream S is repositioned to position P relative to whence-point W,
where W = 0, 1, 2 for beginning, current position, end respectively.
- ftell
:
S -> S I
- I is the current position of stream S.
- unstack
:
[X Y ..] -> ..Y X
- The list [X Y ..] becomes the new stack.
- cons
:
X A -> B
- Aggregate B is A with a new member X (first member for sequences).
- swons
:
A X -> B
- Aggregate B is A with a new member X (first member for sequences).
- first
:
A -> F
- F is the first member of the non-empty aggregate A.
- rest
:
A -> R
- R is the non-empty aggregate A with its first member removed.
- compare
:
A B -> I
- I (=-1,0,+1) is the comparison of aggregates A and B.
The values correspond to the predicates <=, =, >=.
- at
:
A I -> X
- X (= A[I]) is the member of A at position I.
- of
:
I A -> X
- X (= A[I]) is the I-th member of aggregate A.
- size
:
A -> I
- Integer I is the number of elements of aggregate A.
- opcase
:
X [..[X Xs]..] -> [Xs]
- Indexing on type of X, returns the list [Xs].
- case
:
X [..[X Y]..] -> Y i
- Indexing on the value of X, execute the matching Y.
- uncons
:
A -> F R
- F and R are the first and the rest of non-empty aggregate A.
- unswons
:
A -> R F
- R and F are the rest and the first of non-empty aggregate A.
- drop
:
A N -> B
- Aggregate B is the result of deleting the first N elements of A.
- take
:
A N -> B
- Aggregate B is the result of retaining just the first N elements of A.
- concat
:
S T -> U
- Sequence U is the concatenation of sequences S and T.
- enconcat
:
X S T -> U
- Sequence U is the concatenation of sequences S and T
with X inserted between S and T (== swapd cons concat)
- name
:
sym -> "sym"
- For operators and combinators, the string "sym" is the name of item sym,
for literals sym the result string is its type.
- intern
:
"sym" -> sym
- Pushes the item whose name is "sym".
- body
:
U -> [P]
- Quotation [P] is the body of user-defined symbol U.
predicate
- null
:
X -> B
- Tests for empty aggregate X or zero numeric.
- small
:
X -> B
- Tests whether aggregate X has 0 or 1 members, or numeric 0 or 1.
- >=
:
X Y -> B
- Either both X and Y are numeric or both are strings or symbols.
Tests whether X greater than or equal to Y. Also supports float.
- >
:
X Y -> B
- Either both X and Y are numeric or both are strings or symbols.
Tests whether X greater than Y. Also supports float.
- <=
:
X Y -> B
- Either both X and Y are numeric or both are strings or symbols.
Tests whether X less than or equal to Y. Also supports float.
- <
:
X Y -> B
- Either both X and Y are numeric or both are strings or symbols.
Tests whether X less than Y. Also supports float.
- !=
:
X Y -> B
- Either both X and Y are numeric or both are strings or symbols.
Tests whether X not equal to Y. Also supports float.
- =
:
X Y -> B
- Either both X and Y are numeric or both are strings or symbols.
Tests whether X equal to Y. Also supports float.
- equal
:
T U -> B
- (Recursively) tests whether trees T and U are identical.
- has
:
A X -> B
- Tests whether aggregate A has X as a member.
- in
:
X A -> B
- Tests whether X is a member of aggregate A.
- integer
:
X -> B
- Tests whether X is an integer.
- char
:
X -> B
- Tests whether X is a character.
- logical
:
X -> B
- Tests whether X is a logical.
- set
:
X -> B
- Tests whether X is a set.
- string
:
X -> B
- Tests whether X is a string.
- list
:
X -> B
- Tests whether X is a list.
- leaf
:
X -> B
- Tests whether X is not a list.
- user
:
X -> B
- Tests whether X is a user-defined symbol.
- float
:
R -> B
- Tests whether R is a float.
- file
:
F -> B
- Tests whether F is a file.
combinator
- i
:
[P] -> ...
- Executes P. So, [P] i == P.
- x
:
[P]i -> ...
- Executes P without popping [P]. So, [P] x == [P] P.
- dip
:
X [P] -> ... X
- Saves X, executes P, pushes X back.
- app1
:
X [P] -> R
- Executes P, pushes result R on stack without X.
- app11
:
X Y [P] -> R
- Executes P, pushes result R on stack.
- app12
:
X Y1 Y2 [P] -> R1 R2
- Executes P twice, with Y1 and Y2, returns R1 and R2.
- construct
:
[P] [[P1] [P2] ..] -> R1 R2 ..
- Saves state of stack and then executes [P].
Then executes each [Pi] to give Ri pushed onto saved stack.
- nullary
:
[P] -> R
- Executes P, which leaves R on top of the stack.
No matter how many parameters this consumes, none are removed from the stack.
- unary
:
X [P] -> R
- Executes P, which leaves R on top of the stack.
No matter how many parameters this consumes,
exactly one is removed from the stack.
- unary2
:
X1 X2 [P] -> R1 R2
- Executes P twice, with X1 and X2 on top of the stack.
Returns the two values R1 and R2.
- unary3
:
X1 X2 X3 [P] -> R1 R2 R3
- Executes P three times, with Xi, returns Ri (i = 1..3).
- unary4
:
X1 X2 X3 X4 [P] -> R1 R2 R3 R4
- Executes P four times, with Xi, returns Ri (i = 1..4).
- app2
:
X1 X2 [P] -> R1 R2
- Obsolescent. == unary2
- app3
:
X1 X2 X3 [P] -> R1 R2 R3
- Obsolescent. == unary3
- app4
:
X1 X2 X3 X4 [P] -> R1 R2 R3 R4
- Obsolescent. == unary4
- binary
:
X Y [P] -> R
- Executes P, which leaves R on top of the stack.
No matter how many parameters this consumes,
exactly two are removed from the stack.
- ternary
:
X Y Z [P] -> R
- Executes P, which leaves R on top of the stack.
No matter how many parameters this consumes,
exactly three are removed from the stack.
- cleave
:
X [P1] [P2] -> R1 R2
- Executes P1 and P2, each with X on top, producing two results.
- branch
:
B [T] [F] -> ...
- If B is true, then executes T else executes F.
- ifte
:
[B] [T] [F] -> ...
- Executes B. If that yields true, then executes T else executes F.
- ifinteger
:
X [T] [E] -> ...
- If X is an integer, executes T else executes E.
- ifchar
:
X [T] [E] -> ...
- If X is a character, executes T else executes E.
- iflogical
:
X [T] [E] -> ...
- If X is a logical or truth value, executes T else executes E.
- ifset
:
X [T] [E] -> ...
- If X is a set, executes T else executes E.
- ifstring
:
X [T] [E] -> ...
- If X is a string, executes T else executes E.
- iflist
:
X [T] [E] -> ...
- If X is a list, executes T else executes E.
- iffloat
:
X [T] [E] -> ...
- If X is a float, executes T else executes E.
- iffile
:
X [T] [E] -> ...
- If X is a file, executes T else executes E.
- cond
:
[..[[Bi] Ti]..[D]] -> ...
- Tries each Bi. If that yields true, then executes Ti and exits.
If no Bi yields true, executes default D.
- while
:
[B] [D] -> ...
- While executing B yields true executes D.
- linrec
:
[P] [T] [R1] [R2] -> ...
- Executes P. If that yields true, executes T.
Else executes R1, recurses, executes R2.
- tailrec
:
[P] [T] [R1] -> ...
- Executes P. If that yields true, executes T.
Else executes R1, recurses.
- binrec
:
[B] [T] [R1] [R2] -> ...
- Executes P. If that yields true, executes T.
Else uses R1 to produce two intermediates, recurses on both,
then executes R2 to combines their results.
- genrec
:
[B] [T] [R1] [R2] -> ...
- Executes B, if that yields true executes T.
Else executes R1 and then [[B] [T] [R1] [R2] genrec] R2.
- condlinrec
:
[ [C1] [C2] .. [D] ] -> ...
- Each [Ci] is of the forms [[B] [T]] or [[B] [R1] [R2]].
Tries each B. If that yields true and there is just a [T], executes T and exit.
If there are [R1] and [R2], executes R1, recurses, executes R2.
Subsequent case are ignored. If no B yields true, then [D] is used.
It is then of the forms [[T]] or [[R1] [R2]]. For the former, executes T.
For the latter executes R1, recurses, executes R2.
- step
:
A [P] -> ...
- Sequentially putting members of aggregate A onto stack,
executes P for each member of A.
- fold
:
A V0 [P] -> V
- Starting with value V0, sequentially pushes members of aggregate A
and combines with binary operator P to produce value V.
- map
:
A [P] -> B
- Executes P on each member of aggregate A,
collects results in sametype aggregate B.
- times
:
N [P] -> ...
- N times executes P.
- infra
:
L1 [P] -> L2
- Using list L1 as stack, executes P and returns a new list L2.
The first element of L1 is used as the top of stack,
and after execution of P the top of stack becomes the first element of L2.
- primrec
:
X [I] [C] -> R
- Executes I to obtain an initial value R0.
For integer X uses increasing positive integers to X, combines by C for new R.
For aggregate X uses successive members and combines by C for new R.
- filter
:
A [B] -> A1
- Uses test B to filter aggregate A producing sametype aggregate A1.
- split
:
A [B] -> A1 A2
- Uses test B to split aggregate A into sametype aggregates A1 and A2 .
- some
:
A [B] -> X
- Applies test B to members of aggregate A, X = true if some pass.
- all
:
A [B] -> X
- Applies test B to members of aggregate A, X = true if all pass.
- treestep
:
T [P] -> ...
- Recursively traverses leaves of tree T, executes P for each leaf.
- treerec
:
T [O] [C] -> ...
- T is a tree. If T is a leaf, executes O. Else executes [[O] [C] treerec] C.
- treegenrec
:
T [O1] [O2] [C] -> ...
- T is a tree. If T is a leaf, executes O1.
Else executes O2 and then [[O1] [O2] [C] treegenrec] C.
miscellaneous commands
- help
:
->
- Lists all defined symbols, including those from library files.
Then lists all primitives of raw Joy
(There is a variant: "_help" which lists hidden symbols).
- helpdetail
:
[ S1 S2 .. ]
- Gives brief help on each symbol S in the list.
- manual
:
->
- Writes this manual of all Joy primitives to output file.
- setautoput
:
I ->
- Sets value of flag for automatic put to I (if I = 0, none;
if I = 1, put; if I = 2, stack.
- setundeferror
:
I ->
- Sets flag that controls behavior of undefined functions
(0 = no error, 1 = error).
- setecho
:
I ->
- Sets value of echo flag for listing.
I = 0: no echo, 1: echo, 2: with tab, 3: and linenumber.
- gc
:
->
- Initiates garbage collection.
- system
:
"command" ->
- Escapes to shell, executes string "command".
The string may cause execution of another program.
When that has finished, the process returns to Joy.
- getenv
:
"variable" -> "value"
- Retrieves the value of the environment variable "variable".
- argv
:
-> A
- Creates an aggregate A containing the interpreter's command line arguments.
- argc
:
-> I
- Pushes the number of command line arguments. This is quivalent to 'argv size'.
- get
:
-> F
- Reads a factor from input and pushes it onto stack.
- put
:
X ->
- Writes X to output, pops X off stack.
- putch
:
N ->
- N : numeric, writes character whose ASCII is N.
- putchars
:
"abc.." ->
- Writes abc.. (without quotes)
- include
:
"filnam.ext" ->
- Transfers input to file whose name is "filnam.ext".
On end-of-file returns to previous input file.
- abort
:
->
- Aborts execution of current Joy program, returns to Joy main cycle.
- quit
:
->
- Exit from Joy.


Our strategy is to develop a Temporal Convolutional Neural Network model and train our model on historical OHLCV data to predict the movement of future prices. Then, when trading, we take the most recent data, feed it into our model, and bet on the direction of the price movement based on our model prediction. We will walk through the code required for building the Neural Network Architecture and for preparing the data for our model, as this part is the harder part to understand.
Before we build our Neural Network Architecture, we need to understand the inputs and outputs to our model. The input to the model will be the OHLC+Volume data for t-14 to t time steps (past 15 time steps). The output is a direction (Up, Down, Stationary) of the movement of the average close of the t+1 to t+5 time steps (5 future timestamps). The movement is considered stationary if the abs(% change 5-step average close) < .01%. These three directions will form the labels for which our model will try to classify, thus we have a classification problem.
Now, we will need to build our Neural Network Architecture, which we will build using Keras, a high-level Python Deep Learning API. To begin, we will need a few import statements:
import tensorflow as tf from tensorflow.keras.layers import Input, Conv1D, Dense, Lambda, Flatten, Concatenate from tensorflow.keras import Model from tensorflow.keras import metrics from tensorflow.keras.losses import CategoricalCrossentropy from tensorflow.keras import utils from sklearn.preprocessing import StandardScaler import numpy as np import math
We start with an Input Layer, where training and testing data are initially accepted. With 15 time steps and 5 input variables (OHLCV), our input shape will be 15 x 5.
inputs = Input(shape=(15, 5))
We then feed this Layer into our Convolutional Layer, where we extract features, which will serve as the Neural Network's method of extracting patterns from the time-series data.
feature_extraction = Conv1D(30, 4, activation='relu')(inputs)
long_term = Lambda( lambda x: tf.split(x, num_or_size_splits=3, axis=1)[0])(feature_extraction) mid_term = Lambda( lambda x: tf.split(x, num_or_size_splits=3, axis=1)[1])(feature_extraction) short_term = Lambda( lambda x: tf.split(x, num_or_size_splits=3, axis=1)[2])(feature_extraction) long_term_conv = Conv1D(1, 1, activation='relu')(long_term) mid_term_conv = Conv1D(1, 1, activation='relu')(mid_term) short_term_conv = Conv1D(1, 1, activation='relu')(short_term)
These three layers are then combined, and since we will be working with 2D input matrices, we will then need to flatten our layer.
combined = Concatenate(axis=1)([long_term_conv, mid_term_conv, short_term_conv]) flattened = Flatten()(combined)
Our final layer will be our output layer, and since we have three outputs (Up, Stationary, Down), this layer will have three nodes.
outputs = Dense(3, activation='softmax')(flattened)
The resulting Neural Network Architecture is shown in the following:
First, we need to define a class and a few variables:
input_vars = ['open', 'high', 'low', 'close', 'volume'] class Direction: UP = 0 DOWN = 1 STATIONARY = 2 rolling_avg_window_size = 5 shift = -(rolling_avg_window_size-1) stationary_threshold = .0001 scaler = StandardScaler()
input_vars define the variables we want to use to make our predictions. The class Direction defines a few integers that we will label our data with (labels are needed for classification problems). The reason we use integers instead of strings is because Keras, like most ML libraries, only work with numerical data. Moving on, rolling_avg_window_size is the number of time steps used for the calculate the average of future closing prices, described earlier in Inputs/Outputs (t+1 to t+5 is 5 time steps, thus this value accordingly is set to 5). The constant stationary_threshold defines the threshold for a change in price to be considered stationary, and this change also described in Inputs/Outputs. The shift is the shift needed to align the average value (mentioned earlier), in our pandas DataFrame to make it easier for us to slice our DataFrame into pieces manageable for our Neural Network model. The scaler object will be used later to scale our data. The purpose of the variables will become clearer in use.
Next, say we are at time t in the pandas DataFrame, to calculate the average closing prices of t+1 to t+5, and calculate the percent change from the close at t, we use the following lines of code:
df['close_avg'] = df['close'].rolling(window=rolling_avg_window_size).mean().shift(shift) df['close_avg_change_pct'] = (df['close_avg'] - df['close']) / df['close']
The rolling mean should be self explanatory for those familiar with pandas (if not, I hope by now readers realize this is a more advanced resource). Here, .shift(shift) aligns the five time step rolling average 'close_avg' column to the end of the last time step we want to use as an input for prediction, and this action will make slicing up the DataFrame into input and labeled data for our model much easier.
To label our data, we need to first define a function that we will use with the DataFrame's apply() method. Usually, lambda functions are used for this purpose, however, our function's logic will not fit inside a lambda.
def label_data(row): if row['close_avg_change_pct'] > stationary_threshold: return Direction.UP elif row['close_avg_change_pct'] < -stationary_threshold: return Direction.DOWN else: return Direction.STATIONARY
Now, we apply the above function to our DataFrame to get a column of labels:
df['movement_labels'] = df.apply(label_data, axis=1)
With our labels in place, we can now slice up our DataFrame into pieces manageable for our model and collect them into lists:
data = [] labels = [] for i in range(len(df)-self.n_tsteps+1+shift): label = df['movement_labels'].iloc[i+self.n_tsteps-1] data.append(df[input_vars].iloc[i:i+self.n_tsteps].values) labels.append(label) data = np.array(data)
Here, we iterate numerically through the DataFrame, with a carefully calculated value in our range() function to make sure we do access an out-of-bounds index. We cast the list of numpy arrays to a numpy array because Keras works best with numpy arrays.
Now, we need to scale our data. It is good practice to scale data when using Machine Learning models so that the range of values is normalized across the features.
dim1, dim2, dim3 = data.shape data = data.reshape(dim1*dim2, dim3) data = scaler.fit_transform(data) data = data.reshape(dim1, dim2, dim3)
The reason we reshape the data before the scaling is because sklearn is only able to handle 2D data, but right after, we can return the data to the original shape with another reshaping.
Finally, since Keras requires the labels to be dummified (which essentially turns a list of labels into a matrix of 1s and 0s, where the index of the 1 is equal to the value of the integer label), we use the following:
labels = utils.to_categorical(labels, num_classes=3)
Specifying num_classes to 3 ensures our matrix will have three columns, one for each label (Up, Down, Stationary).
We have now finished the walk through of the difficult parts of the code.
After we feed in the prepared data into the model (the corresponding code, as well as the rest of the code, can be
found in Algorithm) we can
use our model to make predictions. We take the most recent 15 bars of OHLCV data and apply our model on it to make
a prediction. If the model predicts with above 55% confidence that the future direction is up (resp. down), we emit
an Price Insight with direction InsightDirection.Up (resp. InsightDirection.Down). Since we are
betting on the direction of the average of the future five closing prices, it would be intuitive to emit an Insights
in the respective direction for timedeltas of one through five. However, we choose to only emit an Insight
with a timedelta with a random integer between one and five to constrain the number of insights we emit.
As an additional note, we decided to set the trading fees to zero (the default fee
is one dollar per trade), or else our algorithm will only lose money due to the frequency at which we trade.
We have covered the difficult aspects of the code, as well as give an overview of our strategy. The rest of the necessary code to execute the strategy can be found in Algorithm.


What is BZCareer Search?
We
provide an advanced search engine to help you find the ideal career. When searching for the ideal career, it
may be time consuming but with our search engine you can find the ideal career in seconds. Our searches
are fresh and updated frequently. With BZCareer, what you see in our results is exactly what is
available in the job market.


Snakey has been reborn.
We have completed the construction of the new robotic snake. It consists of eight robotic links connected by aluminum brackets. There is an inherent joint bias in the second motor from the head unfortunately, but we are going to try and fix that before continuing. While doing that we have an impending deadline for our research proposal for Opportunity Research Scholars. Thus we have divided up the responsibilites. I am responsible for the literature review, method and procedures, and my section in the individual contribution.
The whole endeavor should not take extremely long. Hopefully we can have it completed before the weekend, so we can focus more on resetting the configuration on the robot. I will have to put some thought into describing what is required for the methods and procedures for this experiment given that the vision processing can play a pivotal role in the motion planning process.
Based off of the feedback recieved from the vision processing and tactile sensing the robotic snake can deliberate its next motion strategy in real time.
To see how each of the programs play a part in the larger role click here .
Photographs by NASA on The Commons.


Miloš Bovan (@mbovan)
- Drupal 8 Developer at MD Systems
- Student at Google Summer of Code 2016
- Mentor at Google Code-In 2016
- Among World's leading Drupal contributors
- 20% of every project to the community
- Full projects, Bootstrap weeks, Consulting, ...
What we'll cover
- Use-cases
- Inmail architecture
- Mailhandler overview
- Demo
- Current status
- Future ideas
Why emails?
March 2015, The Radicati Group
Use-cases
- News portals
- An additional channel of content creation
- Comment replies
Mailhandler + Inmail
- Redefined for Drupal 8
- Based on
Inmail
- Pluggable
Architecture
PGP Analyzer
- Default support for digitally signed emails
- An additional layer or security
- Easy setup
Entity Type Analyzer
[{entity_type}][{bundle}]
parsing
- Validation
Sender Analyzer
- Identifies e-mail sender
- Matches the user
- Disabled by default
Footer Analyzer
- Identifies e-mail message footer
- Basic implementation
- 2 cases supported:
- "-- \n" (RFC 3676)
- "On {day}, {month} {date}, {year} at {hour}:{minute} {AM|PM}" (Gmail standard)
Body Analyzer
- Analyzes the mail body
- Body manipulation
Node Handler
- Authenticates and authorizes a user
- Matches
type,
body,
uid,
title based on analyzed data
- Creates a new node entity
Comment Handler
- Available in the submodule
- Validates a user
- Authentication
- Authorization
- Signature verification
- Extracts referenced #ID information
- Matches
entity_type,
entity_id,
subject,
comment_body,
uid
- Creates a new comment entity
The current status
- Still under development
- API breaks
- Collect integration
- Extensive test coverage
E-mail display
Next steps
- Drupal as a CRM
- Inmail + Collect + CRM Core
- Mailhandler
- Rules integration
- Handle Drupal commands
Thanks!


Projects of Our Research Team
by Song Wu, Chao Niu, Jia Rao, Hai Jin and Xiaohai Dai
Published on IPDPS 2017
With the explosive growth of smartphones and cloud computing, mobile cloud, which leverages cloud resource to boost the performance of mobile applications, becomes attractive. Many efforts have been made to improve the performance and reduce energy consumption of mobile devices by ofﬂoading computational codes to the cloud. However, the ofﬂoading cost caused by the cloud platform has been ignored for many years. In this paper, we propose Rattrap, a lightweight cloud platform which improves the ofﬂoading performance from cloud side. To achieve such goals, we analyze the characteristics of typical ofﬂoading workloads and design our platform solution accordingly. Rattrap develops a new runtime environment, Cloud Android Container, for mobile computation ofﬂoading, replacing heavyweight virtual machines (VMs). Our design exploits the idea of running operating systems with differential kernel features inside containers with driver extensions, which partially breaks the limitation of OS-level virtualization. With proposed resource sharing and code cache mechanism, Rattrap fundamentally improves the ofﬂoading performance. Our evaluation shows that Rattrap not only reduces the startup time of runtime environments and shows an average speedup of 16x, but also saves a large amount of system resources such as 75% memory footprint and at least 79% disk capacity. Moreover, Rattrap improves ofﬂoading response by as high as 63% over the cloud platform based on VM, and thus saving the battery life.
Mobile application
Computation offloading
Container


Select Player
‹
›
Zombie Uncle
Play
Controls
Left Arrow Key : Move Backward
Right Arrow Key : Move Forward
Spacebar key : Jump
Enter key : Pause/Resume
'M' key: Change Music
How to play ?
Avoid obstacles by jumping.
Achieve target score.
Your Score :
0
Target Score :
100
Made with 💖 by
Sahil Kavitake


% LaTeX test file for kate's syntax highlighting and code folding \ordinaryLaTeXcommandwithoption[10pt,a4paper]{article} % BEGIN region %comment, this is all ok % $ \%no comments please \\%comment % END of region \newcommand{\nohighlighting} \section{normal} \ref{blue} \pageref{blue} \cite{blue} \begin{environmentshavespecialcolors} normal \end{environmentshavespecialcolors} $equations are green, \commands somewhat darker$ normal $$equations are green, \commands somewhat darker$$ normal \( \frac{1}{2} \begin{test} \end{test} \) normal \[ %comment displaymath \] normal \begin{equation} green\darkergreen \begin{test} \test \end{test} \end{equation} \begin{equation*} green\darkergreen %comment \begin{test} \test \end{test} \%no comment \end{equation*} \{ %this should be comment \verb%this shouldn't be%and this should be normal text \begin{verbatim} text inside a verbatim environment is also treated special $ %, you can even put a \begin{verbatim} inside \end{verbatim} normal \begin{Verbatim} &@@#^%&^#$ \end{Verbatim} \begin{Verbatim*} @*&^#@*(^#(*@& \end{Verbatim*} normal % test alignat \begin{alignat}{2} A &= B &= C \\ A &= B &= C \end{alignat} normal text \iffalse \fill commented out text \fi


<juicy-tile-list>
Masonry-like Polymer Element for sortable tiles that packs efficiently without changing HTML structure (changes CSS only).
Item 0, 100% x 100px, priority 1, nested
Item 4, 100% x 25% , priority 0, nested twice
API
juicytilelist.resizeItem
(, , )juicytilelist.reprioritizeItem
(, , )


Class: Rack::Runtime
| Relationships & Source Files | |
| Inherits: | Object |
| Defined in: | lib/rack/runtime.rb |
Overview
Sets an “x-runtime” response header, indicating the response time of the request, in seconds
You can put it right before the application to see the processing time, or before all the other middlewares to include time for them, too.
Constant Summary
-
FORMAT_STRING =
Internal use only
# File 'lib/rack/runtime.rb', line 13"%0.6f"
-
HEADER_NAME =
Internal use only
# File 'lib/rack/runtime.rb', line 14"x-runtime"
Class Method Summary
- .new(app, name = nil) ⇒ Runtime constructor
Instance Method Summary
Constructor Details
.new(app, name = nil) ⇒ Runtime
# File 'lib/rack/runtime.rb', line 16
def initialize(app, name = nil) @app = app @header_name = HEADER_NAME @header_name += "-#{name.to_s.downcase}" if name end
Instance Method Details
#call(env)
[ GitHub ]# File 'lib/rack/runtime.rb', line 22
def call(env) start_time = Utils.clock_time _, headers, _ = response = @app.call(env) request_time = Utils.clock_time - start_time unless headers.key?(@header_name) headers[@header_name] = FORMAT_STRING % request_time end response end


Chelsea rival Liverpool for transfer of highly-rated 21-year-old
by Mark BrusChelsea are reportedly the latest club to show an interest in the potential transfer of Genk midfielder Sander Berge, who has also been on Liverpool’s radar.
This is according to Goal, who list the Blues as suitors for Berge as they hope to once again use their relationship with Genk to good effect, having signed Thibaut Courtois and Kevin De Bruyne from the Belgian side in the past.
MORE: Chelsea star sends clear message over his future amid transfer links with Premier League club
The Norway international looks an exciting prospect after showing what he can do in the Champions League this season, particularly in games against Liverpool.
Goal note that this has worked the 21-year-old onto the Reds’ radar, while Napoli are also mentioned as admirers of his.
Berge could certainly fit in well in Frank Lampard’s youthful Chelsea side, with the new manager putting together a very promising team for the future after promoting a number of academy players this season.
Goal claims Genk are yet to receive a formal offer for Berge, but it would be exciting to see him end up at Chelsea or Liverpool next as it’s always great to see the world’s best young talents coming to the Premier League.
LFC might be the more tempting option right now due to their great success under Jurgen Klopp, but Berge may also feel he’d have more chances of getting regular playing time as part of Lampard’s exciting project at Stamford Bridge.


Home
Servers
Alerts
Admin
Alerts History
Filter Options
Filter alerts by level:
All
Warning
Error
Filter alerts by server:
# of alerts to view:
50
100
200
250
500
Keywords to search for:
Keywords to filter out:
Submit
No alerts found :(


Templates info,
Type: Business
Design by: Template empire team
URL:
http://www.templateempire.cjb.com
Enhance your site,
Get some add-on tools for your web site like graphic add-on, button images
add-on and others cool add-on tools. Visit
www.templateempire.cjb.com for
more info.
Become a webmaster in a minute,
Become a web master in a minute by reading through the template empire
tutorial central. The tutorial central consist of large gallery of tutorial.
This include of FrontPage tutorial, Fireworks and much more.
Get a custom templates,
Are you requiring a custom made template to suit your need, Then order one
of our custom templates costing a affordable price. For more info visit template
empire or email us at
<EMAIL_ADDRESS>Needing help,
Require help in our templates? Then visit the template empire help central.
The large help central gallery contains all help file about template empire
templates.
Needing more assistant....
If you require more help about the templates, Contact us at
<EMAIL_ADDRESS>Please read through the help central
before emailing to us. Note: Please do not include any attachment while emailing
to us, Any attachment on email will be delete.


qController Example
Main Features
- Fully Configurable, Adjustable and Customizable.
- Two ways for user input (plus minus button and range slider for quickly input). (Slider is Optional)
- Provide way to handle Minimum and Maximum Quantity.
- Automatically Creates UI Elements, However Provide Classes for Fully Customization with CSS.
- Provide easy way to handle user quantity inputs.
Why qController
The qController let's developers to handle user's small inputs (quantities) and perform various kinds of things according to the user input. You can easily implement this lightweight Plugin in your projects. The qController also can be used in functions, conditions, loops, arrays, dynamic & static contents of the javascript programs.
Sometimes, user needs to input a little bit number while performing some kind of task on a website/app. (i.e selecting quantity of item in shopping website, quantity for level of something, quantity of font size, zooming level, increasing or decreasing number, in short to do something after selecting specific quantity).
This lightweight plugin will helps you to handle such kinds of inputs more easily.
What's qController Offer
Basically, this plugin control quantity of something. However, it can be used for various purposes according to its available options. There are five total options, these are:
qStart: 50, //quantity where from start to increase or decrease qMax: 100, //quantity maximum limit to increase qMin: 1, // quantity to minimum limit to decrease qSlider: true, //also show input range slider for increasing or decreasing along with plus and minus buttons qStatus: "Quantity: ", //text that will show along with the quantity status
How to Implement
First, create a container (an empty div element) in HTML where you want to adjust this controller. After this, initialize it with that container's id or class name in DOM ready function.
$(document).ready(function(){ $(".classname").qController({ //options goes here }); });
Note: Use the above mentioned options to get the desired input from the user.
Working with User's Inputs
You can do something when its value reached to the specific number, maximum or minimum with the following condition.
if ( Quantity == setting.qMax){ // block of code }
Note:
Use setting.qMin
for minimum value.
You can use your desired condition.
Add the conditions, loops and arrays in structure of this plugin.
In plugin code structure, var Quantity
stores all the values. It has global scope in plugin. You can use this variable to handle user inputs.
To store it's specific value in another array, use the push method.


|
SystemC
2.3.3
Accellera SystemC proof-of-concept library
|
#include <sysc/datatypes/fx/sc_fxnum.h>
Public Member Functions | |
| sc_fxnum_fast_subref (const sc_fxnum_fast_subref &) | |
| void | scan (::std::istream &=::std::cin) |
| Public Member Functions inherited from sc_dt::sc_fxnum_fast_subref_r | |
| sc_fxnum_fast_subref_r (const sc_fxnum_fast_subref_r &) | |
| ~sc_fxnum_fast_subref_r () | |
| bool | and_reduce () const |
| bool | nand_reduce () const |
| bool | or_reduce () const |
| bool | nor_reduce () const |
| bool | xor_reduce () const |
| bool | xnor_reduce () const |
| int | length () const |
| int | to_int () const |
| unsigned int | to_uint () const |
| long | to_long () const |
| unsigned long | to_ulong () const |
| int64 | to_int64 () const |
| uint64 | to_uint64 () const |
| const std::string | to_string () const |
| const std::string | to_string (sc_numrep) const |
| const std::string | to_string (sc_numrep, bool) const |
| operator sc_bv_base () const | |
| void | print (::std::ostream &=::std::cout) const |
| void | dump (::std::ostream &=::std::cout) const |
Friends | |
| class | sc_fxnum_fast |
| class | sc_fxnum_subref |
Additional Inherited Members | |
| Protected Member Functions inherited from sc_dt::sc_fxnum_fast_subref_r | |
| bool | get () const |
| sc_fxnum_fast_subref_r (sc_fxnum_fast &, int, int) | |
| Protected Attributes inherited from sc_dt::sc_fxnum_fast_subref_r | |
| sc_fxnum_fast & | m_num |
| int | m_from |
| int | m_to |
| sc_bv_base & | m_bv |
Definition at line 547 of file sc_fxnum.h.
|
inline |
Definition at line 2548 of file sc_fxnum.h.
| void sc_dt::sc_fxnum_fast_subref::scan | ( | ::std::istream & | = ::std::cin | ) |
|
friend |
Definition at line 549 of file sc_fxnum.h.
|
friend |
Definition at line 550 of file sc_fxnum.h.


Home
Rates
Gallery
Contact
Balloons!
We make balloons!
The following contains rate info:
Price per hour:
Travel reimbursement:
You can see samples below:
The following contains contact info:
Email:
Cellphone:


gordon.contrib¶
When using gordon, you’ll quickly see contrib
apps take an important role while
deploying and wiring your lambdas.
Gordon uses CloudFormation
a lot. It is a great AWS service, but it’s API doesn’t
always include the latest services AWS is releasing almost every week! These services
will eventually make it into CloudFormation
, but in the meantime we need to use
low-level APIs to interact with them.
We could (as some other projects) decide to fill the gaps streaming API commands... but we decided to do things differently.
We believe CloudFormation
is the way to move forward, and the advantages it provides
surpass some of the gotchas, so we decided to fill the gaps using Lambdas and custom
CloudFormation
resources.
But... how could you use Lambdas and CloudFormation
to create Lambdas in CloudFormation
?
Easy - eating your own dog food; That’s gordon.contrib
!
gordon.contrib
is a set of reusable gordon applications your gordon projects use to
be able to deploy your resources and fill the gaps in CloudFormation
until AWS fills them.
When will AWS allow us to create those resources “natively”?¶
We have no idea, but we have make a big effort trying to make our Custom CloudFormation
resources look as similar as possible to what we think those resources will look like. Once
AWS releases those APIs in CloudFormation
, subsequent versions of gordon will stop
using our lambda-based Resources and use native ones.
Available contrib
apps¶
contrib.lambdas
¶
This application exposes two CloudFormation
resources:
- version: Creates Versions for our lambda functions. Nothing super fancy under the hood: https://github.com/jorgebastida/gordon/blob/master/gordon/contrib/lambdas/version/version.py
contrib.s3
¶
This application exposes one CloudFormation
resource:
- bucket_notification_configuration: This resource allows us to manage S3 bucket notifications. This is a complex resource because the API AWS has develop around... it is not very nice (imho). You can see more details here: https://github.com/jorgebastida/gordon/blob/master/gordon/contrib/s3/bucket_notification_configuration/bucket_notification_configuration.py
contrib.helpers
¶
This application exposes one simple CloudFormation
resource called Sleep
. Yes, this is lame ¯\_(ツ)_/¯
but
it was the only possible way to make resilient integrations with streams such as kinesis
and dynamodb
.
This is because the IAM role of the lambda is not propagated fast enough uppon creation, and CloudFormation
checks
if the referenced lambda has permission to consume this stream on creation time. A small sleep fixes the problem. We
will probably try fix this in the future with a generic make-sure-this-is-ready
lambda.


Lorem ipsum dolor sit amet consectetur, adipisicing elit. Eveniet, rerum? Quam ipsam iste modi ut voluptatem porro, molestiae sunt laboriosam?
Lorem, ipsum dolor sit amet consectetur adipisicing elit. Exercitationem dolore beatae velit dolor corporis modi provident dolorem culpa obcaecati inventore?
Lorem ipsum dolor sit amet consectetur adipisicing elit. Deserunt quaerat possimus laboriosam ut animi optio aut distinctio, sunt hic quia!
Thanks to MDB you can take advantage of all feature of newest Bootstrap 4.
 It will help you to implement your ideas easily.
We care about the development of our users. We have prepared numerous tutorials, which allow you to learn how to use MDB as well as other technologies.
Thanks to MDB you can take advantage of all feature of newest Bootstrap 4.
 It will help you to implement your ideas easily.
We care about the development of our users. We have prepared numerous tutorials, which allow you to learn how to use MDB as well as other technologies.


By the end of this module, students will be able to:
Calculate the financial cost of a payday loan.
Measure the geographical correlation between payday lenders and minority populations.
Define the concept of risk.
Outline the social implications of payday lending on individuals and communities.
Evaluate potential alternatives to payday lending through a mathematical lens.


TranslatablePair
Represents key-value pair from Localizable.strings files. It contains key, value and expression if exists for the key. It can also validate if text matches expression’s requirements.
-
Key from Localizable.strings.
Declaration
Swift
var key: Key
-
Value from Localizable.strings.
Declaration
Swift
var value: Value
-
Expression
which is parsed fromkey
.Declaration
Swift
var expression: Expression? = nil
-
Tells if pair has
expression
or not.Declaration
Swift
var hasExpression: Bool { return expression != nil }
-
It returns key without expression pattern. If pair has
expression
set to nil it will returnkey
. Ifexpression
exist thekey
will be parsed and returned without expression pattern.Declaration
Swift
var keyWithoutExpression: String
-
Creates
TranslatablePair
. It automatically tries to parse expression from key - if there is any.Declaration
Swift
init(key: Key, value: Value)
Parameters
key
A key from Localizable.strings
value
A value from Localizable.strings
-
Method parses expression from the
key
property.Declaration
Swift
mutating func parseExpression()
-
Validates string and check if matches
expression
’s requirements. If pair has no expression it return false.Declaration
Swift
func validate(value: String) -> Bool
Parameters
value
A value that will be matched.
Return Value
true
if value matchesexpression
, otherwisefalse
.


project title: TAJ PARADICE
SKILLS UGE: C++, data structure,graphics
DESCRIPTION
this project was totally based on HOTEL MANAGEMENT .
it contains different module and function according to uses.
1 INFORMATION MODULE which provide information of HOTEL TAJ.
this module has two section single room inquiry and double room inquiry
2 BOOK MODULE it also contains two different section
single room booking and double room boooking
3 PAYMENT MODULE this module is based on payment at the time of booking.
4 STATUS MODULE this module show about the current status of availability
of single room and double room
5 there is some other module are also available show module,display module
data structure use for storing data of customer such as name,address,number of book room
advance amount etc.
data store in file using file handling .
6. This is my second project.


Home
Login
Avatao Demo Challenge
Welcome to Avatao!
Hack this site, find the flag and submit it on the platform!
I'm ready!


Best Ethereum Wallet Survey Form
Let us know which wallet you think is the best for navigating Ethereum
Name
Email
How many years have you been in crypto?
How would you describe your role in Ethereum?
Select your role
Trader
NFT Collector
Developer
Miner
Validator
Which wallet type do you prefer?
Hot Wallet
Cold Wallet
Smart Contract
Paper
Which wallets do you use the most?
Metamask
Coinbase Wallet
Portis
imToken
Fortmatic
MyEtherWallet
MyCrypto
Argent
Gnosis Safe
Ledger
Trezor
Trust
Torus
Rainbow
Status
Dharma
Additional Comments?
Submit


Search
Make a Request
My Profile
Find a Courthouse
Find a Server
Newsroom
Terms of Service
Settings
UPIKM
Online Courthouse, Process Helper and Record Database


 Even after reading the lease, you may be unaware of when your rights supersede or even contradict the terms in that document. And when the vast majority of tenants facing eviction lack legal representation, it is absolutely essential to at least have an accessible way to learn your rights. That knowledge could save you from being homeless tonight.
The Eviction Fighter is intended to help tenants and attorneys who serve them fight unlawful evictions. It helps users drill down on and understand the legal issues facing them.
Many tenants remain at a disadvantage when landlord-tenant conflicts arise. Tenants facing eviction or living in poorly maintained buildings often under-utilize legal resources at their disposal. The most common reasons one may fail to use available legal remedies seem to be:


This example shows the use of a sudden expansion / contraction model, which is connected to two boundary conditions prescribing static pressure. Notice that the prescribed static pressure on the right boundary is higher than on the left one. Still, the fluid flows from left to right.
The reason for this is that the boundary conditions model
infinite reservoirs with an infinite diameter and thus zero flow
velocity. The sudden expansion model does however have two ends
with finite diameters, and, as explained in the Overview of the
Users' Guide, the momentum balance is not fulfilled exactly for
this type of connections. Using a simple
connect()
-statement, the difference of the kinetic
terms is neglected, which is not reasonable in the present model:
At the left boundary condition it is zero, and on the left side of
the sudden expansion it has a non-zero value. It is not reasonable
to neglect it in the shown model, because there is little friction
and therefore these kinetic effects dominate. Consequently, only
modelling these effects explicitly leads to the correct
results.
To do so, two additional sudden expansions / contractions are
included in the model. The diameter is set to inf
close to the boundaries and the proper values close to the original
model. These additional components now introduce exact
momentum balances and the results are as expected.
The total pressures offer an additional perspective on the
model. After setting the parameter show_totalPressures
on the Advanced tab of the AbruptAdaptor
s to
true
, the total pressures are included in said models
and may be plotted. This allows to confirm that the
total pressure always reduces along the
flow direction, even in the upper model.


📅 (2023-03-13 12:42:05 UTC)
# Packages matching: installed # Name # Installed # Synopsis base-bigarray base base-threads base base-unix base conf-findutils 1 Virtual package relying on findutils conf-gmp 4 Virtual package relying on a GMP lib system installation coq 8.16.0 Formal proof management system dune 3.7.0 Fast, portable, and opinionated build system ocaml 4.11.2 The OCaml compiler (virtual package) ocaml-base-compiler 4.11.2 Official release 4.11.2 ocaml-config 1 OCaml Switch Configuration ocamlfind 1.9.5 A library manager for OCaml zarith 1.12 Implements arithmetic and logical operations over arbitrary-precision integers # opam file: opam-version: "2.0" authors: [ "Andres Erbsen<EMAIL_ADDRESS>"Google Inc." "Jade Philipoom<EMAIL_ADDRESS><EMAIL_ADDRESS>"Massachusetts Institute of Technology" "Zoe Paraskevopoulou<EMAIL_ADDRESS>] maintainer: "Jason Gross<EMAIL_ADDRESS>homepage: "https://github.com/mit-plv/fiat-crypto" bug-reports: "https://github.com/mit-plv/fiat-crypto/issues" license: "MIT OR Apache-2.0 OR BSD-1-Clause" build: [ [make "-j%{jobs}%" "EXTERNAL_DEPENDENCIES=1" "SKIP_COQSCRIPTS_INCLUDE=1" "coq" "standalone-ocaml"] ] install: [make "EXTERNAL_DEPENDENCIES=1" "SKIP_COQSCRIPTS_INCLUDE=1" "BINDIR=%{bin}%" "install" "install-standalone-ocaml"] depends: [ "conf-findutils" {build} "ocaml" {build & >= "4.08~"} "ocamlfind" {build} "coq" {>= "8.15~"} "coq-coqprime" {>= "1.2.0"} "coq-rewriter" {>= "0.0.6" & <= "0.0.7"} "coq-rupicola" {= "0.0.6"} "coq-bedrock2-compiler" {= "0.0.4"} ] conflict-class: [ "coq-fiat-crypto" ] dev-repo: "git+https://github.com/mit-plv/fiat-crypto.git" synopsis: "Cryptographic Primitive Code Generation by Fiat" description: """ Coq code and proofs for a command-line binary that can synthesize proven-correct big-integer modular field arithmetic operations for cryptography. Target languages include C, Rust, Zig, Go, and bedrock2. """ tags: ["logpath:Crypto"] url { src: "https://github.com/mit-plv/fiat-crypto/archive/refs/tags/v0.0.16.tar.gz" checksum: "sha512=db5e3ce6eb30066150c3611222c48f0eaab02f5b6101faab20d8a586c4f23bacb0c46372eff03736d7f017195500b3ea0203895052bf6ade752030a08c77e86d" }
true
Dry install with the current Coq version:
opam install -y --show-action coq-fiat-crypto.0.0.16 coq.8.16.0
Dry install without Coq/switch base, to test if the problem was incompatibility with the current Coq/OCaml version:
true
opam list; echo; ulimit -Sv 4000000; timeout 4h opam install -y --deps-only coq-fiat-crypto.0.0.16 coq.8.16.0
opam list; echo; ulimit -Sv 16000000; timeout 4h opam install -y -v coq-fiat-crypto.0.0.16 coq.8.16.0
# Packages matching: installed # Name # Installed # Synopsis base-bigarray base base-threads base base-unix base conf-findutils 1 Virtual package relying on findutils conf-gmp 4 Virtual package relying on a GMP lib system installation coq 8.16.0 Formal proof management system coq-bedrock2 0.0.4 A work-in-progress language and compiler for verified low-level programming coq-bedrock2-compiler 0.0.4 A work-in-progress language and compiler for verified low-level programming (compiler part) coq-bignums 8.16.0 Bignums, the Coq library of arbitrary large numbers coq-coqprime 1.3.0 Certifying prime numbers in Coq coq-coqutil 0.0.2 Coq library for tactics, basic definitions, sets, maps coq-record-update 0.3.1 Generic support for updating record fields in Coq coq-rewriter 0.0.7 Reflective PHOAS rewriting/pattern-matching-compilation framework for simply-typed equalities and let-lifting, experimental and tailored for use in Fiat Cryptography coq-riscv 0.0.3 RISC-V Specification in Coq, somewhat experimental coq-rupicola 0.0.6 Gallina to imperative code compilation, currently in design phase dune 3.7.0 Fast, portable, and opinionated build system ocaml 4.11.2 The OCaml compiler (virtual package) ocaml-base-compiler 4.11.2 Official release 4.11.2 ocaml-config 1 OCaml Switch Configuration ocamlfind 1.9.5 A library manager for OCaml zarith 1.12 Implements arithmetic and logical operations over arbitrary-precision integers [NOTE] Package coq is already installed (current version is 8.16.0). The following actions will be performed: - install coq-fiat-crypto 0.0.16 <><> Gathering sources ><><><><><><><><><><><><><><><><><><><><><><><><><><><><> Processing 1/1: [coq-fiat-crypto.0.0.16: http] [coq-fiat-crypto.0.0.16] downloaded from https://github.com/mit-plv/fiat-crypto/archive/refs/tags/v0.0.16.tar.gz Processing 1/1: <><> Processing actions <><><><><><><><><><><><><><><><><><><><><><><><><><><><> Processing 1/2: [coq-fiat-crypto: make coq] + /home/bench/.opam/opam-init/hooks/sandbox.sh "build" "make" "-j4" "EXTERNAL_DEPENDENCIES=1" "SKIP_COQSCRIPTS_INCLUDE=1" "coq" "standalone-ocaml" (CWD=/home/bench/.opam/ocaml-base-compiler.4.11.2/.opam-switch/build/coq-fiat-crypto.0.0.16) - ./src/Rewriter/PerfTesting/Specific/make.py primes.txt - GENTEST --makefile fiat-amd64/*.asm > Makefile.test-amd64-files.mk - ECHO > _CoqProject - COQ_MAKEFILE -f _CoqProject > Makefile.coq - Warning: native compilation is globally deactivated by the configure flag - fatal: not a git repository (or any parent up to mount point /) - Stopping at filesystem boundary (GIT_DISCOVERY_ACROSS_FILESYSTEM not set). - Makefile:154: warning: overriding recipe for target 'all' - Makefile.coq:408: warning: ignoring old recipe for target 'all' - Makefile:489: warning: overriding recipe for target 'validate' - Makefile.coq:536: warning: ignoring old recipe for target 'validate' - ECHO > src/Util/Tactics.v - fatal: not a git repository (or any parent up to mount point /) - Stopping at filesystem boundary (GIT_DISCOVERY_ACROSS_FILESYSTEM not set). - COQDEP VFILES - fatal: not a git repository (or any parent up to mount point /) - Stopping at filesystem boundary (GIT_DISCOVERY_ACROSS_FILESYSTEM not set). - Makefile:154: warning: overriding recipe for target 'all' - Makefile.coq:408: warning: ignoring old recipe for target 'all' - Makefile:489: warning: overriding recipe for target 'validate' - Makefile.coq:536: warning: ignoring old recipe for target 'validate' - COQC src/Util/ZUtil/Hints/Core.v - COQC src/Util/NatUtil.v - COQC src/Util/Pointed.v - COQC src/Util/IffT.v - COQC src/Util/Isomorphism.v - COQC src/Util/HProp.v - COQC src/Util/GlobalSettings.v - COQC src/Util/Tactics/Test.v - COQC src/Util/Tactics/ConstrFail.v - COQC src/Util/ZUtil/Tactics/ReplaceNegWithPos.v - File "./src/Util/NatUtil.v", line 14, characters 0-57: - Warning: Notation plus_le_compat is deprecated since 8.16. - The Arith.Plus file is obsolete. Use Nat.add_le_mono instead. - [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 34, characters 13-32: - Warning: Notation Min.min_case_strong is deprecated since 8.16. - The Arith.Min file is obsolete. Use Nat.min_case_strong instead. - [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 34, characters 13-32: - Warning: Notation Min.min_case_strong is deprecated since 8.16. - The Arith.Min file is obsolete. Use Nat.min_case_strong instead. - [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 36, characters 13-32: - Warning: Notation Max.max_case_strong is deprecated since 8.16. - The Arith.Max file is obsolete. Use Nat.max_case_strong instead. - [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 36, characters 13-32: - Warning: Notation Max.max_case_strong is deprecated since 8.16. - The Arith.Max file is obsolete. Use Nat.max_case_strong instead. - [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 50, characters 44-63: - Warning: Notation Max.max_case_strong is deprecated since 8.16. - The Arith.Max file is obsolete. Use Nat.max_case_strong instead. - [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 49, characters 44-63: - Warning: Notation Min.min_case_strong is deprecated since 8.16. - The Arith.Min file is obsolete. Use Nat.min_case_strong instead. - [deprecated-syntactic-definition,deprecated] - COQC src/Util/Tactics/GetGoal.v - COQC src/Util/Strings/Decimal.v - COQC src/Util/Tactics/Contains.v - File "./src/Util/NatUtil.v", line 178, characters 12-23: - Warning: Notation mult_succ_r is deprecated since 8.16. - The Arith.Mult file is obsolete. Use Nat.mul_succ_r instead. - [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 178, characters 12-23: - Warning: Notation mult_succ_r is deprecated since 8.16. - The Arith.Mult file is obsolete. Use Nat.mul_succ_r instead. - [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 178, characters 12-23: - Warning: Notation mult_succ_r is deprecated since 8.16. - The Arith.Mult file is obsolete. Use Nat.mul_succ_r instead. - [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 229, characters 8-21: - Warning: Notation beq_nat is deprecated since 8.16. Use Nat.eqb instead. - [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 232, characters 23-39: - Warning: Notation beq_nat_true_iff is deprecated since 8.16. - Use Nat.eqb_eq instead. [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 233, characters 23-40: - Warning: Notation beq_nat_false_iff is deprecated since 8.16. - Use Nat.eqb_neq instead. [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 232, characters 23-39: - Warning: Notation beq_nat_true_iff is deprecated since 8.16. - Use Nat.eqb_eq instead. [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 232, characters 23-39: - Warning: Notation beq_nat_true_iff is deprecated since 8.16. - Use Nat.eqb_eq instead. [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 233, characters 23-40: - Warning: Notation beq_nat_false_iff is deprecated since 8.16. - Use Nat.eqb_neq instead. [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 233, characters 23-40: - Warning: Notation beq_nat_false_iff is deprecated since 8.16. - Use Nat.eqb_neq instead. [deprecated-syntactic-definition,deprecated] - COQC src/Util/Comparison.v - COQC src/Util/ZUtil/Tactics/SplitMinMax.v - COQC src/Util/Tactics/HasBody.v - File "./src/Util/NatUtil.v", line 330, characters 13-24: - Warning: Notation Max.max_0_l is deprecated since 8.16. - The Arith.Max file is obsolete. Use Nat.max_0_l instead. - [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 330, characters 25-36: - Warning: Notation Max.max_0_r is deprecated since 8.16. - The Arith.Max file is obsolete. Use Nat.max_0_r instead. - [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 330, characters 37-55: - Warning: Notation Max.max_idempotent is deprecated since 8.16. - The Arith.Max file is obsolete. Use Nat.max_id instead. - [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 330, characters 56-67: - Warning: Notation Min.min_0_l is deprecated since 8.16. - The Arith.Min file is obsolete. Use Nat.min_0_l instead. - [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 330, characters 68-79: - Warning: Notation Min.min_0_r is deprecated since 8.16. - The Arith.Min file is obsolete. Use Nat.min_0_r instead. - [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 330, characters 80-98: - Warning: Notation Min.min_idempotent is deprecated since 8.16. - The Arith.Min file is obsolete. Use Nat.min_id instead. - [deprecated-syntactic-definition,deprecated] - COQC src/Util/Tactics/PrintContext.v - File "./src/Util/NatUtil.v", line 408, characters 12-19: - Warning: Notation beq_nat is deprecated since 8.16. Use Nat.eqb instead. - [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 408, characters 12-19: - Warning: Notation beq_nat is deprecated since 8.16. Use Nat.eqb instead. - [deprecated-syntactic-definition,deprecated] - File "./src/Util/NatUtil.v", line 409, characters 10-22: - Warning: Notation beq_nat_true is deprecated since 8.16. - Use the bidirectional version Nat.eqb_eq instead. - [deprecated-syntactic-definition,deprecated] - File "./src [...] truncated rflows in OCaml compilation, setting stack size to the recommended minimum of 32768 kbytes - OCAMLOPT src/ExtractionOCaml/with_bedrock2_word_by_word_montgomery.mli - ulimit - /bin/sh: 10: [: 8192: unexpected operator - Warning: Stack size (8192) may be too small. - Warning: To avoid stack overflows in OCaml compilation, setting stack size to the recommended minimum of 32768 kbytes - OCAMLOPT src/ExtractionOCaml/with_bedrock2_base_conversion.mli - ulimit - /bin/sh: 10: [: 8192: unexpected operator - Warning: Stack size (8192) may be too small. - Warning: To avoid stack overflows in OCaml compilation, setting stack size to the recommended minimum of 32768 kbytes - COQC src/Bedrock/Field/Synthesis/New/ComputedOp.v - COQC src/Bedrock/Group/ScalarMult/CSwap.v - OCAMLOPT src/ExtractionOCaml/bedrock2_unsaturated_solinas.ml -o src/ExtractionOCaml/bedrock2_unsaturated_solinas - ulimit - /bin/sh: 10: [: 8192: unexpected operator - Warning: Stack size (8192) may be too small. - Warning: To avoid stack overflows in OCaml compilation, setting stack size to the recommended minimum of 32768 kbytes - Compilation incomplete. - You may need to add new compilation lemmas using `Hint Extern 1 => simple eapply … : compiler` or to tell Rupicola about your custom bindings using `Hint Extern 2 (IsRupicolaBinding (xlet (A := ?A) ?vars _ _)) => exact (RupicolaBinding A vars) : typeclass_instances`. - OCAMLOPT src/ExtractionOCaml/bedrock2_saturated_solinas.ml -o src/ExtractionOCaml/bedrock2_saturated_solinas - ulimit - /bin/sh: 10: [: 8192: unexpected operator - Warning: Stack size (8192) may be too small. - Warning: To avoid stack overflows in OCaml compilation, setting stack size to the recommended minimum of 32768 kbytes - File "src/ExtractionOCaml/bedrock2_unsaturated_solinas.ml", line 715697, characters 10-25: - 715697 | | S x' -> Pervasives.succ (int_of_nat x') - ^^^^^^^^^^^^^^^ - Alert deprecated: module Stdlib.Pervasives - Use Stdlib instead. - - If you need to stay compatible with OCaml < 4.07, you can use the - stdlib-shims library: https://github.com/ocaml/stdlib-shims - OCAMLOPT src/ExtractionOCaml/bedrock2_word_by_word_montgomery.ml -o src/ExtractionOCaml/bedrock2_word_by_word_montgomery - ulimit - /bin/sh: 10: [: 8192: unexpected operator - Warning: Stack size (8192) may be too small. - Warning: To avoid stack overflows in OCaml compilation, setting stack size to the recommended minimum of 32768 kbytes - File "src/ExtractionOCaml/bedrock2_saturated_solinas.ml", line 641936, characters 10-25: - 641936 | | S x' -> Pervasives.succ (int_of_nat x') - ^^^^^^^^^^^^^^^ - Alert deprecated: module Stdlib.Pervasives - Use Stdlib instead. - - If you need to stay compatible with OCaml < 4.07, you can use the - stdlib-shims library: https://github.com/ocaml/stdlib-shims - OCAMLOPT src/ExtractionOCaml/bedrock2_base_conversion.ml -o src/ExtractionOCaml/bedrock2_base_conversion - /bin/sh: 10: [: 8192: unexpected operator - Warning: Stack size (8192) may be too small. - ulimit - Warning: To avoid stack overflows in OCaml compilation, setting stack size to the recommended minimum of 32768 kbytes - File "src/ExtractionOCaml/bedrock2_word_by_word_montgomery.ml", line 789681, characters 10-25: - 789681 | | S x' -> Pervasives.succ (int_of_nat x') - ^^^^^^^^^^^^^^^ - Alert deprecated: module Stdlib.Pervasives - Use Stdlib instead. - - If you need to stay compatible with OCaml < 4.07, you can use the - stdlib-shims library: https://github.com/ocaml/stdlib-shims - File "src/ExtractionOCaml/bedrock2_base_conversion.ml", line 636104, characters 10-25: - 636104 | | S x' -> Pervasives.succ (int_of_nat x') - ^^^^^^^^^^^^^^^ - Alert deprecated: module Stdlib.Pervasives - Use Stdlib instead. - - If you need to stay compatible with OCaml < 4.07, you can use the - stdlib-shims library: https://github.com/ocaml/stdlib-shims - OCAMLOPT src/ExtractionOCaml/with_bedrock2_unsaturated_solinas.ml -o src/ExtractionOCaml/with_bedrock2_unsaturated_solinas - ulimit - /bin/sh: 10: [: 8192: unexpected operator - Warning: Stack size (8192) may be too small. - Warning: To avoid stack overflows in OCaml compilation, setting stack size to the recommended minimum of 32768 kbytes - OCAMLOPT src/ExtractionOCaml/with_bedrock2_saturated_solinas.ml -o src/ExtractionOCaml/with_bedrock2_saturated_solinas - ulimit - /bin/sh: 10: [: 8192: unexpected operator - Warning: Stack size (8192) may be too small. - Warning: To avoid stack overflows in OCaml compilation, setting stack size to the recommended minimum of 32768 kbytes - File "src/ExtractionOCaml/with_bedrock2_unsaturated_solinas.ml", line 715697, characters 10-25: - 715697 | | S x' -> Pervasives.succ (int_of_nat x') - ^^^^^^^^^^^^^^^ - Alert deprecated: module Stdlib.Pervasives - Use Stdlib instead. - - If you need to stay compatible with OCaml < 4.07, you can use the - stdlib-shims library: https://github.com/ocaml/stdlib-shims - File "src/ExtractionOCaml/with_bedrock2_saturated_solinas.ml", line 641936, characters 10-25: - 641936 | | S x' -> Pervasives.succ (int_of_nat x') - ^^^^^^^^^^^^^^^ - Alert deprecated: module Stdlib.Pervasives - Use Stdlib instead. - - If you need to stay compatible with OCaml < 4.07, you can use the - stdlib-shims library: https://github.com/ocaml/stdlib-shims - OCAMLOPT src/ExtractionOCaml/with_bedrock2_word_by_word_montgomery.ml -o src/ExtractionOCaml/with_bedrock2_word_by_word_montgomery - ulimit - /bin/sh: 10: [: 8192: unexpected operator - Warning: Stack size (8192) may be too small. - Warning: To avoid stack overflows in OCaml compilation, setting stack size to the recommended minimum of 32768 kbytes - OCAMLOPT src/ExtractionOCaml/with_bedrock2_base_conversion.ml -o src/ExtractionOCaml/with_bedrock2_base_conversion - ulimit - /bin/sh: 10: [: 8192: unexpected operator - Warning: Stack size (8192) may be too small. - Warning: To avoid stack overflows in OCaml compilation, setting stack size to the recommended minimum of 32768 kbytes - File "src/ExtractionOCaml/with_bedrock2_base_conversion.ml", line 636104, characters 10-25: - 636104 | | S x' -> Pervasives.succ (int_of_nat x') - ^^^^^^^^^^^^^^^ - Alert deprecated: module Stdlib.Pervasives - Use Stdlib instead. - - If you need to stay compatible with OCaml < 4.07, you can use the - stdlib-shims library: https://github.com/ocaml/stdlib-shims - File "src/ExtractionOCaml/with_bedrock2_word_by_word_montgomery.ml", line 789681, characters 10-25: - 789681 | | S x' -> Pervasives.succ (int_of_nat x') - ^^^^^^^^^^^^^^^ - Alert deprecated: module Stdlib.Pervasives - Use Stdlib instead. - - If you need to stay compatible with OCaml < 4.07, you can use the - stdlib-shims library: https://github.com/ocaml/stdlib-shims - COQC src/Bedrock/Field/Synthesis/New/UnsaturatedSolinas.v - COQC src/Bedrock/Group/ScalarMult/MontgomeryLadder.v - COQC src/Bedrock/Field/Synthesis/Specialized/UnsaturatedSolinas.v - COQC src/Bedrock/Field/Synthesis/Specialized/WordByWordMontgomery.v - COQC src/Bedrock/Field/Synthesis/New/WordByWordMontgomery.v - COQC src/Bedrock/Field/Synthesis/Examples/p256_64.v - COQC src/Bedrock/End2End/Poly1305/Field1305.v - Finished transaction in 41.878 secs (6.174u,0.074s) (successful) - Finished transaction in 3.205 secs (0.48u,0.s) (successful) - Finished transaction in 4.044 secs (0.663u,0.s) (successful) - Finished transaction in 9.709 secs (1.479u,0.s) (successful) - Finished transaction in 8.297 secs (1.255u,0.004s) (successful) - Finished transaction in 2.407 secs (0.348u,0.s) (successful) - Finished transaction in 3.282 secs (0.49u,0.s) (successful) - COQC src/Bedrock/End2End/RupicolaCrypto/Low.v - File "./src/Bedrock/End2End/RupicolaCrypto/Low.v", line 127, characters 40-53: - Warning: Notation le_plus_minus is deprecated since 8.16. - The Arith.Minus file is obsolete. Use Nat.sub_add (together with Nat.add_com) instead. - [deprecated-syntactic-definition,deprecated] - File "./src/Bedrock/End2End/RupicolaCrypto/Low.v", line 127, characters 40-53: - Warning: Notation le_plus_minus is deprecated since 8.16. - The Arith.Minus file is obsolete. Use Nat.sub_add (together with Nat.add_com) instead. - [deprecated-syntactic-definition,deprecated] - File "./src/Bedrock/End2End/RupicolaCrypto/Low.v", line 127, characters 40-53: - Warning: Notation le_plus_minus is deprecated since 8.16. - The Arith.Minus file is obsolete. Use Nat.sub_add (together with Nat.add_com) instead. - [deprecated-syntactic-definition,deprecated] - COQC src/Bedrock/End2End/X25519/Field25519.v - Compilation incomplete. - You may need to add new compilation lemmas using `Hint Extern 1 => simple eapply … : compiler` or to tell Rupicola about your custom bindings using `Hint Extern 2 (IsRupicolaBinding (xlet (A := ?A) ?vars _ _)) => exact (RupicolaBinding A vars) : typeclass_instances`. - COQC src/Bedrock/Field/Synthesis/Examples/X25519_64.v - COQC src/Bedrock/Field/Synthesis/Examples/X1305_32.v - Finished transaction in 158.038 secs (24.022u,0.085s) (successful) - Finished transaction in 305.574 secs (47.722u,0.124s) (successful) - File "./src/Bedrock/Field/Synthesis/Examples/p256_64.v", line 29, characters 7-31: - Warning: native_compute disabled at configure time; falling back to - vm_compute. [native-compute-disabled,native-compiler] - COQC src/Bedrock/Field/Synthesis/Examples/p224_64.v - Finished transaction in 17.746 secs (2.671u,0.004s) (successful) - Finished transaction in 86.013 secs (13.576u,0.008s) (successful) - File "./src/Bedrock/Field/Synthesis/Examples/X1305_32.v", line 34, characters 7-35: - Warning: native_compute disabled at configure time; falling back to - vm_compute. [native-compute-disabled,native-compiler] - COQC src/Bedrock/Field/Synthesis/Examples/p224_64_new.v - Finished transaction in 24.302 secs (3.738u,0.007s) (successful) - Finished transaction in 119.339 secs (18.717u,0.02s) (successful) The middle of the output is truncated (maximum 20000 characters)
No files were installed.
true


Home
Disabled
Dropdown link
Add a new user
Another action
Something else here
Contact Us
(current)
This is not the end! this is just skyfall
just for fun!!
Search
Who are we?
Name:
John Doe
Email:
<EMAIL_ADDRESS>Place:
India
Contact:
1234567890


We need you to create your account and log in to start! Once you have your account, you will have access to the tools to help you become the better professor you are meant to be. Let's get started!
Once you are logged in, you will see your dashboard. Here you will see all the important information about your students, their projects and deadlines, and friendly reminders when to reach out and contact the your students.
One of the key features of the Better Professor App © is the streamlined dashboard and how easy it is to make changes.
Have a new student? Simply add a new student profile, fill out their information, and you are ready to go!
Running late or can't make a meeting? No problem! Log in and send a quick message to your student.
Have a lot on your plate? Set reminders so you can prioritize your work load.
Our app uses notifications to keep you one step ahead of everybody else. A friendly reminder will alert you when it's time to schedule a meeting with students, when their deadlines are approaching, and when to submit paperwork.