Class UUID
Defined in: uuid.js.
| Constructor Attributes | Constructor Name and Description |
|---|---|
|
UUID()
|
| Field Attributes | Field Name and Description |
|---|---|
|
List of UUID field values (as binary bit string values).
|
|
|
128-bit binary bit string representation.
|
|
| <static> <constant> |
UUID.FIELD_NAMES
Names of each UUID field.
|
| <static> <constant> |
UUID.FIELD_SIZES
Sizes of each UUID field.
|
|
List of UUID field values (as hexadecimal string values).
|
|
|
Non-delimited hexadecimal string representation ("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx").
|
|
|
UUID hexadecimal string representation ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx").
|
|
|
List of UUID field values (as integer values).
|
|
| <static> |
UUID.overwrittenUUID
Preserves the value of 'UUID' global variable set before the load of UUID.js.
|
|
UUID string representation as a URN ("urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx").
|
|
|
UUID version number defined in RFC 4122.
|
| Method Attributes | Method Name and Description |
|---|---|
|
equals(uuid)
Tests if two UUID objects are equal.
|
|
| <static> |
UUID.generate()
The simplest function to get an UUID string.
|
| <static> |
UUID.genV1()
Generates a version 1 UUID.
|
| <static> |
UUID.genV4()
Generates a version 4 UUID.
|
| <static> |
UUID.makeBackwardCompatible()
Reinstalls UUID.generate method to emulate the interface of UUID.js version 2.x.
|
| <static> |
UUID.parse(strId)
Converts hexadecimal UUID string to an UUID object.
|
| <static> |
UUID.resetState()
Re-initializes version 1 UUID state.
|
|
toString()
Returns UUID string representation.
|
Field Detail
{string[]}
bitFields
List of UUID field values (as binary bit string values).
{string}
bitString
128-bit binary bit string representation.
<static> <constant>
{string[]}
UUID.FIELD_NAMES
Names of each UUID field.
- Since:
- 3.0
<static> <constant>
{int[]}
UUID.FIELD_SIZES
Sizes of each UUID field.
- Since:
- 3.0
{string[]}
hexFields
List of UUID field values (as hexadecimal string values).
{string}
hexNoDelim
Non-delimited hexadecimal string representation ("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx").
- Since:
- v3.3.0
{string}
hexString
UUID hexadecimal string representation ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx").
{int[]}
intFields
List of UUID field values (as integer values).
<static>
{object}
UUID.overwrittenUUID
Preserves the value of 'UUID' global variable set before the load of UUID.js.
- Since:
- 3.2
{string}
urn
UUID string representation as a URN ("urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx").
{int}
version
UUID version number defined in RFC 4122.
Method Detail
{bool}
equals(uuid)
Tests if two UUID objects are equal.
- Parameters:
- {UUID} uuid
- Returns:
- {bool} True if two UUID objects are equal.
<static>
{string}
UUID.generate()
The simplest function to get an UUID string.
- Returns:
- {string} A version 4 UUID string.
<static>
{UUID}
UUID.genV1()
Generates a version 1 UUID.
- Since:
- 3.0
<static>
{UUID}
UUID.genV4()
Generates a version 4 UUID.
- Since:
- 3.0
<static>
UUID.makeBackwardCompatible()
Reinstalls UUID.generate method to emulate the interface of UUID.js version 2.x.
- Deprecated:
- Version 2.x. compatible interface is not recommended.
- Since:
- 3.1
<static>
{UUID}
UUID.parse(strId)
Converts hexadecimal UUID string to an UUID object.
- Parameters:
- {string} strId
- UUID hexadecimal string representation ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx").
- Since:
- 3.0
<static>
UUID.resetState()
Re-initializes version 1 UUID state.
- Since:
- 3.0
{string}
toString()
Returns UUID string representation.
- Returns:
- {string} UUID#hexString.


{% extends "base.html" %} {% block extrahead %} {% endblock %} {% block main_slot %}
Welcome!
Use the form below to choose the subtitles file (.srt) that you want to fix and a time value in seconds (to add or subtract) to its timing synchronization.
{% if subtitle_form.errors.subtitle_file %} {{ subtitle_form.errors.subtitle_file }} {% endif %}


The objective of the CSS-TAG Houdini Task Force (CSS Houdini) is to jointly develop features that explain the “magic” of Styling and Layout on the web.
CSS Houdini
What this means is that we'll finally be able to Extend CSS via JavaScript. This is important because it's currently not possible to extend CSS with JavaScript, only write JavaScript that mimics CSS. Actually polyfilling CSS, or introducing new features (like CSS Grid), is hard-to-impossible to do, doubly so in a way that's not terrible for performance. CSS Houdini will let authors tap in to the actual CSS engine, finally allowing us to extend CSS, and do so at CSS speeds
Much like Service Workers are a low-level JavaScript API for the browser's cache, Houdini introduces low-level JavaScript APIs for the browser's render engines
This is awesome, and is going to give us a lot of power, but unfortunately, it's not quite ready yet
The demos presented are, at best, based off of working drafts that are still in flux. No compatible implementations exist. What little actually works only really does so in Chrome Canary with Experimental Web Platform Features enabled (chrome://flags/#enable-experimental-web-platform-features
). These demos will likely break if not viewed there. Syntax and semantics are likely to change. In fact, in the course of a year, one API has gone through 4ish incompatible API changes. Some of the examples provided are speculative based on previous and current working implementations and may not reflect final syntax. Terms and conditions apply. Not redeemable for cash. Your mileage may vary.
Cool?! Let's get started! Follow the links below to learn more about some of the key Houdini APIs and concepts, including live code you can play with! When you're all done, check out some of the additional resources to learn more!


Gecode::Int::Extensional::BitSet< IndexType > Class Template Reference
Bit-set. More...
#include <extensional.hh>
Public Member Functions | |
| BitSet (Space &home, unsigned int n) | |
| Initialize bit set for a number of words n. | |
| template<class OldIndexType > | |
| BitSet (Space &home, const BitSet< OldIndexType > &bs) | |
| Initialize during cloning. | |
| BitSet (Space &home, const TinyBitSet< 1U > &tbs) | |
| Initialize during cloning (unused). | |
| BitSet (Space &home, const TinyBitSet< 2U > &tbs) | |
| Initialize during cloning (unused). | |
| BitSet (Space &home, const TinyBitSet< 3U > &tbs) | |
| Initialize during cloning (unused). | |
| BitSet (Space &home, const TinyBitSet< 4U > &tbs) | |
| Initialize during cloning (unused). | |
| unsigned int | limit (void) const |
| Get the limit. | |
| bool | empty (void) const |
| Check whether the set is empty. | |
| unsigned int | width (void) const |
| Return the highest active index. | |
| void | clear_mask (BitSetData *mask) const |
| Clear the first limit words in mask. | |
| void | add_to_mask (const BitSetData *b, BitSetData *mask) const |
| Add to mask. | |
| template<bool sparse> | |
| void | intersect_with_mask (const BitSetData *mask) |
| Intersect with mask, sparse mask if sparse is true. | |
| void | intersect_with_masks (const BitSetData *a, const BitSetData *b) |
| Intersect with the "or" of and b. | |
| bool | intersects (const BitSetData *b) const |
| Check if has a non-empty intersection with the set. | |
| void | nand_with_mask (const BitSetData *b) |
| Perform "nand" with b. | |
| unsigned int | words (void) const |
| Return the number of required bit set words. | |
| unsigned int | size (void) const |
| Return the number of required bit set words. | |
Protected Member Functions | |
| void | replace_and_decrease (IndexType i, BitSetData w) |
| Replace the i th word with w, decrease limit if w is zero. | |
Protected Attributes | |
| IndexType | _limit |
| Limit. | |
| IndexType * | index |
| Indices. | |
| BitSetData * | bits |
| Words. |
Detailed Description
template<class IndexType>
class Gecode::Int::Extensional::BitSet< IndexType >
Bit-set.
Definition at line 236 of file extensional.hh.
Constructor & Destructor Documentation
| Gecode::Int::Extensional::BitSet< IndexType >::BitSet | ( | Space & | home, | |
| unsigned int | n | |||
| ) | [inline] |
Initialize bit set for a number of words n.
Definition at line 42 of file bit-set.hpp.
| Gecode::Int::Extensional::BitSet< IndexType >::BitSet | ( | Space & | home, | |
| const BitSet< OldIndexType > & | bs | |||
| ) | [inline] |
Initialize during cloning.
Definition at line 56 of file bit-set.hpp.
| Gecode::Int::Extensional::BitSet< IndexType >::BitSet | ( | Space & | home, | |
| const TinyBitSet< 1U > & | tbs | |||
| ) | [inline] |
Initialize during cloning (unused).
Definition at line 70 of file bit-set.hpp.
| Gecode::Int::Extensional::BitSet< IndexType >::BitSet | ( | Space & | home, | |
| const TinyBitSet< 2U > & | tbs | |||
| ) | [inline] |
Initialize during cloning (unused).
Definition at line 75 of file bit-set.hpp.
| Gecode::Int::Extensional::BitSet< IndexType >::BitSet | ( | Space & | home, | |
| const TinyBitSet< 3U > & | tbs | |||
| ) | [inline] |
Initialize during cloning (unused).
Definition at line 80 of file bit-set.hpp.
| Gecode::Int::Extensional::BitSet< IndexType >::BitSet | ( | Space & | home, | |
| const TinyBitSet< 4U > & | tbs | |||
| ) | [inline] |
Initialize during cloning (unused).
Definition at line 85 of file bit-set.hpp.
Member Function Documentation
| void Gecode::Int::Extensional::BitSet< IndexType >::replace_and_decrease | ( | IndexType | i, | |
| BitSetData | w | |||
| ) | [inline, protected] |
Replace the i th word with w, decrease limit if w is zero.
Definition at line 91 of file bit-set.hpp.
| unsigned int Gecode::Int::Extensional::BitSet< IndexType >::limit | ( | void | ) | const [inline] |
Get the limit.
Definition at line 187 of file bit-set.hpp.
| bool Gecode::Int::Extensional::BitSet< IndexType >::empty | ( | void | ) | const [inline] |
Check whether the set is empty.
Definition at line 193 of file bit-set.hpp.
| unsigned int Gecode::Int::Extensional::BitSet< IndexType >::width | ( | void | ) | const [inline] |
Return the highest active index.
Definition at line 211 of file bit-set.hpp.
| void Gecode::Int::Extensional::BitSet< IndexType >::clear_mask | ( | BitSetData * | mask | ) | const [inline] |
Clear the first limit words in mask.
Definition at line 107 of file bit-set.hpp.
| void Gecode::Int::Extensional::BitSet< IndexType >::add_to_mask | ( | const BitSetData * | b, | |
| BitSetData * | mask | |||
| ) | const [inline] |
Add to mask.
Definition at line 117 of file bit-set.hpp.
| void Gecode::Int::Extensional::BitSet< IndexType >::intersect_with_mask | ( | const BitSetData * | mask | ) | [inline] |
Intersect with mask, sparse mask if sparse is true.
Definition at line 126 of file bit-set.hpp.
| void Gecode::Int::Extensional::BitSet< IndexType >::intersect_with_masks | ( | const BitSetData * | a, | |
| const BitSetData * | b | |||
| ) | [inline] |
Intersect with the "or" of and b.
Definition at line 149 of file bit-set.hpp.
| bool Gecode::Int::Extensional::BitSet< IndexType >::intersects | ( | const BitSetData * | b | ) | const [inline] |
Check if has a non-empty intersection with the set.
Definition at line 177 of file bit-set.hpp.
| void Gecode::Int::Extensional::BitSet< IndexType >::nand_with_mask | ( | const BitSetData * | b | ) | [inline] |
Perform "nand" with b.
Definition at line 165 of file bit-set.hpp.
| unsigned int Gecode::Int::Extensional::BitSet< IndexType >::words | ( | void | ) | const [inline] |
Return the number of required bit set words.
Definition at line 199 of file bit-set.hpp.
| unsigned int Gecode::Int::Extensional::BitSet< IndexType >::size | ( | void | ) | const [inline] |
Return the number of required bit set words.
Definition at line 205 of file bit-set.hpp.
Member Data Documentation
IndexType Gecode::Int::Extensional::BitSet< IndexType >::_limit [protected] |
Limit.
Definition at line 241 of file extensional.hh.
IndexType* Gecode::Int::Extensional::BitSet< IndexType >::index [protected] |
Indices.
Definition at line 243 of file extensional.hh.
BitSetData* Gecode::Int::Extensional::BitSet< IndexType >::bits [protected] |
Words.
Definition at line 245 of file extensional.hh.
The documentation for this class was generated from the following files:
- gecode/int/extensional.hh
- gecode/int/extensional/bit-set.hpp


