| row_group_order {gt} | R Documentation |
We can modify the display order of any row groups in a gt object with the
row_group_order()
function. The groups
argument takes a vector of row
group ID values. After this function is invoked, the row groups will adhere
to this revised ordering. It isn't necessary to provide all row ID values in
groups
, rather, what is provided will assume the specified ordering at the
top of the table and the remaining row groups will follow in their original
ordering.
row_group_order(data, groups)
data |
A table object that is created using the |
groups |
A character vector of row group ID values corresponding to the revised ordering. While this vector must contain valid group ID values, it is not required to have all of the row group IDs within it; any omitted values will be added to the end while preserving the original ordering. |
An object of class gt_tbl
.
5-1
# Use `exibble` to create a gt table # with a stub and with row groups; # modify the order of the row groups # with `row_group_order()`, specifying # the new ordering in `groups` tab_1 <- exibble %>% dplyr::select(char, currency, row, group) %>% gt( rowname_col = "row", groupname_col = "group" ) %>% row_group_order( groups = c("grp_b", "grp_a") )


Enter for a Chance to Win a New Tesla While Donating to Save the Rainforest
Omaze is supporting Global Green by giving away a 2020 S model.
by Nate LouisWant to win a brand new Tesla? Fundraising platform Omaze is offering a chance to win this grand prize while supporting an even grander cause: restoring the Amazon rainforest. The company raises money for nonprofits by giving away experiences and prizes that people can enter to win while donating $10 USD or more to charity. For this Omaze campaign, one winner will be randomly drawn to score a 2020 Tesla Model S Performance along with $20,000 USD cash, and every donation supports Global Green, an organization dedicated to saving the Amazon rainforest.
The 2020 Tesla Model S Performance features state-of-the-art technologies, including full Self-Drive capabilities, switch to autopilot, noise engineering fit for a recording studio and a giant 17-inch touchscreen infotainment system. It’s already deemed one of the fastest accelerating cars on the road, going 0 to 60 mph in 2.4 seconds — and it has hit a top speed of 163 mph. The model is also one of the safest and most efficient cars, reaching 345 miles on full charge and touting incredible handling, aerodynamics, electric range and impact protection. Tesla Founder and CEO Elon Musk has referred to the Tesla S Performance as “a very sophisticated computer on wheels.”
For your chance to win a Tesla S Performance and support a great cause, head to omaze.com/TeslaS.


Introduction
Sponge is a data import service used to get your existing community (comments, authors, assets, and other entities) into the Coral ecosystem.
It is an Extract, Transform, and Load command line tool designed to:
- Read data from a foreign source,
- Translate the schema into Coral conventions, and
- POST entities to our service layer for insertion.
Sponge uses strategy files to assist with data import. Strategy files are JSON files that are used to tell Sponge where to get the data, and how to translate it. You can read more about strategy files here, including information on their structure and examples.
GoDoc source code documentation
Sponge has automatically generated GoDoc generated documentation available, which you can view here. GoDoc generates documentation from Go source code.
Composition
Sponge is made up of several different packages, and you can read more about them on the included packages section. They work together as shown in the diagram below:
Data import sources supported
Sponge currently only supports importing data from mySQL, PostgreSQL, MongoDB or web services with REST APIs.
Command line tool
Usage:
sponge --flag [command]
Available Commands:
import
: Import data to the coral database.index
: Work with indexes in the coral database.show
: Read the report on errors.version
: Print the version number of Sponge.all
: Import and Create Indexes.
Flags
--dbname="report.db": set the name for the db to read
--filepath="report.db": set the file path for the report on errors (default is report.db)
-h, --help[=false]: help for sponge
--limit=9999999999: number of rows that we are going to import (default is<PHONE_NUMBER>)
--offset=0: offset for rows to import (default is 0)
--onlyfails[=false]: import only the the records that failed in the last import(default is import all)
--orderby="": order by field on the external source (default is not ordered)
--query="": query on the external table (where condition on mysql, query document on mongodb). It only works with a specific --type. Example updated_date >'2003-12-31 01:02:03'
--report[=false]: create report on records that fail importing (default is do not report)
--type="": import or create indexes for only these types of data (default is everything)
Sponge installation
Before you begin
Pillar
You will need to have an instance of Pillar running, where your translated data will be sent. Instructions on installing Pillar can be found here.
External database source
You will also have your external database running. This external database is the source of your existing comment data that will be extracted by Sponge and sent to Pillar, which will then load it into the Coral ecosystem.
The external sources we currently support are: PostgreSQL, MySQL, MongoDB, and REST APIs.
Vendoring dependencies
You should be vendoring the packages you choose to use (“vendoring” is the moving of all third party items such as packages into the /vendor
directory). We recommend using govendor. This tool will manage your dependencies from the vendor folder associated with this project repository.
Install from source
Before you begin
If you want to install from source, you will need to have Go installed.
First install Go. The installation and setup instructions on the Go website are pretty good. Ensure that you have exported your $GOPATH environment variable, as detailed in the installation instructions.
If you are not on a version of Go that is 1.7 or higher, you will also have to set the GO15VENDOREXPERIMENT flag.
export GO15VENDOREXPERIMENT=1
If you are not on a version of Go 1.7 or higher, we recommend adding this to your ~/.bash_profile or other startup script.
Get the source code
You can install the source code via using the go get
command, or by manually cloning the code.
 It simply means that there are buildable source files in subdirectories, just not the uppermost sponge directory.
