text:
# `UrlPatternIndex` overview

The UrlPatternIndex component can be used to build an index over a set of URL
rules, and speed up matching network requests against these rules.

A URL rule (see `flat::UrlRule` structure) describes a subset of network
requests that it targets. The essential element of the rule is its URL pattern,
which is a simplified regular expression (a string with wildcards).
`UrlPatternIndex` is mainly based on text fragments extracted from the patterns.

The component uses the [FlatBuffers serialization
library](https://google.github.io/flatbuffers/) to represent the rules and the
index. The key advantage of the format is that it does not require
deserialization. Once built, the data structure can be stored on disk or
transferred, then copied/loaded/memory-mapped and used directly.

# Detailed design

## `UrlPattern`s

The component is built around an underlying concept of a URL pattern, defined in
the class `UrlPattern`. These patterns are largely inspired by patterns in
[EasyList / Adblock Plus filters](https://adblockplus.org/filter-cheatsheet) and
are documented in more detail in the [declarativeNetRequest
documentation](https://developer.chrome.com/docs/extensions/reference/declarativeNetRequest/#type-RuleCondition).

## Building the index

The underlying goal of the index format is to efficiently check to see if URLs
match any URL patterns contained in the index. The data structure used here is
an N-gram filter. An N-gram is a string consisting of N (up to 8) bytes. Currently,
the component has chosen to use [`kNGramSize = 5`](https://source.chromium.org/chromium/chromium/src/+/main:components/url_pattern_index/url_pattern_index.h;drc=e89a43f45befc5c8e549d765018524d2f81c8765;l=54).

The strategy used in this component is to build a data structure which maps
`NGram -> vector<UrlRule>`, by finding all N-grams associated with a given URL
pattern, and picking one of them (the most distinctive one, see
`UrlPatternIndexBuilder::GetMostDistinctiveNGram`). The URL pattern is then
inserted into the map associated with that N-gram.

Note: URL patterns have special characters like `*` and `^` which implement
special wildcard matching. N-grams are built only _between_ these special
characters.

For example, the URL pattern `foo.com/*abc*` will generate the following 5-grams:
```
foo.c
oo.co
o.com
.com/
```

See
[url_pattern_index.fbs](https://source.chromium.org/chromium/chromium/src/+/main:components/url_pattern_index/flat/url_pattern_index.fbs)
for the raw underlying Flatbuffers format which builds the N-gram filter using a
[custom hash table](https://source.chromium.org/chromium/chromium/src/+/main:components/url_pattern_index/closed_hash_map.h)
implementation.

## Querying the index

Querying a built index is very similar to building the index in the first place.
Given a URL, it is broken into all of it's component N-grams, just like the URL
pattern was above. For example, the URL `https://foo.com/?q=abcdef` would
generate the following 5-grams:
```
https
ttps:
tps:/
ps://
s://f
://fo
//foo
/foo.
foo.c
oo.co
o.com
.com/
com/?
om/?q
m/?q=
/?q=a
?q=ab
q=abc
=abcd
abcde
bcdef
```
With these N-grams extracted, we can just consider all of the `UrlPattern`s
which are associated with those N-grams. See `FindMatchInFlatUrlPatternIndex`
and `FindMatchAmongCandidates` for this logic.

Many of these N-grams match ones that are also present in the `foo.com/*abc*`
example above , so we can be sure that that URL pattern will be considered
during pattern evaluation.

## Fallback rules
You might be thinking "what about URLs whose length is less than N, or
patterns that generate no N-grams?" We will make sure to put all rules like that
into a special list called the `fallback_rules` which are applied to every URL
unconditionally.

## Checking an individual `UrlPattern`

This logic is encapsulated in `UrlPattern::MatchesUrl`. This essentially
consists of splitting a URL pattern by the `*` wildcard, and considering each
subpattern in between the `*`s.

There is some complexity here to deal with:
- `^` separator matching, which matches any ASCII symbol except letters, digits,
  and the following: `'_', '-', '.', '%'`. See
  [fuzzy_pattern_matching](https://source.chromium.org/chromium/chromium/src/+/main:components/url_pattern_index/fuzzy_pattern_matching.h).
- `|` Left/right anchors, which specifies the beginning or end of a URL.
- `||` Domain anchors, which specifies the start of a (sub-)domain of a URL.

After all this complexity is dealt with, the bulk of the subpattern logic is
simply `StringPiece::find / std::search`! This component used to use something
much more complicated ([Knuth-Morris-Pratt
algorithm](https://en.wikipedia.org/wiki/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm)),
but benchmarking on real URLs proved the simple solution was more optimal (and
removed the need for a preprocessing step at indexing time), so it was
[removed](https://codereview.chromium.org/2793993002/).

For example, in checking if `https://foo.com/?q=abcdef` matches `foo.com/*abc*`,
the component will:

- Split the URL pattern into two pieces: `foo.com/` and `abc`.
- Try to find `foo.com/` in `https://foo.com/?q=abcdef`, which is a match!
- Remove the matching prefix
- Try to find `abc` in `?q=abcdef`, which is a match! This is the last pattern,
  so return true

repository: chromium/chromium

repo_name: chromium/chromium


text:
[![Build Status](https://travis-ci.org/vadimdemedes/cancan.svg?branch=master)](https://travis-ci.org/vadimdemedes/cancan)

> Authorize easily.

CanCan provides a simple API for handling authorization of actions.
Permissions are defined and validated using simple `allow()` and `can()` functions respectively.

CanCan is inspired by Ryan Bates' [cancan](https://github.com/ryanb/cancan).

## Installation

```
$ npm install --save cancan
```

## Usage

```js
const CanCan = require('cancan');

const cancan = new CanCan();
const {allow, can} = cancan;

class User {}
class Product {}

allow(User, 'view', Product);

const user = new User();
const product = new Product();

can(user, 'view', product);
//=> true

can(user, 'edit', product);
//=> false
```

## API

### allow(model, action, target, [condition])

Adds a new access rule.

#### model

Type: `class` (`function`)

Configure the rule for instances of this class.

#### action

Type: `array|string`

Name(s) of actions to allow.
If action name is `manage`, it allows any action.

#### target

Type: `array|class|string`

Scope this rule to the instances of this class.
If value is `"all"`, rule applies to all models.

#### condition

Type: `object|function`

Optional callback to apply additional checks on both target and action performers.

Examples:

```js
// allow users to view all public posts
allow(User, 'view', Post, {public: true});

// allow users to edit and delete their posts
allow(User, ['edit', 'delete'], Post, (user, post) => post.authorId === user.id);

// allow editors to do anything with all posts
allow(Editor, 'manage', Post);

// allow admins to do anything with everything
allow(AdminUser, 'manage', 'all');
```

### can(instance, action, target[, options])

Checks if the action is possible on `target` by `instance`.

#### instance

Type: `object`

Instance that wants to perform the action.

#### action

Type: `string`

Action name.

#### target

Type: `object`

Target against which the action would be performed.

#### options

Type: `object`

Additional data for the rule condition.

Examples:

```js
const user = new User();
const post = new Post();

can(user, 'view', post);
```

With the use of 'options' parameter
```js
const admin = new User({role: 'administrator'});
const user = new User({role: 'user'});

allow(User, 'update', User, (user, target, options) => {
	if (user.role === 'administrator') {
		return true;
	}

	// Don't let regular user update their role
	if (user.role === 'user' && options.fields.includes('role')) {
		return false;
	}

	return true;
});

can(admin, 'update', user, {fields: ['role']);
//=> true

can(user, 'update', user, {fields: ['username']);
//=> true

can(user, 'update', user, {fields: ['role']);
//=> false
```

### cannot(instance, action, target[, options])

Inverse of `.can()`.

### authorize(instance, action, target[, options])

Same as `.can()`, but throws an error instead of returning `false`.

## License

MIT © [Vadim Demedes](https://github.com/vadimdemedes)

license: MIT

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

license_type: permissive


text:
---
layout: page
title: About
permalink: /about/
---

Some of the cool stuff I work with:

* [SymbiFlow](https://symbiflow.github.io)
* [TensorFlow Lite for Microcontrollers](https://groups.google.com/a/tensorflow.org/g/micro)
* [RISC-V](https://riscv.org/)
* [Renode](https://renode.io/)

More links:

* [Fomu](https://fomu.im)
* [Litex](https://github.com/enjoy-digital/litex/wiki)

branch_name: refs/heads/main


text:
# OpenShift4-tools

[Robert<EMAIL_ADDRESS>tools for installing
etc. OpenShift 4 clusters.

## Cluster utilities

- *oinst*: OpenShift 4.x installer wrapper, currently for AWS and libvirt.

  You may want to install kubechart
  (github.com/sjenning/kubechart/kubechart) and oschart
  (github.com/sjenning/oschart/oschart) to monitor the cluster as it
  boots and runs.

  I welcome PRs to extend this to other platforms.

- *waitfor-pod*: wait for a specified pod to make its appearance (used
  as a helper by *oinst*).

- *bastion-ssh* and *bastion-scp* -- use an ssh bastion to access
   cluster nodes.

- *install-custom-kubelet* -- install a custom kubelet into a cluster.

- *set-worker-parameters* -- set various kubelet parameters and wait
  for the operation to complete

- *clean-cluster*: clean up a libvirt cluster if
  `openshift-install destroy cluster` doesn't work.

- *get-first-master*: find the external IP address first master node of
  a cluster.

- *get-masters*: get the external IP addresses of all of the master
  nodes of a cluster.

- *get-nodes*: get the external (if available) or internal IP address
  of each node in a cluster.

## Testing tools

- *clusterbuster* -- generate pods, namespaces, and secrets to stress
  test a cluster.

- *monitor-pod-status* -- periodically print summary information about
  objects generated by *clusterbuster*.

## General information tools

- *openshift-release-info* -- get various information about one or
  more releases.

- *get-container-status*: retrieve the status of each running
  container on the cluster.

- *get-images*: retrieve the image and version of each image used by
  the cluster.


text:
## Batches

### Catalog

`/datasets/{id}/batches/`

A GET on this resource returns a Shoji Catalog enumerating the batches present in the Dataset. Each tuple in the index includes a "status" member, which may be one of "analyzing", "conflict", "error", "importing", "imported", or "appended".

```json
{
    "element": "shoji:catalog",
    "self": "...datasets/837498a/batches/",
    "index": {
        "0/": {"status": "appended"},
        "2/": {"status": "error"},
        "3/": {"status": "importing"}
    }
}
```

A POST to this resource adds a new batch. The payload can be be a Crunch Table (with variable metadata, row data, or both), the URI of a Source, or the URI of another dataset (provided that the authenticated user has view permissions). All added rows regardless of source obtain the same batch id. A 201 indicates success, and returns the URL of the new batch in the Location header.

If the append operation takes more than two minutes, 202 is returned instead and the batch will continue being appended in the background. The Location header is still returned, pointing to the new batch's URL. The client can GET that URL to query its status.

Batches are created in `analyzing` status and will be advanced through `importing`, `imported`, and `appended` status if there are no problems. If there was a problem in processing it, its status will be `conflict` or `error`.

Note that the status code will always be 202 for asynchronous or 201 for synchronous creation of the batch whether there were conflicts or not. So you need to GET the new batch's URL to see if the data is good to go (status `appended`).

#### Appending a dataset

Must contain the URL of a dataset that the current user can read. This action will create a Source entity mapping to such dataset. Its name and description will match the dataset's name and description respectively at that moment.

```json
{
  "element": "shoji:entity",
  "body": {
      "dataset": "<url>"
  }
}
```

If you wish to include only certain variables from the source dataset you're appending from, you can include an ``function`` in the body of the entity.  The function should be a ZCL function name.  Its arguments should be present in the ``args`` key in the body.

```json
{
  "element": "shoji:entity",
  "body": {
      "dataset": "<url>"
      "function":"select",
      "args": [
                {"map":
                    {"000001": {'variable': "<url>"},
                     "000002": {'variable': "<url>"}}
                }
                ],
  }
}
```

#### Appending a source

Must contain the URL of a source that a user can read.

```json
{
  "element": "shoji:entity",
  "body": {
      "source": "<url>"
  }
}
```

#### Appending a Crunch Table

The variables IDs must match those of the target dataset since their types will be matched based on ID. The data is expected to match the target dataset's variable types. This action will create a new Source entity, its name and description will match those provided on the JSON response, if not provided they'll default to empty string.

```json
{
  "element": "crunch:table",
    "name": "<optional string>",
    "description": "<optional string>",
    "data": {
      "var_url_1": [1, 2, 3, ...],
      "var_url_2": ["a", "b", ...]
    }
}
```

#### Managing Append Failures

In case of failures while appending the batch, the dataset will be automatically reverted
back to the state it was before the append and the batch is automatically deleted.

This behaviour can be changed by providing a `autorollback: false` value into the POST
performed to append the data. When `autorollback: false` is provided a savepoint to which
user can revert to is still created, but the dataset is left in errored state for inspection.
The user can then manually revert to the savepoint and delete the associated batch.

```json
{
  "element": "shoji:entity",
  "autorollback": false,
  "body": {
      "source": "<url>"
  }
}
```

In case of appending to an empty dataset you might want to avoid the cost of creating
a savepoint at all as reverting to it will just lead to an empty dataset which you probably
just want to delete, in such case a `savepoint: false` value can be provided which will
totally disable the savepoint support:

```json
{
  "element": "shoji:entity",
  "savepoint": false,
  "body": {
      "source": "<url>"
  }
}
```

#### Checking if an append will cause problems

`/datasets/{id}/batches/compare/`

An append cannot proceed if there are any conditions in the involved datasets
that will cause ambiguous situations. If such datasets were to be appended
the server will return a 409 response.

It is possible to verify these conditions before trying the append using
the batches compare endpoint.

```
GET /datasets/4bc6af/batches/compare/?dataset=http://app.crunch.io/api/datasets/3e2cfb/
```

The response will contain a conflicts key that can contain either `current`,
`incoming` or `union` depending on the type and location of the problem. The response status
will always be 200, with conflicts, described below, or an empty body.

 * `current` refers to issues find on the dataset where new data would be added
 * `incoming` has issues on the far dataset that contains the new data to add
 * `union` expresses problems on the combined variables(metadata) of the final dataset after append.

```json

{
    "union": {...},
    "current": {...},
    "incoming": {...}
}

```

A successful response will not contain any of the keys returning an empty object.

```json

{}

```

The possible keys in the conflicts and verifications made are:

* **Variables missing alias**: All variables should have a valid alias string. This will indicate the IDs of those that don’t.
* **Variables missing name**:  All variables should have a valid name string. This will indicate the IDs of those that don’t.
* **Variables with duplicate alias**: In the event of two or more variables sharing an alias, they will be reported here. When this occurs as a _union_ conflict, it is likely that names and aliases of a variable or subvariable in _current_ and _incoming_ are swapped (e.g., VariantOne:AliasOne, Variant1:Alias1 in current but VariantOne:Alias1, Variant1:AliasOne in incoming).
* **Variables with duplicate name**: Variable names should be unique across non subvariables.
* **Subvariable in different arrays per dataset**: If a subvariable is used for different arrays that are impossible to match, it will be reported here. User action will be needed to fix this.

For each of these, a list of variable IDs will be made available indicating the
conflicting entities. _Union_ conflicting ids generally refer to variables in
the _current_ dataset and may be referenced by alias in _incoming_.

### Entity

`/datasets/{id}/batches/{id}/`

A GET on this resource returns a Shoji Entity describing the batch, and a link to its Crunch Table (see next).

```json
{
    "conflicts": {},
    "source_children": {},
    "target_children": {},
    "source_columns": 3500,
    "source_rows": 235490,
    "target_columns": 3499,
    "target_rows": 120000,
    "error": "",
    "progress": 100.0,
    "source": "<url>",
    "status": "appended"
}
```

#### The conflicts object

Each batch has a "conflicts" member describing any unresolvable differences found between variables in the two datasets. On a successful append, this object will be empty; if the batch status is "conflict", the object will contain conflict information keyed by id of the variable in the target dataset. The conflict data for each variable follows this shape:

```json
{
    "metadata": {
        "name": "<string>",
        "alias": "<string>",
        "type": "<string>",
        "categories": [{}]
    },
    "source_id": "<id of the matching variable in the source frame",
    "source_metadata": {
        "name, etc": "as above"
    },
    "conflicts": [{
        "message": "<string>"
    }]
}
```

Each conflict has four attributes: `metadata` about the variable on the target dataset (unless it is a variable that only exists on the source dataset), `source_id` and `source_metadata`, which describe the corresponding variable in the source frame (if any), and a `conflicts` member. The `conflicts` member contains an array with a list of individual conflicts that indicate what situations were found during batch preparation.

If there are conflicts in your batch, address the conflicting issues in your datasets, DELETE the batch entity from the failed append attempt, and POST a new one.

#### Table

`/datasets/{id}/batches/{id}/table/{?offset,limit}`

A GET returns the rows of data from the Dataset for the identified batch as a Crunch Table.

repository: cferejohn/apidocs

repo_name: cferejohn/apidocs


text:
### Description
In this task we build a microservice called `shorty`,
which supports two URL shortening providers: [bit.ly](https://dev.bitly.com/) and [tinyurl.com](https://gist.github.com/MikeRogers0/2907534).
The service exposes a single endpoint: `POST /shortlinks`. The endpoint should receive
JSON with the following schema:

| param    | type   | required | description                        |
|----------|--------|----------|------------------------------------|
| url      | string | Y        | The URL to shorten                 |
| provider | string | N        | The provider to use for shortening |

The response should be a `Shortlink` resource containing:

| param    | type   | required | description                        |
|----------|--------|----------|------------------------------------|
| url      | string | Y        | The original URL                   |
| link     | string | Y        | The shortened link                 |

For example:
```json
{
    "url": "https://example.com",
    "link": "https://bit.ly/8h1bka"
}
```
We have a fallback mechanism that means that if the first provider is fallen we try to short the link with the second provider.
Also we assume that if the JSON doesn't clarify the provider we make tinyurl as the default.
The endpoint returns a JSON response with a sensible HTTP status in case of errors or failures.

### How to Review

Firstly you can review the code and feel free to make any comments.

1. Clone  the repo on your local and use **shortlink** branch
2. cd software-engineer-task
3. Install dependencies on a clean virtual environment :
    - sudo apt-get install virtualenv -y
    - virtualenv -p python3 venv
    - source venv/bin/activate
    - pip3 install -r requirements.txt
4. Run the tests as : pytest
You expected to see 3 passed.

Now you have to test also manually the functionality. You have to run the API:  python3 run.py
Open a new terminal and cURL the API:

Use **tinyurl** as the default provider
1. ```curl -X POST "http://localhost:5000/shortlinks" -H "accept: application/json" -H "Content-Type: application/json" -d "{\"url\":\"http://google.com/123/sssdsf\"}"```

Check **bitly** provider
2.```curl -X POST "http://localhost:5000/shortlinks" -H "accept: application/json" -H "Content-Type: application/json" -d "{\"url\":\"http://google.com/123/sssdsf\",\"provider\":\"bitly\"}"```

Check **UNKONWN** provider
3. ```curl -X POST "http://localhost:5000/shortlinks" -H "accept: application/json" -H "Content-Type: application/json" -d "{\"url\":\"http://google.com/123/sssdsf\",\"provider\":\"XYZ\"}"```

Check **tinyurl** provider
4. ```curl -X POST "http://localhost:5000/shortlinks" -H "accept: application/json" -H "Content-Type: application/json" -d "{\"url\":\"http://google.com/123/sssdsf\",\"provider\":\"tinyurl\"}"```

Now you have to **check the fallback strategy**.
You have to edit `shortly/bitly.py` file and replace token with :
```token = 'XYZ'```

Save the file and now the API should be restarted. cURL the API with bitly provider and check the response JSON. Should be tinyurl provider (because token isn't valid anymore)
```curl -X POST "http://localhost:5000/shortlinks" -H "accept: application/json" -H "Content-Type: application/json" -d "{\"url\":\"http://google.com/123/sssdsf\",\"provider\":\"bitly\"}"```

### Sensitive data
**For your convenience, I give you my bitly token. This is a private repo so I suppose that there is no leak.**

### Further imporvments
We could use also FastAPI for performance reasons, you could check my GitHub profile here :arrow_right: https://github.com/revythas/FastAPI_EuroConvension

Also, we could dockerize the application or we could add some ansible tiers to automate the whole process.

Finally, we could use the circuit breaker pattern to handle those failures and make a robust application. We could use pybreaker as a python module or Istio if we have a Kubernetes cluster up and running.

repository: revythas/tinyurl-bitly

repo_name: revythas/tinyurl-bitly


text:
# [Ultimate BitClout Toolset](https://bitclout.com/posts/005de3a6001370ee78d3e777fa7fd677b35350ec3ada90d8a65235b559daeb9e)

## Onboarding

- [BitClout User Onboarding Guide](https://research.bitcloutpulse.com/bitclout-user-onboarding-guide/)

- [Your First Few Days on BitClout](https://www.notion.so/Your-First-Few-Days-on-Bitclout-d78fb1e42e82459fbb5c12aa045ed61d)

- [@nachoaveragecall](https://bitclout.com/u/nachoaveragecall)

- [@allaboard](https://bitclout.com/u/allaboard)

- [@0to10k](https://bitclout.com/u/0to10k) (Read from bottom up)

- [@1dolinski](https://bitclout.com/u/1dolinski)

## Trusted Community Leaders

- [@krassenstein](https://bitclout.com/u/krassenstein)

- [@tijn](https://bitclout.com/u/tijn)

- [@kanshi](https://bitclout.com/u/kanshi)

- [@clayperrymusic](https://bitclout.com/u/clayperrymusic)

- [@paulmp](https://bitclout.com/u/paulmp)

- [@clayoglesby](https://bitclout.com/u/clayoglesby)

## Main Node Blacklist

[BitClout Blacklist](https://bitclout-blacklist.web.app/)

## Node Directories -

- [BitCloutNode.Directory](https://bitcloutnode.directory/) - [@BitCloutNodeDirectory](https://bitclout.com/u/bitcloutnodedirectory)

## BitClout Search Engines

### 1. CloutaVisa

- [Website](https://cloutavista.com/) - [@cloutavista](https://bitclout.com/u/cloutavista)

### 2. Cloutini

- [Website](https://cloutini.com/) - [@cloutini](https://bitclout.com/u/cloutini)

### 3. Tijn Search

- [Website (node) ](https://search.tijn.club/) - [@tijn](https://bitclout.com/u/tijn)

## BitClout History

- [Cloutforum](http://cloutforum.org/) - [@CloutForum](https://bitclout.com/u/cloutforum)

## Block Explorers

- [Clout Angel](https://explorer.cloutangel.com/) - [@cloutangel](https://bitclout.com/u/cloutangel)

- [Explorer.BitClout.com](https://explorer.bitclout.com/)

## Account Analysis

- [BitCloutSignal](https://bitcloutsignal.com/) - [@bitcloutsignal](https://bitclout.com/u/bitcloutsignal)

- [Clout Eye](https://clouteye.com/) - [@CloutEye](https://bitclout.com/u/clouteye)

- [ProsperClout](https://www.prosperclout.com/) - [@ProsperClout](https://bitclout.com/u/prosperclout)

- [CloutGate](https://cloutgate.com/) - [@CloutGate](https://bitclout.com/u/cloutgate)

## Off-Platform Trusted Trading

- [BitCloutPulse](https://www.bitcloutpulse.com/) - [@bitcloutpulse](https://bitclout.com/u/bitcloutpulse)

## Project Analysis

- [BitHunt](https://bithunt.com/) - [@bithunt](https://bitclout.com/u/bithunt)

## News

[@bruhmoments](https://bitclout.com/u/bruhmoments)

- [BitsToday](https://bitstoday.medium.com/) - [@BitsTODAY](https://bitclout.com/u/BitsTODAY)

## Developer Docs

- [Developer Docs](https://docs.bitclout.com/)

## Developer Tools

- [CloutAPIs](https://www.cloutapis.com/) - [@cloutapis](https://bitclout.com/u/cloutapis)

## Buidl a project

### Memgraph

- [Visualize The BitClout Network Using D3JS](https://memgraph.com/blog/visualize-the-bitclout-network-using-d3js)

- [BitClout Visualizing Hodlers](https://github.com/memgraph/bitclout-visualizing-hodlers)

## Developers

### Core Devs

- [@diamondhands 💎](https://bitclout.com/u/diamondhands)

- [@maebeam 💎](https://bitclout.com/u/maebeam)

- [@lazynina 💎](https://bitclout.com/u/LazyNina)

- [@redpartyhat 💎](https://bitclout.com/u/redpartyhat)

- [@bluepartyhat 💎](https://bitclout.com/u/bluepartyhat)

- [@merlin 💎](https://bitclout.com/u/merlin)

### Contributors

- [@carsenk](https://bitclout.com/u/carsenk)

- [@petern](https://bitclout.com/u/petern)

## GitHub Repos

- [BitClout](https://github.com/bitclout)

- [Backend](https://github.com/bitclout/backend)

- [Frontend](https://github.com/bitclout/frontend)

- [Identity](https://github.com/bitclout/identity)

- [Core](https://github.com/bitclout/core)

- [Rosetta BitClout](https://github.com/bitclout/rosetta-bitclout)

- [Run](https://github.com/bitclout/run)

- [Docs](https://github.com/bitclout/docs)

- [MongoDB Dumper](https://github.com/bitclout/mongodb-dumper)

- [GO Deadlock](https://github.com/bitclout/go-deadlock)

- [Glog](https://github.com/bitclout/glog)

- [GO Merkle Tree](https://github.com/bitclout/go-merkle-tree)

- [Desktop](https://github.com/bitclout/desktop)

- [hdkey](https://github.com/bitclout/hdkey)

- [Explorer](https://github.com/bitclout/explorer)

- [Confetti JS](https://github.com/bitclout/confetti-js)

## Trusted Mobile Apps

1. [FlickApp](https://www.flickapp.com/bitclout) - [@flickapp](https://bitclout.com/u/flickapp)

2. [@cloutfeed](https://bitclout.com/u/cloutfeed) - [App Store](https://apps.apple.com/app/id1561532815)

## Community Projects Directory

- [BitHunt](https://bithunt.com/) - [@bithunt](https://bitclout.com/u/bithunt)

## Node Directory

- [@BitCloutNodeList](https://bitclout.com/u/BitcloutNodeList)

repository: znmead/The-Ultimate-BitClout-List

gha_license_id: MIT

repo_name: znmead/The-Ultimate-BitClout-List


text:
# terra-works
Terraform tutorial code
Complete code to provisoin AWS resource using terraform
Contains following file
# connect.tf
# vpc.tf
# web.tf
# db.tf

Connect.tf : Used to confirm the the Terraform can connect to the AWS cloud

vpc.tf : This file contains the code to provisoin AWS resources like VPC, subnet, NAT, IP address and Internet gateway.

web.tf :  It provision an EC2 instance and public IP address in public subnet and associate security group rules

db.tf : It provision an EC2 subnet in private subnet and associate a security group rules.

repository: techiescorner/terra-works

repo_name: techiescorner/terra-works


text:
# Docker for local web development, part 1: a basic LEMP stack

This repository accompanies a [tutorial series](https://tech.osteel.me/posts/docker-for-local-web-development-why-should-you-care "Docker for local web development, introduction: why should you care?") about leveraging Docker for local web development.

The current branch covers part 1 of the series, which is about setting up a basic LEMP stack with Docker Compose. Please refer to the [full article](https://tech.osteel.me/posts/docker-for-local-web-development-part-1-a-basic-lemp-stack "Docker for local web development, part 1: a basic LEMP stack") for a detailed explanation.

## Content

This branch contains a basic LEMP stack running on Docker and orchestrated by Docker Compose, including:

* A container for Nginx;
* A container for PHP-FPM;
* A container for MySQL;
* A container for phpMyAdmin;
* A volume to persist MySQL data.

## Prerequisites

Make sure [Docker Desktop for Mac or PC](https://www.docker.com/products/docker-desktop) is installed and running, or head [over here](https://docs.docker.com/install/) if you are a Linux user. You will also need a terminal running [Git](https://git-scm.com/).

This setup also uses localhost's port 80, so make sure it is available.

## Directions of use

Add the following domain to your machine's `hosts` file:

```
<IP_ADDRESS> php.test
```

Clone the repository and change the current directory for the project's root:

```
$ git clone git@github.com:osteel/docker-tutorial.git
$ cd docker-tutorial
```

Copy `.env.example` to `.env`:

```
$ cp .env.example .env
```

Run the following command:

```
$ docker compose up -d
```

This may take a little bit of time, as some Docker images might need downloading.

Once the script is done, visit [php.test](http://php.test).

## Explanation

The images used by the setup are listed and configured in [`docker-compose.yml`](https://github.com/osteel/docker-tutorial/blob/part-1/docker-compose.yml).

When building and starting the containers based on the images for the first time, a MySQL database named `demo` is automatically created (you can pick a different name in the MySQL service's description in `docker-compose.yml`).

A [minimalist Nginx configuration](https://github.com/osteel/docker-tutorial/blob/part-1/.docker/nginx/conf.d/php.conf) for the PHP application is also copied over to Nginx's container, making it available at [php.test](http://php.test).

The `src/` directory containing the application is mounted onto both Nginx's and the application's containers, meaning any update to the code is immediately available upon refreshing the page, without having to rebuild any container.

The database data is persisted in its own local directory through the volume `mysqldata`, which is mounted onto MySQL's container. A phpMyAdmin interface is available at [localhost:8080](http://localhost:8080) (the database credentials are root / root).

Please refer to the [full article](https://tech.osteel.me/posts/docker-for-local-web-development-part-1-a-basic-lemp-stack "Docker for local web development, part 1: a basic LEMP stack") for a detailed explanation.

repository: osteel/docker-tutorial

gha_language: PHP

repo_name: osteel/docker-tutorial


text:
bytic QA configurations
================================

PHP Code Sniffer
----------------

Configuration file: *bytic.phpcs.xml*

### Usage

1. Link bytic/qaconfig repo as composer dependency

    `$ composer require bytic/qaconfig:^1.0`

2. Extend provided configuration to adapt it to your project.

   ``` xml
    <?xml version="1.0" encoding="UTF-8"?>
    <ruleset name="DEMO-PHP project code style checker config">
        <rule ref="./vendor/bytic/qaconfig/bytic.phpcs.xml">
            <exclude name="PSR2.Classes.PropertyDeclaration.Underscore"/>
        </rule>
        <rule ref="PSR1.Classes.ClassDeclaration">
            <exclude-pattern>*/_stubs.php</exclude-pattern>
        </rule>
        <rule ref="Generic.CodeAnalysis.UnconditionalIfStatement.Found">
            <exclude-pattern>*/_stubs.php</exclude-pattern>
        </rule>
    </ruleset>
    ```

Inspiration
----------------
* https://github.com/jmolivas/phpqa
* https://github.com/Dealerdirect/php-qa-tools
* https://github.com/lovullo/phpqatools
* https://github.com/ramsey/coding-standard
* https://github.com/endroid/quality

repository: bytic/phpqaconfig

repo_name: bytic/phpqaconfig


text:
# [JS Document Onload](https://learn.co/tracks/online-software-engineering-structured/front-end-web-programming/recognizing-javascript-events/javascript-document-onload)

## Resources

1. [DOMContentLoaded](https://developer.mozilla.org/en-US/docs/Web/Events/DOMContentLoaded)
2. [Running Your Code at the Right Time](https://www.kirupa.com/html5/running_your_code_at_the_right_time.htm)

## Introduction

An important part of working with JavaScript is ensuring that your code
runs at the right time.

Every now and then, you may have to add some extra code to ensure your code doesn't run before the page is ready.

There are many factors that go into determining the "right time."

There are two events that represent two important milestones in terms of page load:

1. The `DOMContentLoaded` event fires when your page's DOM is fully parsed
2. The `load` event fires when a resource and its dependent resources (CSS, JavaScript) have finished loading

### 1. Why `DOMContentLoaded` is important?

The `DOMContentLoaded` event is the browser's built-in way to indicate when a
page is loaded. It isn't possible to manipulate HTML elements that haven't
rendered yet, so trying to manipulate the DOM before the page fully loads can
potentially lead to problems.

### 2. Set up an event on `DOMContentLoaded`

As always, `addEventListener` takes a `String` with the name of the
event and a _callback function_.

```js
document.addEventListener("DOMContentLoaded", function() {
  console.log("The DOM has loaded");
});
```

If you put the above code in `index.js`, 'The DOM has loaded' will not be logged
immediately. In fact, you can confirm this yourself by putting a second
`console.log()` _outside_ of the event listener callback:

```js
document.addEventListener("DOMContentLoaded", function() {
  console.log("The DOM has loaded");
});

console.log(
  "This console.log() fires when index.js loads - before DOMContentLoaded is triggered"
);
```

## Conclusion

JavaScript provides use the powerful ability to update webpage content without
refreshing. We can, for instance, have a page with some basic HTML
structure and use JavaScript to fill in the content, enabling the possibility of
dynamic webpages.

This sort of action, however, will only work if the HTML content is actually
loaded on the page. The `DOMContentLoaded` event ensures that our JavaScript
code is being executed immediately after the HTML is finished loading.

## Addendum

The `DOMContentLoaded` event is now a widely accepted standard. Modern web
development, however, provides us with additional choices for setting up when we
want our JavaScript to execute. For example, HTML5 now has a [`defer`][defer]
attribute for use in `<script>` tags:

```html
<script src="index.js" defer></script>
```

This functions in a similar way to `DOMContentLoaded` - the JavaScript code
stored in `index.js` will be loaded up but won't execute until the HTML page
completely loads.

repository: kierblk/code-notes

path: /JavaScript/03 - Recognizing JavaScript Events/03.07-JS-Document-Onload.md

repo_name: kierblk/code-notes


text:
# Nautilsu cluster usage

## Cluster

Getting data: using AWS S3 with Ceph file system
~15GB is reasonable in that
Write a small scipt to retrieve data from the S3 instance

## Kubernetes

Run as jobs, not pods - pods are limited to 2 cores and 8GB Ram

Only submit GPU requests under limits (not request).
Kill GPU jobs under 60% utilization.

- use `python -u` to unbuffer output
- use comet.ml for model monitoring

### Storage

- don't install AWS endpoints!
- just alias the URL for the endpoint

repository: Jswig/ucsc-cgl-synthetic-genomes

repo_name: Jswig/ucsc-cgl-synthetic-genomes


text:
# PartnerAPI - Supplier And Stock Management

PartnerAPI is a mini supplier management system for e-commerce platforms. Developed in an enterprise structure. The suppliers can log in the system with their credentials, create new product request, edit their product stocks and review their order. You can easily connect all specified features with the e-commerce platform of your choice

You will need to make various development in the e-commerce platform used to connect the features of PartnerAPI. You can contact [me](https://github.com/muhammedikinci) via e-mail for necessary development.

The API already has a react-frontend. You can access it [here](https://github.com/muhammedikinci/partner-frontend).

## Project Features

### Suppliers can;
- Preview Orders
    - Suppliers can only view details of orders that include their own products.

- Preview System Products

- Update Stock Of System Products

- Change Identity Informations

- Create New Product Request

- Update Denied Product Request

- Preview Their Product Requests

### Admins can;
- Create New Supplier Account

- Delete And Update Supplier Acoount

- Update Supplier Product List from E-Commerce Platform

- Confirm or Decline a Product Request

## Structure

- WebApi
    - Dotnet Core Api Project

- Application
    - Includes Logic (Services)
    - Has own provider
    - Includes Exception and Auth

- Domain
    - Includes Models and ValueObjects

- Persistence
    - Includes the First Touch of the Database

- Repository
    - Includes Generic Repository Pattern
    - Has own provider

- Tests
    - Includes Tests
    - Changes database during testing
    ```
    // src/Tests/DependencyHelperResolver
    .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
            // test param
            webBuilder.UseSetting("TestProp", "true");
        }).Build();

    // src/WebApi/Startup.cs
    var testProp = Configuration.GetValue<string>("TestProp");

    if (testProp == "true")
    {
        services.Configure<MongoDBSettings>(
            Configuration.GetSection("MongoDBTestSettings")
        );
    }
    ```

## Start The API

```sh
git clone https://github.com/muhammedikinci/partner-api
cd partner-api/src
dotnet run --project WebApi
```

## Run The Tests

Requires data in database for tests. You can run first add tests for the data.

```sh
cd partner-api/src/Tests
dotnet test
```

---

Logging: NLog

Database: MongoDB

repository: muhammedikinci/partner-api

repo_name: muhammedikinci/partner-api


text:
# Snapshots

## Fetch snapshots

[Doc](https://developers.lokalise.com/reference/list-all-snapshots)

```ruby
@client.snapshots(project_id, params = {})  # Input:
                                            ## project_id (string, required)
                                            ## params (hash)
                                            ### :filter_title (string) - set title filter for the list
                                            ### :page and :limit
                                            # Output:
                                            ## Collection of project snapshots
```

For example:

```ruby
project_id = '123.abc'
params = {
  limit: 1,
  page: 2
}

snapshots = @client.snapshots project_id, params

snapshots[0].snapshot_id # => 5678
```

Alternatively:

```ruby
project = @client.project project_id
snapshots = project.snapshots params
```

## Create snapshot

[Doc](https://developers.lokalise.com/reference/create-a-snapshot)

```ruby
@client.create_snapshot(project_id, params = {})  # Input:
                                                  ## project_id (string, required)
                                                  ## params (hash)
                                                  ### :title (string)
                                                  # Output:
                                                  ## Created snapshot
```

For example:

```ruby
params = {
  title: 'My snapshot'
}

snapshot = @client.create_snapshot project_id, params

snapshot.title # => 'My snapshot'
```

Alternatively:

```ruby
project = @client.project project_id
snapshot = project.create_snapshot params
```

## Restore snapshot

[Doc](https://developers.lokalise.com/reference/restore-a-snapshot)

```ruby
@client.restore_snapshot(project_id, snapshot_id)   # Input:
                                                    ## project_id (string, required)
                                                    ## snapshot_id (string, required)
                                                    # Output:
                                                    ## Information about the restored project from the specified snapshot
```

For example:

```ruby
restored_project = test_client.restore_snapshot project_id, snapshot_id

restored_project.name # => 'Project copy'
```

Alternatively:

```ruby
snapshot = @client.snapshots(project_id).first
restored_project = snapshot.restore

# OR

project = @client.project project_id
restored_project = project.restore_snapshot snapshot_id
```

## Delete snapshot

[Doc](https://developers.lokalise.com/reference/delete-a-snapshot)

```ruby
@client.destroy_snapshot(project_id, snapshot_id)   # Input:
                                                    ## project_id (string, required)
                                                    ## snapshot_id (string, required)
                                                    # Output:
                                                    ## Generic with the project id and "snapshot_deleted" set to "true"
```

For example:

```ruby
response = @client.destroy_snapshot project_id, snapshot_id

response.snapshot_deleted # => true
```

Alternatively:

```ruby
snapshot = @client.snapshots(project_id).first
response = snapshot.destroy
```

repository: lokalise/ruby-lokalise-api

gha_language: Ruby

gha_license_id: NOASSERTION

repo_name: lokalise/ruby-lokalise-api


text:
# hdDeepLearningStudy
Papers,code etc for deep learning study group
## Suggestions for future readings
https://arxiv.org/pdf/1605.06431v1.pdf - Deep nets are ensembles
https://arxiv.org/pdf/1602.08124v3.pdf - soa for parallelization
https://arxiv.org/pdf/1404.5997v2.pdf - parallel computation issues
http://www.wsdm-conference.org/2016/slides/WSDM2016-Jeff-Dean.pdf - distributed architecture
https://www.youtube.com/watch?v=sUzQpd-Ku4o - video of jeff dean talk
https://arxiv.org/pdf/1611.01578v1.pdf - RL for finding neural architectures
http://mlg.eng.cam.ac.uk/yarin/blog_2248.html - uncertainty in neural nets
https://arxiv.org/pdf/1611.01587.pdf -  Joint Many-task model: Neural Net for multiple NLP Tasks - Socher
http://papers.nips.cc/paper/5773-deep-generative-image-models-using-a-laplacian-pyramid-of-adversarial-networks.pdf -GAN paper (recc by LeCun)
https://arxiv.org/pdf/1511.05440.pdf - GAN for video prediction
https://arxiv.org/abs/1703.02528 - Generative unadversarial networks
https://arxiv.org/pdf/1611.01578.pdf - Neural architecture search with RL - google brain
https://arxiv.org/pdf/1703.01041.pdf - Large-Scale Evolution of Image Classifiers - google brain
https://arxiv.org/pdf/1708.05866.pdf - Survey of reinforcement learning
https://arxiv.org/pdf/1710.10196.pdf - training improvements for GAN
https://arxiv.org/pdf/1704.00028v2.pdf - improved training for WGANs
https://openreview.net/forum?id=ry_WPG-A-&noteId=ry_WPG-A - rebuttal for IB theory
http://www.mit.edu/~adedieu/pdf/2048.pdf  - deep reinforcement learning
https://arxiv.org/pdf/1710.10784.pdf - geometry of deep learning
https://arxiv.org/pdf/1706.00473.pdf - bayesian perspective
http://openaccess.thecvf.com/content_cvpr_2017/papers/Khoreva_Simple_Does_It_CVPR_2017_paper.pdf - weakly supervised segmentation
https://arxiv.org/pdf/1711.11585.pdf - High resolution image synthesis and semantic manipulation - Nvidia
https://github.com/NVIDIA/pix2pixHD  - Synthesizing and manipulating 2048x1024 images with conditional GAN
https://arxiv.org/pdf/1505.05424.pdf - weight uncertainties
https://arxiv.org/pdf/1711.01297.pdf - weight uncertainties
https://arxiv.org/pdf/1802.03268.pdf - Efficient Neural architecture search
https://github.com/RedditSota/state-of-the-art-result-for-machine-learning-problems - SOTA algorithms
https://arxiv.org/pdf/1711.10925.pdf - deep image prior
https://arxiv.org/pdf/1711.03953.pdf - breaking softmax bottleneck
mixed scale deep convolution - PNAS Dec 26, 2017
http://lanl.arxiv.org/pdf/1803.05049v1 - Fractal AI
https://arxiv.org/abs/1802.05365 - Deep contextualized word representations
https://arxiv.org/pdf/1804.04241.pdf - capsule net for segmentation (improvement 95%)
https://arxiv.org/pdf/1704.00109.pdf - Snapshot ensembles
https://arxiv.org/pdf/1711.00937.pdf - Neural discrete representation learning
https://arxiv.org/find/cs/1/au:+Segler_M/0/1/0/all/0/1 - refs on chemical models
https://arxiv.org/pdf/1801.10130.pdf - spherical CNN
https://arxiv.org/pdf/1804.02958.pdf - GAN for extreme compression
https://arxiv.org/pdf/1703.05698.pdf - Neural Sketch Learning for Conditional Program Generation

Papers on Learning Rate Scheduling --
https://arxiv.org/pdf/1608.03983.pdf - SGD with warm restarts
https://arxiv.org/pdf/1506.01186.pdf - Cyclical learning rates
https://arxiv.org/pdf/1803.10122.pdf - World models - teaching simple world model prepartory to RL - schmidhuber

ICLR top papers - https://iclr.cc/Conferences/2018/Schedule?type=Oral

https://arxiv.org/abs/1703.06114 Deep Sets

https://arxiv.org/abs/1807.02443 Tangent Convolutions for Dense Prediction in 3D.

https://arxiv.org/pdf/1806.01261.pdf - deep mind graph paper
https://arxiv.org/pdf/1805.11604.pdf - How does Batch normalization work - it's not about covariate shift
https://arxiv.org/pdf/1802.05983.pdf - Disentangling by factorizing
https://arxiv.org/pdf/1808.00508.pdf - Neural arithmetic logic units
https://arxiv.org/pdf/1803.08660.pdf - A new activation function
https://arxiv.org/pdf/1803.05268.pdf - Interpretability in CNN
https://arxiv.org/pdf/1808.06601.pdf - Video to video synthesis

## September 24 - Hacker Dojo
https://arxiv.org/pdf/1807.03146.pdf - Discovery of 3d keypoints from 2d image

## September 17 - Hacker Dojo
https://arxiv.org/abs/1709.02371 - PWC-Net: CNNs for Optical Flow Using Pyramid, Warping, and Cost Volume," by Deqing Sun et al. (CVPR 2018)
Phil Ferrier will present the paper and run though his code for us. Phil's code is on his github reop:
https://github.com/philferriere/tfoptflow

## September 10 - Hacker Dojo
https://arxiv.org/pdf/1807.03247.pdf - Intriguing failure (and improvement) to CNN for determining rotations.

## September 3 - Hacker Dojo
https://arxiv.org/pdf/1803.03324.pdf - Learning Deep Generative Models of Graphs

## August 27 - Hacker Dojo
https://arxiv.org/abs/1709.10082 - Optimally decentralized multi-robot collision avoidance w reinforcement learning.

https://github.com/TensorSwarm/TensorSwarm  - Andreas Pasternak code for above

## August 13 - Hacker Dojo
https://s3-us-west-2.amazonaws.com/openai-assets/research-covers/learning-dexterity/learning-dexterity-paper.pdf  -Robot doing single hand manipulations.
https://www.theverge.com/2018/7/30/17621112/openai-robot-dexterity-dactyl-artificial-intelligence

## July 30 - Hacker Dojo -
https://arxiv.org/pdf/1711.03953.pdf - Breaking the softmax bottleneck
https://arxiv.org/pdf/1805.10829.pdf - SigSoftMax: Reanalyzing the softmax bottleneck
https://severelytheoretical.wordpress.com/2018/06/08/the-softmax-bottleneck-is-a-special-case-of-a-more-general-phenomenon/

## July 23 - Hacker Dojo -
https://arxiv.org/pdf/1807.01281.pdf - Human level performance in first person multiplayer games with population reinforcement learning.
https://deepmind.com/blog/capture-the-flag/
https://www.youtube.com/watch?v=steioHoiEms
https://arxiv.org/abs/1711.09846v2
https://arxiv.org/pdf/1611.05397.pdf

## July 16 - Hacker Dojo
https://arxiv.org/pdf/1803.10122.pdf - schmidhuber paper on RL

## July 9 - Hacker Dojo
https://deepmind.com/research/publications/neural-scene-representation-and-rendering/  - Rendering 3d scene

## July 2 - Hacker Dojo -
https://arxiv.org/pdf/1707.06347.pdf - Proximal Optimization Policies

## June 25 - Hacker Dojo
https://openreview.net/pdf?id=BJOFETxR- - Learning to represent programs with graphs

## June 18 - Hacker Dojo
https://openreview.net/pdf?id=BkisuzWRW - Zero Shot Visual Imitation - Reinforcement Learning

## June 11 - Hacker Dojo
https://openreview.net/forum?id=HkL7n1-0b - Wasserstein Auto Encoders - one of ICLR top papers.

## June 4 - Hacker Dojo
https://openreview.net/pdf?id=Hy7fDog0b - Ambient GAN - Generative Models from Lossy Measurements - ICLR top paper

## May 21 - Hacker Dojo
https://arstechnica.com/science/2018/05/ai-trained-to-navigate-develops-brain-like-location-tracking/  - Grid representations in rat brain
https://deepmind.com/documents/200/Banino_at_al_final.pdf  --
https://www.nature.com/articles/s41586-018-0102-6  --

## May 14 - Hacker Dojo
https://arxiv.org/pdf/1712.06567.pdf - Deep Neuroevolution: Genetic Algorithms are a Competitive Alternative for
Training Deep Neural Networks for Reinforcement Learning
https://arxiv.org/pdf/1712.06560.pdf - Improving Exploration in Evolution Strategies for Deep Reinforcement
Learning via a Population of Novelty-Seeking Agents
https://eng.uber.com/deep-neuroevolution/  - Uber engineering blog post

## May 7 - Hacker Dojo
https://arxiv.org/pdf/1801.10130.pdf - spherical CNN

## Apr 30 - Hacker Dojo
https://arxiv.org/pdf/1710.07313.pdf - Using machine learning to replicate chaotic attractors
http://www.bmp.ds.mpg.de/tl_files/bmp/preprints/Zimmermann_Parlitz_preprint.pdf - paper to be published in "chaos"
https://www.quantamagazine.org/machine-learnings-amazing-ability-to-predict-chaos-20180418/ - blog post

## Apr 23 - Hacker Dojo
https://arxiv.org/pdf/1711.10925.pdf - Deep Image Prior
https://dmitryulyanov.github.io/deep_image_prior - git hub from authors
https://box.skoltech.ru/index.php/s/ib52BOoV58ztuPM
http://mlexplained.com/2018/01/18/paper-dissected-deep-image-prior-explained/
http://fortune.com/2018/04/24/nvidia-artificial-intelligence-images/ - Article w video showing photo editing use

## Apr 16 - Hacker Dojo
Finish Fractal AI
https://arxiv.org/pdf/1711.07971.pdf - non-local filtering

## Apr 9 - Hacker Dojo
http://lanl.arxiv.org/pdf/1803.05049v1 - Fractal AI

## Apr 2 - Hacker Dojo
https://arxiv.org/pdf/1803.04831.pdf - IndRNN longer deeper RNN's

## Mar 26 -  Hacker Dojo
https://arxiv.org/pdf/1711.10433.pdf - parallel wavenet
https://arxiv.org/pdf/1708.04552.pdf - regularizing convnet with cutout (desert paper)
http://www.cs.toronto.edu/~jmartens/docs/Deep_HessianFree.pdf - will get short presentation on this one.

## Mar 19 - Hacker Dojo
https://arxiv.org/pdf/1802.03268.pdf - Efficient Neural Architecture Search via Parameter Sharing
https://github.com/carpedm20/ENAS-pytorch

some related papers and reviews.
https://arxiv.org/pdf/1708.05344.pdf - One shot architecture search
https://openreview.net/forum?id=ByQZjx-0-
and
https://openreview.net/forum?id=rydeCEhs-

## Mar 12 - Hacker Dojo
https://arxiv.org/abs/1703.10135 - tacotron - end-to-end speech synthesis
https://arxiv.org/pdf/1712.05884.pdf - tacotron 2
https://research.googleblog.com/2017/12/tacotron-2-generating-human-like-speech.html -
https://github.com/A-Jacobson/tacotron2 - pytorch code
http://research.baidu.com/deep-speech-3%EF%BC%9Aexploring-neural-transducers-end-end-speech-recognition/

## Feb 26 - Hacker Dojo
https://arxiv.org/pdf/1705.09792.pdf - Deep Complex Networks

## Feb 19 - Hacker Dojo
https://arxiv.org/pdf/1801.10308.pdf - Nested LSTM's
https://arxiv.org/pdf/1705.10142.pdf - KRU from Fair
https://github.com/hannw/nlstm  - tf code for Nested LSTM

## Feb 12 - Hacker Dojo
http://openaccess.thecvf.com/content_cvpr_2017/papers/Khoreva_Simple_Does_It_CVPR_2017_paper.pdf - Weakly Supervised Instance and Semantic Segmentation
https://www.mpi-inf.mpg.de/departments/computer-vision-and-multimodal-computing/research/weakly-supervised-learning/simple-does-it-weakly-supervised-instance-and-semantic-segmentation/
https://github.com/philferriere/tfwss - Phil Ferriere's code
 https://drive.google.com/file/d/1wPHMA4PqygawvIxRiy-2ZMKcpUO447cz/view?usp=sharing - mehul's notebook on segmentation

## Feb 5 - Hacker Dojo
https://arxiv.org/pdf/1511.06939.pdf - using rnn for recommendation system
https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/46488.pdf - latest paper on rnn for recommendation

## Jan 29 - Hacker Dojo
https://arxiv.org/pdf/1709.04511.pdf - Empirical study of multi-agent RL
https://github.com/geek-ai/1m-agents - code

## Jan 22 - Hacker Dojo
https://arxiv.org/pdf/1704.00028.pdf - Improvements in Wasserstein GAN training

## Jan 15 - Hacker Dojo

https://arxiv.org/pdf/1710.02298.pdf - Combining improvements in deep reinforcement learning

## Jan 8 - Hacker Dojo
https://openreview.net/pdf?id=HJWLfGWRb - follow-on to capsule network paper
https://www.youtube.com/watch?v=pPN8d0E3900
https://www.youtube.com/watch?v=2Kawrd5szHE
https://github.com/ageron/handson-ml/blob/master/extra_capsnets.ipynb
https://github.com/naturomics/CapsNet-Tensorflow
https://medium.com/ai%C2%B3-theory-practice-business/understanding-hintons-capsule-networks-part-ii-how-capsules-work-153b6ade9f66

## Dec 11 - Hacker Dojo
https://arxiv.org/pdf/1710.09829.pdf - Dynamic routing between capsules - Hinton

## Nov 27 - Hacker Dojo
https://arxiv.org/pdf/1701.01724.pdf - DeepStack: Expert-Level Artificial Intelligence in
Heads-Up No-Limit Poker

## Nov 13 - Hacker Dojo
https://deepmind.com/documents/119/agz_unformatted_nature.pdf - alpha zero paper
https://webdocs.cs.ualberta.ca/~mmueller/talks/2016-LeeSedol-AlphaGo.pdf  - some slides

## Nov 6 - Hacker Dojo
https://arxiv.org/pdf/1703.10593.pdf - cycle consistent GANs

## Oct 30 - Hacker Dojo
https://arxiv.org/pdf/1503.02406.pdf  Naftali Tishby and Noga Zaslavsky. information bottleneck principle.

https://www.cs.huji.ac.il/labs/learning/Papers/allerton.pdf - Naftali Tishby, Fernando C. Pereira, and William Bialek. The information bottleneck method.

https://www.reddit.com/r/MachineLearning/comments/75uua6/r_2_hr_talk_information_theory_of_deep_learning/

## Oct 23 - Hacker Dojo

Mask R-CNN
https://arxiv.org/abs/1703.06870

And these are prerequisites (read at least Fast R-CNN and Faster R-CNN)

R-CNN
https://arxiv.org/abs/1311.2524

Fast R-CNN
https://arxiv.org/pdf/1504.08083.pdf

Faster R-CNN
https://arxiv.org/abs/1506.01497 Feature Pyramid Networks
https://arxiv.org/abs/1612.03144

## Oct 16 - Hacker Dojo
https://arxiv.org/pdf/1703.00810.pdf - Opening the Black Box of Neural Nets via Information
https://www.youtube.com/watch?v=ekUWO_pI2M8
https://www.youtube.com/watch?v=bLqJHjXihK8

## Oct 9 - Hacker Dojo
https://arxiv.org/pdf/1501.00092.pdf - super resolution first paper
https://arxiv.org/abs/1608.00367 - super resolution second paper

## Oct 2 - Hacker Dojo
https://arxiv.org/abs/1604.03901 - Single-Image Depth Perception in the Wild

## Sept 25 - Hacker Dojo
https://arxiv.org/pdf/1706.08947.pdf - Exploring generalization in deep networks.

## Sept 18 - Hacker Dojo
https://arxiv.org/pdf/1705.02550.pdf - nvidia drone nav
https://github.com/NVIDIA-Jetson/redtail/wiki - code

## Sept 11 - Hacker Dojo
http://citeseerx.ist.psu.edu/viewdoc/download?doi=<IP_ADDRESS>5.5060&rep=rep1&type=pdf - hyperneat ref
https://arxiv.org/pdf/1609.09106.pdf - Hypernet ref
http://blog.otoro.net/2016/09/28/hyper-networks/ - blog on hypernet
https://www.youtube.com/watch?v=-8oyTYViuJ4 - vid on hyperNeat
http://eplex.cs.ucf.edu/hyperNEATpage/HyperNEAT.html - blog on hyperNeat

## August 28 - Hacker Dojo
https://arxiv.org/pdf/1708.05344.pdf - SMASH: One-Shot Model Architecture Search through HyperNetworks
https://www.youtube.com/watch?v=79tmPL9AL48 - youtube vid on SMASH

## August 21 - Hacker Dojo
https://arxiv.org/pdf/1706.02515.pdf - Self Normalizing Neural Networks - Hochreiter

## August 14 - Hacker Dojo
https://arxiv.org/pdf/1606.01541.pdf - Reinforcement Learning for Dialog Generation - Jurafsky
https://github.com/liuyuemaicha/Deep-Reinforcement-Learning-for-Dialogue-Generation-in-tensorflow - tensorflow code for same
https://github.com/jiweil/ - some related code
https://arxiv.org/pdf/1612.00563.pdf - self critical training for image captioning - RL for text prob.

Some papers referenced by Jurafsky paper
[1506.05869] A Neural Conversational Model - Vinyals and Le
https://arxiv.org/abs/1604.04562 - Dialogue generation system - Wen

## Aug 7 - Hacker Dojo
https://arxiv.org/pdf/1705.04304.pdf - A Deep Reinforced Model for Abstractive Summarization - socher

## July 31 - Hacker Dojo
https://arxiv.org/pdf/1706.01433.pdf - visual interaction networks - deep mind
https://arxiv.org/pdf/1706.01427.pdf - neural model for relational reasoning - deep mind

## July 24
Guest Speaker - Using FPGA to speed CNN.
https://arxiv.org/pdf/1703.03130.pdf - A structured self-attentive sentence embedding - Lin and Bengio
https://github.com/dennybritz/deeplearning-papernotes/blob/master/notes/self_attention_embedding.md (review)
https://github.com/yufengm/SelfAttentive  code
https://github.com/Diego999/SelfSent  code

## July 17 - Hacker Dojo
https://arxiv.org/pdf/1706.03762.pdf - attention is all you need - Vaswani
https://github.com/tensorflow/tensor2tensor/tree/master/tensor2tensor/models
https://github.com/jadore801120/attention-is-all-you-need-pytorch - easier to read code
https://arxiv.org/pdf/1607.06450.pdf - layer normalization paper - hinton
https://www.youtube.com/watch?v=nR74lBO5M3s - google translate paper - youtube video
https://arxiv.org/pdf/1609.08144.pdf  - google translate paper -

## July 10 - Hacker Dojo
https://arxiv.org/pdf/1706.03762.pdf - attention is all you need - Vaswani
https://github.com/tensorflow/tensor2tensor/tree/master/tensor2tensor/models
https://github.com/jadore801120/attention-is-all-you-need-pytorch - easier to read code
https://arxiv.org/pdf/1607.06450.pdf - layer normalization paper - hinton

#### Some added references regarding positional encodings
http://www.machinelearning.org/proceedings/icml2006/047_Connectionist_Tempor.pdf - A. Graves, S. Fernandez, F. Gomez, and J. Schmidhuber
https://www.reddit.com/r/MachineLearning/comments/6jdi87/r_question_about_positional_encodings_used_in/

## June 26 - Hacker Dojo
https://arxiv.org/pdf/1705.03122.pdf - convolutional sequence to sequence learning
https://arxiv.org/pdf/1706.03762.pdf - attention is all you need - Vaswani
http://www.machinelearning.org/proceedings/icml2006/047_Connectionist_Tempor.pdf - A. Graves, S. Fernandez, F. Gomez, and J. Schmidhuber

## June 19 - Hacker Dojo
https://arxiv.org/pdf/1701.02720.pdf - RNN for end to end voice recognition

## June 12 - Hacker Dojo
New reinforcement learning results -- Too cool for school.  Watch the video and you'll be hooked.
https://www.youtube.com/watch?v=2vnLBb18MuQ&feature=em-subs_digest

http://www.cs.ubc.ca/~van/papers/2017-TOG-deepLoco/index.html - paper

## May 22 - Hacker Dojo
https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/HintonDengYuEtAl-SPM2012.pdf - comparison of RNN and HMM for speech recognition

## May 15 - Hacker Dojo
https://arxiv.org/pdf/1412.6572.pdf -  Explaining and Harnessing Adversarial Examples

## May 1 - Hacker Dojo
https://arxiv.org/abs/1704.03453  - The Space of Transferable Adversarial Examples

## Apr 24 - Hacker Dojo
https://discourse-production.oss-cn-shanghai.aliyuncs.com/original/3X/1/5/15ba4cef726cab390faa180eb30fd82b693469f9.pdf - Using TPU for data center

## Apr 17 - Hacker Dojo
Reservoir Computing by Felix Grezes.
http://www.gc.cuny.edu/CUNY_GC/media/Computer-Science/Student%20Presentations/Felix%20Grezes/Second_Exam_Survey_Felix_Grezes_9_04_2014.pdf

Slides by Felix Grezes: Reservoir Computing for Neural Networks
http://www.gc.cuny.edu/CUNY_GC/media/Computer-Science/Student%20Presentations/Felix%20Grezes/Second_Exam_Slides_Felix_Grezes_9-14-2014.pdf
(more at: http://speech.cs.qc.cuny.edu/~felix/ )

This is a short, very useful backgrounder on randomized projections,
here used for compressed sensing, in a blog post by Terence Tao
https://terrytao.wordpress.com/2007/04/13/compressed-sensing-and-single-pixel-cameras/

and the same story told with illustrations on the Nuit Blanche blog:
http://nuit-blanche.blogspot.com/2007/07/how-does-rice-one-pixel-camera-work.html

(BTW http://nuit-blanche.blogspot.com is a tremendous website.)

---

If we have time, we may discuss this paper:

Information Processing Using a Single Dynamical Node as Complex System.
https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3195233/pdf/ncomms1476.pdf

## Apr 10 - Hacker Dojo

https://arxiv.org/pdf/1603.08678.pdf - Instance-sensitive Fully Convolutional Networks

https://arxiv.org/pdf/1611.07709.pdf - Fully Convolutional Instance-aware Semantic Segmentation

## Apr 3 - Hacker Dojo
https://arxiv.org/pdf/1703.03864.pdf - Sutskever paper on using evolutionary systems for optimizing RL prob
http://jmlr.csail.mit.edu/papers/volume15/wierstra14a/wierstra14a.pdf - ES paper with algo used in Sutskever paper

## Mar 27 - Hacker Dojo
Aurobindo Tripathy will reprise a talk he's going to give at Embedded Summit this year.  His talk will survey recent progress in object detection from RCNN to Single Shot MultiBox Detector and Yolo 9000.

## Mar 20 - Hacker Dojo
https://arxiv.org/pdf/1612.05424.pdf - Unsupervised Pixel-level domain adaptation with generative adversarial networks

## Mar 13 - Hacker Dojo
https://arxiv.org/pdf/1701.06547.pdf - adversarial learning for neural dialog generation

## February 27 - Hacker Dojo
https://arxiv.org/pdf/1612.02699.pdf - Deep Supervision with Shape Concepts for Occlusion-Aware 3D Object Parsing
Zeeshan's slides are in the folder with his name on it.  Along with his descriptions of his own ground-breaking work, he gives an excellent history of efforts to identify 3d objects from 2d images.

## February 20 - Hacker Dojo
https://arxiv.org/pdf/1506.07285.pdf  - Ask me anything - Socher
https://github.com/YerevaNN/Dynamic-memory-networks-in-Theano - Code and implementation notes.
https://www.youtube.com/watch?v=FCtpHt6JEI8&t=27s - Socher presentation of material

## February 13 - Hacker Dojo
https://arxiv.org/pdf/1701.06538v1.pdf - Outrageously large neural networks

## February 6 - Hacker Dojo

https://arxiv.org/pdf/1505.00387v2.pdf - Highway networks
https://arxiv.org/pdf/1507.06228.pdf - Also highway networks - different examples
https://arxiv.org/pdf/1607.03474v3.pdf - Recurrent Highway Networks

## January 30 - Hacker Dojo
https://arxiv.org/pdf/1603.03116v2.pdf - Low-rank pass-through RNN's follow-on to unitary rnn
https://github.com/Avmb/lowrank-gru - theano code

## January 23 - HackerDojo
https://arxiv.org/abs/1612.03242 - Stack Gan Paper
https://github.com/hanzhanggit/StackGAN - Code

## January 16 - Hacker Dojo
https://arxiv.org/pdf/1511.06464v4.pdf - Unitary Evolution RNN
https://github.com/amarshah/complex_RNN - theano code

## January 9 - Hacker Dojo
Cheuksan Edward Wang Talk
https://arxiv.org/pdf/1612.04642v1.pdf - rotation invariant cnn
https://github.com/deworrall92/harmonicConvolutions - tf code for harmonic cnn
http://visual.cs.ucl.ac.uk/pubs/harmonicNets/index.html - blog post by authors

## January 2 - Hacker Dojo
https://arxiv.org/pdf/1602.02218v2.pdf - using typing to improve RNN behavior
http://jmlr.org/proceedings/papers/v37/jozefowicz15.pdf - exploration of alternative LSTM architectures

## December 19 - Hacker Dojo
https://arxiv.org/pdf/1611.01576.pdf - Socher qRnn paper

## December 12 - Hacker Dojo
https://arxiv.org/pdf/1604.02135v2.pdf - latest segmentation fair
https://github.com/MarvinTeichmann/tensorflow-fcn - code for segmenter

## December 5 - Hacker Dojo
https://arxiv.org/pdf/1506.06204.pdf - Object segmentation
https://arxiv.org/pdf/1603.08695v2.pdf - refinement of above segmentation paper
https://code.facebook.com/posts/561187904071636/segmenting-and-refining-images-with-sharpmask/ - blog post
https://github.com/facebookresearch/deepmask - torch code for deepmask

## November 28 - Hacker Dojo
https://arxiv.org/pdf/1506.01497v3.pdf
people.eecs.berkeley.edu/~rbg/slides/rbg-defense-slides.pdf - Girshick thesis slides
Check edge boxes and selective search
https://arxiv.org/pdf/1406.4729v4.pdf - key part of architecture
https://github.com/smallcorgi/Faster-RCNN_TF - excellent code

## November 21 - Hacker Dojo
https://people.eecs.berkeley.edu/~rbg/papers/r-cnn-cvpr.pdf - RCNN
https://arxiv.org/pdf/1504.08083v2.pdf - RCNN - first in series
https://arxiv.org/pdf/1506.01497v3.pdf -  Faster R-CNN
http://techtalks.tv/talks/rich-feature-hierarchies-for-accurate-object-detection-and-semantic-segmentation/60254/ - video of Girshick talk

## November 14 - Hacker Dojo
https://arxiv.org/pdf/1506.02025v3.pdf - Spatial transformer networks
https://github.com/daviddao/spatial-transformer-tensorflow - tf code for above

## October 31 - Hacker Dojo
https://github.com/jazzsaxmafia/show_attend_and_tell.tensorflow - tf code for attention-captioning
http://cs.stanford.edu/people/karpathy/densecap/ - karpathy captioning
https://arxiv.org/pdf/1412.2306v2.pdf - earlier karpathy captioning paper

## October 20 - Galvanize
https://webdocs.cs.ualberta.ca/~sutton/book/the-book.html - Deep dive into reinforcement learning - Sutton and Barto - Chapters 1 and 2.

## Oct 17 - Hacker Dojo
https://arxiv.org/pdf/1608.06993v1.pdf - DenseNet.  New reigning champion image classifier
https://github.com/liuzhuang13/DenseNet - lua code
The DenseNet paper is straight-forward, so we're also going to start on image captioning

http://www.cs.toronto.edu/~zemel/documents/captionAttn.pdf
http://kelvinxu.github.io/projects/capgen.html
http://people.ee.duke.edu/~lcarin/Yunchen9.25.2015.pdf - slides for caption attention

collections of captioning papers.
https://github.com/kjw0612/awesome-deep-vision#image-captioning - images
https://github.com/kjw0612/awesome-deep-vision#video-captioning - video

## Oct 13 - SF
http://www.mit.edu/~dimitrib/NDP_Encycl.pdf - (early) Bersekas paper on RL, policy and value iteration
http://www.nervanasys.com/demystifying-deep-reinforcement-learning/?imm_mid=0e2d7e&cmp=em-data-na-na-newsltr_20160420 - blog post on RL. Nice coverage of value iteration

## Oct 10 - Hacker Dojo
https://github.com/carpedm20/pixel-rnn-tensorflow - tensorflow code for pixel rnn (and cnn)

## Sept 19 - Hacker Dojo
https://arxiv.org/pdf/1606.05328v2.pdf - Conditional Image Generation with PixelCNN decoders
https://arxiv.org/pdf/1601.06759v3.pdf - Pixel RNN
https://drive.google.com/file/d/0B3cxcnOkPx9AeWpLVXhkTDJINDQ/view - wavenet Generative Audio
https://deepmind.com/blog/wavenet-generative-model-raw-audio/ - wavenet blog

## Sept 15 - Galvanize SF
http://www.gitxiv.com/posts/fepYG4STYaej3KSPZ/densely-connected-convolutional-netowork-densenet

## Sept 12 - Hacker Dojo
http://arxiv.org/pdf/1410.3916v11.pdf - original memory networks
https://arxiv.org/pdf/1606.03126v1.pdf - key/value memory augmented nn
http://www.thespermwhale.com/jaseweston/icml2016/icml2016-memnn-tutorial.pdf#page=87 - tutorial on memory networks in language understanding

## August 29 - Hacker Dojo
https://arxiv.org/pdf/1410.5401v2.pdf - Neural Turing Machines
https://github.com/carpedm20/NTM-tensorflow
https://www.youtube.com/watch?v=_H0i0IhEO2g - Alex Graves presentation at microsoft research
http://www.robots.ox.ac.uk/~tvg/publications/talks/NeuralTuringMachines.pdf - slides for ntm

## August 25 - Galvanize (SF)
http://arxiv.org/pdf/1410.3916v11.pdf - original memory networks
https://arxiv.org/pdf/1606.03126v1.pdf - key/value memory augmented nn
http://www.thespermwhale.com/jaseweston/icml2016/icml2016-memnn-tutorial.pdf#page=87 - tutorial on memory networks in language understanding

## August 22 - Hacker Dojo
https://arxiv.org/pdf/1605.07648v1.pdf - fractal net - alternative to resnet for ultra-deep convolution
https://github.com/edgelord/FractalNet - tf code
http://www.gitxiv.com/posts/ibA8QEu8bvBJSDxr9/fractalnet-ultra-deep-neural-networks-without-residuals

## August 18, 2016 - Galvanize (SF)
https://arxiv.org/pdf/1602.01783v2.pdf - new RL architecture - deep mind

Code:
https://github.com/Zeta36/Asynchronous-Methods-for-Deep-Reinforcement-Learning - tf
https://github.com/miyosuda/async_deep_reinforce - tf
https://github.com/coreylynch/async-rl - keras (tf)
https://github.com/muupan/async-rl - chainer (good discussion)

## August 15, 2016 - Hacker Dojo
https://arxiv.org/pdf/1607.02533v1.pdf - Hardening deep networks to adversarial examples.

## August 11, 2016 - Galvanize (SF)
http://www.gitxiv.com/posts/HQJ3F9YzsQZ3eJjpZ/model-free-episodic-control - deep mind gitxiv paper and code on github
https://github.com/sudeepraja/Model-Free-Episodic-Control - other code
https://github.com/ShibiHe/Model-Free-Episodic-Control

## August 8, 2016 - Hacker Dojo
https://arxiv.org/pdf/1406.2661.pdf - originating paper on generative adversarial net (gan) - goodfellow, bengio
http://arxiv.org/pdf/1511.06434v2.pdf - deep cnn gan - radford
https://github.com/Newmu/dcgan_code - theano code for cnn gan - radford

## August 4, 2016 - Galvanize (SF)
http://www.gitxiv.com/posts/HQJ3F9YzsQZ3eJjpZ/model-free-episodic-control - deep mind gitxiv paper and code on github

## August 1, 2016 - Hacker Dojo
Papers -
https://drive.google.com/file/d/0B8Dg3PBX90KNWG5KQXNQOFlBLU1JWWVONkN1UFpnbUR6Y0cw/view?pref=2&pli=1 - Using Stochastic RNN for temporal anomaly detection
https://home.zhaw.ch/~dueo/bbs/files/vae.pdf  - cover math
https://arxiv.org/pdf/1401.4082v3.pdf - Rezende - Other Original VAE paper

Code Review -
https://github.com/oduerr/dl_tutorial/blob/master/tensorflow/vae/vae_demo.ipynb
https://github.com/oduerr/dl_tutorial/blob/master/tensorflow/vae/vae_demo-2D.ipynb

## July 28, 2016 - SF
Papers:
http://arxiv.org/pdf/1410.5401v2.pdf - Neural Turing Machines - Graves et. al.
https://arxiv.org/pdf/1605.06065v1.pdf - One Shot Learning - DeepMind

Code:
http://icml.cc/2016/reviews/839.txt
https://github.com/brendenlake/omniglot
https://github.com/tristandeleu/ntm-one-shot
https://github.com/MLWave/extremely-simple-one-shot-learning

## July 25, 2016 - Hacker Dojo
Papers - Using VAE for anomaly detection
https://arxiv.org/pdf/1411.7610.pdf - Stochastic Recurrent Networks
https://drive.google.com/file/d/0B8Dg3PBX90KNWG5KQXNQOFlBLU1JWWVONkN1UFpnbUR6Y0cw/view?pref=2&pli=1 - Using Stochastic RNN for temporal anomaly detection

## July 21, 2016 - SF
Papers to read:
http://www.thespermwhale.com/jaseweston/ram/papers/paper_16.pdf
http://snowedin.net/tmp/Hochreiter2001.pdf -

Comments / Code
http://icml.cc/2016/reviews/839.txt
https://github.com/brendenlake/omniglot
https://github.com/tristandeleu/ntm-one-shot
https://github.com/MLWave/extremely-simple-one-shot-learning
https://www.periscope.tv/hugo_larochelle/1ypJdnPRYEoKW

## July 18, 2016 - Hacker Dojo
Papers to read:
http://arxiv.org/pdf/1312.6114v10.pdf - variational autoencoders - U of Amsterdam - Kingma and Welling
http://arxiv.org/pdf/1310.8499v2.pdf - deep autoregressive networks - deep mind
 https://arxiv.org/abs/1606.05908 - tutorial on vae

Commentaries/Code
https://jmetzen.github.io/2015-11-27/vae.html - metzen - code and discussion
http://blog.keras.io/building-autoencoders-in-keras.html - chollet - discusses different autoencoders, gives keras code.

## June 27, July 11 2016 - Hacker Dojo
Recurrent network for image generation - Deep Mind
https://arxiv.org/pdf/1502.04623v2.pdf
Background and some references cited
http://blog.evjang.com/2016/06/understanding-and-implementing.html - blog w. code for VAE
http://arxiv.org/pdf/1312.6114v10.pdf - Variational Auto Encoder
https://jmetzen.github.io/2015-11-27/vae.html - tf code for variational auto-encoder
https://www.youtube.com/watch?v=P78QYjWh5sM

https://arxiv.org/pdf/1401.4082.pdf  - stochastic backpropagation and approx inference - deep mind
http://www.cs.toronto.edu/~fritz/absps/colt93.html - keep neural simple by minimizing descr length - hinton
https://github.com/vivanov879/draw - code

## June 20, 2016 - Penninsula
Recurrent models of visual attention - Deep Mind
https://papers.nips.cc/paper/5542-recurrent-models-of-visual-attention.pdf

## June 23, 29 2016 - SF
http://arxiv.org/pdf/1410.5401v2.pdf - Neural Turing Machines - Graves et. al.
https://arxiv.org/pdf/1605.06065v1.pdf - One Shot Learning - DeepMind
http://www.shortscience.org/paper?bibtexKey=journals/corr/1605.06065 - Larochell comments on One-Shot paper
https://github.com/shawntan/neural-turing-machines - Code
https://www.reddit.com/r/MachineLearning/comments/2xcyrl/i_am_j%C3%BCrgen_schmidhuber_ama/cp4ecce - schmidhuber's comments
http://www.thespermwhale.com/jaseweston/ram/papers/paper_16.pdf
http://snowedin.net/tmp/Hochreiter2001.pdf -
Reviews:
http://icml.cc/2016/reviews/839.txt
Code
https://github.com/brendenlake/omniglot
https://github.com/tristandeleu/ntm-one-shot
https://github.com/MLWave/extremely-simple-one-shot-learning

## June 13, 2016 - TBD, Penninsula
Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning:
http://arxiv.org/pdf/1602.07261v1.pdf

## June 9, 2016 - Galvanize
Visualizing and Understanding RNN:
https://arxiv.org/pdf/1506.02078v2.pdf

## June 6, 2016 - Hacker Dojo
Google inception paper - origin of 1x1 convolution layers
http://arxiv.org/pdf/1409.4842v1.pdf

## June 2, May 26, 2016 - Galvanize

Image segmentation with deep encoder-decoder

https://arxiv.org/pdf/1511.00561.pdf

## May 23, 2016 - Hacker Dojo

Compressed networks, reducing flops by pruning

https://arxiv.org/pdf/1510.00149.pdf

http://arxiv.org/pdf/1602.07360v3.pdf

## May 16, 2016

Word2Vec meets LDA:

http://arxiv.org/pdf/1605.02019v1.pdf - Paper

https://twitter.com/chrisemoody - Chris Moody's twiter with links to slides etc.

http://qpleple.com/topic-coherence-to-evaluate-topic-models/ - writeup on topic coherence

## May 9, 2016

https://arxiv.org/pdf/1603.05027v2.pdf - Update on microsoft resnet - identity mapping

http://gitxiv.com/posts/MwSDm6A4wPG7TcuPZ/recurrent-batch-normalization - batch normalization w. RNN

## May 2, 2016

Go playing DQN - AlphaGo

https://gogameguru.com/i/2016/03/deepmind-mastering-go.pdf

https://m.youtube.com/watch?sns=em&v=pgX4JSv4J70 - video of slide presentation on paper

https://en.m.wikipedia.org/wiki/List_of_Go_games#Lee.27s_Broken_Ladder_Game - Handling "ladders" in alphgo

https://en.m.wikipedia.org/wiki/Ladder_(Go) - ladders in go

_____________________________________________________________________________________________________________________
## April 25, 2016 - Microsoft Resnet
The Paper

http://arxiv.org/pdf/1512.03385v1.pdf

References:

http://arxiv.org/pdf/1603.05027v2.pdf - Identity mapping paper

Code:

https://keunwoochoi.wordpress.com/2016/03/09/residual-networks-implementation-on-keras/ - keras code

https://github.com/ry/tensorflow-resnet/blob/master/resnet.py - tensorflow code

https://github.com/tensorflow/tensorflow/blob/master/tensorflow/examples/skflow/resnet.py
_________________________________________________________________________________________________________________
## April 18, 2016 - Batch Normalization
The Paper
https://www.cs.toronto.edu/~vmnih/docs/dqn.pdf
http://gitxiv.com/posts/MwSDm6A4wPG7TcuPZ/recurrent-batch-normalization - Batch Normalization for RNN

___________________________________________________________________________________________________________
## April 11, 2016 - Atari Game Playing DQN
The Paper
https://www.cs.toronto.edu/~vmnih/docs/dqn.pdf)

Related references:

This adds 'soft' and 'hard' attention and the 4 frames are replaced with an LSTM layer:

http://gitxiv.com/posts/NDepNSCBJtngkbAW6/deep-attention-recurrent-q-network

http://home.uchicago.edu/~arij/journalclub/papers/2015_Mnih_et_al.pdf - Nature Paper

http://www.nature.com/nature/journal/v518/n7540/full/nature14236.html - videos at the bottom of the page

http://llcao.net/cu-deeplearning15/presentation/DeepMindNature-preso-w-David-Silver-RL.pdf - David Silver's slides

http://www.cogsci.ucsd.edu/~ajyu/Teaching/Cogs118A_wi09/Class0226/dayan_watkins.pdf

http://www0.cs.ucl.ac.uk/staff/d.silver/web/Teaching.html - David Silver

Implementation Examples:

http://stackoverflow.com/questions/35394446/why-doesnt-my-deep-q-network-master-a-simple-gridworld-tensorflow-how-to-ev?rq=1

http://www.danielslater.net/2016/03/deep-q-learning-pong-with-tensorflow.html

__________________________________________________________________________________________________________
##  March 3, 2016 Gated Feedback RNN
The Paper

"Gated RNN" (http://arxiv.org/pdf/1502.02367v4.pdf

-Background Material

http://arxiv.org/pdf/1506.00019v4.pdf - Lipton's excellent review of RNN
http://www.nehalemlabs.net/prototype/blog/2013/10/10/implementing-a-recurrent-neural-network-in-python/ - Discussion of RNN and theano code for Elman network - Tiago Ramalho
http://deeplearning.cs.cmu.edu/pdfs/Hochreiter97_lstm.pdf - Hochreiter's original paper on LSTM
https://www.youtube.com/watch?v=izGl1YSH_JA - Hinton video on LSTM

-Skylar Payne's GF RNN code
https://github.com/skylarbpayne/hdDeepLearningStudy/tree/master/tensorflow

-Slides
https://docs.google.com/presentation/d/1d2keyJxRlDcD1LTl_zjS3i45xDIh2-QvPWU3Te29TuM/edit?usp=sharing
https://github.com/eadsjr/GFRNNs-nest/tree/master/diagrams/diagrams_formula

## Reviews
http://www.computervisionblog.com/2016/06/deep-learning-trends-iclr-2016.html
https://indico.io/blog/iclr-2016-takeaways/


text:
# Wolf Examples

This is a hello world example using wolf, a Simple Workflow
library. To build this example:

    $ ./build.sh

To run this example, export your AWS credentials and run:

    $ export AWS_ACCESS_KEY_ID=***
    $ export AWS_SECRET_ACCESS_KEY=***
    $ ./run.sh

## Background

Wolf provides commands and configuration to run containerized tasks
with Simple Workflow. Using a few conventions around input, output,
and storage, wolf composes tasks into workflows that can be run in
containers in any language environment.

### Containers

Tasks are run from containers. This example defines a single
container, [./hello-world][4], that contains two python scripts,
[./hello-world/hello.py][5] and [./hello-world/world.py][6].

Tasks' JSON input is accessible in the contents of the file at
`/app/data/input.json` - this is workflow specific input, where these
is an inital input that is subsequently transformed by each task.

JSON metadata about the workflow is accessible in the contents of the
file at `/app/data/control.json` - useful identifiers about the
workflow can be found there.

Tasks' JSON output should be written to the file at
`/app/data/output.json` - this output will serve as input into the
next task in the workflow.

Any artifacts needing to be stored besides simple outputs can be
written to the directory `/app/store`, where all files will be
uploaded to S3.

The initial input for the this example is found in
[./execute.json][7].

### Configuration

The general configuration for wolf is found in
[./cfg/config.yaml][8] - it contains information around AWS region,
timeouts, credential environment variable names, SWF domains, and S3
prefix and bucket information. NOTE: change the S3 bucket to somewhere
you have permissions to write to.

Tasks are composed together in the workflow's plan configuration found
in [./cfg/plan.yaml][9], specifying that we want to run the Hello
task, followed by 15 seconds of Sleep, followed by the World
task. This workflow loops on itself and will continuously keep
running - after World ends, Hello will start.

The configuration for each task is found in a specific yaml file
containing the task's container parameters: which image to use, which
command to run, etc. The Hello's task configuration is found in
[./cfg/hello.yaml][10] and the World's task configuration is found in
[./cfg/world.yaml][11].

Finally, the specification of containers to run is found in
[./docker-compose.yml][12] - Hello and World containers will be
started up along with a Decide container to drive the workflow.

### Sample Output

    hello_1  |
    hello_1  | {u'run_uid': u'e9e59f03-556f-4d2a-92cb-b6ba0f451263'}
    hello_1  |
    hello_1  |
    hello_1  | {u'step-0': u'execute'}
    hello_1  |
    hello_1  |
    hello_1  | hello worker
    hello_1  |
    hello_1  |
    hello_1  | {'step-1': 'hello', u'step-0': u'execute'}
    hello_1  |
    hello_1  |
    hello_1  | {'step-1': 'hello', u'step-0': u'execute', 'storage': 'true'}
    hello_1  |
    world_1  |
    world_1  | {u'run_uid': u'e9e59f03-556f-4d2a-92cb-b6ba0f451263'}
    world_1  |
    world_1  |
    world_1  | {u'step-1': u'hello', u'step-0': u'execute'}
    world_1  |
    world_1  |
    world_1  | world worker
    world_1  |
    world_1  |
    world_1  | {'step-2': 'world', u'step-1': u'hello', u'step-0': u'execute'}
    world_1  |
    world_1  |
    world_1  | {'step-2': 'world', u'step-1': u'hello', u'step-0': u'execute', 'storage': 'true'}
    world_1  |

### Dependencies

To build and run this example, the following dependencies are required:

+ [stack][1] is a tool for building Haskell projects. See the linked downloads page.
+ [docker][2] is container tooling.
+ [docker-compose][3] is container tooling.

[1]: https://github.com/commercialhaskell/stack/blob/master/doc/install_and_upgrade.md
[2]: https://www.docker.com/
[3]: https://docs.docker.com/compose/install/
[4]: https://github.com/swift-nav/wolf/blob/master/examples/hello-world/Dockerfile
[5]: https://github.com/swift-nav/wolf/blob/master/examples/hello-world/hello.py
[6]: https://github.com/swift-nav/wolf/blob/master/examples/hello-world/world.py
[7]: https://github.com/swift-nav/wolf/blob/master/examples/execute.json
[8]: https://github.com/swift-nav/wolf/blob/master/examples/cfg/config.yaml
[9]: https://github.com/swift-nav/wolf/blob/master/examples/cfg/plan.yaml
[10]: https://github.com/swift-nav/wolf/blob/master/examples/cfg/hello.yaml
[11]: https://github.com/swift-nav/wolf/blob/master/examples/cfg/world.yaml
[12]: https://github.com/swift-nav/wolf/blob/master/examples/docker-compose.yml

repository: alanz/wolf

repo_name: alanz/wolf


text:
# @jscad/modeling

> Solid Modelling Library for 2D and 3D Geometries

[![NPM version](https://badge.fury.io/js/%40jscad%2Fmodeling.svg)](https://www.npmjs.com/package/@jscad/modeling)
[![NPM downloads](https://img.shields.io/npm/dw/@jscad/modeling)](https://www.npmjs.com/package/@jscad/modeling)
[![Build Status](https://travis-ci.org/jscad/OpenJSCAD.org.svg?branch=master)](https://travis-ci.org/jscad/OpenJSCAD.org)
[![Stability](https://img.shields.io/badge/stability-stable-success)](https://github.com/emersion/stability-badges#stable)
[![License](https://img.shields.io/github/license/jscad/OpenJSCAD.org)](https://github.com/jscad/OpenJSCAD.org/blob/master/LICENSE)

[![User Group](https://img.shields.io/badge/maintained%20by-user%20group-blue)](https://openjscad.nodebb.com/)
[![Lerna](https://img.shields.io/badge/maintained%20with-lerna-blue)](https://lernajs.io/)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-blue)](https://standardjs.com)

[![Backers](https://img.shields.io/opencollective/backers/openjscad)](https://opencollective.com/openjscad)
[![Sponsors](https://img.shields.io/opencollective/sponsors/openjscad)](https://opencollective.com/openjscad)

## Overview

This library contains boolean operations based on Constructive Solid Geometry (CSG). CSG is a modelling technique that uses boolean operations like union and intersection to combine 3D solids. This library implements CSG operations on meshes elegantly and concisely using BSP trees, and is meant to serve as an easily understandable implementation of the algorithm.

## Table of Contents

- [Installation](#installation)
- [Usage](#usage)
- [Documentation](#documentation)
- [Contributing](#contributing)
- [Community](#community)
- [Copyrights](#copyrights)
- [License](#license)

## Installation

```
npm install @jscad/modeling
```

## Usage

As a Node module:

```
const {color, connectors, geometry, math, primitives, text, utils} = require('@jscad/modeling')
const {booleans, expansions, extrusions, hulls, measurements, transforms} = require('@jscad/modeling')
```

## Documentation

- [API Reference](https://openjscad.xyz/docs/).
- [JSCAD User Guide](https://openjscad.xyz/guide.html)

## Contributing

The various JSCAD packages and all source code are part of the JSCAD Organization, and maintained by a group of volunteers.
We welcome and encourage anyone to pitch in but please take a moment to read the following guidelines.

* If you want to submit a bug report please make sure to follow the [Reporting Issues](https://github.com/jscad/OpenJSCAD.org/wiki/Reporting-Issues) guide. Bug reports are accepted as [Issues](https://github.com/jscad/OpenJSCAD.org/issues/) via GitHub.

* If you want to submit a change or a patch, please read the [Contributing Guide](../../CONTRIBUTING.md). New contributions are accepted as [Pull Requests](https://github.com/jscad/OpenJSCAD.org/pulls/) via GitHub.

* We only accept bug reports and pull requests on **GitHub**.

* If you have a question about how to use JSCAD, then please start a conversation at the [JSCAD User Group](https://openjscad.xyz/forum.html). You might find the answer in the [JSCAD User Guide](https://openjscad.xyz/guide.html).

* If you have a change or new feature in mind, please start a conversation with the [Core Developers](https://openjscad.xyz/forum.html) and start contributing changes.

Small Note: If editing this README, please conform to the [standard-readme](https://github.com/RichardLitt/standard-readme) specification.

## Community

See for more details
* [JSCAD User Group](https://openjscad.xyz/forum.html)

## Copyrights

Some copyrights apply from integration of original libraries.

CSG Library : Copyright (c) 2012 Joost Nieuwenhuijse, under the MIT license. Copyright (c) 2011 Evan Wallace, under MIT license.

Portions of glMatrix Library: Copyright (c) 2015-2020, Brandon Jones, Colin MacKenzie IV, under MIT license.

Quickhull Library: Copyright (c) 2015 Mauricio Poppe, under the MIT license.

## License

[The MIT License (MIT)](../../LICENSE)
(unless specified otherwise)


text:
League of Legend

League of Legends App is a small demo application based on modern Android application tech-stacks and MVVM architecture.
Also fetching data from the network and integrating persisted data in the database via repository pattern.

## Tech stack & Open-source libraries
- Minimum SDK level 21
- [Kotlin](https://kotlinlang.org/) based, [Coroutines](https://github.com/Kotlin/kotlinx.coroutines) + [Flow](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/) for asynchronous.
- [Koin](https://github.com/InsertKoinIO/koin) for dependency injection.
- JetPack
  - LiveData - notify domain layer data to views.
  - Lifecycle - dispose of observing data when lifecycle state changes.
  - ViewModel - UI related data holder, lifecycle aware.
  - Room Persistence - construct a database using the abstract layer.
  - Palette - A helper class to extract prominent colors from an image.
  - Databinding - Bind UI components in your layouts to data sources in your app.
- Architecture
  - MVVM Architecture (View - DataBinding - ViewModel - Model)
  - Repository pattern
- [Retrofit2 & OkHttp3](https://github.com/square/retrofit) - construct the REST APIs and paging network data.
- [Gson](https://github.com/google/gson) - A modern JSON library for Kotlin and Java.
- [Coil](https://github.com/coil-kt/coil) - loading images.
- [Timber](https://github.com/JakeWharton/timber) - logging.
- [Stetho](http://facebook.github.io/stetho/) - Http Inspector
- [Material-Components](https://github.com/material-components/material-components-android) - Material design components like ripple animation, cardView.

## Architecture
League of Legends App is based on MVVM architecture and a repository pattern.

![architecture](https://developer.android.com/topic/libraries/architecture/images/final-architecture.png)

## Open API

League of Legends App using the [LoLAPI](https://developer.riotgames.com/docs/lol#data-dragon) for constructing RESTful API.

LoLAPI provides a RESTful API interface to highly detailed objects.

# License
```xml
Designed and developed by 2020 dsemprich (David Semprich)

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.
```

repository: dsemprich/LeagueOfLegends

repo_name: dsemprich/LeagueOfLegends


text:
# AIPND
This repository contains code and associated files for the AI Programming with Python Nanodegree program. This repository consists of a number of tutorial notebooks for various coding exercises and programming labs that will be used to supplement the lessons of the course.

## Table Of Contents

### Tutorial Notebooks
* Linear Algebra Essentials
    * [Vectors Lab](https://github.com/udacity/AIPND/tree/master/linearalgebra-vectors_lab "Vectors Lab") Learn how to graph 2D vectors.
    * [Linear Combination Lab](https://github.com/udacity/AIPND/tree/master/linearalgebra-linear_combination "Linear Combination Lab") Learn how to computationally determine a vector's span and solve a simple system of equations.
    * [Linear Mapping](https://github.com/udacity/AIPND/tree/master/linearalgebra-linear_mapping "Linear Mapping Labs") Learn how to solve some problems computationally using vectors and matrices.
### Programming Labs
* [Intro to Python Lab - Classifying Images Lab:](https://github.com/udacity/AIPND/tree/master/intropylab-classifying-images "Classifying Images Lab") Determine which CNN architecture model works best at classifying images of dogs and their breeds.

### NumPy and Pandas Mini-Projects
* [NumPy Mini-Project](https://github.com/udacity/AIPND/tree/master/NumPy%20Mini-Project) Mean normalize and separate data
* [Pandas Mini-Project](https://github.com/udacity/AIPND/tree/master/Pandas%20Mini-Project) Get statistics from stock data

### Matplotlib
* [Matplotlib](https://github.com/udacity/AIPND/tree/master/Matplotlib) Notebooks containing practice exercises for the Matplotlib lesson(s)

### Quiz Notes
* [Notes:](https://github.com/udacity/AIPND/tree/master/notes "Notes") This directory contains more information about certain quizzes that are testing more challenging concepts. The filename indicates which _quiz_ the note is covering. Additionally, one will find the [Frequently Asked Questions](https://github.com/udacity/AIPND/blob/master/notes/lab_intro-to-python-lab.md) for the _Intro to Python Lab_. Click on the filename to view the contents of the notes on a _quiz_ or the _Intro to Python Lab_.

## Dependencies

Each directory has a `requirements.txt` describing the minimal dependencies required to run the notebooks in that directory.

### pip

To install these dependencies with pip, you can issue `pip3 install -r requirements.txt`.

repository: vtheagarajan/AIPND

repo_name: vtheagarajan/AIPND


text:
# hsluv-ts

**hsluv-ts** is a TypeScript wrapper around the [`hsluv`](https://www.npmjs.com/package/hsluv) color library, which lacks type definitions.

## Install

```sh
// If you use yarn
yarn add hsluv-ts

// If you use npm
npm install hsluv-ts
```

## Usage

The type definition file should illustrate the usage of the various conversion functions.

```ts
export declare type ThreeNumbers = [number, number, number];
/**
 * hue is a number between 0 and 360, saturation and lightness are numbers between 0 and 100. This function returns the resulting color as a hex string.
 */
export declare function hsluvToHex([hue, saturation, lightness]: ThreeNumbers): string;
/**
 * Like above, but returns an array of 3 numbers between 0 and 1, for the r, g, and b channel.
 */
export declare function hsluvToRgb([hue, saturation, lightness]: ThreeNumbers): ThreeNumbers;
/**
 * Takes a hex string and returns the HSLuv color as array that contains the hue(0 - 360), saturation(0 - 100) and lightness(0 - 100) channel.Note: The result can have rounding errors.For example saturation can be<PHONE_NUMBER>0000007
 */
export declare function hexToHsluv(hex: string): ThreeNumbers;
/**
 * Like above, but red, green and blue are passed as numbers between 0 and 1.
 */
export declare function rgbToHsluv([red, green, blue]: ThreeNumbers): any;
/**
 * hue is a number between 0 and 360, saturation and lightness are numbers between 0 and 100. This function returns the resulting color as a hex string.
 */
export declare function hpluvToHex([hue, saturation, lightness]: ThreeNumbers): string;
/**
 * Like above, but returns an array of 3 numbers between 0 and 1, for the r, g, and b channel.
 */
export declare function hpluvToRgb([hue, saturation, lightness]: ThreeNumbers): ThreeNumbers;
/**
 * Takes a hex string and returns the HSLuv color as array that contains the hue(0 - 360), saturation(0 - 100) and lightness(0 - 100) channel.Note: The result can have rounding errors.For example saturation can be<PHONE_NUMBER>0000007
 */
export declare function hexToHpluv(hex: string): ThreeNumbers;
/**
 * Like above, but red, green and blue are passed as numbers between 0 and 1.
 */
export declare function rgbToHpluv([red, green, blue]: ThreeNumbers): any;
export declare function hsluvToLch([hue, saturation, lightness]: ThreeNumbers): ThreeNumbers;
export declare function lchToHsluv([lightness, chroma, hue]: ThreeNumbers): ThreeNumbers;
export declare function hpluvToLch([hue, pastelSaturation, lightness]: ThreeNumbers): ThreeNumbers;
export declare function lchToHpluv([lightness, chroma, hue]: ThreeNumbers): ThreeNumbers;
export declare function rgbToXyz([red, green, blue]: ThreeNumbers): ThreeNumbers;
export declare function xyzToRgb([x, y, z]: ThreeNumbers): ThreeNumbers;
export declare function rgbToLch([red, green, blue]: ThreeNumbers): ThreeNumbers;
export declare function lchToRgb([lightness, chroma, hue]: ThreeNumbers): ThreeNumbers;
export declare function luvToXyz([l, u, v]: ThreeNumbers): ThreeNumbers;
export declare function xyzToLuv([x, y, z]: ThreeNumbers): ThreeNumbers;
export declare function lchToLuv([lightness, chroma, hue]: ThreeNumbers): ThreeNumbers;
export declare function luvToLch([l, u, v]: ThreeNumbers): ThreeNumbers;
```

repository: gfmio/hsluv-ts

repo_name: gfmio/hsluv-ts


text:
# GPS-Demo

This Project is simple GPS tracker, which give you current Lat-Long every 10 sec.
Use Location Listener for get Current Location.
Use Result Receiver as local broadcast receiver for display location update on UI.
And also display distance between last location and new location if it'll change.

repository: HypnoticLemon/GPS-Demo

gha_language: Java

repo_name: HypnoticLemon/GPS-Demo


text:
---
slug: "/services/pos-point-of-sale/training-services"
title: "Training services"
sidebarName: "posSidebar"
---

The timely activation of your end-users ensuring that they are trained to use your products and services correctly are critical to the success of your business. Our professional training staff will contact your end-users in advance to schedule a training to coincide with the arrival of new equipment. Training is performed using approved and tested scripts; confirmation of the completed training is recorded in the Sonoma CRM system. Reporting is available on a daily basis to track and report all training activities.

- Introduction to the terminal (hardware, software)
- Installation (printer/mode, pin pad, IP or dial connectivity)
- General operating instructions (transaction functions, training tips, reports, basic troubleshooting
- Activate terminal and run successful test transaction


text:
# Feature Layer Dictionary Renderer

Displays a FeatureLayer with military symbology, using ArcGIS Runtime's DictionaryRenderer.

![Feature Layer Dictionary Renderer App](feature-layer-dictionary-renderer.png)

## How it works

This sample loads a number of point, line, and polygon feature tables from a Runtime geodatabase. For each feature table, a FeatureLayer is created, and a DictionaryRenderer object is created and applied to the layer. Note that each layer needs its own renderer, though all renderers can share the DictionarySymbolStyle, in which case all layers will use the same symbology specification (MIL-STD-2525D in the case of this sample). Each layer is added to the map, and when all layers are loaded, the map's viewpoint is set to zoom to the full extent of all feature layers.

## Relevant API

* DictionaryRenderer
* DictionarySymbolStyle
* FeatureLayer
* Geodatabase

## Offline data
1. Download the data from the table below.
2. Extract the contents of the downloaded zip file to disk.
3. Create an ArcGIS/samples/Dictionary folder on your device. You can use the [Android Debug Bridge (adb)](https://developer.android.com/guide/developing/tools/adb.html) tool found in **<sdk-dir>/platform-tools**.
4. Open up a command prompt and execute the `adb shell` command to start a remote shell on your target device.
5. Navigate to your sdcard directory, e.g. `cd /sdcard/`.
6. Create the ArcGIS/samples/Dictionary directory, `mkdir ArcGIS/samples/Dictionary`.
7. You should now have the following directory on your target device, `/sdcard/ArcGIS/samples/Dictionary`. We will copy the contents of the downloaded data into this directory. Note:  Directory may be slightly different on your device.
8. Exit the shell with the, `exit` command.
9. While still in your command prompt, navigate to the folder where you extracted the contents of the data from step 1 and execute the following command:
	* `adb push mil2525d.stylx /sdcard/ArcGIS/samples/Dictionary`
	* `adb push militaryoverlay.geodatabase /sdcard/ArcGIS/samples/Dictionary`

Link | Local Location
---------|-------|
|[Mil2525d Stylx File](https://www.arcgis.com/home/item.html?id=c78b149a1d52414682c86a5feeb13d30)| `<sdcard>`/ArcGIS/samples/Dictionary/mil2525d.stylx |
|[Military Overlay geodatabase](https://www.arcgis.com/home/item.html?id=e0d41b4b409a49a5a7ba11939d8535dc)| `<sdcard>`/ArcGIS/samples/Dictionary/militaryoverlay.geodatabase |

### Tags
Visualization