All my previous posts on machine learning have dealt with supervised learning. But we can also use machine learning for unsupervised learning. The latter are e.g. used for clustering and (non-linear) dimensionality reduction.
For this task, I am using Kaggle’s credit card fraud dataset from the following study:
Andrea Dal Pozzolo, Olivier Caelen, Reid A. Johnson and Gianluca Bontempi. Calibrating Probability with Undersampling for Unbalanced Classification. In Symposium on Computational Intelligence and Data Mining (CIDM), IEEE, 2015
The dataset gives > 280,000 instances of credit card use and for each transaction, we know whether it was fraudulent or not.
Datasets like this needs special treatment when performing machine learning because they are severely unbalanced: in this case, only 0.17% of all transactions are fraudulent.
While we could try to work with classifiers, like random forests or support vector machines, by applying over- or under-sampling techniques, we can alternatively try to find anomalies in the data (assuming we expect our fraud cases to be anomalies within the whole dataset).
When dealing with such a severe unbalance of response labels, we also need to be careful when measuring model performance. Because there are only a handful of fraudulent instances, a model that predicts everything as non-fraud will already achieve a > 99% accuracy. But despite its high accuracy, such a model won’t necessarily help us find fraudulent cases - the proverbial “needle-in-a-haystack” - that we actually want to find!
Below, I will show how you can use autoencoders and anomaly detection, how you can use autoencoders to pre-train a classification model and how you can measure model performance on unbalanced data.
Exploring the data
library(tidyverse)
# download from https://www.kaggle.com/dalpozz/creditcardfraud
creditcard <- read.csv("creditcard.csv")
The dataset contains numerical input variables V1 to V28, which are the result of a PCA transformation of the original features (which could not be provided due to confidentiality issues).
The response variable Class tell us whether a transaction was fraudulent (value = 1) or not (value = 0).
creditcard %>%
ggplot(aes(x = Class)) +
geom_bar(color = "grey", fill = "lightgrey") +
theme_bw()
There are two additional features, Time (time in seconds between each transaction and the first transaction) and Amount (how much money was transferred in this transaction).
Because Time only tells us the order in which transactions have been done, it doesn’t actually tell us anything about the actual times (i.e. time of day) of the transaction. Therefore, I am normalizing them by day and bin them into four groups according to time of day.
summary(creditcard$Time)
## Min. 1st Qu. Median Mean 3rd Qu. Max.
## 0 54202 84692 94814<PHONE_NUMBER>92
# how many seconds are 24 hours
# 1 hr = 60 mins = 60 x 60 s = 3600 s
3600 * 24
## [1] 86400
# separate transactions by day
creditcard$day <- ifelse(creditcard$Time > 3600 * 24, "day2", "day1")
# make transaction relative to day
creditcard$Time_day <- ifelse(creditcard$day == "day2", creditcard$Time - 86400, creditcard$Time)
summary(creditcard[creditcard$day == "day1", ]$Time_day)
## Min. 1st Qu. Median Mean 3rd Qu. Max.
## 0 38432 54689 52948 70977 86400
summary(creditcard[creditcard$day == "day2", ]$Time_day)
## Min. 1st Qu. Median Mean 3rd Qu. Max.
## 1 37843 53425 51705 68182 86392
# bin transactions according to time of day
creditcard$Time <- as.factor(ifelse(creditcard$Time_day <= 38138, "gr1", # mean 1st Qu.
ifelse(creditcard$Time_day <= 52327, "gr2", # mean mean
ifelse(creditcard$Time_day <= 69580, "gr3", # mean 3rd Qu
"gr4"))))
creditcard %>%
ggplot(aes(x = day)) +
geom_bar(color = "grey", fill = "lightgrey") +
theme_bw()
We can see now that the transactions in this dataset have all been recorded on two consecutive days and there are roughly the same number of transactions on these two days.
Now, I remove the columns I used to create the Time bins.
creditcard <- select(creditcard, -Time_day, -day)
# convert class variable to factor
creditcard$Class <- factor(creditcard$Class)
creditcard %>%
ggplot(aes(x = Time)) +
geom_bar(color = "grey", fill = "lightgrey") +
theme_bw() +
facet_wrap( ~ Class, scales = "free", ncol = 2)
The distribution of transactions over the four Time bins shows, that the majority of fraud cases have happened in group 1 (although, I can’t say when exactly because the original Time feature did not tell us when the first transaction occurred).
I also want to look at the distribution of the amounts of money that were transferred:
summary(creditcard[creditcard$Class == "0", ]$Amount)
## Min. 1st Qu. Median Mean 3rd Qu. Max.
## 0.00 5.65 22.00 88.29 77.05 25691.16
summary(creditcard[creditcard$Class == "1", ]$Amount)
## Min. 1st Qu. Median Mean 3rd Qu. Max.
## 0.00 1.00 9.25 122.21 105.89 2125.87
creditcard %>%
ggplot(aes(x = Amount)) +
geom_histogram(color = "grey", fill = "lightgrey", bins = 50) +
theme_bw() +
facet_wrap( ~ Class, scales = "free", ncol = 2)
Interestingly, fraudulent credit card transactions had a higher mean amount of money that was transferred, but the maximum amount was much lower compared to regular transactions.
Modeling
For modeling, I am using R’s H2O implementation with the h2o package. For more details and other examples, see my posts on my machine learning webinar, on building neural nets with h2o and on performing grid search for hyperparameter tuning.
library(h2o)
h2o.init(nthreads = -1)
## Connection successful!
##
## R is connected to the H2O cluster:
## H2O cluster uptime: 7 minutes 6 seconds
## H2O cluster version: <IP_ADDRESS>
## H2O cluster version age: 16 days
## H2O cluster name: H2O_started_from_R_Shirin_nly512
## H2O cluster total nodes: 1
## H2O cluster total memory: 1.60 GB
## H2O cluster total cores: 2
## H2O cluster allowed cores: 2
## H2O cluster healthy: TRUE
## H2O Connection ip: localhost
## H2O Connection port: 54321
## H2O Connection proxy: NA
## H2O Internal Security: FALSE
## R Version: R version 3.4.0 (2017-04-21)
# convert data to H2OFrame
creditcard_hf <- as.h2o(creditcard)
Then, I am splitting the dataset into training and test sets. Because I want to check how a pre-trained model with perform, I am splitting my data into two separate training sets and one independent test set for final model comparison.
splits <- h2o.splitFrame(creditcard_hf,
ratios = c(0.4, 0.4),
seed = 42)
train_unsupervised <- splits[[1]]
train_supervised <- splits[[2]]
test <- splits[[3]]
response <- "Class"
features <- setdiff(colnames(train_unsupervised), response)
Autoencoders
First, I am training the unsupervised neural network model using deep learning autoencoders. With h2o, we can simply set autoencoder = TRUE
.
Here, I am applying a technique called “bottleneck” training, where the hidden layer in the middle is very small. This means that my model will have to reduce the dimensionality of the input data (in this case, down to 2 nodes/dimensions).
The autoencoder model will then learn the patterns of the input data irrespective of given class labels. Here, it will learn, which credit card transactions are similar and which transactions are outliers or anomalies. We need to keep in mind though, that autoencoder models will be sensitive to outliers in our data, which might throw off otherwise typical patterns.
model_nn <- h2o.deeplearning(x = features,
training_frame = train_unsupervised,
model_id = "model_nn",
autoencoder = TRUE,
reproducible = TRUE, #slow - turn off for real problems
ignore_const_cols = FALSE,
seed = 42,
hidden = c(10, 2, 10),
epochs = 100,
activation = "Tanh")
Because training can take a while, I am saving the model:
h2o.saveModel(model_nn, path="model_nn", force = TRUE)
model_nn <- h2o.loadModel("model_nn")
model_nn
## Model Details:
## ==============
##
## H2OAutoEncoderModel: deeplearning
## Model ID: model_nn
## Status of Neuron Layers: auto-encoder, gaussian distribution, Quadratic loss, 776 weights/biases, 16.0 KB, 2,622,851 training samples, mini-batch size 1
## layer units type dropout l1 l2 mean_rate rate_rms momentum
## 1 1 34 Input 0.00 %
## 2 2 10 Tanh 0.00 % 0.000000 0.000000 0.709865 0.320108 0.000000
## 3 3 2 Tanh 0.00 % 0.000000 0.000000 0.048458 0.109033 0.000000
## 4 4 10 Tanh 0.00 % 0.000000 0.000000 0.164717 0.192053 0.000000
## 5 5 34 Tanh 0.000000 0.000000 0.369681 0.425672 0.000000
## mean_weight weight_rms mean_bias bias_rms
## 1
## 2 -0.039307 0.691302 0.008052 0.965178
## 3 -0.097383 0.314106 0.226376 0.067917
## 4 0.227664 1.089589 0.112032 0.672444
## 5 0.011072 0.605586 0.091124 0.722602
##
##
## H2OAutoEncoderMetrics: deeplearning
## ** Reported on training data. **
##
## Training Set Metrics:
## =====================
##
## MSE: (Extract with `h2o.mse`) 0.001472071
## RMSE: (Extract with `h2o.rmse`) 0.03836757
#Convert to autoencoded representation
test_autoenc <- h2o.predict(model_nn, test)
Dimensionality reduction with hidden layers
Because I had used a bottleneck model with two nodes in the hidden layer in the middle, we can use this dimensionality reduction to explore our feature space (similar to what to we could do with a principal component analysis). We can extract this hidden feature with the h2o.deepfeatures()
function and plot it to show the reduced representation of the input data.
train_features <- h2o.deepfeatures(model_nn, train_unsupervised, layer = 2) %>%
as.data.frame() %>%
mutate(Class = as.vector(train_unsupervised[, 31]))
ggplot(train_features, aes(x = DF.L2.C1, y = DF.L2.C2, color = Class)) +
geom_point(alpha = 0.1)
Here, we do not see a cluster of fraudulent transactions that is distinct from non-fraud instances, so dimensionality reduction with our autoencoder model alone is not sufficient to identify fraud in this dataset.
But we could use the reduced dimensionality representation of one of the hidden layers as features for model training. An example would be to use the 10 features from the first or third hidden layer:
# let's take the third hidden layer
train_features <- h2o.deepfeatures(model_nn, train_unsupervised, layer = 3) %>%
as.data.frame() %>%
mutate(Class = as.factor(as.vector(train_unsupervised[, 31]))) %>%
as.h2o()
features_dim <- setdiff(colnames(train_features), response)
model_nn_dim <- h2o.deeplearning(y = response,
x = features_dim,
training_frame = train_features,
reproducible = TRUE, #slow - turn off for real problems
balance_classes = TRUE,
ignore_const_cols = FALSE,
seed = 42,
hidden = c(10, 2, 10),
epochs = 100,
activation = "Tanh")
h2o.saveModel(model_nn_dim, path="model_nn_dim", force = TRUE)
model_nn_dim <- h2o.loadModel("model_nn_dim/DeepLearning_model_R_1493574057843_49")
model_nn_dim
## Model Details:
## ==============
##
## H2OBinomialModel: deeplearning
## Model ID: DeepLearning_model_R_1493574057843_49
## Status of Neuron Layers: predicting Class, 2-class classification, bernoulli distribution, CrossEntropy loss, 184 weights/biases, 7.1 KB, 4,098,024 training samples, mini-batch size 1
## layer units type dropout l1 l2 mean_rate rate_rms
## 1 1 10 Input 0.00 %
## 2 2 10 Tanh 0.00 % 0.000000 0.000000 0.299549 0.363303
## 3 3 2 Tanh 0.00 % 0.000000 0.000000 0.009907 0.012193
## 4 4 10 Tanh 0.00 % 0.000000 0.000000 0.248854 0.126722
## 5 5 2 Softmax 0.000000 0.000000 0.160990 0.078139
## momentum mean_weight weight_rms mean_bias bias_rms
## 1
## 2 0.000000 -0.539949 4.601841 -0.060170 2.765655
## 3 0.000000 -0.384247 1.763649 -1.429832 0.570700
## 4 0.000000 -0.004865 0.774441 -0.320202 0.668747
## 5 0.000000 0.563951 1.365125 0.000000 0.397460
##
##
## H2OBinomialMetrics: deeplearning
## ** Reported on training data. **
## ** Metrics reported on temporary training frame with 9974 samples **
##
## MSE: 0.4905394
## RMSE: 0.7003852
## LogLoss: 2.763673
## Mean Per-Class Error: 0.3856454
## AUC: 0.6656933
## Gini: 0.3313867
##
## Confusion Matrix (vertical: actual; across: predicted) for F1-optimal threshold:
## 0 1 Error Rate
## 0 1438 3594 0.714229 =3594/5032
## 1 282 4660 0.057062 =282/4942
## Totals 1720 8254 0.388610 =3876/9974
##
## Maximum Metrics: Maximum metrics at their respective thresholds
## metric threshold value idx
## 1 max f1 0.002173 0.706275 300
## 2 max f2 0.001540 0.842820 335
## 3 max f0point5 0.002531 0.619024 280
## 4 max accuracy 0.002531 0.619711 280
## 5 max precision 0.030005 1.000000 0
## 6 max recall 0.000496 1.000000 388
## 7 max specificity 0.030005 1.000000 0
## 8 max absolute_mcc 0.002173 0.302697 300
## 9 max min_per_class_accuracy 0.002590 0.554634 277
## 10 max mean_per_class_accuracy 0.002531 0.622276 280
##
## Gains/Lift Table: Extract with `h2o.gainsLift(<model>, <data>)` or `h2o.gainsLift(<model>, valid=<T/F>, xval=<T/F>)`
For measuring model performance on test data, we need to convert the test data to the same reduced dimensions as the trainings data:
test_dim <- h2o.deepfeatures(model_nn, test, layer = 3)
h2o.predict(model_nn_dim, test_dim) %>%
as.data.frame() %>%
mutate(actual = as.vector(test[, 31])) %>%
group_by(actual, predict) %>%
summarise(n = n()) %>%
mutate(freq = n / sum(n))
## Source: local data frame [4 x 4]
## Groups: actual [2]
##
## actual predict n freq
## <chr> <fctr> <int> <dbl>
## 1 0 0 16710 0.29506286
## 2 0 1 39922 0.70493714
## 3 1 0 7 0.07608696
## 4 1 1 85 0.92391304
Now, this actually looks quite good in terms of identifying fraud cases: 92% of fraud cases were identified! However, many non-fraud cases were also classified as fraud. For real-life application, this wouldn’t be a good model. Let’s try some other techniques…
Anomaly detection
We can also ask which instances were considered outliers or anomalies within our test data, using the h2o.anomaly()
function. Based on the autoencoder model that was trained before, the input data will be reconstructed and for each instance, the mean squared error (MSE) between actual value and reconstruction is calculated.
I am also calculating the mean MSE for both class labels.
anomaly <- h2o.anomaly(model_nn, test) %>%
as.data.frame() %>%
tibble::rownames_to_column() %>%
mutate(Class = as.vector(test[, 31]))
mean_mse <- anomaly %>%
group_by(Class) %>%
summarise(mean = mean(Reconstruction.MSE))
This, we can now plot:
ggplot(anomaly, aes(x = as.numeric(rowname), y = Reconstruction.MSE, color = as.factor(Class))) +
geom_point(alpha = 0.3) +
geom_hline(data = mean_mse, aes(yintercept = mean, color = Class)) +
scale_color_brewer(palette = "Set1") +
labs(x = "instance number",
color = "Class")
As we can see in the plot, there is no perfect classification into fraud and non-fraud cases but the mean MSE is definitely higher for fraudulent transactions than for regular ones.
We can now identify outlier instances by applying an MSE threshold for what we consider outliers. We could e.g. say that we consider every instance with an MSE > 0.02 (chosen according to the plot above) to be an anomaly/outlier.
anomaly <- anomaly %>%
mutate(outlier = ifelse(Reconstruction.MSE > 0.02, "outlier", "no_outlier"))
anomaly %>%
group_by(Class, outlier) %>%
summarise(n = n()) %>%
mutate(freq = n / sum(n))
## Source: local data frame [4 x 4]
## Groups: Class [2]
##
## Class outlier n freq
## <chr> <chr> <int> <dbl>
## 1 0 no_outlier 56602 0.9994702642
## 2 0 outlier 30 0.0005297358
## 3 1 no_outlier 60 0.6521739130
## 4 1 outlier 32 0.3478260870
As we can see, outlier detection is not sufficient to correctly classify fraudulent credit card transactions either (at least not with this dataset).
Pre-trained supervised model
We can now try using the autoencoder model as a pre-training input for a supervised model. Here, I am again using a neural network. This model will now use the weights from the autoencoder for model fitting.
model_nn_2 <- h2o.deeplearning(y = response,
x = features,
training_frame = train_supervised,
pretrained_autoencoder = "model_nn",
reproducible = TRUE, #slow - turn off for real problems
balance_classes = TRUE,
ignore_const_cols = FALSE,
seed = 42,
hidden = c(10, 2, 10),
epochs = 100,
activation = "Tanh")
h2o.saveModel(model_nn_2, path="model_nn_2", force = TRUE)
model_nn_2 <- h2o.loadModel("model_nn_2/DeepLearning_model_R_1493574057843_9")
model_nn_2
## Model Details:
## ==============
##
## H2OBinomialModel: deeplearning
## Model ID: DeepLearning_model_R_1493574057843_9
## Status of Neuron Layers: predicting Class, 2-class classification, bernoulli distribution, CrossEntropy loss, 424 weights/biases, 11.7 KB, 3,643,248 training samples, mini-batch size 1
## layer units type dropout l1 l2 mean_rate rate_rms
## 1 1 34 Input 0.00 %
## 2 2 10 Tanh 0.00 % 0.000000 0.000000 0.274110 0.291925
## 3 3 2 Tanh 0.00 % 0.000000 0.000000 0.004480 0.002651
## 4 4 10 Tanh 0.00 % 0.000000 0.000000 0.210337 0.326239
## 5 5 2 Softmax 0.000000 0.000000 0.137694 0.123830
## momentum mean_weight weight_rms mean_bias bias_rms
## 1
## 2 0.000000 -0.006945 1.058583 -0.501068 1.576798
## 3 0.000000 0.021012 0.309286 0.360286 0.105522
## 4 0.000000 0.934361 1.759343 0.304729 0.532527
## 5 0.000000 -0.133149 2.641065 2.392999 3.137845
##
##
## H2OBinomialMetrics: deeplearning
## ** Reported on training data. **
## ** Metrics reported on temporary training frame with 9973 samples **
##
## MSE: 0.01500211
## RMSE: 0.1224831
## LogLoss: 0.04408663
## Mean Per-Class Error: 0.00169424
## AUC: 0.9995075
## Gini: 0.9990149
##
## Confusion Matrix (vertical: actual; across: predicted) for F1-optimal threshold:
## 0 1 Error Rate
## 0 5000 17 0.003388 =17/5017
## 1 0 4956 0.000000 =0/4956
## Totals 5000 4973 0.001705 =17/9973
##
## Maximum Metrics: Maximum metrics at their respective thresholds
## metric threshold value idx
## 1 max f1 0.134320 0.998288 96
## 2 max f2 0.134320 0.999314 96
## 3 max f0point5 0.134320 0.997263 96
## 4 max accuracy 0.134320 0.998295 96
## 5 max precision 1.000000 1.000000 0
## 6 max recall 0.134320 1.000000 96
## 7 max specificity 1.000000 1.000000 0
## 8 max absolute_mcc 0.134320 0.996597 96
## 9 max min_per_class_accuracy 0.134320 0.996612 96
## 10 max mean_per_class_accuracy 0.134320 0.998306 96
##
## Gains/Lift Table: Extract with `h2o.gainsLift(<model>, <data>)` or `h2o.gainsLift(<model>, valid=<T/F>, xval=<T/F>)`
pred <- as.data.frame(h2o.predict(object = model_nn_2, newdata = test)) %>%
mutate(actual = as.vector(test[, 31]))
pred %>%
group_by(actual, predict) %>%
summarise(n = n()) %>%
mutate(freq = n / sum(n))
## Source: local data frame [4 x 4]
## Groups: actual [2]
##
## actual predict n freq
## <chr> <fctr> <int> <dbl>
## 1 0 0 56512 0.997881057
## 2 0 1 120 0.002118943
## 3 1 0 16 0.173913043
## 4 1 1 76 0.826086957
pred %>%
ggplot(aes(x = actual, fill = predict)) +
geom_bar() +
theme_bw() +
scale_fill_brewer(palette = "Set1") +
facet_wrap( ~ actual, scales = "free", ncol = 2)
Now, this looks much better! We did miss 17% of the fraud cases but we also did not mis-classify too many of the non-fraud cases.
In real-life, we would now spend some more time trying to improve the model by e.g. performing grid search for hyperparameter tuning, going back to the original features (which we did not have here) and trying different engineered features and/or trying different algorithms. But here, I will leave it at that.
Measuring model performance on highly unbalanced data
Because of the severe bias towards non-fraud cases, we can not use performance measures like accuracy or area under the curve (AUC), as they would give overly optimistic results based on the high percentage of correct classifications of the majority class.
An alternative to AUC is to use the precision-recall curve or the sensitivity (recall)-specificity curve. To calculate and plot these metrics, we can use the ROCR package. There are different ways to calculate the area under a curve (see the PRROC package for details) but I am going to use a simple function that calculates the area between every consecutive points-pair of x (i.e. x1 - x0, x2 - x1, etc.) under the corresponding values of y.
library(ROCR)
# http://stackoverflow.com/questions/24563061/computing-integral-of-a-line-plot-in-r
line_integral <- function(x, y) {
dx <- diff(x)
end <- length(y)
my <- (y[1:(end - 1)] + y[2:end]) / 2
sum(dx * my)
}
prediction_obj <- prediction(pred$p1, pred$actual)
par(mfrow = c(1, 2))
par(mar = c(5.1,4.1,4.1,2.1))
# precision-recall curve
perf1 <- performance(prediction_obj, measure = "prec", x.measure = "rec")
x <-<EMAIL_ADDRESS>y <-<EMAIL_ADDRESS>y[1] <- 0
plot(perf1, main = paste("Area Under the\nPrecision-Recall Curve:\n", round(abs(line_integral(x,y)), digits = 3)))
# sensitivity-specificity curve
perf2 <- performance(prediction_obj, measure = "sens", x.measure = "spec")
x <-<EMAIL_ADDRESS>y <-<EMAIL_ADDRESS>y[1] <- 0
plot(perf2, main = paste("Area Under the\nSensitivity-Specificity Curve:\n", round(abs(line_integral(x,y)), digits = 3)))
Precision is the proportion of test cases predicted to be fraud that were indeed fraudulent (i.e. the true positive predictions), while recall or sensitivity is the proportion of fraud cases that were identified as fraud. And specificity is the proportion of non-fraud cases that are identified as non-fraud.
The precision-recall curve tells us the relationship between correct fraud predictions and the proportion of fraud cases that were detected (e.g. if all or most fraud cases were identified, we also have many non-fraud cases predicted as fraud and vice versa). The sensitivity-specificity curve thus tell us the relationship between correctly identified classes of both labels (e.g. if we have 100% correctly classified fraud cases, we will have no correctly classified non-fraud cases and vice versa).
We can also look at this a little bit differently, by manually going through different prediction thresholds and calculating how many cases were correctly classified in the two classes:
thresholds <- seq(from = 0, to = 1, by = 0.1)
pred_thresholds <- data.frame(actual = pred$actual)
for (threshold in thresholds) {
prediction <- ifelse(pred$p1 > threshold, 1, 0)
prediction_true <- ifelse(pred_thresholds$actual == prediction, TRUE, FALSE)
pred_thresholds <- cbind(pred_thresholds, prediction_true)
}
colnames(pred_thresholds)[-1] <- thresholds
pred_thresholds %>%
gather(x, y, 2:ncol(pred_thresholds)) %>%
group_by(actual, x, y) %>%
summarise(n = n()) %>%
ggplot(aes(x = as.numeric(x), y = n, color = actual)) +
geom_vline(xintercept = 0.6, alpha = 0.5) +
geom_line() +
geom_point(alpha = 0.5) +
theme_bw() +
facet_wrap(actual ~ y, scales = "free", ncol = 2) +
labs(x = "prediction threshold",
y = "number of instances")
This plot tells us that we can increase the number of correctly classified non-fraud cases without loosing correctly classified fraud cases when we increase the prediction threshold from the default 0.5 to 0.6:
pred %>%
mutate(predict = ifelse(pred$p1 > 0.6, 1, 0)) %>%
group_by(actual, predict) %>%
summarise(n = n()) %>%
mutate(freq = n / sum(n))
## Source: local data frame [4 x 4]
## Groups: actual [2]
##
## actual predict n freq
## <chr> <dbl> <int> <dbl>
## 1 0 0 56558 0.998693318
## 2 0 1 74 0.001306682
## 3 1 0 16 0.173913043
## 4 1 1 76 0.826086957
Our final model now correctly identified 83% of fraud cases and almost 100% of non-fraud cases.
If you are interested in more machine learning posts, check out the category listing for machine_learning on my blog.
sessionInfo()
## R version 3.4.0 (2017-04-21)
## Platform: x86_64-apple-darwin15.6.0 (64-bit)
## Running under: macOS Sierra 10.12.3
##
## Matrix products: default
## BLAS: /Library/Frameworks/R.framework/Versions/3.4/Resources/lib/libRblas.0.dylib
## LAPACK: /Library/Frameworks/R.framework/Versions/3.4/Resources/lib/libRlapack.dylib
##
## locale:
## [1] en_US.UTF-8/en_US.UTF-8/en_US.UTF-8/C/en_US.UTF-8/en_US.UTF-8
##
## attached base packages:
## [1] stats graphics grDevices utils datasets methods base
##
## other attached packages:
## [1] ROCR_1.0-7 gplots_3.0.1 h2o_<IP_ADDRESS> dplyr_0.5.0
## [5] purrr_0.2.2 readr_1.1.0 tidyr_0.6.1 tibble_1.3.0
## [9] ggplot2_2.2.1 tidyverse_1.1.1
##
## loaded via a namespace (and not attached):
## [1] gtools_3.5.0 reshape2_1.4.2 haven_1.0.0
## [4] lattice_0.20-35 colorspace_1.3-2 htmltools_0.3.6
## [7] yaml_2.1.14 foreign_0.8-68 DBI_0.6-1
## [10] RColorBrewer_1.1-2 modelr_0.1.0 readxl_1.0.0
## [13] plyr_1.8.4 stringr_1.2.0 munsell_0.4.3
## [16] gtable_0.2.0 cellranger_1.1.0 rvest_0.3.2
## [19] caTools_1.17.1 psych_<IP_ADDRESS> evaluate_0.10
## [22] labeling_0.3 knitr_1.15.1 forcats_0.2.0
## [25] parallel_3.4.0 broom_0.4.2 Rcpp_0.12.10
## [28] KernSmooth_2.23-15 scales_0.4.1 backports_1.0.5
## [31] gdata_2.17.0 jsonlite_1.4 mnormt_1.5-5
## [34] hms_0.3 digest_0.6.12 stringi_1.1.5
## [37] grid_3.4.0 rprojroot_1.2 tools_3.4.0
## [40] bitops_1.0-6 magrittr_1.5 lazyeval_0.2.0
## [43] RCurl_1.95-4.8 xml2_1.1.1 lubridate_1.6.0
## [46] assertthat_0.2.0 rmarkdown_1.5 httr_1.2.1
## [49] R6_2.2.0 nlme_3.1-131 compiler_3.4.0