package github.com/coralproject/sponge: no buildable Go source files in [directory]
Cloning manually
You can also clone the code manually.
mkdir $GOPATH/src/github.com/coralproject/sponge
cd $GOPATH/src/github.com/coralproject/sponge
git clone https://github.com/coralproject/sponge.git
Set up your strategy.json file
You can read about strategy files in depth here.
The strategy.json file tells Sponge how to do the transformation between the publisher’s existing data and the Coral data schema. It also tells us how to connect to the external publisher’s source data. We currently support the following sources: PostgreSQL, MySQL, MongoDB, and REST APIs.
We have example strategy.json files for each of those source types. You can see those example strategy.json files in the examples
folder: $GOPATH/src/github.com/coralproject/sponge/examples
To copy one of the example strategy.json files to another folder, where you can then customize it:
cp $GOPATH/src/github.com/coralproject/sponge/examples/strategy.json.example $GOPATH/src/github.com/coralproject/sponge/strategy/strategy.json
Set your environment variables
Setting your environment variables tells Sponge which strategy file you want to use, and the URL for the Pillar instance you are pushing data to.
Make your own copy of the config/dev.cfg
file (you can edit this configuration file with your own values, and then ensure that you don’t commit it back to the repository). Call your config file whatever you like; we’ll call it “custom” in this example.
cd $GOPATH/src/github.com/coralproject/sponge
cp config/dev.cfg config/custom.cfg
Now edit the values in your custom.cfg file:
export STRATEGY_CONF=/path/to/my/strategy.json
export PILLAR_URL=http://localhost:8080
STRATEGY_CONF
: Specifies the path to your strategy.json file.PILLAR_URL
: Specifies the URL where your Pillar instance is running. If you installed Pillar locally from source, this will probably behttp://localhost:8080
.
Once you’ve edited and saved your custom.cfg file, source it:
source $GOPATH/src/github.com/coralproject/sponge/config/custom.cfg
Run Sponge
You can either run Sponge using Go, or via a CLI tool.
Running Sponge using go run
cd $GOPATH/src/github.com/coralproject/sponge/cmd/sponge
go run main.go
Running Sponge using the CLI tool
First build the CLI tool:
cd $GOPATH/src/github.com/coralproject/cmd/cmd/sponge
go build
Then run the CLI tool
./sponge -h
Install as a Docker container
Building image
To build the docker image, run this command:
docker build -t "sponge:latest" -f Dockerfile ./
Edit env.list
Setting your environment variables tells Sponge which strategy file you want to use, and the URL for the Pillar instance you are pushing data to.
PILLAR_URL=http://<IP_ADDRESS>:8080
STRATEGY_CONF=/strategy/strategy_psql.json
# DATABASE
# (optional if you want to overwrite strategy file values)
DB_database= ""
DB_username= ""
DB_password= ""
DB_host= ""
DB_port= ""
# WEB SERVICE
# (optional if you want to overwrite strategy file values)
WS_appkey= ""
WS_endpoint= ""
WS_records= ""
WS_pagination= ""
WS_useragent= ""
WS_attributes= ""
Required edits:
STRATEGY_CONF
: Specifies the path to your strategy.json file.PILLAR_URL
: Specifies the URL where your Pillar instance is running. If you installed Pillar locally from source, this will probably behttp://localhost:8080
.
Running the container
Spinning up the container will start importing everything setup in the strategy file.
docker run --env-file env.list -d sponge
Packages included in Sponge
- Strategy reads the translations file.
- Source performs the extraction of data from the external data source.
- Fiddler performs the transformation of data.
- Coral sends data to Pillar.
- Sponge ties all the pieces together.
Strategy
import "github.com/coralproject/sponge/pkg/strategy"
The Strategy package reads in the external strategy JSON file and creates a structure containing translation information.
Variables
var pillarURL string
: URL that points to the Pillar instance, where the data will be sent.- This is initialized by the
PILLAR_URL
environment variable.
- This is initialized by the
var uuid string
: Universally Unique Identifier used for the logs.
To read more about strategy JSON files, you can read our section on strategy files.
Source
import "github.com/coralproject/sponge/pkg/source"
The Source package contains the drivers that we use to connect to the external source and retrieve data. The credentials for the external data source are set up in the strategy file.
Variables
var strategy str.Strategy
: Holds the credentials for the external source, as well as all the entities that need to be extracted.var uuid string
: Universally Unique Identifier used for the logs.var credential str.Credential
: Credential for the external source (database or web service).
Sourcer interface
This is the interface that needs to be implemented by any driver that connects to an external data source.
func GetData
GetData(string, *Options) ([]map[string]interface{}, error)
Returns all the data (query by options in Options) in the format []map[string]interface{}
func IsWebService
IsWebService() bool
Returns true if the implementation of Sourcer is a web service.
func New
func New(d string) (Sourcer, error)
Returns a structure with the connection to the external source that implements the interface Sourcer.
func GetEntities
func GetEntities() ([]string, error)
Gets all of the entity names from the external data source.
func GetforeignEntity
func GetForeignEntity(name string) string
Gets a single foreign entity’s name.
mySQL driver
The mySQL driver is contained in the mysql.go
file. It has a mySQL struct that implements the Sourcer interface, and enables data extraction from a mySQL database.
PostgreSQL driver
The PostgreSQL driver is contained in the postgresql.go
file. It has a PostgreSQL struct that implements the Sourcer interface, and enables data extraction from a PostgreSQL database.
MongoDB driver
The MongoDB driver is contained in the mongodb.go
file. It has a MongoDB struct that implements the Sourcer interface, and enables data extraction from a MongoDB database.
API driver
The API driver is contained in the api.go
file. It has an API struct that implements the Sourcer interface, and enables data extraction from an API interface.
How to add a new source
Currently, we offer the four drivers listed above (mySQL, PostgreSQL, MongoDB, and REST API). If you need to add a new type of external source, you can write your own driver. To write your own driver, you will implement the Sourcer interface for your type of external data source.
Fiddler
import "github.com/coralproject/sponge/pkg/fiddler"
The Fiddler package performs the translation from the external database schema into Coral’s database schema.
Variables
strategy str.Strategy
Holds the translation, in JSON form, to apply to the data.dateLayout string
Date Layout as specified in the strategy file.uuid string
Universally Unique Identifier used for the logs.
Functions
func GetID
func GetID(modelName string) string
Returns the field that is the identifier for that model
func GetCollections
func GetCollections() []string
Returns the names of all the collections in the strategy file.
func TransformRow
func TransformRow(row map[string]interface{}, coralName string) (interface{}, []map[string]interface{}, error)
Applies the coral schema to a row of data from the external source.
Coral
Note: The “Coral” package is not to be confused with the Coral ecosystem as a whole. In this instance, this is merely the name of a package included in the Sponge app.
import "github.com/coralproject/sponge/pkg/coral"
Coral interacts with Pillar endpoints to import data into the Coral system.
Constants
retryTimes int = 3
Determines how many times to retry communication with Pillar, if it initially fails.methodGet string = "GET"
methodPost string = "POST"
Variables
endpoints map[string]string
endpoints
is a map containing all of the services where we can send data. Right now, that is only Pillar.uuid string
Universally Unique Identifier used for the logs.str strategy.Strategy
Holds the translation, in JSON form, to apply to the data.
Functions
func AddRow
func AddRow(data map[string]interface{}, tableName string) error
Adds data to the collection tableName
.
func CreateIndex
func CreateIndex(collection string) error
Calls the service to create index for collection
.
Sponge
Note: The “Sponge” package is not to be confused with the Sponge app as a whole. In this instance, this is merely the name of a package included in the larger Sponge app.
import "github.com/coralproject/sponge/pkg/sponge"
The Sponge package ties together all of the other packages, so that they all communicate and work with each other.
Constants
VersionNumber = 0.1
Provides the version number of Sponge.
Variables
dbsource source.Sourcer
uuid string
options source.Options
Functions
func AddOptions
func AddOptions(limit int, offset int, orderby string, query string, types string, importonlyfailed bool, reportOnFailedRecords bool, reportdbfile string)
AddOptions
sets options for how Sponge will run. The options are:
Limit
: Limit for the query.Offset
: Offset for the query.Orderby
: Order by this fieldQuery
: We use this field if we want to specific a filter on WHERE for mySQL/PostgreSQL and Find for MongoDB.Types
: Specifies which entities to import (the default is “everything”).Importonlyfailed
: Import only the documents that are in the report.ReportOnFailedRecords
: Create a report with all the documents that failed the import.Reportdbfile
: Name of the file for the report on documents that fail the import.
func Import
func Import()
Gets data, transforms it and sends it to Pillar. It bases everything on the STRATEGY_CONF environment variable and the PILLAR_URL environment variable.
func CreateIndex
func CreateIndex(collection string)
Creates index on the collection collection
. This feature creates indexes on the Coral database, depending on the data in the strategy file.
For example:
"Index": [
{
"name": "asset-url",
"keys": ["asseturl"],
"unique": "true",
"dropdups": "true"
}
],
You can read more information at the mongodb’s create index definition.
Strategy files
Strategy files are JSON configuration files that contain all the information Sponge needs to extract data from a source, translate it to the Coral schema, and send it on to Pillar and from there to the Coral MongoDB.
The external data sources we currently support are: PostgreSQL, MySQL, MongoDB, and REST APIs.
The strategy spec is still being refined. We have examples that you can view in the examples directory.
Examples:
Fields in the strategy.json file
General fields
Name
: The name of the strategy that we are describing.Map
: Contains all the information to map fields from the external data source to our local Coral database.Foreign
: Describes the type of external database source (for example, “mysql” or “mongodb”).DateTimeFormat
: Tells us how to parse date/time fields in the external data source. You should populate this field with the date and time of2006 Mon Jan 2 15:04:05
, written in the format that appears in your external database.
Entity fields
Entities
is a JSON object that describes all of the different entities in the Coral database, and how to perform the transformation for that entity.
Foreign
: The name of the foreign entity.Local
: The collection into which we are importing this entity.Priority
: This is a number that specifies which entity to import first (the highest priority is 0).OrderBy
: The field to order the results by when querying the foreign source.ID
: The identifier field for the foreign entity. We use this field when we need to import only some records and not the whole entity.Endpoint
: This is the Pillar endpoint URL where we will push the data.Fields
: All the fields that are being mapped.foreign
: The name of the field in the foreign entity.local
: The name of the field in our local database.relation
: The relationship between the foreign field and the local one. We have the following options:Passthrough
: When the value is the same.Source
: When it needs to be added to our source struct for the local collection (the original identifiers have to go into source).ParseTimeDate
: When we need to parse the foreign value as date time.Constant
: When the local field should always be the same value. In this case we will have “foreign” blank and we will have other field called “value” with the value of the local field.SubDocument
: When the local field has an array of documents in one of the fields.Status
: When the field need to be translated based on the status map that is declared in that same strategy file for the entity.
Type
: The type of the value we are converting.String
Timedate
Credentials
This contains the credentials for the external data source. It could be a REST API or a database (MySQL, PostgreSQL or MongoDB).
adapter
: This tells us which driver we need to use to extract data. Right now, the options available aremysql
,postgresql
,mongodb
, orservice
.type
: Right now this is alwaysforeign
, but in future it could tell us what type of credential this is.
Logging
We are using (Ardanlabs Log’s package)[https://github.com/ardanlabs/kit/tree/master/log] for all of the tools we are developing in Go.
Logging levels:
Dev
: To be outputted in development environment only.User
(prod): To be outputted in dev and production environments.
All logs should contain:
- Context uuid to identify a particular execution (aka, run of Sponge or a Request/Response execution from a web server).
- The name of the function that is executing.
- A readable message including relevant data.
Logs should write to stdout
so that they can be flexibly directed.
Roadmap
There are features we would like to incorporate into Sponge at a future date, but that we haven’t yet prioritized into issues or releases.
API Import
Pull data from HTTP(S) sources:
- Disqus - https://disqus.com/api/docs/
- Wordpress Core - https://codex.wordpress.org/XML-RPC_WordPress_API/Comments
- Lyvewire - http://answers.livefyre.com/developers/api-reference/
- Facebook - https://developers.facebook.com/docs/graph-api/reference/v2.5/comment
Rate Limit Counter
In order to protect source databases, we want to be able to throttle the number of queries that Sponge is making.
- Keep a sliding count of how many requests were made in the past time frame based on the strategy.
- Expose isOkToQuery() to determine if we are currently at the limit.
- Each request will send a message to this routine each time a request is made.
Synchronization
An internal mechanism that regularly polls the source and imports any updates.
Basic polling specification
The main loop that keeps the data up to date. Gets slices of records based on updated_at timestamps to account for changing records.
For each table or api in the strategy:
- Ensure maximum rate limit is not met
- Determine which slice of data to get next
- Find the last updated timestamp in the log collection (or the collection itself?)
- Use the strategy to request the slice (either db query or api call)
- Update the rate limit counter
- For each record returned
- Check to ensure the document isn’t already added
- If not, add the document and kick off import actions
- If it’s there, update the document
- Update the log collection


Specify notes to push at the completion of the build.
Environment variables may be used in notes - they will be replaced at build time.
Note's namespace and remote repository's name are optional. Those are master and origin by default.
Note messages additional environment variables:
$BUILDRESULT = Build result so far. This doesn't pay attention to all post-build actions
$BUILDDURATION = Says how long the build took to run. This doesn't include time which is spent to post-build actions.


Magnitude 5.9 temblor jolts Bukidnon
(UPDATED) Phivolcs says Kadingilan, Bukidnon was the epicenter of the earthquake which struck Monday night
by Bobby LagsaSubscribe
Email Address
Newsletters
- Glenda Gloria's Take this Tuesday
- Huddle by Miriam Grace Go
- The Newsbreak Agenda by Chay Hofileña
- Sometimes, all you need is video by Lilibeth Frondoso


home
|
features
|
getting started
|
FAQ
|
Stone
|
Iron
|
download
|
help
|
about
Iron
Iron is a StarCraft AI based on the BWEM library (same author).
Iron can be seen as an extension of Stone.
Like Stone:
- Iron is Terran bot.
- Iron is Agent Oriented.
- Focus has been on individual behaviors: Agents are highly autonomous and versatile.
- These behaviors have been carefully designed to avoid indecisiveness, one of the most common and frustrating issues of AIs.
- Iron aims at robustness and doesn't contain any code specific to a particular bot.
- SCVs play an important role.
Unlike Stone:
- Iron is a complete bot that can deal with most types of threats.
- Iron can expand.
- Iron uses a mix of supervised and unsupervised algorithms.
Iron is still under developement.
To see its progress, go to SSCAIT Tournament.
Iron's FAQ
I'd like to watch some of its games...
Iron is currently playing games against other bots in SSCAIT Tournament's ladder.
How to play against Iron?
To play against Iron you need:
- a proper Brood War installation.
- the last release of the BWAPI library.
- Iron's binaries: available here.
A tutorial is available here: Starcraft Broodwar: Play vs custom AI .
Which version of the BWEM does Iron use?
Iron uses the latest version of the BWEM Library.
home
|
features
|
getting started
|
FAQ
|
Stone
|
Iron
|
download
|
help
|
about


Source: {{article.SourceTitle}}
{{article.Content}}
Swipe right to add more sources.
Swipe right to add sources to read articles from.
NO INTERNET CONNECTION!


Contextual Robustness¶
A toolset for contextually-relevant verification of image classification Neural Networks as described by DeepCert.
Install & Setup¶
Prerequisites¶
python 3.5.0 <= 3.8.7
cmake >= 3.12 (for compiling Marabou)
Setup Environment & Install Python Deps¶
git clone <GITHUB_REPO_URL>
cd contextual-robustness
python3 -m venv venv
source venv/bin/activate
pip install --upgrade pip
pip install -r requirements.txt
Install Marabou¶
You can download and compile Marabou using the ./scripts/install_marabou.sh
script or by following the instructions in the Marabou repo.
Gurobi (optional - improves Marabou performance)¶
Gurobi can optionally be installed to improve Marabou’s performance. Gurobi can be downloaded here, and installation steps are here. After installing Gurobi and obtaining the license, you can install and compile marabou with Gurobi support using the install script ./scripts/install_marabou.sh -g <GUROBI_PATH>
.
Install LaTeX¶
By default, the plotting functions in ContextualRobustnessReporting
use LaTeX for rendering text. To use this feature, you’ll need to install LaTeX and add it to your PATH
. If you don’t need/want to use the latex rendering, simply pass usetex=False
to the relevant plotting functions.
Prepare Datasets¶
The examples rely on test samples from the GTSRB and CIFAR datasets. Run ./scripts/setup_datasets.sh
to prepare the datasets.
Usage Examples¶
Test-Based Technique¶
The test based technique uses the model’s built-in ‘predict’ function to analyze the model’s robustness to a transform. This technique can be used to get an overall picture of the model’s robustness by testing a large number of samples from the dataset. It is faster than the formal verification technique, but may not always discover the real “epsilon” for all samples.
Test-Based Technique: Analyzing a Model/Transform¶
The sample code below shows how to analyze a model on a particular image transformation (e.g. haze). The analysis will generate a csv containing the epsilon for each image, and a pickle containing counterexamples showing examples where the change in prediction occured.
from contextual_robustness import ContextualRobustnessTest, ContextualRobustnessReporting
from contextual_robustness.transforms import haze
# instantiate ContextualRobustness object for modelA/haze
modelA_haze_test = ContextualRobustnessTest(
model_name='./models/modelA.h5', # (*required) model
model_name='ModelA', # name of model
transform_fn=haze, # (*required) transform function
transform_name='Haze', # name of transform
X=X_test, # (*required) np.array of images
Y=Y_test, # (*required) np.array of labels
verbosity=0 # amount of logging
)
# run analysis and save to CSV
modelA_haze_test.analyze(epsilons_outpath='./results/modelA_haze/epsilons.csv')
Test-Based Technique: Load & Visualize Results¶
from contextual_robustness import ContextualRobustnessTest, ContextualRobustnessReporting
from contextual_robustness.transforms import haze
# Load saved CSV results from 'Haze' analysis on 'ModelA'
modelA_haze = ContextualRobustnessTest(
model_path='./models/modelA.h5',
model_name='ModelA',
X=X,
Y=Y,
transform_fn=haze,
transform_name='Haze')
modelA_haze.load_results(epsilons_path='./results/modelA_haze/epsilons.csv')
# Load saved CSV results from 'Haze' analysis on 'ModelB'
modelB_haze = ContextualRobustnessTest(
model_path='./models/modelB.h5',
model_name='ModelB',
X=X,
Y=Y,
transform_fn=haze,
transform_name='Haze')
modelB_haze.load_results(epsilons_path='./results/modelB_haze/epsilons.csv')
# Generate individual 'epsilon' boxplots for each model
ContextualRobustnessReporting.generate_epsilons_plot(
modelA_haze,
outfile='./results/modelA_haze/epsilons.png')
ContextualRobustnessReporting.generate_epsilons_plot(
modelB_haze,
outfile='./results/modelB_haze/epsilons.png')
# Generate individual 'counterexample' plots for each model
ContextualRobustnessReporting.generate_counterexamples_plot(
modelA_haze,
outfile='./results/modelA_haze/counterexamples.png')
ContextualRobustnessReporting.generate_counterexamples_plot(
modelB_haze,
outfile='./results/modelB_haze/counterexamples.png')
# Generate individual 'class accuracy' line charts for each model
ContextualRobustnessReporting.generate_class_accuracy_plot(
modelA_haze,
outfile='./results/modelA_haze/class-accuracy.png')
ContextualRobustnessReporting.generate_class_accuracy_plot(
modelB_haze,
outfile='./results/modelB_haze/class-accuracy.png')
# Generate haze accuracy report comparing the transform on multiple models
ContextualRobustnessReporting.generate_accuracy_report_plot(
cr_objects=[modelA_haze, modelB_haze],
outfile='./results/haze-accuracy-report.png')
Formal Verification Technique¶
The formal verification technique uses the Marabou neural network verification framework to evaluate the model’s robustness to a transform encoded as a Marabou input query. This method provides the true “epsilon” and formal guarantees about the model’s robustness to the transform, however it takes significantly longer than the test-based method. Using the sample_indexes
option to select a subset of samples to test is recommended.
Formal Verification Technique: Model Preparation¶
Marabou relies on the output of the network’s logits layer, so if the network has a softmax output layer, the activation function will need to be removed from that layer. The remove_softmax_activation
function is supplied to do this for Tensorflow v2 models. The example below shows how to use remove_softmax_activation
to save a copy of the model without the softmax activation function on the output layer.
from contextual_robustness.utils import remove_softmax_activation
# save a copy the model without softmax activation function
remove_softmax_activation('./models/modelA.h5', save_path='./models/modelA-verification')
Formal Verification Technique: Analyzing a Model/Transform¶
import sys
from contextual_robustness import ContextualRobustnessFormal, ContextualRobustnessReporting
from contextual_robustness.transforms import encode_haze
# Instantiate ContextualRobustness object for modelA/haze
modelA_haze_formal = ContextualRobustnessFormal(
model_path='./models/modelA-verification', # (*required) path to model
model_name='ModelA', # name of model
model_args=dict(modelType='savedModel_v2'), # specify model type for marabou
transform_fn=encode_haze, # (*required) transform encoder function
transform_name='Haze', # name of transform
X=X, # (*required) np.array of images
Y=Y, # (*required) np.array of labels
sample_indexes=list(range(0,10)), # list of indexes of samples to test
marabou_options=dict(), # marabou options (e.g. if Gurobi support: dict(solveWithMILP=True))
verbosity=1 # amount of logging
)
# run analysis and save to CSV
modelA_haze_formal.analyze(
epsilons_outpath='./results/modelA_haze_formal/epsilons.csv',
counterexamples_outpath='./results/modelA_haze_formal/counterexamples.p')
Formal Verification Technique: Load & Visualize Results¶
from contextual_robustness import ContextualRobustnessFormal, ContextualRobustnessReporting
from contextual_robustness.transforms import encode_haze
# Load saved CSV results from 'Haze' analysis on 'ModelA'
modelA_haze_formal = ContextualRobustnessFormal(
model_path='./models/modelA-verification', # (*required) path to model
model_name='ModelA', # name of model
model_args=dict(modelType='savedModel_v2'), # specify model type for marabou
transform_fn=encode_haze, # (*required) transform encoder function
transform_name='Haze', # name of transform
X=X, # (*required) np.array of images
Y=Y, # (*required) np.array of labels
sample_indexes=list(range(0,10)), # list of indexes of samples to test
verbosity=0 # amount of logging
)
modelA_haze_formal.load_results(
epsilons_path='./results/modelA_haze/epsilons.csv',
counterexamples_path='./results/modelA_haze_formal/counterexamples.p')
# Generate individual 'epsilon' boxplots for each model
ContextualRobustnessReporting.generate_epsilons_plot(
modelA_haze_formal,
outfile='./results/modelA_haze_formal/epsilons.png')
# Generate individual 'counterexample' plots for each model
ContextualRobustnessReporting.generate_counterexamples_plot(
modelA_haze_formal,
outfile='./results/modelA_haze_formal/counterexamples.png')
Full Examples¶
Example code used to analyze and generate reports for the GTSRB models and CIFAR models from the DeepCert paper. The models and their descriptions can be found in the models folder, and the example analysis code can be found in the examples folder.


Can be useful for finding associations among different positions in a position-wise aligned sequence dataset. The approach adopted for finding associations among positions is based on the latent multivariate normal distribution.
| Version: | 1.0.1 |
| Depends: | R (≥ 3.3.0) |
| Imports: | mvtnorm |
| Published: | 2018-04-05 |
| Author: | Prabina Kumar Meher & A. R. Rao |
| Maintainer: | Prabina Kumar Meher <meherprabin at yahoo.com> |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| NeedsCompilation: | no |
| CRAN checks: | corrDNA results |
| Reference manual: | corrDNA.pdf |
| Package source: | corrDNA_1.0.1.tar.gz |
| Windows binaries: | r-devel: corrDNA_1.0.1.zip, r-release: corrDNA_1.0.1.zip, r-oldrel: corrDNA_1.0.1.zip |
| OS X binaries: | r-release: corrDNA_1.0.1.tgz, r-oldrel: corrDNA_1.0.1.tgz |
Please use the canonical form https://CRAN.R-project.org/package=corrDNA to link to this page.


| Drag a colum header and drop it here to group by that column | |||||
| ProductID | Product name | Unit price | Quantity per unit | Units in stock | Discontinued |
| 1 | Chai | $18.00 | 10 boxex x 20 bags | 39 | |
| 2 | Chang | $19.00 | 24 -12 oz bottles | 17 | |
| 3 | Aniseed Syrup | $10.00 | 12 - 550 ml bottles | 13 | |
| 4 | Cheaf Anton's Cajun Seasoning | $22.00 | 48 - 6 oz jar | 53 | |
| 5 | Cheaf Anton's Gumbo mix | $21.35 | 36 boxes | 0 | |
| 6 | Grandma Bousendberry Spread | $25.00 | 12 - 8 oz jar | 120 | |
| 7 | Uncle Bob Organic Dried Pairs | $30.00 | 12 - 1 lb pkgs. | 15 | |
| 8 | Northwoods Cranberry Sause | $40.00 | 12 - 12 oz jar | 6 | |
| 9 | Mishi Cobe Niku | $97.00 | 18 - 500 g pakgs. | 29 | |
| 10 | Icura | $31.00 | 12 - 200 ml jars | 31 | |
| 1 2 3 4 5 6 7 8 9 10.... Page size: 335104 items in 33511 pages |


Understanding npm
npm is the default package manager for Node.js. It was initially created to help developers manage dependencies for their JavaScript applications. Born as an open source project in 2009, npm features a package registry and client that enables developers to consume and distribute open source code.
Since its creation, the role of npm has expanded to fulfill the broader needs of the JavaScript and Node.js developer community to include management of front-end web applications, mobile applications and other JavaScript development tools and frameworks. Today, the npm project and registry is hosted and managed as a free service by npm, Inc, supporting more than a billion downloads a month.
This visualization is intended to help you understand the role and scope of npm.
npm Registry
This is the npm registry. Every time you download a package using npm install
,
you're downloading it from here – it's essentially a huge database containing each package's
files and associated metadata.
Packages
This is a package. Each package contains a little bit of JavaScript serving a particular purpose, and has useful metadata associated with it as well: its license type, a short description, GitHub repository, and so on.
Packages
npm has a lot of packages. Right now, there's 142,000 of them that have been published by the community.
Registry Growth
npm's growing significantly every day. Right now, there are about 5,925 new packages published per week. Of those, here's 32,768 of npm's most downloaded packages.
Downloads
Lots of packages means lots of downloads, too. In the last week alone, there's been a total of 353,296,858 package downloads from the registry.
Downloads
To give you an idea of what that's like, here's an illustration of each package downloaded at the current rate: each beam fired is roughly equivalent to 5 downloads.
Package Quality
npm's greatest strength, its size, is also its greatest weakness. There's too much code out there to conceivably digest on your own. However, there are a few quick checks you can make to narrow down the list of potential packages to use.
Package Quality
Let's separate the packages that are missing a readme. A readme is the central point of documentation for any package published to npm, and is more or less essential if you’d like to learn how it works.
Package Quality
And any packages that are missing a license field from their package.json. Unlicensed packages default to being copyrighted by the author, and as such are unusable in many commercial environments without permission.
Package Quality
It's important that packages link to a git repository that holds their original source. Without that, it becomes more difficult to review the code and submit improvements.
Package Quality
Finally, most packages need some kind of test script to survive changes submitted by the community. This won't always be the case, but can be a useful metric for a number of different kinds of packages.
Package Quality
After removing all of these, we're left with 100% of our original 32,768 packages that meet our criteria for "good quality modules", just a small fraction of our original sample.
Scatterplots
There's a lot more insight yet to be gained from the registry, though. Lets take a look at the data in a more traditional format: the scatterplot.
Downloads and Activity
If we look at each package's weekly download count based on their last publish date, we can see that recently updated packages appear to be much more popular overall. It's also worth noting that the vast majority of packages are dwarfed in their usage by a select few.
Stars and Activity
We can see a similar pattern by plotting out a project's GitHub stars instead of downloads, although there is a wider margin between the majority and the most popular packages.
Invisible Utilities
If we compare downloads and stars together, we can see that there's actually very little correlation between usage (downloads) and visibility (stars). This seems to imply that the really useful packages are "invisible" utilities. For example: core-util-is is downloaded 1,652,405 times a week, but only has 39 stars on GitHub. Conversely, hover.css has 9,608 stars but only 30 downloads per week.
We can divide our data into categories for a deeper understanding of behaviour specific to certain authors and communities.
Let's break things up based on license choice and look at dependency counts over time. You'll notice that WTFPL projects tend to use less dependencies, and that ISC only became popular when it became npm's default license choice.
If we look at downloads on a logarithmic scale we can see that MIT packages are more popular overall, and GPL-type licenses are slightly less popular amongst users than other choices.
Communities tend to share a package name prefix to identify themselves, for example grunt-contrib-watch and gulp-autoprefixer are Grunt and Gulp plugins respectively. Here we have our scatterplots grouped into npm's 48 most used prefixes.
You'll notice that react and ember packages use a lot of supporting tooling by the amount of development dependencies they use.
Or you can observe the relative activity of each community by plotting their total number of published versions per package on a logarithmic scale.
We're only scratching the surface here: npm is full of data waiting to be explored. You can start delving deeper by tweaking the inputs below.


New Zealanders to vote in referendum on legalising euthanasia
Legislators pass bill enabling terminally ill people to request a medically assisted death after years of debate.
New Zealand legislators passed a bill on Wednesday that would legalise euthanasia, paving the way for the public to vote on the issue in a referendum next year.
The bill, which enables terminally ill people to request a medically assisted death, was passed 69-51 in parliament, after several amendments and years of heated debate.
Previous attempts by legislators to legalise euthanasia have failed, and when the bill was introduced in parliament again in 2017 it was met with several concerns, including the possible vulnerability of elderly patients being coerced.
More:
-
Doctor in landmark euthanasia trial cleared by Dutch court
-
Should minors have euthanasia rights?
-
OPINION: Misplaced moral outrage over euthanasia
The bill has since been amended with what its sponsors say are safeguards, including a requirement that patients be diagnosed as having less than six months left to live.
The patient must be the first to suggest assisted dying, and two doctors must agree the patient is well-informed and other legal criteria are met.
The politician behind the bill, David Seymour of the libertarian ACT Party, said people who are genuinely concerned have absolutely nothing to fear as there are robust safeguards in place.
"It is entirely about choice. Just as their rights and choices are respected, they will also need to respect the choices of others," Seymour said.
Strong resistance
The fate of the law rests in the hands of New Zealanders who will vote in a referendum at the general election, which must be held by November next year.
The public will also be voting in a referendum over legalising recreational cannabis.
Recent polls have indicated a majority support the measure to legalise euthanasia.
However, there has also been strong resistance from faith-based organisations, medical professionals and others. The bill received 39,000 public submissions, most opposing it.
Opposition National Party politician Maggie Barry called it a "dangerous and permissive bill" and said it was important to stop it through the referendum.
Dozens of protesters opposing the law gathered outside Parliament on Wednesday holding placards that said "assist us to live, not die" and "euthanasia is not the solution".
Many countries have legalised euthanasia, including Canada, the Netherlands, Switzerland, and some US states.


Toggle navigation
Wzystal's Blog
Home
About
Tags
Tags
keep hungry keep foolish
Ubuntu
Java
Android
算法
LeetCode
生活
读书笔记
Ubuntu
Ubuntu系统下安装和配置JDK
如何在Ubuntu下，根据自己的需要来安装和配置JDK
Java
Ubuntu系统下安装和配置JDK
如何在Ubuntu下，根据自己的需要来安装和配置JDK
Android
安卓应用角标那些事儿
聊一聊安卓应用角标适配那些事儿
《Android开发艺术探索》读书笔记 - View的工作原理
探一探View的工作原理
基于Chipsee资料编译Android系统
基于Chipsee提供的相关资料编译出Android 4.0.3文件系统，并移植到Pandaboard ES开发板上运行
算法
LeetCode | Single Number II
Given an array of integers, every element appears three times except for one. Find that single one.
LeetCode | Single Number
Given an array of integers, every element appears twice except for one. Find that single one.
LeetCode | Copy List with Random Pointer
A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null. Return a deep copy of the list.
LeetCode | Word Break
Given a string s and a dictionary of words dict, determine if s can be segmented into a space-separated sequence of one or more dictionary words.
LeetCode | Word Break II
Given a string s and a dictionary of words dict, add spaces in s to construct a sentence where each word is a valid dictionary word. Return all such possible sentences.
LeetCode | Linked List Cycle
判断一个单链表是否有环，若有环的话，返回环的入口点。空间复杂度为O(1)
LeetCode | Reorder List
Given a singly linked list L: L0→L1→…→Ln-1→Ln, reorder it to: L0→Ln→L1→Ln-1→L2→Ln-2→… You must do this in-place without altering the nodes' values.
LeetCode | Binary Tree Traversal
分别使用递归、非递归方法，实现二叉树的先序、中序和后序遍历。
LeetCode | LRU Cache
Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.
LeetCode
LeetCode | Single Number II
Given an array of integers, every element appears three times except for one. Find that single one.
LeetCode | Single Number
Given an array of integers, every element appears twice except for one. Find that single one.
LeetCode | Copy List with Random Pointer
A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null. Return a deep copy of the list.
LeetCode | Word Break
Given a string s and a dictionary of words dict, determine if s can be segmented into a space-separated sequence of one or more dictionary words.
LeetCode | Word Break II
Given a string s and a dictionary of words dict, add spaces in s to construct a sentence where each word is a valid dictionary word. Return all such possible sentences.
LeetCode | Linked List Cycle
判断一个单链表是否有环，若有环的话，返回环的入口点。空间复杂度为O(1)
LeetCode | Reorder List
Given a singly linked list L: L0→L1→…→Ln-1→Ln, reorder it to: L0→Ln→L1→Ln-1→L2→Ln-2→… You must do this in-place without altering the nodes' values.
LeetCode | Binary Tree Traversal
分别使用递归、非递归方法，实现二叉树的先序、中序和后序遍历。
LeetCode | LRU Cache
Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.
生活
2017，新博客，心启航！
欢迎来到wzystal的新博客！
读书笔记
《Android开发艺术探索》读书笔记 - View的工作原理
探一探View的工作原理


Damian McCrory vows to help Notts County overcome 'major blip'
Magpies are looking for a response to heavy Barrow defeat
by Leigh CurtisDamien McCrory is determined to help Notts County respond to a “major blip” as he targeted a much-improved performance against Aldershot tomorrow.
The Magpies suffered their first home defeat since August last weekend when they were beaten 3-0 by Barrow in a performance that boss Neal Ardley admitted was below par.
But Notts have the chance to return to winning ways against struggling Aldershot as they look to cut the gap to leaders Barrow at the summit.
McCrory says the players were shown the video of last weekend’s defeat and they are more than aware of the problems they needed to address.
“The gaffer showed us the video and it was clear that it just was not good enough,” revealed McCrory.
“We were off it in both ways – with the ball and without it. It was a major blip and, as players, we’ve got to make sure it doesn’t happen again.
“We know what we did wrong and what was missing from last Saturday’s performance, so we need to make sure that it is there this weekend.
“A lot of lads were hurt so I think it will be a good learning process to make sure that it doesn’t happen again this season.
“Other teams won’t let us play nice football all the time – some will get in our faces like Barrow and we’ve got to do the horrible stuff as well.
“We have got to learn from last Saturday."
Notts’ task tomorrow has been made increasingly difficult as Aldershot will be fired up after suffering a 6-1 hammering at the hands of Dagenham last week.
Their manager Damon Searle pulled no punches in his criticism of their performance having blasted it as a disgrace and is eager for his players not to produce a repeat showing.
Having been on the end of big defeats before in his career, McCrory says the mindset of the Shots will be to ensure they are tough to beat.
But he says the main priority for Notts is to concentrate on their own game.
“I think they will be working on not conceding,” said the 29-year-old.
“I‘ve been beaten 5-0 in my career and you go back to basics to make sure you are solid and hard to break down.
“I can see that happening on Saturday, which is going to be another test for us.
“I think we have got to play our own game and be solid ourselves while trying to score goals.”


Many of the scripts that we've written so far perform the data processing tasks just fine, but the output has not been formatted properly. That is because there is only so much you can do with the basic print statement. And since one of awk's most common functions is to produce reports, it is crucial that we be able to format our reports in an orderly fashion. The filesum program performs the arithmetic tasks well but the report lacks an orderly format.
Awk offers an alternative to the print statement, printf, which is borrowed from the C programming language. The printf statement can output a simple string just like the print statement.
awk 'BEGIN { printf ("Hello, world\n") }'
The main difference that you will notice at the outset is that, unlike print, printf does not automatically supply a newline. You must specify it explicitly as "\n".
The full syntax of the printf statement has two parts:
printf ( format-expression [, arguments] )
The parentheses are optional. The first part is an expression that describes the format specifications; usually this is supplied as a string constant in quotes. The second part is an argument list, such as a list of variable names, that correspond to the format specifications. A format specification is preceded by a percent sign (%) and the specifier is one of the characters shown in Table 7.6. The two main format specifiers are s for strings and d for decimal integers.[11]
[11] The way printf does rounding is discussed in Appendix B.
| Character | Description |
|---|---|
| c | ASCII character |
| d | Decimal integer |
| i | Decimal integer. (Added in POSIX) |
| e | Floating-point format ([-]d.precisione[+-]dd) |
| E | Floating-point format ([-]d.precisionE[+-]dd) |
| f | Floating-point format ([-]ddd.precision) |
| g | e or f conversion, whichever is shortest, with trailing zeros removed |
| G | E or f conversion, whichever is shortest, with trailing zeros removed |
| o | Unsigned octal value |
| s | String |
| x | Unsigned hexadecimal number. Uses a-f for 10 to 15 |
| X | Unsigned hexadecimal number. Uses A-F for 10 to 15 |
| % | Literal % |
This example uses the printf statement to produce the output for rule 2 in the filesum program. It outputs a string and a decimal value found in two different fields:
printf("%d\t%s\n", $5, $9)
The value of $5 is to be output, followed by a tab (\t) and $9 and then a newline (\n).[12] For each format specification, you must supply a corresponding argument.
[12] Compare this statement with the print statement in the filesum program that prints the header line. The print statement automatically supplies a newline (the value of ORS); when using printf, you must supply the newline, it is never automatically provided for you.
This printf statement can be used to specify the width and alignment of output fields. A format expression can take three optional modifiers following "%" and preceding the format specifier:
%-
width
.
precision format-specifier
The width of the output field is a numeric value. When you specify a field width, the contents of the field will be right-justified by default. You must specify "-" to get left-justification. Thus, "%-20s" outputs a string left-justified in a field 20 characters wide. If the string is less than 20 characters, the field will be padded with whitespace to fill. In the following examples, a "|" is output to indicate the actual width of the field. The first example right-justifies the text:
printf("|%10s|\n", "hello")
It produces:
| hello|
The next example left-justifies the text:
printf("|%-10s|\n", "hello")
It produces:
|hello |
The precision modifier, used for decimal or floating-point values, controls the number of digits that appear to the right of the decimal point. For string values, it controls the maximum number of characters from the string that will be printed. Note that the default precision for the output of numeric values is "%.6g".
You can specify both the width and precision dynamically, via values in the printf or sprintf argument list. You do this by specifying asterisks, instead of literal values.
printf("%*.*g\n", 5, 3, myvar);
In this example, the width is 5, the precision is 3, and the value to print will come from myvar.
The default precision used by the print statement when outputting numbers can be changed by setting the system variable OFMT. For instance, if you are using awk to write reports that contain dollar values, you might prefer to change OFMT to "%.2f".
Using the full syntax of the format expression can solve the problem with filesum of getting fields and headings properly aligned. One reason we output the file size before the filename was that the fields had a greater chance of aligning themselves if they were output in that order. The solution that printf offers us is the ability to fix the width of output fields; therefore, each field begins in the same column.
Let's rearrange the output fields in the filesum report. We want a minimum field width so that the second field begins at the same position. You specify the field width place between the % and the conversion specification. "%-15s" specifies a minimum field width of 15 characters in which the value is left-justified. "%10d", without the hyphen, is right-justified, which is what we want for a decimal value.
printf("%-15s\t%10d\n", $9, $5) # print filename and size
This will produce a report in which the data is aligned in columns and the numbers are right-justified. Look at how the printf statement is used in the END action:
printf("Total: %d bytes (%d files)\n", sum, filenum)
The column header in the BEGIN rule is also changed appropriately. With the use of the printf statement, filesum now produces the following output:
$filesum g*
FILE BYTES g 23 gawk 2237 gawk.mail 1171 gawk.test 74 gawkro 264 gfilesum 610 grades 64 grades.awk 231 grepscript 6 Total: 4680 bytes (9 files)


{{ message }}
Since you are using a Twitter account, you don't need to set a password. You can set one later if you want.
Your {{ screen_name }} Twitter account will be associated with this account. (no thanks)


Our Team
Born and raised in Portland, OR, I spent the decade previous to enrolling in Epicodus working as a barista and making hip hop music. I'm passionate about art, community and social change, and am super stoked to be a part of this project and apply tech to the challenges of helping those who need it most!
Lil' Mike, the OG, born in San-Diego, CA, and still being raised in Vancouver, WA, is way ahead of his time. He is into soccer, technology and music. With a work background in the dental field as a CAD CAM technician, he decided it wasn't a life long career and enrolled in Epicodus.
Jordan is a real radical dude. He has been a dental technician, a child adolscent treatment specialist, went to school for building guitars, and studied drafting.
Ethan is a computer genius.
Last year I took a year off & traveled around the world. That adventure opened my eyes to the numerous daily struggles of people. Many areas of the world and our own country and local communites could beneift by the generosity of its citizens. I have been fortunate to have the opportunity to contribute to Change Collective as a platform. Now the average person can contribute a small amount to helping bring a positive change to thier area of interest and concern.


@* * Copyright 2021 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import uk.gov.hmrc.cbcrfrontend.controllers.routes @(enableLanguageSwitching: Boolean)(implicit messages: Messages) @if(enableLanguageSwitching) {
}


Preparation time
over 2 hours
Cooking time
over 2 hours
Serves
Makes 1 large tart
Rich chocolate mousse and ganache is balanced with the tangy citrus flavours of passionfruit in this extravagant tart.
For this recipe you will need a piping bag fitted with a 1cm/½in plain nozzle and an electric mixer.
For the pastry, put all the ingredients, except the egg white, in a food processor and briefly blitz to combine. Add a few drops of water and pulse to bring the dough together. Cover with cling film and chill for 20 minutes.
To make the macarons, blitz the ground almonds and icing sugar to a fine powder using a food processor. In a separate bowl, whisk the egg white until stiff peaks form when the whisk is removed. Add the caster sugar and whisk until glossy. Add a drop of the food colouring and stir through. Fold the powder mixture into the egg whites. Transfer to a piping bag fitted with a plain nozzle.
Line a baking tray with non-stick baking paper. Pipe small rounds of the macaron mixture about the size of a 10p coin then set aside until they form a skin. Preheat the oven to 160C/140C Fan/Gas 3.
Bake the macarons for 12-15 minutes, or until they are no longer sticky to the touch. Place the macarons on wire racks to cool.
Roll out the chilled pastry on a lightly floured work surface until it is about 4mm thick. Line a 23cm/9in tart tin with the pastry. Chill for 20 minutes.
Preheat the oven to 200C/180C Fan/Gas 6.
For the passion fruit layer, put all the ingredients in a saucepan and whisk gently over a low heat until it thickens.
Line the pastry case with baking parchment and fill with baking beans. Bake for 10 minutes, then remove from the oven and reduce the temperature to 180C/160C Fan/Gas 4. Remove the baking beans and brush the pastry with the egg white.
Pour in the passion fruit layer and return to the oven for 10 minutes, or until set. Allow to cool slightly then place in the fridge to chill.
For the chocolate mousse layer, melt the chocolate drops, butter and marshmallows together until combined. Leave to cool.
Whip the cream until stiff peaks form when the whisk is removed. Fold in the chocolate mixture then whisk it in the bowl of a freestanding mixer for approximately 10 minutes, or until very pale in colour and fluffy. Pour on top of the passion fruit layer, smooth the surface and chill again.
To make the jelly, combine the sugar and passion fruit in a pan with 100ml/3½fl oz water. Bring to the boil then squeeze any excess water from the gelatin and add to the pan. When the gelatin is dissolved, pour the mixture into a 23cm/9in sandwich tin lined with cling film. Chill until set.
To make the buttercream for the macarons mix all the ingredients together until smooth. Transfer to a piping bag fitted with a 1cm/½in plain nozzle. Use the buttercream to sandwich the macarons together.
For the passion fruit ganache, heat the cream in a pan then add the chocolate drops. When the chocolate is melted, stir in the passion fruit, leave to cool slightly then smooth on top of the chocolate mousse and chill in the fridge until set.
To assemble the tart, cut the jelly into cubes. Decorate the top of the tart with the macarons, some squares of jelly and pansies.


Male
Sunday: Kwasi
Monday: Kwadwo
Tuesday: Kwabena
Wednesday: Kwaku
Thursday: Yaw
Friday: Kofi
Saturday: Kwame
Female
Sunday: Akosua
Monday: Adwoa
Tuesday: Abenaa
Wednesday: Akua
Thursday: Yaa
Friday: Afua
Saturday: Ama
Sunday: Kwasi
Monday: Kwadwo
Tuesday: Kwabena
Wednesday: Kwaku
Thursday: Yaw
Friday: Kofi
Saturday: Kwame
Sunday: Akosua
Monday: Adwoa
Tuesday: Abenaa
Wednesday: Akua
Thursday: Yaa
Friday: Afua
Saturday: Ama


Gen 4S
This watch has a digital smartwatch timepiece. The clock face is digital adjustable and covered with lcd glass. The strap is made of silicone.
Contour Horloge
This watch has a quartz timepiece. The clock face is black and covered with mineral glass. The strap is made of plastic
Remix Horloge
This watch has a quartz timepiece.  The strap is made of stainless steel


This application allows you to find GO-JEK drivers around a certain area.
You can use the search button on the left to enter your area/city (e.g. Bandung or Jakarta). You will need to zoom the map to get a better view of the drivers.
DISCLAIMER: THIS APP IS NOT AFFILIATED IN ANY WAY WITH GO-JEK. USE IT AT YOUR OWN RISK. THE APP IS PROVIDED AS-IS WITHOUT ANY GUARANTEE.


| Properties' Summary |
::com::sun::star::util::Color
BackgroundColor |
specifies the background color (RGB) of the control.
|
short
Border |
specifies the border style of the control.
|
long
BorderColor |
[ OPTIONAL ]
specifies the color of the border, if present
|
boolean
Enabled |
determines whether the control is enabled or disabled.
|
string
HelpText |
specifies the help text of the control.
|
string
HelpURL |
specifies the help URL of the control.
|
string
ImageURL |
specifies an URL to an image to use for the control.
|
[ transient ] ::com::sun::star::graphic::XGraphic
Graphic |
[ OPTIONAL ]
specifies a graphic to be displayed on the control
|
boolean
Printable |
specifies that the control will be printed with the document.
|
boolean
ScaleImage |
specifies if the image is automatically scaled to the size of the
control.
|
short
ScaleMode |
[ OPTIONAL ]
defines how to scale the image
|
boolean
Tabstop |
[ OPTIONAL ]
specifies that the control can be reached with the TAB key.
|
| Properties' Details |
BackgroundColor
::com::sun::star::util::Color BackgroundColor;
- Description
- specifies the background color (RGB) of the control.
|
|
Border
short Border;
- Description
- specifies the border style of the control.
0: No border
1: 3D border
2: simple border
|
|
BorderColor
long BorderColor;
- Usage Restrictions
- optional
- Description
- specifies the color of the border, if present
Not every border style (see Border) may support coloring.
For instance, usually a border with 3D effect will ignore the BorderColor setting.
- Since
- OOo 2.0
|
|
Enabled
boolean Enabled;
- Description
- determines whether the control is enabled or disabled.
|
|
HelpText
string HelpText;
- Description
- specifies the help text of the control.
|
|
HelpURL
string HelpURL;
- Description
- specifies the help URL of the control.
|
|
ImageURL
string ImageURL;
- Description
- specifies an URL to an image to use for the control.
- See also
- Graphic
|
|
Graphic
[ transient ] ::com::sun::star::graphic::XGraphic Graphic;
- Usage Restrictions
- optional
- Description
- specifies a graphic to be displayed on the control
If this property is present, it interacts with the ImageURLin the
following way:
- If ImageURL is set, Graphic will be reset
to an object as loaded from the given image URL, or NULL if ImageURL
does not point to a valid image file.
- If Graphic is set, ImageURL will be reset
to an empty string.
- Since
- OOo 2.1
|
|
Printable
boolean Printable;
- Description
- specifies that the control will be printed with the document.
|
|
ScaleImage
boolean ScaleImage;
- Description
- specifies if the image is automatically scaled to the size of the
control.
|
|
ScaleMode
short ScaleMode;
- Usage Restrictions
- optional
- Description
- defines how to scale the image
If this property is present, it supersedes the ScaleImage property.
The value of this property is one of the ImageScaleMode constants.
- Since
- OOo 3.1
|
|
Tabstop
boolean Tabstop;
- Usage Restrictions
- optional
- Description
- specifies that the control can be reached with the TAB key.
- Since
- OOo 1.1.2
|
|
Copyright © 2013, The Apache Software Foundation, Licensed under the Apache License, Version 2.0. Apache, the Apache feather logo, Apache OpenOffice and OpenOffice.org are trademarks of The Apache Software Foundation. Other names may be trademarks of their respective owners.


Discover a Space Between
A hybrid Exhibition to highlight how digital exhibit companion pieces can increase engagement, accessibility and understanding of artists' work.
Problem Statement
The Coronavirus has brought the physical art world to a halt.1 Since the onset of COVID-19, 92% of Minnesota Art Organizations have reported canceled events, with an estimated loss of 2,351,612 attendees. Americans for the Arts has found that out of those Minnesota organizations, 11% are not confident their organizations will survive the impact of COVID-19.2
In response to the changing time, many organizations are quickly increasing their online presence and making artwork more accessible through digital means. The use of online viewing rooms and virtual tours is rising, becoming more and more common from large and small organizations alike.3
Despite this, there will always be a desire for collectors and art viewers to have an in-person experience and to be able to physically interact with works of art. The transition from Coronavirus to a new normal will likely reveal a new hybrid exhibition approach of physical and digital in the future.4 For artists delving into New Media Art, this presents a special opportunity to expand their influence and enhance viewers understanding of their work and process.
The aim of my capstone project is to show how digital exhibition companion pieces can increase engagement and accessibility, specifically in regards to New Media artists' work, in times of social distancing and beyond, creating tools that can be used both online and in the exhibition space to engage the viewers and enhance the understanding of their work.
Questions and Inspirations
In February 2020, I attended the CoExhibition’s Interior Violence, the first solo exhibition of artist Meg Lionel Murphy’s work. From the pink walls to the delicate details along the floor and various points on the walls, I was transfixed by the way these details created an intimacy with the paintings and how they enhanced my overall experience of the artist’s work.
Fast forward a few weeks and the world found itself in a much different reality, where attending in person exhibitions was no longer possible, due to a stay-at-home order during the rise of the COVID-19 pandemic.During this stay-at-home order, my mind wandered back to the show, and to the show that was supposed to follow, which, of course, I never had a chance to see. The impact on the gallery, as well as the artists, felt significant.
With these restrictions in place, I began to notice how unengaging a traditional exhibition website could be. They typically hold a brief overview of the work with single images and the title and prices below the piece. With the recent exhibition in mind, I wondered if you could bring in the doll houses and horses that line the floor and shelves next to the paintings through digital means. Could there be digital coloring books or animated horses galloping by as you scroll through the pages?
This is where the idea for my capstone project originated - how to create an engaging experience on the website exhibition page that allows a viewer to get a glimpse of the details that make the exhibition or work special.
Tools
- Paper, Pencil, Pens
- Apple iPad and Apple Pencil
- MacBook Pro
- Adobe Draw
- Photoshop
- Atom Text Editor
- HTML, CSS, javascript
- p5.js
- After Effects
Process
I took this concept and set out to explore it with my own work. I took in the feedback from my previous exhibition, Infinite Abyss in Motion Millyard show at Stonebridge Lofts. The works featured were my Computational Drawings created with p5.js. Some of the viewers had trouble understanding how the pieces were made. Were they drawings? Were they made by the computer? If so, how?
I felt an appropriate digital companion piece to a physical exhibition would be a drawing tool that aims to help the viewer get an inside look at how these drawings are being created. The drawing tool would also allow the viewer to interact with the work, seeing firsthand how the designs can be transformed and altered with just a few small changes, thus creating an active versus passive viewing experience.
I have been working with p5.js and exploring Computational Aesthetics since my introduction to the topic during the Experimental Interaction course taught at MCAD in 2015. Below are a few of my first computational sketches that were created during the course.
What I found so engaging was the ability the program gave me to create delicate lines, similar to a pencil drawing. I wanted to build this drawing tool with my aesthetic in mind and demonstrate why I find the world of computational drawings to be so transfixing.
My initial concept/thoughts for the Drawing Tool are sketched above. I envisioned the tool to be accessed in person or from home. I knew from the beginning I wanted the user to have easy control through sliders or knobs, so that no technical knowledge or background in coding was needed to manipulate the drawing tool.
When thinking about the sketch the drawing tool would manipulate, I went back to some of my earlier works from 2017. I was drawn to this earlier composition because of its contained circle composition. You could get a variety of outputs by keeping the final output within the sketch boundaries.
With the sketch decided on, I set out to connect it to sliders through the p5.js canvas interface.
Once the basic functionality was set, I began to increase the complexity of the tool. I was able to use input from my Expert Feedback and User Testing to enhance the continued development of the tool.
Weekly Process Summary can be found documented on my Progress Platform
User Testing and Research
Throughout the building process, I collected Expert and User Testing. Below is a summary of the feedback received that helped create the final product.
Expert Feedback Implemented
Kobby Appiah Creative Technology Director at KNOCK, Inc. MCAD Adjunct Faculty teaching Coding Concepts in the Web and Multimedia Environments program.
- p5.js over Processing
- Restructure so that Sliders and Drawing are in separate containers. Allows for the sketch to be downloaded as an image without the sliders.
- Invert option
- Changing colors on the objects so users can quickly identify which shape is being manipulated
- Reduce framerate
- Goal should be to get the drawing to the point where it doesn't bog down the sliders
- Changelog
Ken Korth Senior Software Engineer at SPS Commerce
- Idea to incorporate Chaos
User Testing Feedback Implemented
User Group The users selected for testing ranged in age from 20's-60's. The selected user audience was a group who has, or would likely, attend an Exhibition of mine. User knowledge ranged from Professional Programmers to those with a more basic understanding of web technology.
Issues/Suggestions Implemented- 4 noted the Translate and Invert buttons are sticking
- 4 mentioned Lack of Slider names
- Slider Values (1 User did not find them necessary, 1 User noted liking them)
- 1 user noted that they did not know what "invert" meant in this context at first
- 1 user noted not being sure what Translate meant and how to use that slider
- Slider for color integration
- 4 users spent an average of 5-15 minutes playing with the tool
- 3 users noted they liked the Rotate, Translate, and Invert options
- 4 Users noted that there are a large variety of output options
- 3 Users noted they would like to share and save the images created
Along with collecting the user feedback, I used my own traditional working methods to influence the final Drawing Tool. In the process shown below, while working towards creating one of the final printed pieces for the exhibition, I realized how important the Translate and Rotate functionality was to creating my final works. Consequently, this functionality was built into the Drawing Tool.
Please find my full Research Documentation here.
Deliverables
For this project, I created three final deliverables: The Drawing Tool, a Physical Exhibition prototype, and the Exhibition Website that houses the exhibition work summary and final Drawing Tool.
Drawing Tool
Physical Exhibition
The physical exhibition required 5 framed pieces, an iPad formatted version of the Drawing Tool, an exhibition poster, and a physical install of the works and digital companion piece.
The Physical Exhibition was installed in MCAD's Main Building in the month of November. The final Exhibition photos can be found on the Exhibition Website.
Exhibition Website
Link to Exhibition Summary PageSummary
During the first half of 2020, online sales made up 37% of total sales for the gallery sector, compared with only 10% of total online sales in 2019. The gallery sector has long lagged behind in converting sales to the online marketplace. But with the restrictions set out by the COVID-19 pandemic, many have been forced to rethink their online strategies. In the market research report published by Art Basel and USB, it found that online sales from a new audience (one who did not previously interact with the gallery) was largest for smaller galleries. This means there is room for smaller, local galleries, to utilize digital methods to capture the interest of new and existing audiences. This will widen the reach for the artists and galleries alike.
The exploration of Discover a Space Between serves as a prototype example of how a gallery could conceptualize and integrate digital companion pieces into a physical exhibition. As noted in form + code, “Games can be physically engrossing and socially engaging, and they can sustain intense fascination of a period of months”. By creating a digital companion piece with which users can engage, a gallery can not only enhance the users’ understanding of the work, but also draw their interest, increasing the chances of their sharing the work, thus allowing the work to be seen by a wider audience than it otherwise would. This is one solution, of many that can be created, for discovering a space that exists between the physical and the digital gallery experience.
Endnotes
- "The Economic Impact of Coronavirus on the Arts and Culture Sector," Americans for the Arts, accessed September 23, 2020, https://www.americansforthearts.org/by-topic/disaster-preparedness/the-economic-impact-of-coronavirus-on-the-arts-and-culture-sector
- Dominic-Madori Davis, "No more ritzy galas, dinner parties, or jet-set fairs: The art world is coming to terms with a 'shelter-in-place' market. 5 insiders reveal how the industry is faring — and their hopes for what's next," Business Insider, June 13, 2020, https://www.businessinsider.com/how-5-key-art-industry-insiders-are-handling-coronavirus-pandemic-2020-5
- Americans for the Arts, "The Economic Impact of Coronavirus on the Arts and Culture Sector."
- Americans for the Arts, "The Economic Impact of Coronavirus on the Arts and Culture Sector."
Please find my full Bibliography here.


SUMMER NIGHT
"The warm bronze sunlight was swallowed by the horizon. The bright sunny day engulfed in darkness. A beautiful darkness. A darkness where my laughter lines illuminated and seemed to turn from creaks to craters as I smiled at the scintillating
moon. The warm night tired me and I closed my eyes. Somewhere in the distance an owl sounded, awakening the nocturnal nature. The lustrous, dancing stars glinted in the sky, brightening it even more. I feel there is no such thing as darkness,
as long as the moon is iridescently shining and the stars gleam above me, I am never completely in darkness."
Tao Minta
Wollongong - 08/08/1966


It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using 'Content here, content here', making it look like readable English.
Availability: In Stock Size: SM, XL Colors: Green, Red, Black, Grey Add to cart Add to wishlistIt is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using 'Content here, content here', making it look like readable English.
| Weight: | 0.15 Kg |
| Dimensions: | 100 x 37 x 100 cm |
| Materials: | 80% cotton, 20% linen |
| Size: | S, M, XL |
| Other Info: | Lorem ipsum dolor sit amet. |
Mark Smith
Nov. 12, 2016 at 11:15: AMLorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat.
Mark Smith
Nov. 12, 2016 at 11:15: AMLorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat.


Easy 3D printing of Braille
Wherein I digress
Taking a break from the usual book review, I thought I would talk about something cool that turned out to be very easy, thanks to my local library.
I was talking to my instructor at the wonderful Hadley School for the Blind, a correspondence school for blind people and those with low-vision (and their families). We were discussing clothing markers, which are attached to hangers and used to distinguish colours (blue, black, brown, etc.) when you can’t see them. There are various ways of doing this, using raised markers on paper or plastic tags, using Braille on tags, and there are several commercial solutions out there for this, as well.
Something I have been thinking about as a librarian is the 3D printer revolution that is happening in libraries across Canada and around the world.
An aside:
Seriously, check out your local public library to see if they have a 3D printer in their "maker space" or "innovation lab". They are often inexpensive ways of making things like art or replacement parts for that pesky stroller thingy.
If your library doesn't have some a) ask them to get one (they just might, unless they are being bled a slow budgetary death, which many are) or b) ask around your community to see if there is a hack lab nearby. These are places where interested members come together, usually on a Tuesday, to make stuff and help each other learn new skills.
Anyway, the conjunction of these two thoughts led me to think that 3D printing Braille clothing tags was a (nearly) obvious solution.
Two problems: I don’t read Braille (yet, though I am learning) and all I knew about 3D printing was that it’s a thing. So, what’s to do? Ask the Internet, of course.
The answer, of course, is on GitHub, where user v01pe posted a tool to generate text to 3D printable Braille. How awesome is that? It’s an online tool – in German – that creates a downloadable file for a 3D printer.
So, I input my text and kept contracted Braille, the default, selected. I waited for a while, about a minute or so, and there was a downloadable STL file. I put it on a thumb drive and beetled off to the maker space in my public library.
The guy who worked there said the files were fine and ready to use. He set them up for me, trying various configurations to shorten the printing time (I was printing two of them at once), and let me choose a bright red plastic to print them in.
A couple of hours later, and I had printed Braille! [S]ee very short video.](https://youtu.be/7SZFlv8hcZc)
I snapped off the extra printed base (you can see it on the printer shot, above) from one of them, but left the base on the other one so it could stand up.
It was fun and easy and made me feel clever, which doesn’t always happen a lot. 🙂 Even better: the plastic they use is biodegradable, although chemically stable for a number of years.
Clever AND virtuous.
Now, for it to be useful for my original purpose – clothing markers – I would need to learn a bit more: how to extend the piece and add a little hole to put the hanger’s head through. The library offers “3D printer certification” workshops, where they teach you the software and how to use it. I think I will sign up.