- Learn about forensic science as a field of study.
- Discuss the history and development of the field of forensic science.
- Examine some of the responsibilities that forensic scientists have in their work.
- Investigate the relationship between forensic science and the criminal justice system.
- Explore some of the specialty areas within forensic science.
The five boxing wizards jump quickly.
Contact information
|
|
Name |
Phone number |
City |
| 1. |
Joel Garner |
412-212-5421 |
Pittsburgh |
| 2. |
Clive Lloyd |
410-306-1420 |
Baltimore |
| 3. |
Gordon Greenidge |
281-564-6720 |
Houston |
Required fields are marked with an asterisk (*)


First class
-
${{seat.price}}
{{seat.column}}{{seat.row}}
${{seat.price}}{{seat.column}}{{seat.row}}
{{seat.column}}{{seat.row}}
-
${{seat.price}}
{{seat.column}}{{seat.row}}
${{seat.price}}{{seat.column}}{{seat.row}}
{{seat.column}}{{seat.row}}
Business
-
${{seat.price}}
{{seat.column}}{{seat.row}}
${{seat.price}}{{seat.column}}{{seat.row}}
{{seat.column}}{{seat.row}}
-
${{seat.price}}
{{seat.column}}{{seat.row}}
${{seat.price}}{{seat.column}}{{seat.row}}
{{seat.column}}{{seat.row}}
Economy
-
${{seat.price}}
{{seat.column}}{{seat.row}}
${{seat.price}}{{seat.column}}{{seat.row}}
{{seat.column}}{{seat.row}}
-
${{seat.price}}
{{seat.column}}{{seat.row}}
${{seat.price}}{{seat.column}}{{seat.row}}
{{seat.column}}{{seat.row}}
Basic Economy
-
${{seat.price}}
{{seat.column}}{{seat.row}}
${{seat.price}}{{seat.column}}{{seat.row}}
{{seat.column}}{{seat.row}}
-
${{seat.price}}
{{seat.column}}{{seat.row}}
${{seat.price}}{{seat.column}}{{seat.row}}
{{seat.column}}{{seat.row}}


Jana Antonissen
As a journalist
Jana Antonissen (1992) is fascinated by the human stories behind the news. Hailing from Belgium, but based in
Berlin she writes mostly for titles such as
De Morgen and
Humo.
Nadja Scherff
With a background in cultural and spatial sciences Nadja (1993) is intrigued by culture as an urban catalyst. She is based
in Berlin where she studies a Master of Eastern European Studies at Freie Unversity.
Ksenia Les
As a photojournalist,
Ksenia (1988) focuses on social issues in the countries of the former Soviet Union and explores a shift of the
East-European identity beyond the stereotypes. Her work has been published in
News Deeply,
NEON,
Taz.die Tageszeitung and
Spiegel Online among others.
Bogdan Kolchenko
Having worked on international educational and fashion projects in Ukraine, Bogdan (1996) studies now in Berlin, though still
following the cultural developments in his hometown Kyiv closely.
The project 'Kak Dela Kyiv‘ has been funded by and implemented within the framework of MitOst e.V.


Brian Crisp
Home/About
(current)
Porfolio
Contact
Contact Info
Gmail
linkedin
Call me
yahoo
facebook
github
Instagram
Resume


She can sing and play guitar at the same time.
Click below for a modal example.
Born as Annie Erin Clark in Tulsa, Oklahoma, St. Vicnent played in many bands before her solo debut as an artist in 2003. Her first solo album was released in 2007 and has seen a rise in popularity ever since.
Most of her work revolves around a band setup with her playing the lead guitar. She is known to make certain pop sounds, however she changes her style of playing depending on the album. On certain occasions she plays other instruments like the piano, showing her level of expertise as a musician.
Her latest album titled 'Daddy's Home' shows a range of styles and influences that makes her music unique and recognizable. She was influenced by a lot of older 70's synthesizer music and 60's sunflower music. This style was intentional and seperates her from other artists at the moment.
With an album borrowing from 60's and 70's music there is no concrete dirrection on where her style of music will go from here. At the moment many artists are borrowing from 90's music and aethetics, with St. Vincent however there is a bit of suspense on what her next move will be.


@realDonaldTrump Donald, the USD is the largest enabler of illicit transactions and activities in the world.
Bitcoin is actually terrible for these purposes, as all transactions are recorded on a public ledger, forever, with 1000's of backups around the world.
SAD!!!


multigram generator
deoxy.org
>
iching
Build the set of
1
2
3
4
5
6
line structures
Show as
numbers or
images or
both.
horizontal spacing
vertical spacing
cellpadding
zero all spacing
reset spacing
border


BITCrashExceptionApplication Class Reference
| Inherits from | NSApplication |
| Declared in | BITCrashExceptionApplication.h |
Overview
NSApplication
subclass to catch additional exceptions
On OS X runtime not all uncaught exceptions do end in an custom NSUncaughtExceptionHandler
.
In addition “sometimes” exceptions don’t even cause the app to crash, depending on where and
when they happen.
Here are the known scenarios:
- Custom
NSUncaughtExceptionHandler
don’t start working until afterNSApplication
has finished calling all of its delegate methods!
Example: - (void)applicationDidFinishLaunching:(NSNotification *)note { … [NSException raise:@“ExceptionAtStartup” format:@“This will not be recognized!”]; … }
- The default
NSUncaughtExceptionHandler
inNSApplication
only logs exceptions to the console and ends their processing. Resulting in exceptions that occur in theNSApplication
“scope” not occurring in a registered customNSUncaughtExceptionHandler
.
Example: - (void)applicationDidFinishLaunching:(NSNotification *)note { … [self performSelector:@selector(delayedException) withObject:nil afterDelay:5]; … }
(void)delayedException { NSArray *array = [NSArray array]; [array objectAtIndex:23]; }
Any exceptions occurring in IBAction or other GUI does not even reach the NSApplication default UncaughtExceptionHandler.
Example: - (IBAction)doExceptionCrash:(id)sender { NSArray *array = [NSArray array]; [array objectAtIndex:23]; }
Solution A:
Implement NSExceptionHandler
and set the ExceptionHandlingMask
to NSLogAndHandleEveryExceptionMask
Benefits:
Solves all of the above scenarios
Clean solution using a standard Cocoa System specifically meant for this purpose.
Safe. Doesn’t use private API.
Problems:
To catch all exceptions the
NSExceptionHandlers
mask has to includeNSLogOtherExceptionMask
andNSHandleOtherExceptionMask
. But this will result in @catch blocks to be called after the exception handler processed the exception and likely lets the app crash and create a crash report. This makes the @catch block basically not working at all.If anywhere in the app a custom
NSUncaughtExceptionHandler
will be registered, e.g. in a closed source library the develop has to use, the complete mechanism will stop workingNot clear if this solves all scenarios there can be.
Requires to adjust PLCrashReporter not to register its
NSUncaughtExceptionHandler
which is not a good idea, since it would require theNSExceptionHandler
would catch all exceptions and that would cause PLCrashReporter to stop all running threads every time an exception occurs even if will be handled right away, e.g. by a system framework.
Solution B:
Overwrite and extend specific methods of NSApplication
. Can be implemented via subclassing NSApplication or
by using a category.
Benefits:
Solves scenarios 2 (by overwriting
reportException:
) and 3 (by overwritingsendEvent:
)Subclassing approach isn’t enforcing the mechanism onto apps and let developers opt-in. (Category approach would enforce it and rather be a problem of this soltuion.)
Safe. Doesn’t use private API.
Problems:
Does not automatically solve scenario 1. Developer would have to put all that code into @try @catch blocks
Not a clean implementation, rather feels like a workaround.
Not clear if this solves all scenarios there can be.
Chosen Solution: B via subclassing
Reasons:
The Problems 1. and 2. of Solution A are too drastic and aren’t acceptable for every developer using this SDK Especially Problem 1 is a big No Go for lots of developers.
Solution B can be used optionally, can be adopted easily into developers own
NSApplication
subclasses and by implementing it in a subclass instead of a category isn’t enforced even though it requires additional steps for setup.The not covered Scenario 1. can be achieved by the developer by enclosing most of the code within NSApplication startup delegates in @try @catch blocks or moving as much code as possible out of these methods and deferring their execution, e.g. using background threads. Not ideal though.
References: https://developer.apple.com/library/mac/documentation/cocoa/Conceptual/Exceptions/Tasks/ControllingAppResponse.html#//apple_ref/doc/uid/20000473-BBCHGJIJ http://stackoverflow.com/a/4199717/474794 http://stackoverflow.com/a/3419073/474794 http://macdevcenter.com/pub/a/mac/2007/07/31/understanding-exceptions-and-handlers-in-cocoa.html


--- inscription: http://techup.ch/1087/ adresse-gmaps: http://goo.gl/maps/Wkkax adresse: "Le Romandie\r\nPlace de l'Europe 1a\r\nLausanne" datemeeting: 21 mai 2013 à 19h00 number: '16' event_date: '1369162800' speaker: Jeroen van Geel number: 16 speaker: Jeroen van Geel layout: post status: publish published: true title: Storytelling for User Experience author: display_name: Simon Farine login: simon_bricolo email<EMAIL_ADDRESS>url: '' author_login: simon_bricolo author_email<EMAIL_ADDRESS>excerpt: 21 mai 2013 - Jeroen Van Geel joins us to discuss what is the Product Narrative wordpress_id: 500 wordpress_url: http://uxromandie.ch/?p=500 date: '2013-05-07 13:18:37 +0200' date_gmt: '2013-05-07 13:18:37 +0200' categories: - événements tags: - Conférence - storytelling comments: [] ---
It’s the job of designers to make the world a more livable place, to build up relationships between brands and customers and to facilitate good experiences. Our core task is to add meaning. And it’s Jeroen's belief that understanding storytelling is of the essence if we want to do this.
During this talk Jeroen takes you from traditional storytelling to our everyday life as designers. There he will show that designing a product isn’t just about features, design principles and usability, but about facilitating the birth of new stories between people and products.
Jeroen van Geel is interaction director at Fabrique - brands, design & interaction.
He is an international speaker and a writer on the field of interaction design and has a great interest in the world of product personality. Jeroen has pushed forward many design projects, ranging from the next generation mobile apps for Dutch public transport to interactive projects for Rijksmuseum Amsterdam and the new automated border control systems at Schiphol.
He was the founder of Johnny Holland. His goal is to return a bit of wonder into the world, even if it is just for himself.
La venue de Jeroen est généreusement financé par Urturn. Urturn is a consumer social media start-up that aims at providing everyone with the most expressive way to share. Its audience is mainly in US and UK, and it has welcomed bands such as David Bowie, Alicia Keys, The Script and One Direction as early adopters.


An Appender that outputs to an in-memory data.table
. This kind of
Appender is useful for interactive use, and has very little overhead.
AppenderDt
supports custom fields, but they have to be
pre-allocated in the prototype
argument. Custom fields that are not
part of the prototype are discarded. If you want an Appender that retains
all custom fields (at the cost of slightly less performance), take a look at
AppenderBuffer.
With the default settings, the custom field value
is included in the
data.table
as a list column to store arbitrary R objects (see example).
It is recommended to use this feature only TRACE
level.
x <- AppenderDt$new(threshold = NA_integer_, layout = LayoutFormat$new(fmt = "%L [%t] %m %f", timestamp_fmt = "%H:%M:%OS3", colors = getOption("lgr.colors", list())), prototype = data.table::data.table(.id = NA_integer_, level = NA_integer_, timestamp = Sys.time(), logger = NA_character_, caller = NA_character_, msg = NA_character_, .custom = list(list())), buffer_size = 1e+05, filters = NULL) x$append(event) x$show(threshold = NA_integer_, n = 20L) x$set_layout(layout) x$set_threshold(level) x$filter(event) x$add_filter(filter, name = NULL) x$remove_filter(pos) x$set_filters(filters) x$data x$destination x$dt x$layout x$threshold x$filters
In addition to the usual fields, AppenderDt$new()
requires that you supply
a buffer_size
and a prototype
. These determine the structure of the
data.table
used to store the log this appender creates and cannot be
modified anymore after the instantiation of the appender.
The Layout for this Appender is used only to format console output of
its $show()
method.
integer
scalar. Number of rows of the in-memory
data.table
A prototype data.table
. The prototype must be a
data.table
with the same columns and column types as the data
you want to log. The actual content of the columns is irrelevant.
There are a few columns that have special meaning, based on their name:
.id
: integer
(mandatory). Must always be the first column
and is used internally by the Appender
.custom
: list
(optional). If present all custom values of the
event (that are not already part of the prototype) are stored in
this list column.
dt
Get the log recorded by this Appender
as a data.table
with a maximum of buffer_size
rows
data
Get the log recorded by this Appender
as a data.frame
threshold
, set_threshold(level)
character
or integer
scalar.
The minimum log level that triggers this logger. See log_levels
layout
, set_layout(layout)
a Layout
that will be used for
formatting the LogEvents
passed to this Appender
destination
The output destination of the Appender
in
human-readable form (mainly for print output)
filters
, set_filters(filters)
a list
that may contain
functions
or any R object with a filter()
method. These functions
must have exactly one argument: event
which will get passed the
LogEvent when the Filterable's filter()
method is invoked.
If all of these functions evaluate to TRUE
the LogEvent is passed on.
Since LogEvents have reference semantics, filters can also be abused to
modify them before they are passed on. Look at the source code of
with_log_level()
or with_log_value()
for examples.
show(n, threshold)
Show the last n
log entries with a log level
bellow threshold
. The log entries will be formatted for console output
via this Appenders Layout
append(event)
Tell the Appender to process a LogEvent event
.
This method is usually not called by the user, but invoked by a
Logger
filter(event)
Determine whether the LogEvent x
should be passed
on to Appenders (TRUE
) or not (FALSE
). See also the active binding
filters
add_filter(filter, name = NULL)
, remove_filter(pos)
Add or remove a filter. When adding a filter an optional name
can
be specified. remove_filter()
can remove by position or name (if one
was specified)
Both AppenderBuffer and AppenderDt do in memory buffering of events.
AppenderBuffer retains a copies of the events it processes and has the
ability to pass the buffered events on to other Appenders. AppenderDt
converts the events to rows in a data.table
and is a bit harder to
configure. Used inside loops (several hundred iterations),
AppenderDt has much less overhead than AppenderBuffer. For single logging
calls and small loops, AppenderBuffer is more performant. This is related to
how memory pre-allocation is handled by the appenders.
In short: Use AppenderDt if you want an in-memory log for interactive use, and AppenderBuffer if you actually want to buffer events
lg <- Logger$new( "test", appenders = list(memory = AppenderDt$new()), threshold = NA, propagate = FALSE # to prevent routing to root logger for this example ) lg$debug("test") lg$error("test") # Displaying the log lg$appenders$memory$data#> .id level timestamp logger caller msg .custom #> 1 1 500 2019-03-25 12:43:02 test eval test NULL #> 2 2 200 2019-03-25 12:43:02 test eval test NULLlg$appenders$memory$show()#> DEBUG [12:43:02.751] test #> ERROR [12:43:02.780] test#> DEBUG [12:43:02.751] test #> ERROR [12:43:02.780] test# If you pass a Logger to show_log(), it looks for the first AppenderDt # that it can find. show_log(target = lg)#> DEBUG [12:43:02.751] test #> ERROR [12:43:02.780] test# Custom fields are stored in the list column .custom by default lg$info("the iris data frame", caps = LETTERS[1:5]) lg$appenders$memory$data#> .id level timestamp logger caller msg .custom #> 1 1 500 2019-03-25 12:43:02 test eval test NULL #> 2 2 200 2019-03-25 12:43:02 test eval test NULL #> 3 3 400 2019-03-25 12:43:02 test eval the iris data frame A, B, C, D, Elg$appenders$memory$data$.custom[[3]]$caps#> [1] "A" "B" "C" "D" "E"


{% extends "tutorial.html" %} {% block pagebreadcrumb %}{{ tut.title }}{% endblock %} {% block head %} {% endblock %} {% block html5badge %} {% endblock %} {% block iscompatible %} return !!(window.requestFileSystem || window.webkitRequestFileSystem); {% endblock %} {% block content %}
The HTML5 FileSystem API and Web Workers are massively powerful in their own regard. The FileSystem API finally brings hierarchical storage and file I/O to web applications and Workers bring true asynchronous 'multi-threading' to JavaScript. However, when you use these APIs together, you can build some truly interesting apps.
This tutorial provides a guide and code examples for leveraging the HTML5 FileSystem inside of a Web Worker. It assumes a working knowledge of both APIs. If you're not quite ready to dive in or are interested in learning more about those APIs, read two great tutorials that discuss the basics: Exploring the FileSystem APIs and Basics of Web Workers.
Asynchronous JavaScript APIs can be tough to use. They're large. They're complex. But what's most frustrating is that they offer plenty of opportunities for things to go wrong. The last thing you want to deal with is layering on a complex asynchronous API (FileSystem) in an already asynchronous world (Workers)! The good news is that the FileSystem API defines a synchronous version to ease the pain in Web Workers.
For the most part, the synchronous API is exactly the same as its asynchronous cousin. The methods, properties, features, and functionality will be familiar. The major deviations are:
requestFileSystem()
and
resolveLocalFileSystemURL()
) become requestFileSystemSync()
and
resolveLocalFileSystemSyncURL()
. Note: These methods are members of the
worker's global scope, not the window
object.Apart from these exceptions, the APIs are the same. OK, we're good to go!
A web application obtains access to the synchronous filesystem by requesting a
LocalFileSystemSync
object from within a Web Worker. The requestFileSystemSync()
is exposed to the Worker's global scope:
var fs = requestFileSystemSync(TEMPORARY, 1024*1024 /*1MB*/);
Notice the new return value now that we're using the synchronous API as well as the absence of success and error callbacks.
As with the normal FileSystem API, methods are prefixed at the moment:
self.requestFileSystemSync = self.webkitRequestFileSystemSync ||
self.requestFileSystemSync;
Currently, it's not possible to request PERSISTENT
quota in a Worker context. I recommend taking care of quota issues outside of Workers.
The process could look like something this:
try/catch
so any
QUOTA_EXCEED_ERR
errors are caught.QUOTA_EXCEED_ERR
, send a postMessage('get me more quota')
back to the main app.window.webkitStorageInfo.requestQuota()
dance when #2 is received.postMessage('resume writes')
back
to the worker to inform it of additional storage space.That's a fairly involved workaround, but it should work. See requesting quota for more information on using PERSISTENT
storage with the FileSystem API.
The synchronous version of getFile()
and getDirectory()
return a FileEntrySync
and DirectoryEntrySync
, respectively.
For example, the following code creates an empty file called "log.txt" in the root directory.
var fileEntry = fs.root.getFile('log.txt', {create: true});
The following creates a new directory in the root folder.
var dirEntry = fs.root.getDirectory('mydir', {create: true});
If you've never had to debug Web Worker code, I envy you! It can be a real pain to figure out what is going wrong.
The lack of error callbacks in the synchronous world makes dealing with problems
trickier than they should be. If we add the general complexity of debugging Web Worker code,
you'll be frustrated in no time. One thing that can make life easier is to wrap all
of your relevant Worker code in a try/catch. Then, if any errors occur, forward
the error to the main app using postMessage()
:
function onError(e) {
postMessage('ERROR: ' + e.toString());
}
try {
// Error thrown if "log.txt" already exists.
var fileEntry = fs.root.getFile('log.txt', {create: true, exclusive: true});
} catch (e) {
onError(e);
}
When Web Workers first came on the scene, they only allowed string data to be
sent in postMessage()
. Later, browsers began accepting serializable data, which
meant passing a JSON object was possible. Recently however, some browsers like Chrome
accept more complex data types to be passed through postMessage()
using the
structured clone algorithm.
What does this really mean? It means that it's a heck of a lot easier to pass
binary data between main app and the Worker thread. Browsers that support structured cloning
for Workers allow you to pass Typed Arrays, ArrayBuffer
s, File
s, or Blob
s
into Workers. Although the data is still a copy, being able to pass a File
means
a performance benefit over the former approach, which involved base64ing the file
before passing it into postMessage()
.
The following example passes a user-selected list of files to an dedicated Worker.
The Worker simply passes through the file list (simple to show the returned data
is actually a FileList
) and the main app reads each file as an ArrayBuffer
.
The sample also uses an improved version of the inline Web Worker technique described in Basics of Web Workers.
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="chrome=1">
<title>Passing a FileList to a Worker</title>
<script type="javascript/worker" id="fileListWorker">
self.onmessage = function(e) {
// TODO: do something interesting with the files.
postMessage(e.data); // Pass through.
};
</script>
</head>
<body>
</body>
<input type="file" multiple>
<script>
document.querySelector('input[type="file"]').addEventListener('change', function(e) {
var files = this.files;
loadInlineWorker('#fileListWorker', function(worker) {
// Setup handler to process messages from the worker.
worker.onmessage = function(e) {
// Read each file aysnc. as an array buffer.
for (var i = 0, file; file = files[i]; ++i) {
var reader = new FileReader();
reader.onload = function(e) {
console.log(this.result); // this.result is the read file as an ArrayBuffer.
};
reader.onerror = function(e) {
console.log(e);
};
reader.readAsArrayBuffer(file);
}
};
worker.postMessage(files);
});
}, false);
function loadInlineWorker(selector, callback) {
window.URL = window.URL || window.webkitURL || null;
var script = document.querySelector(selector);
if (script.type === 'javascript/worker') {
var blob = new Blob([script.textContent]);
callback(new Worker(window.URL.createObjectURL(blob));
}
}
</script>
</html>
It's perfectly acceptable to use the asynchronous FileReader
API to read files in a Worker. However, there's a better way. In Workers, there's a
synchronous API (FileReaderSync
) that streamlines reading files:
Main app:
<!DOCTYPE html>
<html>
<head>
<title>Using FileReaderSync Example</title>
<style>
#error { color: red; }
</style>
</head>
<body>
<input type="file" multiple />
<output id="error"></output>
<script>
var worker = new Worker('worker.js');
worker.onmessage = function(e) {
console.log(e.data); // e.data should be an array of ArrayBuffers.
};
worker.onerror = function(e) {
document.querySelector('#error').textContent = [
'ERROR: Line ', e.lineno, ' in ', e.filename, ': ', e.message].join('');
};
document.querySelector('input[type="file"]').addEventListener('change', function(e) {
worker.postMessage(this.files);
}, false);
</script>
</body>
</html>
worker.js
self.addEventListener('message', function(e) {
var files = e.data;
var buffers = [];
// Read each file synchronously as an ArrayBuffer and
// stash it in a global array to return to the main app.
[].forEach.call(files, function(file) {
var reader = new FileReaderSync();
buffers.push(reader.readAsArrayBuffer(file));
});
postMessage(buffers);
}, false);
As expected, callbacks are gone with the synchronous FileReader
. This simplifies
the amount of callback nesting when reading files. Instead, the readAs* methods
returns the read file.
In some cases, the synchronous API is much cleaner for certain tasks. Fewer callbacks are nice and certainly make things more readable. The real downside of the synchronous API stems from the limitations of Workers.
For security reasons, data between the calling app and a Web Worker thread is
never shared. Data is always copied to and from the Worker when postMessage()
is called.
As a result, not every data type can be passed.
Unfortunately, FileEntrySync
and DirectoryEntrySync
don't currently fall
into the accepted types. So how can you get entries back to the calling app?
One way to circumvent the limitation is to return a list of filesystem: URLs instead of a list of entries. filesystem:
URLs are just strings,
so they're super easy to pass around. Furthermore, they can be resolved to
entries in the main app using resolveLocalFileSystemURL()
. That gets you back
to a FileEntrySync
/DirectoryEntrySync
object.
Main app:
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<meta http-equiv="X-UA-Compatible" content="chrome=1">
<title>Listing filesystem entries using the synchronous API</title>
</head>
<body>
<script>
window.resolveLocalFileSystemURL = window.resolveLocalFileSystemURL ||
window.webkitResolveLocalFileSystemURL;
var worker = new Worker('worker.js');
worker.onmessage = function(e) {
var urls = e.data.entries;
urls.forEach(function(url, i) {
window.resolveLocalFileSystemURL(url, function(fileEntry) {
console.log(fileEntry.name); // Print out file's name.
});
});
};
worker.postMessage({'cmd': 'list'});
</script>
</body>
</html>
worker.js
self.requestFileSystemSync = self.webkitRequestFileSystemSync ||
self.requestFileSystemSync;
var paths = []; // Global to hold the list of entry filesystem URLs.
function getAllEntries(dirReader) {
var entries = dirReader.readEntries();
for (var i = 0, entry; entry = entries[i]; ++i) {
paths.push(entry.toURL()); // Stash this entry's filesystem: URL.
// If this is a directory, we have more traversing to do.
if (entry.isDirectory) {
getAllEntries(entry.createReader());
}
}
}
function onError(e) {
postMessage('ERROR: ' + e.toString()); // Forward the error to main app.
}
self.onmessage = function(e) {
var data = e.data;
// Ignore everything else except our 'list' command.
if (!data.cmd || data.cmd != 'list') {
return;
}
try {
var fs = requestFileSystemSync(TEMPORARY, 1024*1024 /*1MB*/);
getAllEntries(fs.root.createReader());
self.postMessage({entries: paths});
} catch (e) {
onError(e);
}
};
A common use case for Workers is to download a bunch of files using XHR2, and write those files to the HTML5 FileSystem. This is a perfect task for a Worker thread!
The following example only fetches and writes one file, but you can image expanding it to download a set of files.
Main app:
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<meta http-equiv="X-UA-Compatible" content="chrome=1">
<title>Download files using a XHR2, a Worker, and saving to filesystem</title>
</head>
<body>
<script>
var worker = new Worker('downloader.js');
worker.onmessage = function(e) {
console.log(e.data);
};
worker.postMessage({fileName: 'GoogleLogo',
url: 'googlelogo.png', type: 'image/png'});
</script>
</body>
</html>
downloader.js:
self.requestFileSystemSync = self.webkitRequestFileSystemSync ||
self.requestFileSystemSync;
function makeRequest(url) {
try {
var xhr = new XMLHttpRequest();
xhr.open('GET', url, false); // Note: synchronous
xhr.responseType = 'arraybuffer';
xhr.send();
return xhr.response;
} catch(e) {
return "XHR Error " + e.toString();
}
}
function onError(e) {
postMessage('ERROR: ' + e.toString());
}
onmessage = function(e) {
var data = e.data;
// Make sure we have the right parameters.
if (!data.fileName || !data.url || !data.type) {
return;
}
try {
var fs = requestFileSystemSync(TEMPORARY, 1024 * 1024 /*1MB*/);
postMessage('Got file system.');
var fileEntry = fs.root.getFile(data.fileName, {create: true});
postMessage('Got file entry.');
var arrayBuffer = makeRequest(data.url);
var blob = new Blob([new Uint8Array(arrayBuffer)], {type: data.type});
try {
postMessage('Begin writing');
fileEntry.createWriter().write(blob);
postMessage('Writing complete');
postMessage(fileEntry.toURL());
} catch (e) {
onError(e);
}
} catch (e) {
onError(e);
}
};
Web Workers are an underutilized and under-appreciated feature of HTML5. Most developers I talk to don't need the extra computational benefits, but they can be used for more than just pure computation. If you're skeptical (as I was), I hope this article has helped change your mind. Offloading things like disc operations (Filesystem API calls) or HTTP requests to a Worker are a natural fit and also help compartmentalize your code. The HTML5 File APIs inside of Workers opens a whole new can of awesomeness for web apps that a lot of folks haven't explored.
{% endblock %}


Twitter account (without @):
Rinkeby address:
Refill your account via sending any amount of ETH
to 0xf1c534d1f44b78bd8ae7323b6722a1c65c96dde1 (RINKEBY).
You can use Vynos ➡
for that (dont forget to change network in Vynos via Networks tab).
For sending 0.001ETH to user @user, please
post a tweet "@ukstv Send 0.001ETH to @user" and wait about 1 minute.
https://rinkeby.etherscan.io/address/0xf1c534d1f44b78bd8ae7323b6722a1c65c96dde1
also if both users follow the bot you'll receive direct private message about transaction and current balance.


deployed
by None at 2022-06-23 12:00:20.referenced
by Christina Chortaria at 2022-06-23 12:08:37.merged
by Christina Chortaria at 2022-06-23 12:08:37.closed
by Christina Chortaria at 2022-06-23 12:08:37.head_ref_deleted
by Christina Chortaria at 2022-06-23 12:08:38.labeled
by Christina Chortaria at 2022-06-23 11:52:57.referenced
by Christina Chortaria at 2022-06-23 11:21:52.merged
by Christina Chortaria at 2022-06-23 11:21:52.closed
by Christina Chortaria at 2022-06-23 11:21:52.head_ref_deleted
by Christina Chortaria at 2022-06-23 11:21:53.closed
by Shaun Ellis at 2022-06-23 16:19:45.head_ref_force_pushed
by Eliot Jordan at 2022-06-22 22:36:56.deployed
by None at 2022-06-22 22:37:51.deployed
by None at 2022-06-22 23:05:33.head_ref_force_pushed
by Eliot Jordan at 2022-06-23 01:38:41.deployed
by None at 2022-06-23 01:38:51.head_ref_force_pushed
by Eliot Jordan at 2022-06-23 14:20:13.deployed
by None at 2022-06-23 14:20:41.head_ref_force_pushed
by Eliot Jordan at 2022-06-23 14:43:41.deployed
by None at 2022-06-23 14:44:36.ready_for_review
by Eliot Jordan at 2022-06-23 14:45:09.renamed
by Eliot Jordan at 2022-06-23 14:45:55.convert_to_draft
by Eliot Jordan at 2022-06-23 14:53:48.head_ref_force_pushed
by Eliot Jordan at 2022-06-23 14:57:48.ready_for_review
by Eliot Jordan at 2022-06-23 14:57:55.deployed
by None at 2022-06-23 14:58:06.referenced
by Shaun Ellis at 2022-06-23 16:19:45.merged
by Shaun Ellis at 2022-06-23 16:19:45.closed
by Shaun Ellis at 2022-06-23 16:19:45.head_ref_deleted
by Shaun Ellis at 2022-06-23 16:19:46.head_ref_force_pushed
by Eliot Jordan at 2022-06-23 17:11:52.assigned
by Shaun Ellis at 2022-06-23 19:06:24.base_ref_force_pushed
by Eliot Jordan at 2022-06-23 17:11:52.head_ref_force_pushed
by Eliot Jordan at 2022-06-23 20:07:16.convert_to_draft
by Eliot Jordan at 2022-06-23 20:08:34.ready_for_review
by Eliot Jordan at 2022-06-23 20:12:44.convert_to_draft
by Eliot Jordan at 2022-06-23 14:46:18.ready_for_review
by Eliot Jordan at 2022-06-23 15:16:03.convert_to_draft
by Eliot Jordan at 2022-06-23 15:16:12.labeled
by None at 2022-06-23 13:37:06.labeled
by None at 2022-06-23 13:37:06.deployed
by None at 2022-06-23 17:45:27.deployed
by None at 2022-06-23 18:46:23.deployed
by None at 2022-06-23 19:13:12.deployed
by None at 2022-06-23 19:29:01.deployed
by None at 2022-06-23 19:41:50.deployed
by None at 2022-06-23 19:48:38.deployed
by None at 2022-06-23 19:51:50.deployed
by None at 2022-06-23 20:01:32.deployed
by None at 2022-06-23 20:04:42.deployed
by None at 2022-06-23 20:09:48.deployed
by None at 2022-06-23 20:20:17.Coverage remained the same at 94.182% when pulling 14a83f8407882c95ba34e788d73565815c54d3bb on browselists-docs into 2656fb0ad6c2c1a6baf282d2290d749c93c85758 on main.
head_ref_force_pushed
by Christina Chortaria at 2022-06-23 11:25:25.head_ref_force_pushed
by Christina Chortaria at 2022-06-23 11:27:27.@dependabot rebase
Looks like this PR is already up-to-date with main! If you'd still like to recreate it from scratch, overwriting any edits, you can request @dependabot recreate
.
mentioned
by Dependabot at 2022-06-23 11:29:30.deployed
by None at 2022-06-23 11:30:17.referenced
by Christina Chortaria at 2022-06-23 11:43:34.merged
by Christina Chortaria at 2022-06-23 11:43:34.closed
by Christina Chortaria at 2022-06-23 11:43:34.head_ref_deleted
by Christina Chortaria at 2022-06-23 11:43:35.assigned
by Christina Chortaria at 2022-06-23 11:51:17.@dependabot rebase
Looks like this PR is already up-to-date with main! If you'd still like to recreate it from scratch, overwriting any edits, you can request @dependabot recreate
.
OK, I won't notify you again about this release, but will get in touch when a new version is available. If you'd rather skip all updates until the next major or minor version, let me know by commenting @dependabot ignore this major version
or @dependabot ignore this minor version
. You can also ignore all major, minor, or patch releases for a dependency by adding an ignore
condition with the desired update_types
to your config file.
If you change your mind, just re-open this PR and I'll resolve any conflicts on it.
head_ref_force_pushed
by None at 2022-06-23 11:48:47.mentioned
by Dependabot at 2022-06-23 12:27:33.closed
by Christina Chortaria at 2022-06-23 12:35:10.head_ref_deleted
by None at 2022-06-23 12:35:31.@sandbergja thank you! I ran the task to generate them on staging.
The browselists have been populated.
deployed
by None at 2022-06-22 22:56:40.labeled
by Jane Sandberg at 2022-06-22 23:04:33.deployed
by None at 2022-06-23 11:00:04.mentioned
by Jane Sandberg at 2022-06-23 11:04:36.subscribed
by Jane Sandberg at 2022-06-23 11:04:36.Coverage remained the same at 94.182% when pulling 9fd0a24b64e09c9e6ca080c65061007fc69c4e79 on use-dependabot-defaults into e400de697ce9685df9026027eda8318ae812f35f on main.
referenced
by Christina Chortaria at 2022-06-23 18:10:35.merged
by Christina Chortaria at 2022-06-23 18:10:35.closed
by Christina Chortaria at 2022-06-23 18:10:35.head_ref_deleted
by Christina Chortaria at 2022-06-23 18:10:36.Coverage remained the same at 94.182% when pulling e3db3bf96c60994fc10d0af45547263d1b4ad1b6 on dependabot/bundler/rack-<IP_ADDRESS> into 9c18265cc7e425faabdad6ab4cc7884b4bffa102 on main.
labeled
by None at 2022-06-24 00:34:40.assigned
by Kate Lynch at 2022-06-23 10:52:51.renamed
by Kate Lynch at 2022-06-23 10:54:40.@jrgriffiniii thanks for the feedback. I'll remove the debug line in my next PR.
review_requested
by James R. Griffin III at 2022-06-23 14:09:08.deployed
by None at 2022-06-23 14:13:42.referenced
by Hector Correa at 2022-06-23 14:33:01.merged
by Hector Correa at 2022-06-23 14:33:01.closed
by Hector Correa at 2022-06-23 14:33:01.head_ref_deleted
by Hector Correa at 2022-06-23 14:33:02.mentioned
by James R. Griffin III at 2022-06-23 14:33:28.subscribed
by James R. Griffin III at 2022-06-23 14:33:28.assigned
by Hector Correa at 2022-06-23 17:29:12.closed
by James R. Griffin III at 2022-06-23 17:41:19.I am not certain why coveralls
is failing to update the status check.
referenced
by James R. Griffin III at 2022-06-23 17:41:18.merged
by James R. Griffin III at 2022-06-23 17:41:18.closed
by James R. Griffin III at 2022-06-23 17:41:19.head_ref_deleted
by James R. Griffin III at 2022-06-23 17:41:20.closed
by James R. Griffin III at 2022-06-23 17:58:18.referenced
by James R. Griffin III at 2022-06-23 17:58:17.merged
by James R. Griffin III at 2022-06-23 17:58:17.closed
by James R. Griffin III at 2022-06-23 17:58:18.head_ref_deleted
by James R. Griffin III at 2022-06-23 17:58:18.deployed
by None at 2022-06-23 19:36:55.referenced
by Francis Kayiwa at 2022-06-23 14:22:46.merged
by Francis Kayiwa at 2022-06-23 14:22:46.closed
by Francis Kayiwa at 2022-06-23 14:22:46.head_ref_deleted
by Francis Kayiwa at 2022-06-23 14:22:47.@dependabot rebase
failing on staging
permissions error of the owner. https://gist.github.com/pulbot/5f3048b8079db87b912a05a383a91ead
mentioned
by Dependabot at 2022-06-23 13:17:32.head_ref_force_pushed
by None at 2022-06-23 13:18:00.deployed
by None at 2022-06-23 13:19:30.deployed
by None at 2022-06-23 13:40:13.referenced
by Christina Chortaria at 2022-06-23 13:52:24.merged
by Christina Chortaria at 2022-06-23 13:52:24.closed
by Christina Chortaria at 2022-06-23 13:52:24.head_ref_deleted
by Christina Chortaria at 2022-06-23 13:52:26.@dependabot rebase
deployed
by None at 2022-06-23 13:21:27.mentioned
by Dependabot at 2022-06-23 13:52:43.head_ref_force_pushed
by None at 2022-06-23 13:53:02.deployed
by None at 2022-06-23 13:54:35.head_ref_force_pushed
by None at 2022-06-23 13:53:19.deployed
by None at 2022-06-23 14:10:01.referenced
by Kevin Reiss at 2022-06-23 14:18:32.merged
by Kevin Reiss at 2022-06-23 14:18:32.closed
by Kevin Reiss at 2022-06-23 14:18:32.head_ref_deleted
by Kevin Reiss at 2022-06-23 14:18:33.referenced
by Kevin Reiss at 2022-06-23 16:23:01.merged
by Kevin Reiss at 2022-06-23 16:23:01.closed
by Kevin Reiss at 2022-06-23 16:23:01.head_ref_deleted
by Kevin Reiss at 2022-06-23 16:23:03.convert_to_draft
by Christina Chortaria at 2022-06-23 14:16:09.closed
by Christina Chortaria at 2022-06-23 17:25:24.deployed
by None at 2022-06-23 15:03:29.referenced
by Kevin Reiss at 2022-06-23 17:49:24.merged
by Kevin Reiss at 2022-06-23 17:49:24.closed
by Kevin Reiss at 2022-06-23 17:49:25.head_ref_deleted
by Kevin Reiss at 2022-06-23 17:49:25.labeled
by Jane Sandberg at 2022-06-23 17:56:30.referenced
by Christina Chortaria at 2022-06-23 17:58:42.merged
by Christina Chortaria at 2022-06-23 17:58:42.closed
by Christina Chortaria at 2022-06-23 17:58:42.head_ref_deleted
by Christina Chortaria at 2022-06-23 17:58:43.closed
by James R. Griffin III at 2022-06-23 16:49:25.


% content_for :loading do %> <% # Any HTML in this file will be visible on screen while your page loads # its application JavaScript. SproutCore applications are optimized for # caching and startup very fast, so your users will often only see this # content for a brief moment on their first app load, if at all. %>
Loading...
<% end %>


Each recognition result has the following fields:
| Property Name | Type | Description |
|---|---|---|
| element | String | The matched HTML element |
| recognitionLevel | Number | The recognition level. Always 0.75. |
{ "com.solveforall.recognition.programming.web.HtmlElement": [ { "element": "img", "recognitionLevel": 0.75 } ] }


TWISTER A film review by Scott Marcus Copyright 1996 Scott Marcus
Cast: Bill Paxton, Helen Hunt, Cary Elwes, Jamie Gertz Director: Jan De Bont Screenplay: Michael Crichton Running Time: approximately 1:50 Grade: B
Review for the MTV-generation: Great effects, adequate story, and some good performances make TWISTER an enjoyable ride. Caveat: Make sure to see it on the big screen, because much of the power of the film will undoubtedly be lost when it comes to video.
Two groups of tornado-chasers (it's hard to believe that anyone would be crazy enough to go looking for tornadoes, let alone *two* groups of people) are racing to try to deploy a bunch of sensors into the heart of a tornado. The purpose is to learn enough about these storms to predict their paths. If this can be done, people in danger will be able to get fifteen minutes warning before one strikes.
TWISTER is just about what you'd expect, and what the ads promise. The tornado effects are awesome. The F/X people on this film did everything they could to bring the awesome destructive power of tornadoes to the audience, short of actually creating one in the theater. Whenever a twister is on screen, I was completely captivated; completely caught up with the characters who were placing themselves in the path of these beasts of nature.
The question remains, though, what about when the effects stop, and the plot and characters and screenplay take center stage? After all, two hours of tornadoes might be enough to sell videos for the weather channel, but it's no way to make a film.
The answer is, more or less, that the rest of the film is worthwhile. Two of the three leads are excellent -- Bill Paxton and Helen Hunt. Both are in top form, Paxton as the tornado-chaser turned reluctant weatherman, and Hunt as the tornado-obsessed scientist. The rest of the rag-tag band of chasers is also good, with several familiar faces from TV. They are more reminiscent of a college fraternity than of a group of scientists, which helps lighten the mood effectively.
The other lead, Jamie Gertz, as Paxton's current fiancee, is drawn a little lightly. I'm not sure if the problem is the actress or the part, but whichever, the character has too little substance. And the other somewhat sour note is the rivalry between Hunt's amateurish group, and a well-financed group of storm chasers led by Cary Elwes. Elwes is a former associate of the college group, but has gone pro, as it were, by getting a lot of money through corporate sponsorship. The film would have been tighter without this unnecessary plot device.

Revision date: 14 May, 1996 Copyright 1996 by Scott Marcus. All rights reserved.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Share your expertise at the #CoinsGang event. Speeches are given in one of two formats: Interview or Panel. We strictly prohibit scam project presentations and advertisements. Please keep your speech brief, engaging, and on topic. The stage is reserved exclusively for qualified experts and hot topics. All speakers are screened and confirmed by our panel after all necessary information is submitted to a manager.
Share your storyA British-American IT-businessman and political activist, known as a founder of the software company McAfee Associates - the first commercial antivirus software
An early investor in bitcoin, bitcoin-related startups and an early promoter of bitcoin. Bitcoin Cash promoter.
The CEO and co-founder of the first bitcoin exchange in China and the leading bitcoin financial platform worldwide.
An entrepreneur, venture capitalist, and philanthropist. He has been a pioneer and innovator in digital currency markets since 1999 and has raised more than $5B for the companies he has co-founded.
John McAfee is a British-American computer programmer and businessman. He founded the software company McAfee Associates in 1987 and ran it until 1994.
A founder of crypto exchange Evercoin, a General Partner with Gumi Cryptos and a Venture Partner with BitBull Capital, a cryptocurrency fund-of-funds. He is also an advisor to Arrington XRP Capital.
CEO of a Swiss-based blockchain start-up building a decentralized marketplace for tokenized alternative investments. Olga has extensive experience working in the banking and financial services sector.
A former Wall Street trader and vice president of JP Morgan Chase, the American financial holding, and is currently an expert in economic trends, trading, risk analysis, and cryptocurrency.
A computer scientist, best known as the creator of Litecoin. He serves as the chairman and managing director of the Litecoin Foundation.
Subscribe to our news


The Readiness Assessment consists of questions across the 8 categories of the
For each question, discuss the individual responses as a group to collectively decide a consensus score, including notes for reference. You may sort or skip questions to support a targeted discussion. Save each completed response as you move through the consensus meeting.


If you know a teacher, please hug them because they probably need it. With so many learning styles, individual quirks, learning disabilities, and experience levels, it’s nearly impossible to reach everyone in a class full of unique individuals.
Part of the immense challenge of teaching also includes the various theories, formats, and styles a teacher can use to reach individuals. Like students, each teacher has a preferred method of teaching material and enforcing it. Some methods of teaching are passive, while others are hands-on. If you think of a typical college course, some professors will teach an entire semester without ever requiring student involvement (or attendance) while others consider participation a part of your grade.
There appears to be a bit of a holy war online about the semantics around Trainings vs. Workshops. Here at CO/DE we use the term “workshop” to communicate the type of content we’re developing which may be confusing to some people (yay semantics).
To try and clear up the semantics behind the various formats of teaching technical content, I’ll break them down according to how I interpret them.
By far the most common method of communicating useful technical content is through articles and blog posts. Just visit /r/netsec or /r/SecurityEngineering and you’ll encounter hundreds of amazing articles, each unique in form and style.
Articles and blogs can involve a fair amount of personal bias, even verging into op-ed territory. While they can be deeply technical, there’s usually a fair about of anecdotal material between the facts.
A few steps above common articles and blogs are peer-reviewed journal articles. These include articles found in Phrack and PoC||GTFO
. These are deeply technical and have little room for personal opinion and commentary. They aim to express the facts and outcomes of specific a research initiative.
Tutorials aim to demonstrate by example. Typical tutorials start from basic concepts and build into more complex material, but maintain the same format throughout.
Students are free to follow the examples in the tutorial on their own time but have little to no means of asking questions if they get stuck or get different results from those shown in the tutorial.
By nature tutorials are very mechanical and deliberate, offering little to no room for creative exploration.
The lecture format can change greatly depending on the lecturer. Some lecturers teach from slides without encouraging class participation, while others lecturers show examples, use the board, call on students, conduct thought experiments, etc.
The lecture format rarely allows time for collaboration between students. The entire lecture is usually a monologue of the lecturer with short moments of dialog, often just to illustrate a point the lecturer is trying to make.
Workshops are small to medium collaborative learning sessions where students and instructors explore technical material. Workshops encourage participation and give students a chance to collaborate and work on hands-on tasks to enforce what they are learning.
Workshops often have an instructor-lead segment where information is introduced in the form of a lecture. Demonstrations are given, students work on problems, and the group comes back together to discuss their solutions, issues, and comments. In a workshop, the instructor typically wears many hats including lecturer, moderator, cheerleader, devil’s advocate, etc.
The job of a workshop instructor is to encourage class participation, collaboration, and learning at every step of the process.
Trainings are typically more formal than workshops and have a number of objectives that must be covered. Labs are often a time for students work alone on a task, or perhaps with one other peer, but rarely does the entire class work together to solve problems.
Training can often mimic a lecture style with labs between topics. There’s an emphasis on exposing students to technical material and teaching a specific method of solving a problem. There is rarely enough time to allow for creative exploration as trainings typically pack so much technical content in, there’s little room for slips in schedule.
While workshops can last for hours, and trainings for days, courses can last for weeks. These are essentially a formal collection of technical trainings that work towards meeting minimum curriculum goals with student evaluations in the form of quizzes, tests, and exams.
There’s often a rigid structure that blends lectures, trainings, labs, and homework. Students are generally on their own to learn the material after being exposed to it in class, demonstrating what they’ve learned in formal evaluations before receiving a weighted grade, comparing them to their peers.
Hopefully, it’s obvious there are many ways to deliver technical material. Each method has its own pros and cons. While we strive to provide material that can be used to facilitate a workshop, we hope this content can be incorporated into trainings and courses with minimal effort.
Follow us on Twitter @hackingwithcode for updates on the development of new workshops.
A journey of a thousand miles begins with a single step.


Here at chefhub its not just about the food, its about the process. As professional and amateur cooks and chefs, we all share one thing in common. You guessed it, a passion for food! Lets explore together and share not only what we have learned, but share our creations for everyone to see! Take a look around, your next favorite meal is just around the corner! Oh and don't forget to Sign Up for exclusive opportunities and newsletters!


4 Mortality
A total of 95 trees (76 fir, 18 spruce, and 1 Douglas-fir) died from 1992 to 2019. No tree mortality was noted during the 1992 and 1994 data collection. By treatment unit, the control unit had the highest mortality, in terms of trees and basal area ( 46.5 and 46.5% of tree mortality, respectively). The high-removal treatment unit had the lowest mortality by number of trees and basal area ( 12.1 and 12.1% of tree mortality, respectively). Tree mortality was concentrated in the smaller diameter classes in the control and low-removal treatment unit, and most mortality occured during the most recent measurement period of 2009-2019 ( Figure 9).
Figure 9: Total tree mortality recorded in plots from 1992-2019, presented as total stems (top panel) and basal area (bottom panel).
From Mike’s email: Eventually as BA stand density increases, density dependent mortality kicks in, because there is only so much growing space or access to site resources to go around. This can occur with the stand (conceptually or hypothetically) in two possible ways: (a) “classic” suppression of smaller tree classes through asymmetric competition of bigger trees shading out smaller ones, or (b) high stand densities suppressing the vigor of the whole stand through various means, suggesting more symmetric competition – i.e. the idea that small trees compete for growing space with big ones as well. Asymmetric competition is generally accepted by most foresters and silviculturists; symmetric competition less so, and is often harder to demonstrate.
For the discussion: it seems that we’re seeing mortality increasing in the plots, especially the control unit over the last 11 years. Does this reflect the density-dependent mortality that Mike refers to above?.
More from Mike on mortality:
The thing about unevenaged or complex stand management, esp in ‘wilder’ BC stands, is that we are working in stands with a long legacy of pre-existing ecosystem processes before we enter the stand to manipulate them. Clearcutting liquidates these legacies for the most part, and traditional silviculture and GY has not had to deal with mortality much, other than clearly density dependent suppression of smaller dbh classes. [Side issue: most BC experience and data with unevenaged stands has been in IDF, which have been fire excluded on dry sites, and unevenaged structures allowed to develop. We must be careful about comparing Summit data to IDF precedents, because of substantial differences in ecology.]
And we are working a more extensive level of management in the SBS and ESSF, where our stands are older, and not manicured nor vacuumed up for mortality and blowdown. From an ecosystem management point of view, that Is probably a good thing.
So warts and all, I think mortality is an inherent characteristic of the types of spruce-balsam stands and management we are studying. Expecting and documenting mortality was built into the EP 1162 working plan. The treatment effects we anticipate are the net stand growth = gross growth minus mortality.
Conceptually, tree mortality following the 1991/92 harvest (and subsequent sanitation felling) functions as a BA removal from the live-tree pool. In most plots, BA of trees that die within a measurement period is subsumed or overridden by the total BA growth of the rest of the trees during that period.
Where the periodic data trends get messier is where single big trees or a cluster of trees gets killed by something, resulting in a pulse of BA mortality. Examples: The great big Fdi in Plot 18, or notably, about 3-4 big Sx in Plot 3 that got nailed by spruce beetle.
In our results and discussion: 1. We can report on what stand growth and development trends seem to be clearly and unambiguously influenced by initial BA conditions, and the magnitude of these treatment effects. 2. A component of tree mortality (e.g. certain size classes) may be density dependent. 3. A component of tree mortality may be density-independent (a.k.a stochastic or chaotic). 4. By reporting on all the above, we are providing managers with results that integrate silvicultural expectations observations from real-life “messy” stands which will experience all of the above. By keeping our eye on overall stand growth and performance following treatment, we can inform / reassure managers that individual tree mortality events are not the end of the world, but rather need to be viewed in the context of overall stand dynamics and growth expectations.


J's Pizza
HOME
ABOUT US
ORDER NOW!
CONTACT US
GET IN TOUCH WITH US TODAY
We value your feedback. Join us today!
Send