In May 2014, Google announced its crawler would execute javascript. Previously, Googlebot and other crawlers could not execute javascript which means any single page app (regardless of framework) would not get indexed.
The solution was to have your server detect for crawlers, and then serve up a rendered version of your page. If your backend was written in NodeJS, you could somewhat painlessly use PhantomJS. If you didn’t have a Node backend, it was a bigger pain. At Flixel, we have a Django backend which means using the Django Casper module. However, our server instances didn’t support using Node and Django on the same instance meaning we would have to set up another instance to even run this extra module.
The effort mentioned above is do-able but with Googlebot executing JS, we opted not to bother with a server side solution. Considering the opaque nature of indexing, we waited a while to see results.
We spent some time making the app more SEO-friendly (i.e. meta description, etc.) and still saw no results.
I e-mailed the author of AngularJS & SEO - finally a piece of cake to see what advice he had. His experience was similar to mine, after a month or two of waiting, no pages were being indexed. From the author:
That’s also the reason I haven’t written my actually planned follow-up post to this point. When I wrote the piece you read, we hadn’t any indexed, but a good amount of crawled pages. We’ve been waiting for a good month i published the write-up, trying to make some difference with the tools available in google webmaster tools; manually adding urls, recrawling, url-parameter stuff etc. At the end there hasn’t been a single page in the index crawled by the ‘js-feature’!
Perhaps things have changed since May, but it seems from two people’s experience, relying on Googlebot to execute your javascript is not a good option if SEO is a concern.


| write.mitmlSAV {mitml} | R Documentation |
mitml
objects to native SPSS formatSaves objects of class mitml
in the .sav
format used by the statistical software SPSS (IBM Corp., 2013).
The function serves as a front-end for write_sav
from the haven
package.
write.mitmlSAV(x, filename)
x |
An object of class |
filename |
Name of the destination file. The file extension ( |
This function exports multiply imputed data sets to a single .sav
file, in which an Imputation_
variable separates the original data and the various imputed data sets.
This allows exporting imputed data directly to the native SPSS format.
Alternatively, write.mitmlSPSS
may be used for creating separate text and SPSS syntax files, which offers more control over the data format.
None (invisible NULL
).
Simon Grund
IBM Corp. (2013). IBM SPSS Statistics for Windows, Version 22.0. Armonk, NY: IBM Corp
panImpute
, jomoImpute
, mitmlComplete
, write.mitmlSPSS
## Not run: data(studentratings) fml <- ReadDis + SES ~ ReadAchiev + (1|ID) imp <- panImpute(studentratings, formula = fml, n.burn = 1000, n.iter = 100, m = 5) # write data file and SPSS syntax write.mitmlSAV(imp, filename = "imputation") ## End(Not run)


CURLOPT_PROXY_SSLVERSION explained
NAME
CURLOPT_PROXY_SSLVERSION - set preferred proxy TLS/SSL version
SYNOPSIS
#include <curl/curl.h>
CURLcode curl_easy_setopt(CURL *handle, CURLOPT_PROXY_SSLVERSION, long version);
DESCRIPTION
Pass a long as parameter to control which version of SSL/TLS to attempt to use when connecting to an HTTPS proxy.
Use one of the available defines for this purpose. The available options are:
The default action. This will attempt to figure out the remote SSL protocol version.
TLSv1.x
TLSv1.0
TLSv1.1
TLSv1.2
TLSv1.3
The maximum TLS version can be set by using one of the CURL_SSLVERSION_MAX_ macros below. It is also possible to OR one of the CURL_SSLVERSION_ macros with one of the CURL_SSLVERSION_MAX_ macros. The MAX macros are not supported for SSL backends axTLS or wolfSSL.
The flag defines the maximum supported TLS version as TLSv1.2, or the default value from the SSL library. (Added in 7.54.0)
The flag defines maximum supported TLS version as TLSv1.0. (Added in 7.54.0)
The flag defines maximum supported TLS version as TLSv1.1. (Added in 7.54.0)
The flag defines maximum supported TLS version as TLSv1.2. (Added in 7.54.0)
The flag defines maximum supported TLS version as TLSv1.3. (Added in 7.54.0)
DEFAULT
PROTOCOLS
EXAMPLE
CURL *curl = curl_easy_init(); if(curl) { curl_easy_setopt(curl, CURLOPT_URL, "https://example.com"); /* ask libcurl to use TLS version 1.0 or later */ curl_easy_setopt(curl, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1); /* Perform the request */ curl_easy_perform(curl); }
AVAILABILITY
RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
SEE ALSO
CURLOPT_USE_SSL, CURLOPT_HTTP_VERSION, CURLOPT_IPRESOLVE
This HTML page was made with roffit.


It's similar to TodoMVC but with more
stuff you might encounter in a business application such as:
- Data grid with column sorting
- Data grid search with "no matching data" / empty results UI
- Select / drop-down menus
- Complex input validation & sanitization
- Integration with jQuery plugins (jQuery-UI Date Picker)
- Modal dialogs
- Navigate away warnings when you have unsaved changes
- Prevent double-form submission
- Componentized for re-use
- A pie chart!
Each example uses an in-memory "backend" which will be re-set every time you reload the app.


I find fulfillment in using my skills to make things and/or support the people who make things.

Experience
Played With:
- Android Dev (Java, XML, Android Studio)
- Game Dev (C#, Unity, MonoDevelop)
- Bot Dev (Python, Discord, Sublime)
- Web Dev (HTML, CSS, Javascript, Visual Studio)
Worked With:
- Writing/Editing (Novel, Journalism, and Copywriting)
- Printing (Litho, Roll2Roll & Sheetfed)
- Marketing (Social Media Focus)
- The Art of Scaring People (TV Zombie and Theme Park Cave Monster)
- Lifting Heavy Things (Logistics and Fullfillment)
Education
- Codefellows HTML, CSS, Javascript, Java
- Onward 2 Opportunity Certified Associate in Project Management
- University of Washington Bachelor of Arts in Anthropology
Top Ten Favorite Games
- Tomb Raider Reboot
- Halo Reach
- The Elder Scrolls Legends
- Age of Empires
- Candy Crush Jelly
- Graveyard Keeper
- Overwatch
- Pokemon Black
- Assassin's Creed Chronicles: China
- Shadow of Mordor
Bonus Questions
Want to learn some random facts? Try out this trivia game:
All About Paula


Felicia's Journey (1999) Reviewed by Eugene Novikov http://www.ultimate-movie.com/ Member: Online Film Critics Society
Starring Bob Hoskins, Elaine Cassidy, Arsinée Khanjian. Rated PG-13.
There are many superficial similarities between Atom Egoyan's flawed but resonant new movie Felicia's Journey and his 1997 critical smash The Sweet Hereafter, but the two films are fundamentally different. Hereafter was a concept movie, dealing with the idea of grief after a tragedy. Felicia's Journey is nothing of the sort. It's a character movie, one that plunges into the deepest, darkest depths of human nature. The main character is a serial killer and yet the killings are never shown; the movie is not about them.
Young, naive, pregnant Felicia comes to Great Britain from Ireland in search of her lover, who has reportedly gone away to serve in the army. He promised Felicia he would write every day, but she has not heard a word from him since he left. The only information she has came from a friend of a friend, and that is that he works in a lawnmower factory. She wonders around England's industrial midlands in search of Wonderboy; she is instead taken in by Joseph Ambrose Hilditch (Bob Hoskins), who obligingly assists her in her search but has dark ulterior motives himself.
You see, Hilditch has murdered a number of young women. They were all lonely young things, undergoing major crises. He preyed on their emotions and when they tried to leave, he killed them. Hilditch himself doesn't know he did it: he remembers the girls, but not the crimes. He obsessively follows along with tapes of his classy mother's old cooking shows, where he, as a child was the co-star -- whenever his mother needed someone to humiliate.
Meanwhile, Hilditch takes steps to make sure Felicia stays by his side and she never suspects him for a moment. Felicia's Journey develops into a suspense thriller that uses drastically untraditional methods to generate that suspense: no quickening of the pace, no dramatic swells of the soundtrack to indicate something exciting happening. The result is, unfortunately, an effective drama but not much of a thriller. We're involved, emotionally and viserally, but never particularly, um, thrilled. Not that there's anything wrong with that.
One of Egoyan's more tangible fallacies here is the film's first 45 minutes. He limps out of the starting line with a deadly slow first third, to the point where I had almost given up on the movie by the time things got interesting. It's a well-known fact that non-mainstream directors like to take their time, but isn't grabbing the audience's attention immediately one of the first rules of filmmaking?
Fortunately, once things get interesting, they really get interesting. The performances quickly develop into rich, deep characterizations and the plot becomes intricate and involving. Egoyan is a craftsman, one of the most effectively subtle directors in the business. His films take on an eerie quality of a whole other level running beneath the main storyline. We get glimpses of it once in a while, through character revelations, script allusions, et al -- or we think we do -- but for the most part it remains hidden from us. Of course, it may not even exist, but in that case Egoyan's deliberate, mystical style is sure good at making us imagine it.
The ending of Felicia's Journey is a tour de force. At that point, everything becomes clear and you realize just how good everything that preceded it was. It creates the temptation to go back and watch the movie again (something I plan to do, since I have the video) to learn more about Joseph Ambrose Hilditch.
I do wish the character of Felicia was more of a person than a concept. She barely even has dialogue and, as a result, never fully becomes human. Thus, we can't identify with her and the film's protagonist becomes the serial killer himself, something that should turn off audiences. It also makes the title kinda strange -- this is hardly Felicia's journey. The movie ceases to be about her as soon as we see Hilditch's first cooking scene.
I'm not as enthusiastic about this movie as I was about The Sweet Hereafter because it's rougher around the edges. The film "wakes up" in its last 20 minutes, but there is no reason why the whole movie couldn't have been as rich and as complex as those final moments. But I won't complain too much. Go see this one.
Grade: B+
©1999 Eugene Novikov
Sent via Deja.com http://www.deja.com/ Before you buy.
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


{% extends "layout/base.html" %} {% load static widget_tweaks i18n entrepreneur_tags %} {% block title %}{{ company }} - {% trans 'Settings' %}{% endblock %} {% block css %} {% endblock %} {% block content %}
{% trans 'Industry sectors' %}
{% trans "Transfer company ownership to another active administrator. You will keep your role as administrator active." %}
{% else %}{% trans 'To transfer a company to another user, this user must have an active administrator membership in the company' %}. {% trans 'Go to roles section.' %}
{% endif %}{% trans "Delete company profile. Created job offers and memberships will be deleted too." %}
{% trans 'Delete' %} {% else %}{% trans "Only the company owner can delete it." %}
{{ company.owner }} {% trans "is the company owner." %}
{% endif %}


| #invoice123ABC | 18 july 2020 | ||
|---|---|---|---|
|
Pay to : the tech park 123,USA |
Customer : jhon lark main street,123 USA |
||
| Name/Description | Qty. | MRP | Amount |
| Biriyani | 3 | 400 | 1200 |
| Chocolate | 3 | 200 | 600 |
| Subtotal: | 1800 | ||
| Tax | 10% | 180 | |
| Grand Total: | BDT.1620 /= |


We have sent an email to the address you specified, containing an authentication code.
Enter or copy/paste the code in the box to authenticate your password reset request, so you
can change your password.
If you cannot find the email with your code, you may need to check your spam/junk folder.


Blob
Represents a BLOB value.
| Methods |
| void |
free()
Release all resources of this object.
|
| void |
free()
Release all resources of this object.
|
| InputStream |
getBinaryStream()
Returns the input stream.
|
| InputStream |
getBinaryStream() throws SQLException
Returns the input stream.
Returns:
the input stream
Throws:
SQLException
|
| InputStream |
getBinaryStream(long pos, long length)
[Not supported] Returns the input stream, starting from an offset.
|
| InputStream |
getBinaryStream(long pos, long length) throws SQLException
[Not supported] Returns the input stream, starting from an offset.
Parameters:
pos - where to start reading
length - the number of bytes that will be read
Returns:
the input stream to read
Throws:
SQLException
|
| byte[] |
getBytes(long pos, int length)
Returns some bytes of the object.
|
| byte[] |
getBytes(long pos, int length) throws SQLException
Returns some bytes of the object.
Parameters:
pos - the index, the first byte is at position 1
length - the number of bytes
Returns:
the bytes, at most length bytes
Throws:
SQLException
|
| long |
length()
Returns the length.
|
| long |
length() throws SQLException
Returns the length.
Returns:
the length
Throws:
SQLException
|
| long |
position(byte[] pattern, long start)
[Not supported] Searches a pattern and return the position.
|
| long |
position(byte[] pattern, long start) throws SQLException
[Not supported] Searches a pattern and return the position.
Parameters:
pattern - the pattern to search
start - the index, the first byte is at position 1
Returns:
the position (first byte is at position 1), or -1 for not found
Throws:
SQLException
|
| long |
position(Blob blobPattern, long start)
[Not supported] Searches a pattern and return the position.
|
| long |
position(Blob blobPattern, long start) throws SQLException
[Not supported] Searches a pattern and return the position.
Parameters:
blobPattern - the pattern to search
start - the index, the first byte is at position 1
Returns:
the position (first byte is at position 1), or -1 for not found
Throws:
SQLException
|
| OutputStream |
setBinaryStream(long pos)
Get a writer to update the Blob.
|
| OutputStream |
setBinaryStream(long pos) throws SQLException
Get a writer to update the Blob. This is only supported for new, empty
Blob objects that were created with Connection.createBlob(). The Blob is
created in a separate thread, and the object is only updated when
OutputStream.close() is called. The position must be 1, meaning the whole
Blob data is set.
Parameters:
pos - where to start writing (the first byte is at position 1)
Returns:
an output stream
|
| int |
setBytes(long pos, byte[] bytes)
Fills the Blob.
|
| int |
setBytes(long pos, byte[] bytes) throws SQLException
Fills the Blob. This is only supported for new, empty Blob objects that
were created with Connection.createBlob(). The position
must be 1, meaning the whole Blob data is set.
Parameters:
pos - where to start writing (the first byte is at position 1)
bytes - the bytes to set
Returns:
the length of the added data
|
| int |
setBytes(long pos, byte[] bytes, int offset, int len)
[Not supported] Sets some bytes of the object.
|
| int |
setBytes(long pos, byte[] bytes, int offset, int len) throws SQLException
[Not supported] Sets some bytes of the object.
Parameters:
pos - the write position
bytes - the bytes to set
offset - the bytes offset
len - the number of bytes to write
Returns:
how many bytes have been written
Throws:
SQLException
|
| void |
truncate(long len)
[Not supported] Truncates the object.
|
| void |
truncate(long len) throws SQLException
[Not supported] Truncates the object.
Parameters:
len - the new length
Throws:
SQLException
|
|


It's possible to use Preview tab in the Find in Path dialog box, for quicker search, without ever leaving the dialog box.
The first 100 search results show in the Preview tab right away.


Looks like you have {{ wallets.length }} pending wallets!
Looks like you have a locked wallet!
Remind the person who invited you to Merit to confirm your invite request.
Once confirmed, your wallet will be unlocked and you'll be able to send, receive, and mine Merit.


This site was created to help UHM students!!! Students can visit pages such as textbooks to see if anyone is selling textbooks at a low price!!!
-Navigate using the top bar and visit sites you are interested in
-Intructions and additional information will be included in the site that you visit
-Make the best out of your college experience
-Subscribe to Chegg(Don't abuse it!!!)
-Dont be afraid to ask questions
-Make friends
-Do not conduct any illegal activities
-Do not bully, harass, or discriminate others
-Do not use this site to cheat on any class ( BE ETHICAL OR WE WILL REPORT YOU TO THE FBI!!! )


Before Change
self.mock_get_instance_primary_vnic = self.enter_context(
mock.patch.object(ibm_api.IbmAPICommand, "InstanceGetPrimaryVnic"))
self.mock_instance_fip_create = self.enter_context(
mock.patch.object(ibm_api.IbmAPICommand, "InstanceFipCreate"))
self.mock_list_resources = self.enter_context(
mock.patch.object(ibm_api.IbmAPICommand, "ListResources"))
self.mock_create_vpc = self.enter_context(
After Change
mock.patch.object(ibm_api.IbmAPICommand, "CreateSubnet"))
self.mock_check_environment = self.enter_context(
mock.patch.object(ibm_api.IbmAPICommand, "_CheckEnvironment"))
with mock.patch.object(ibm_api.IbmAPICommand, "__init__", lambda self: None):
self.cmd = ibm_api.IbmAPICommand()
self.vm = self._CreateTestIbmCloudVirtualMachine()
def _CreateBenchmarkSpecFromYaml(self, yaml_string,
benchmark_name=BENCHMARK_NAME):


Toggle navigation
Sapphire
Home
Pages
sliders
Nivo slider
Flexslider
Camera
ecommerce
Category page
Category page left menu
Product page
Cart
Checkout
Blog
Blog
Blog post
Other pages
Homepage center logo
About
Account
Forgot password
Sitemap
404 Not found
Blog
Contact
5
Black Dress
x 3
$130.00
Blue Dress
x 3
$230.00
Sub-Total:
$400.00
Total:
$400.00
View Cart
|
Checkout
Sofas
trendy
elegant
expensive
elegant
expensive
Couches
trendy
elegant
expensive
elegant
Tables
expensive
elegant
expensive
EN
IT
FR
Euro
Pounds
US Dollars
Elegant Dress
$200.00
Lace Dress
$250.00
Floral Dress
$500.00
Midi Dress
$50.00
White Dress
$120.00
-30%
Red Dress
$20.00
Sale
Elegant Dress
$200.00
Lace Dress
$250.00
Floral Dress
$500.00
Newsletter


Jekyll traverses your site looking for files to process.
Any files with front matter are subject to processing.
For each of these files, Jekyll makes a variety of data available via Liquid.
The following is a reference of the available data.
| Variable | Description |
|---|---|
|
Site wide information + configuration settings from |
|
Page specific information + the front matter. |
|
Layout specific information + the front matter. |
|
In layout files, the rendered content of the Post or Page being wrapped. |
|
When the |
| Variable | Description |
|---|---|
|
The current time (when you run the |
|
A list of all Pages. |
|
A reverse chronological list of all Posts. |
|
If the page being processed is a Post, |
|
A list of all static files |
|
A subset of |
|
A subset of |
|
A list of all the collections (including posts). |
|
A list containing the data loaded from the YAML files located in the |
|
A list of all the documents in every collection. |
|
The list of all Posts in category |
|
The list of all Posts with tag |
|
Contains the url of your site as it is configured in the |
|
All the variables set via the command line and your |
| Variable | Description |
|---|---|
|
The content of the Page, rendered or un-rendered depending upon what Liquid is being processed and what |
|
The title of the Page. |
|
The un-rendered excerpt of a document. |
|
The URL of the Post without the domain, but with a leading slash, |
|
The Date assigned to the Post. |
|
An identifier unique to a document in a Collection or a Post (useful in RSS feeds). |
|
The list of categories to which this post belongs. |
|
The label of the collection to which this document belongs. |
|
The list of tags to which this post belongs. |
|
The path between the source directory and the file of the post or page, e.g. |
|
The filename of the post or page, e.g. |
|
The path to the raw post or page. |
|
The next post relative to the position of the current post in |
|
The previous post relative to the position of the current post in |
| Variable | Description |
|---|---|
|
The number of the current page |
|
Number of posts per page |
|
Posts available for the current page |
|
Total number of posts |
|
Total number of pages |
|
The number of the previous page, or |
|
The path to the previous page, or |
|
The number of the next page, or |
|
The path to the next page, or |


It is always a good practice to validate all input on the server side. XSS can occur when unvalidated user input is used in an HTTP response. In a reflected XSS attack, an attacker can craft a URL with the attack script and post it to another website, email it, or otherwise get a victim to click on it.
For this exercise, your mission is to come up with some input containing a script. You have to try to get this page to reflect that input back to your browser, which will execute the script and do something bad.


Alerts
Provide contextual feedback messages for typical user actions.
Basic example
A simple primary alert with an example link. Give it a click if you like.
A simple secondary alert with an example link. Give it a click if you like.
A simple success alert with an example link. Give it a click if you like.
A simple danger alert with an example link. Give it a click if you like.
A simple warning alert with an example link. Give it a click if you like.
A simple info alert with an example link. Give it a click if you like.
A simple light alert with an example link. Give it a click if you like.
A simple dark alert with an example link. Give it a click if you like.

A simple primary alert with an example link. Give it a click if you like.

A simple secondary alert with an example link. Give it a click if you like.

A simple success alert with an example link. Give it a click if you like.

A simple danger alert with an example link. Give it a click if you like.

A simple warning alert with an example link. Give it a click if you like.

A simple info alert with an example link. Give it a click if you like.

A simple light alert with an example link. Give it a click if you like.

A simple dark alert with an example link. Give it a click if you like.

Alert with icon
A simple primary alert with an example link. Give it a click if you like.
A simple secondary alert with an example link. Give it a click if you like.
A simple success alert with an example link. Give it a click if you like.
A simple danger alert with an example link. Give it a click if you like.
A simple warning alert with an example link. Give it a click if you like.
A simple info alert with an example link. Give it a click if you like.
A simple light alert with an example link. Give it a click if you like.
A simple dark alert with an example link. Give it a click if you like.

A simple primary alert with an example link. Give it a click if you like.

A simple secondary alert with an example link. Give it a click if you like.

A simple success alert with an example link. Give it a click if you like.

A simple danger alert with an example link. Give it a click if you like.

A simple warning alert with an example link. Give it a click if you like.

A simple info alert with an example link. Give it a click if you like.

A simple light alert with an example link. Give it a click if you like.

A simple dark alert with an example link. Give it a click if you like.

Dismissible alerts
Primary alert: Dismiss me by clicking the close button on the right.
Secondary alert: Dismiss me by clicking the close button on the right.
Success alert: Dismiss me by clicking the close button on the right.
Danger alert: Dismiss me by clicking the close button on the right.
Warning alert: Dismiss me by clicking the close button on the right.
Info alert: Dismiss me by clicking the close button on the right.
Light alert: Dismiss me by clicking the close button on the right.
Dark alert: Dismiss me by clicking the close button on the right.

Primary alert: Dismiss me by clicking the close button on the right.
<button class="btn-close" type="button" data-bs-dismiss="alert" aria-label="Close"></button>

Secondary alert: Dismiss me by clicking the close button on the right.
<button class="btn-close" type="button" data-bs-dismiss="alert" aria-label="Close"></button>

Success alert: Dismiss me by clicking the close button on the right.
<button class="btn-close" type="button" data-bs-dismiss="alert" aria-label="Close"></button>

Danger alert: Dismiss me by clicking the close button on the right.
<button class="btn-close" type="button" data-bs-dismiss="alert" aria-label="Close"></button>

Warning alert: Dismiss me by clicking the close button on the right.
<button class="btn-close" type="button" data-bs-dismiss="alert" aria-label="Close"></button>

Info alert: Dismiss me by clicking the close button on the right.
<button class="btn-close" type="button" data-bs-dismiss="alert" aria-label="Close"></button>

Light alert: Dismiss me by clicking the close button on the right.
<button class="btn-close" type="button" data-bs-dismiss="alert" aria-label="Close"></button>

Dark alert: Dismiss me by clicking the close button on the right.
<button class="btn-close btn-close-white" type="button" data-bs-dismiss="alert" aria-label="Close"></button>

Additional content
Well done!
Aww yeah, you successfully read this important alert message. This example text is going to run a bit longer so that you can see how spacing within an alert works with this kind of content.
Whenever you need to, be sure to use margin utilities to keep things nice and tidy.

Well done!

Aww yeah, you successfully read this important alert message. This example text is going to run a bit longer so that you can see how spacing within an alert works with this kind of content.

Whenever you need to, be sure to use margin utilities to keep things nice and tidy.


Overview
This example allows you to walk through the features of camundaBPM guided by a simple invoice process.
Get started with the example by logging into the camunda Tasklist using
the credentials demo:demo
.
Available Personas
The following logins are provided by the show case and can be used to play around with the invoice process:
| Username | Password | Groups |
|---|---|---|
| demo | demo | Sales, Accounting, Management |
| john | john | Sales |
| mary | mary | Accounting |
| peter | peter | Management |
Async Continuation Demo
This process allows you to experiment with asychronous continuations:
- Start a new instance of the Invoice Receipt process.
- Log into cockpit. Select an instance of the Invoice Receipt process.
- Add a variable named
shouldFail
to the process and set it totrue
- Using the tasklist, make the process advance to the Archive Invoice service task.
- Back to cockpit, you see an Incident which has been created for the service task.
- Set the value of the variable
shouldFail
tofalse
and increment the retries of the failed job. As a result, the process instance is completed.


Before Change
depth, height, width = image.shape[:3]
// initialize cluster centroids for desired number of segments
grid_z, grid_y, grid_x = np.mgrid[:depth, :height, :width]
slices = regular_grid(image.shape[:3], n_segments)
step_z, step_y, step_x = [int(s.step if s.step is not None else 1)
for s in slices]
segments_z = grid_z[slices]
After Change
depth, height, width = image.shape[:3]
// initialize cluster centroids for desired number of segments
grid_z, grid_y, grid_x = np.meshgrid(np.arange(depth, dtype=dtype),
np.arange(height, dtype=dtype),
np.arange(width, dtype=dtype),
indexing="ij")
slices = regular_grid(image.shape[:3], n_segments)
step_z, step_y, step_x = [int(s.step if s.step is not None else 1)
for s in slices]
segments_z = grid_z[slices]


Bugfix Release 4.6.1 - Better Battlelog Forums #133786
Sitemap
27. January 2015 08:05
Topicstarter
BrainFooLong
Administrator
Today we released a minor bugifx release that fixed several bugs that have been introduced with the new battlelog update from 24.01.2015.


ExtractJSONArray()
语法
ExtractJSONArray(JSONValue, Array())概要
Extract elements from the given JSON value of type #PB_JSON_Array into the specified Array(). The array will be resized to the number of elements contained in the JSON value.
参数
JSONValue The JSON value. The value must be of type #PB_JSON_Array. Array() The array to fill with the JSON elements. The array will be resized to have the same size as the JSON value. Any previous content of the array will be lost.
返回值
无.
备注
The extraction is performed recursively if the array has a structure type. If the JSON value contains any elements that do not have the proper type to match the Array(), they will be ignored and the corresponsing array element will be left empty.
If the specified Array() has more than one dimension, the JSON data is expected to be a nested array of arrays to represent the multi-dimensional data. See the below example for more details.
示例
ParseJSON(0, "[1, 3, 5, 7, 9]") Dim a(0) ExtractJSONArray(JSONValue(0), a()) For i = 0 To ArraySize(a()) Debug a(i) Next i
示例
ParseJSON(0, "[[0, 1, 2], [3, 4, 5], [6, 7, 8]]") Dim a(0, 0) ExtractJSONArray(JSONValue(0), a()) For x = 0 To 2 For y = 0 To 2 Debug a(x, y) Next y Next x
参阅
ExtractJSONList(), ExtractJSONMap(), ExtractJSONStructure(), InsertJSONArray(), InsertJSONList(), InsertJSONMap(), InsertJSONStructure(), SetJSONArray(), JSONType()
已支持操作系统
所有


Gradient-Based Optimization
-
Define Gradient Methods:
- Give examples of Gradient-Based Algorithms:
- What is Gradient Descent:
- Explain it intuitively:
- Give its derivation:
- What is the learning rate?
- Where does it come from?
- How does it relate to the step-size?
- We go from having a fixed step-size to [blank]:
- How do we choose the learning rate?
- Compare Line Search vs Trust Region:
- Describe the convergence of the algorithm:
-
How does GD relate to Euler?
- List the variants of GD:
- How do they differ?:
- BGD:
- SGD:
- How should we handle the lr in this case? Why?
- What conditions guarantee convergence of SGD?
- M-BGD:
- What advantages does it have?
- Explain the different kinds of gradient-descent optimization procedures:
- Batch Gradient Descent AKA Vanilla Gradient Descent, computes the gradient of the objective wrt. the parameters \(\theta\) for the entire dataset:
$$\theta=\theta-\epsilon \cdot \nabla_{\theta} J(\theta)$$
- SGD performs a parameter update for each data-point:
$$\theta=\theta-\epsilon \cdot \nabla_{\theta} J\left(\theta ; x^{(i)} ; y^{(i)}\right)$$
- Mini-batch Gradient Descent a hybrid approach that perform updates for a, pre-specified, mini-batch of \(n\) training examples:
$$\theta=\theta-\epsilon \cdot \nabla_{\theta} J\left(\theta ; x^{(i : i+n)} ; y^{(i : i+n)}\right)$$
- Batch Gradient Descent AKA Vanilla Gradient Descent, computes the gradient of the objective wrt. the parameters \(\theta\) for the entire dataset:
- State the difference between SGD and GD?
Gradient Descent’s cost-function iterates over ALL training samples.
Stochastic Gradient Descent’s cost-function only accounts for ONE training sample, chosen at random. - When would you use GD over SDG, and vice-versa?
GD theoretically minimizes the error function better than SGD. However, SGD converges much faster once the dataset becomes large.
That means GD is preferable for small datasets while SGD is preferable for larger ones.
- What is the problem of vanilla approaches to GD?
- List the challenges that account for the problem above:
- List the different strategies for optimizing GD:
- List the different variants for optimizing GD:
- Momentum:
- Motivation:
- Definitions/Algorithm:
- Intuition:
- Parameter Settings:
- Nesterov Accelerated Gradient (Momentum):
- Motivation:
- Definitions/Algorithm:
- Intuition:
- Parameter Settings:
- Successful Applications:
- Adagrad
- Motivation:
- Definitions/Algorithm:
- Intuition:
- Parameter Settings:
- Successful Application:
- Properties:
- Adadelta
- Motivation:
- Definitions/Algorithm:
- Intuition:
- Parameter Settings:
- Properties:
- RMSprop
- Motivation:
- Definitions/Algorithm:
- Intuition:
- Parameter Settings:
- Properties:
- Adam
- Motivation:
- Definitions/Algorithm:
- Intuition:
- Parameter Settings:
- Properties:
- Which methods have trouble with saddle points?
- How should you choose your optimizer?
- Summarize the different variants listed above. How do they compare to each other?
-
What’s a common choice in many research papers?
- List additional strategies for optimizing SGD:
Maximum Margin Classifiers
- Define Margin Classifiers:
- What is a Margin for a linear classifier?
- Give the motivation for margin classifiers:
- Define the notion of the “best” possible classifier
- How can we achieve the “best” classifier?
- What unique vector is orthogonal to the hp? Prove it:
- What do we mean by “signed distance”? Derive its formula:
- Given the formula for signed distance, calculate the “distance of the point closest to the hyperplane”:
- Use geometric properties of the hp to Simplify the expression for the distance of the closest point to the hp, above
- Characterize the margin, mathematically:
- Characterize the “Slab Existence”:
- Formulate the optimization problem of maximizing the margin wrt analysis above:
- Reformulate the optimization problem above to a more “friendly” version (wrt optimization -> put in standard form):
- Give the final (standard) formulation of the “Optimization problem for maximum margin classifiers”:
- What kind of formulation is it (wrt optimization)? What are the parameters?
Hard-Margin SVMs
- Define:
- SVMs:
- Support Vectors:
- Hard-Margin SVM:
- Define the following wrt hard-margin SVM:
- Goal:
- Procedure:
- Decision Function:
- Constraints:
- The Optimization Problem:
- The Optimization Method:
- Elaborate on the generalization analysis:
- List the properties:
- Give the solution to the optimization problem for H-M SVM:
- What method does it require to be solved:
- Formulate the Lagrangian:
- Optimize the objective for each variable:
- Get the Dual Formulation w.r.t. the (tricky) constrained variable \(\alpha_n\):
- Set the problem as a Quadratic Programming problem:
- What are the inputs and outputs to the Quadratic Program Package?
- Give the final form of the optimization problem in standard form:
Soft-Margin SVM
- Motivate the soft-margin SVM:
- What is the main idea behind it?
- Define the following wrt soft-margin SVM:
- Goal:
- Procedure:
- Decision Function:
- Constraints:
- Why is there a non-negativity constraint?
- Objective/Cost Function:
- The Optimization Problem:
- The Optimization Method:
- Properties:
- Specify the effects of the regularization hyperparameter \(C\):
- Describe the effect wrt over/under fitting:
- How do we choose \(C\)?
- Give an equivalent formulation in the standard form objective for function estimation (what should it minimize?)
Loss Functions
- Define:
- Loss Functions:
- Distance-Based Loss Functions:
- Describe an important property of dist-based losses:
- What are they used for?
- Relative Error - What does it lack?
- List 3 Regression Loss Functions
- MSE
- What does it minimize:
- Formula:
- Graph:
- Derivation:
- MAE
- What does it minimize:
- Formula:
- Graph:
- Derivation:
- List properties:
- Huber Loss
- AKA:
- Formula:
- Graph:
- Derivation:
- List properties:
- Analyze MSE vs MAE:
- List 7 Classification Loss Functions
- \(0-1\) loss
- What does it minimize:
- Formula:
- Graph:
- MSE
- Formula:
- Graph:
- Derivation (for classification) - give assumptions:
- Properties:
- Hinge Loss
- What does it minimize:
- Formula:
- Graph:
- Describe the Properties of the Hinge loss and why it is used?
- Logistic Loss
- AKA:
- What does it minimize:
- Formula:
- Graph:
- Derivation:
- Properties:
- Cross-Entropy
- What does it minimize:
- Formula:
- Binary Cross-Entropy:
- Graph:
- CE and Negative-Log-Probability:
- CE and Log-Loss:
- Derivation:
- CE and KL-Div:
- Exponential Loss
- Formula:
- Properties:
- Perceptron Loss
- Formula:
- Analysis
- Logistic vs Hinge Loss:
- Cross-Entropy vs MSE:
Information Theory
- What is Information Theory? In the context of ML?
- Describe the Intuition for Information Theory. Intuitively, how does the theory quantify information (list)?
- Measuring Information - Definitions and Formulas:
- In Shannons Theory, how do we quantify “transmitting 1 bit of information”?
- What is the amount of information transmitted?
- What is the uncertainty reduction factor?
- What is the amount of information in an event \(x\)?
- Define the Self-Information:
- What is it defined with respect to?
- Define Shannon Entropy - what is it used for?
- Describe how Shannon Entropy relate to distributions with a graph:
- Define Differential Entropy:
- How does entropy characterize distributions?
- Define Relative Entropy:
- Give an interpretation:
- List the properties:
- Describe it as a distance:
- List the applications of relative entropy:
- How does the direction of minimization affect the optimization:
- Define Cross Entropy:
- What does it measure?
- How does it relate to relative entropy?
- When are they equivalent (wrt. optimization)?
- Mutual Information:
- Definition:
- What does it measure?
- Intuitive Definitions:
- Interpretations XXX:
- Properties:
- Applications:
- As KL-Divergence:
- In-terms of PMFs for discrete distributions:
- In terms of PDFs for continuous distributions:
- Relation to PMI:
- Pointwise Mutual Information (PMI):
- Definition:
- Relation to MI:
Recommendation Systems
- Describe the different algorithms for recommendation systems:
Ensemble Learning
- What are the two paradigms of ensemble methods?
- Random Forest VS GBM?
Data Processing and Analysis
- What are 3 data preprocessing techniques to handle outliers?
- Describe the strategies to dimensionality reduction:
- What are 3 ways of reducing dimensionality?
- List methods for Feature Selection
- List methods for Feature Extraction
- How to detect correlation of “categorical variables”?
- Feature Importance
- Capturing the correlation between continuous and categorical variable? If yes, how?
- What cross validation technique would you use on time series data set?
- How to deal with missing features? (Imputation?)
- Do you suggest that treating a categorical variable as continuous variable would result in a better predictive model?
- What are collinearity and multicollinearity?
- What is data normalization and why do we need it?
ML/Statistical Models
- What are parametric models?
- What is a classifier?
K-NN
PCA
- What is PCA?
- What is the Goal of PCA?
- List the applications of PCA:
- Give formulas for the following:
- Assumptions on \(X\):
- SVD of \(X\):
- Principal Directions/Axes:
- Principal Components (scores):
- The \(j\)-th principal component:
- Describe how to find the principal components:
- Define the transformation, mathematically:
- What does PCA produce/result in?
- Finds a lower dimensional subspace spanned by what?:
- Finds a lower dimensional subspace that minimizes what?:
- What does each PC have (properties)?
- What does the procedure find in terms of a “basis”?
- What does the procedure find in terms of axes? (where do they point?):
- Describe the PCA algorithm:
- What Data Processing needs to be done?
- How to compute the Principal Components?
- How do you compute the Low-Rank Approximation Matrix \(X_k\)?
- Describe the Optimality of PCA:
- List limitations of PCA:
- Intuition:
- What property of the internal structure of the data does PCA reveal/explain?
- What object does it fit to the data?:
- How does PCA relate to CCA?
- How does PCA relate to ICA?
- Should you remove correlated features b4 PCA?
- How can we measure the “Total Variance” of the data?
- How can we measure the “Total Variance” of the projected data?
- How can we measure the “Error in the Projection”?
- What does it mean when this ratio is high?
The Centroid Method
- Define “The Centroid”:
- Describe the Procedure:
- What is the Decision Function:
- Describe the Decision Boundary:
K-Means
- What is K-Means?
- What is the idea behind K-Means?
- What does K-Mean find?
- Formal Description of the Model:
- What is the Objective?
- Description of the Algorithm:
- What is the Optimization method used? What class does it belong to?
- How does the optimization method relate to EM?
- What is the Complexity of the algorithm?
- Describe the convergence and prove it:
- Describe the Optimality of the Algorithm:
- Derive the estimated parameters of the algorithm:
- Objective Function:
- Optimization Objective:
- Derivation:
- When does K-Means fail to give good results?
Naive Bayes
- Define:
- Naive Bayes:
- Naive Bayes Classifiers:
- Bayes Theorem:
- List the assumptions of Naive Bayes:
- List some properties of Naive Bayes:
- Is it a Bayesian Method or Frequentest Method?
- Is it a Bayes Classifier? What does that mean?:
- Define the Probabilistic Model for the method:
- What kind of model is it?
- What is a conditional probability model?
- Decompose the conditional probability w/ Bayes Theorem:
- How does the new expression incorporate the joint probability model?
- Use the chain rule to re-write the joint probability model:
- Use the Naive Conditional Independence assumption to rewrite the joint model:
- What is the conditional distribution over the class variable \(C_k\):
- Construct the classifier. What are its components? Formally define it.
- What’s the decision rule used?
- List the difference between the Naive Bayes Estimate and the MAP Estimate:
- What are the parameters to be estimated for the classifier?:
- What method do we use to estimate the parameters?:
- What are the estimates for each of the following parameters?:
- The prior probability of each class:
- The conditional probability of each feature (word) given a class:
CNNs
- What is a CNN?
- What are the layers of a CNN?
- What are the four important ideas and their benefits that the convolution affords CNNs:
- What is the inspirational model for CNNs:
- Describe the connectivity pattern of the neurons in a layer of a CNN:
- Describe the process of a ConvNet:
- Convolution Operation:
- Define:
- Formula (continuous):
- Formula (discrete):
- Define the following:
- Feature Map:
- Does the operation commute?
- Cross Correlation:
- Define:
- Formulae:
- What are the differences/similarities between convolution and cross-correlation:
- Write down the Convolution operation and the cross-correlation over two axes and:
- Convolution:
- Convolution (commutative):
- Cross-Correlation:
- The Convolutional Layer:
- What are the parameters and how do we choose them?
- Describe what happens in the forward pass:
- What is the output of the forward pass:
- How is the output configured?
- Spatial Arrangements:
- List the Three Hyperparameters that control the output volume:
- How to compute the spatial size of the output volume?
- How can you ensure that the input & output volume are the same?
- In the output volume, how do you compute the \(d\)-th depth slice:
- Calculate the number of parameters for the following config:
Given:
1. Input Volume: \(64\times64\times3\)
1. Filters: \(15 7\times7\)
1. Stride: \(2\)
1. Pad: \(3\) - Definitions:
- Receptive Field:
- Suppose the input volume has size \([ 32 × 32 × 3 ]\) and the receptive field (or the filter size) is \(5 × 5\) , then each neuron in the Conv Layer will have weights to a __Blank__ region in the input volume, for a total of __Blank__ weights:
- How can we achieve the greatest reduction in the spatial dims of the network (for classification):
- Pooling Layer:
- Define:
- List key ideas/properties and benefits:
- List the different types of Pooling:
Answer - List variations of pooling and their definitions:
- What is “Learned Pooling”:
- What is “Dynamical Pooling”:
- List the hyperparams of Pooling Layer:
- How to calculate the size of the output volume:
- How many parameters does the pooling layer have:
- What are other ways to perform downsampling:
- Weight Priors:
- Define “Prior Prob Distribution on the parameters”:
- Define “Weight Prior” and its types/classes:
- Weak Prior:
- Strong Prior:
- Infinitely Strong Prior:
- Describe the Conv Layer as a FC Layer using priors:
- What are the key insights of using this view:
- When is the prior imposed by convolution INAPPROPRIATE:
- What happens when the priors imposed by convolution and pooling are not suitable for the task?
- What kind of other models should Convolutional models be compared to? Why?:
- When do multi-channel convolutions commute?
Answer - Why do we use several different kernels in a given conv-layer?
- Strided Convolutions
- Define:
- What are they used for?
- What are they equivalent to?
- Formula:
- Zero-Padding:
- Definition/Usage:
- List the types of padding:
- Locally Connected Layers/Unshared Convolutions:
- Bias Parameter:
- How many bias terms are used per output channel in the tradional convolution:
- Dilated Convolutions
- Define:
- What are they used for?
- Stacked Convolutions
- Define:
- What are they used for?
- What is the rule of Bias(es) in CNNs:
Theory
RNNs
- What is an RNN?
- Definition:
- What machine-type is the standard RNN:
- What is the big idea behind RNNs?
- Dynamical Systems:
- Standard Form:
- RNN as a Dynamical System:
- Unfolding Computational Graphs
- Definition:
- List the Advantages introduced by unfolding and the benefits:
- Graph and write the equations of Unfolding hidden recurrence:
- Describe the State of the RNN, its usage, and extreme cases of the usage:
- RNN Architectures:
- List the three standard architectures of RNNs:
- Graph:
- Architecture:
- Equations:
- Total Loss:
- Complexity:
- Properties:
- List the three standard architectures of RNNs:
- Teacher Forcing:
- Definition:
- Application:
- Disadvantages:
- Possible Solutions for Mitigation:
Optimization
- Define the sigmoid function and some of its properties:
- Backpropagation:
- Definition:
- Derive Gradient Descent Update:
- Explain the difference kinds of gradient-descent optimization procedures:
- List the different optimizers and their properties:
- Error-Measures:
- Define what an error measure is:
- List the 5 most common error measures and where they are used:
- Specific Questions:
- Derive MSE carefully:
- Derive the Binary Cross-Entropy Loss function:
- Explain the difference between Cross-Entropy and MSE and which is better (for what task)?
- Describe the properties of the Hinge loss and why it is used?
- Show that the weight vector of a linear signal is orthogonal to the decision boundary?
- What does it mean for a function to be well-behaved from an optimization pov?
- Write \(\|\mathrm{Xw}-\mathrm{y}\|^{2}\) as a summation
- Compute:
- \(\dfrac{\partial}{\partial y}\vert{x-y}\vert=\)
- State the difference between SGD and GD?
- When would you use GD over SDG, and vice-versa?
- What is convex hull ?
- OLS vs MLE
ML Theory
- Explain intuitively why Deep Learning works?
- List the different types of Learning Tasks and their definitions:
answer - Describe the relationship between supervised and unsupervised learning?
answer - Describe the differences between Discriminative and Generative Models?
- Describe the curse of dimensionality and its effects on problem solving:
- How to deal with curse of dimensionality
- Describe how to initialize a NN and any concerns w/ reasons:
- Describe the difference between Learning and Optimization in ML:
- List the 12 Standard Tasks in ML:
- What is the difference between inductive and deductive learning?
Statistical Learning Theory
- Define Statistical Learning Theory:
- What field is it the theory for?:
- What fields does it draw from?:
- What does it allow us to do?:
- What question does it answer?:
- What is it a subfield-of/approach-to?:
- What assumptions are made by the theory?
- Define the i.i.d assumptions?
- Why assume a joint probability distribution \(p(x,y)\)?
- Why do we need to model \(y\) as a target-distribution and not a target-function?
- Give the Formal Definition of SLT:
- The Definitions:
- The Assumptions:
- The Inference Problem:
- The Expected Risk:
- The Target Function:
- The Empirical Risk:
- Define Empirical Risk Minimization:
- What is the Complexity of ERM?
- How do you Cope with the Complexity?
- Definitions:
- Generalization:
- Generalization Error:
- Generalization Gap:
- Computing the Generalization Gap:
- What is the goal of SLT in the context of the Generalization Gap given that it can’t be computed?
- Achieving (“good”) Generalization:
An algorithm is said to generalize when - Empirical Distribution:
- Describe the difference between Learning and Optimization in ML:
- Describe the difference between Generalization and Learning in ML:
- How to achieve Learning?
- What does the (VC) Learning Theory Achieve?
- Why do we need the probabilistic framework?
- Give the Formal Definition of SLT:
- What is the Approximation-Generalization Tradeoff? How is it characterized?:
- What are the factors determining how well an ML-algo will perform?
- Define the following and their usage/application & how they relate to each other:
- Underfitting:
- Overfitting:
- Capacity:
- Models with Low-Capacity:
- Models with High-Capacity:
- Hypothesis Space:
- VC-Dimension:
- What does it measure?
- Graph the relation between Error, and Capacity in the ctxt of (Underfitting, Overfitting, Training Error, Generalization Err, and Generalization Gap):
- What is the most important result in SLT that show that learning is feasible?
Bias-Variance Decomposition Theory
- What is the Bias-Variance Decomposition Theory:
- What are the Assumptions made by the theory?
- What is the question that the theory tries to answer? How do you achieve the answer to this question? What assumption is important?
- What is the Bias-Variance Decomposition:
- Define each term w.r.t. source of the error (error from):
- Bias:
- Variance:
- Irreducible Error:
- What does each of the following measure (error in)? Describe this measured quantity in words, mathematically. Describe Bias&Variance in Words as a question statement. Give their AKA in statistics.
- Bias:
- Variance:
- Irreducible Error:
- Give the Formal Definition of the Decomposition (Formula):
- What is the Expectation over?
- Define the Bias-Variance Tradeoff:
- Effects of Bias:
- High Bias:
- Low Bias:
- Effects of Variance:
- High Variance:
- Low Variance:
- Draw the Graph of the Tradeoff (wrt model capacity):
- Effects of Bias:
- Derive the Bias-Variance Decomposition with explanations:
- What are the key Takeaways from the Tradeoff?
- What are the most common ways to negotiate the Tradeoff? (i.e. selecting/comparing models)
- How does the decomposition relate to Classification?
- Increasing/Decreasing Bias&Variance:
- Adding Good Feature:
- Adding Bad Feature:
- Adding ANY Feature:
- Adding more Data:
- Noise in Test Set:
- Noise in Training Set:
- Dimensionality Reduction:
- Feature Selection:
- Regularization:
- Increasing # of Hidden Units in ANNs:
- Increasing # of Hidden Layers in ANNs:
- Increasing \(k\) in K-NN:
- Increasing Depth in Decision-Trees:
- Boosting:
- Bagging:
Activation Functions
- Describe the Desirable Properties for activation functions:
- Non-Linearity:
- Range:
- Continuously Differentiable:
- Monotonicity:
- Smoothness with Monotonic Derivatives:
- Approximating Identity near Origin:
- Zero-Centered Range:
- Describe the NON-Desirable Properties for activation functions:
- Saturation:
- Vanishing Gradients:
- Range Not Zero-Centered:
- List the different activation functions used in ML?
Names, Definitions, Properties (pros&cons), Derivatives, Applications, pros/cons:
- Fill in the following table:
- Tanh VS Sigmoid for activation?
- ReLU:
- What makes it superior/advantageous?
- What problems does it have?
- What solution do we have to mitigate the problem?
- Compute the derivatives of all activation functions:
- Graph all activation functions and their derivatives:
Kernels
- Define “Local Kernel” and give an analogy to describe it:
- Write the following kernels:
- Polynomial Kernel of degree, up to, \(d\):
- Gaussian Kernel:
- Sigmoid Kernel:
- Polynomial Kernel of degree, exactly, \(d\):
Math
-
What is a metric?
Metric -
Describe Binary Relations and their Properties?
answer - Formulas:
- Set theory:
- Number of subsets of a set of \(N\) elements:
- Number of pairs \((a,b)\) of a set of N elements:
- Binomial Theorem:
- Binomial Coefficient:
- Expansion of \(x^n - y^n =\)
- Number of ways to partition \(N\) data points into \(k\) clusters:
- \(\log_x(y) =\)
- The length of a vector \(\mathbf{x}\) along a direction (projection):
- Along a unit-length vector \(\hat{\mathbf{w}}\):
- Along an unnormalized vector \(\mathbf{w}\):
- \(\sum_{i=1}^{n} 2^{i}=\)
- Set theory:
-
List 6 proof methods:
answer - Something
Statistics
- ROC curve:
- Definition:
- Purpose:
- How do you create the plot?
- How to identify a good classifier:
- How to identify a bad classifier:
- What is its application in tuning the model?
- AUC - AUROC:
- Definition:
- Range:
- What does it measure:
- Usage in ML:
- Define Statistical Efficiency (of an estimator)?
- Intuitive Difference:
- How do we define Efficiency?
- What’s the difference between an efficient and inefficient estimators?
- How’s the use of an inefficient estimator bad compared to an efficient one?
- Whats the difference between Errors and Residuals:
- Compute the statistical errors and residuals of the univariate, normal distribution defined as \(X_{1}, \ldots, X_{n} \sim N\left(\mu, \sigma^{2}\right)\):
- What is a biased estimator?
- Why would we prefer biased estimators in some cases?
- What is the difference between “Probability” and “Likelihood”:
- Estimators:
- Define:
- Formula:
- Whats a good estimator?
- What are the Assumptions made regarding the estimated parameter:
- What is Function Estimation:
- Whats the relation between the Function Estimator \(\hat{f}\) and Point Estimator:
- Define “marginal likelihood” (wrt naive bayes):
(Statistics) - MLE
- Clearly Define MLE and derive the final formula:
- Write MLE as an expectation wrt the Empirical Distribution:
- Describe formally the relationship between MLE and the KL-divergence:
- Extend the argument to show the link between MLE and Cross-Entropy. Give an example of a well-known loss function:
- How does the form of the model (model family) affect the MLE Estimate?
- How does MLE relate to the model distribution and the empirical distribution?
- What is the intuition behind using MLE?
- What does MLE find/result in?
- What kind of problem is MLE and how to solve for it?
- How does it relate to SLT:
- Explain clearly why we maximize the natural log of the likelihood
Text-Classification | Classical
- List some Classification Methods:
- List some Applications of Txt Classification:
NLP
- List some problems in NLP:
- List the Solved Problems in NLP:
- List the “within reach” problems in NLP:
- List the Open Problems in NLP:
- Why is NLP hard? List Issues:
- Define:
- Morphology:
- Morphemes:
- Stems:
- Affixes:
- Stemming:
- Lemmatization:
Language Modeling
- What is a Language Model?
- List some Applications of LMs:
- Traditional LMs:
- How are they setup?
- What do they depend on?
- What is the Goal of the LM task? (in the ctxt of the problem setup)
- What assumptions are made by the problem setup? Why?
- What are the MLE Estimates for probabilities of the following:
- Bi-Grams:
$$p(w_2\vert w_1) = $$
- Tri-Grams:
$$p(w_3\vert w_1, w_2) = $$
- Bi-Grams:
- What are the issues w/ Traditional Approaches?
- What+How can we setup some NLP tasks as LM tasks:
- How does the LM task relate to Reasoning/AGI:
- Evaluating LM models:
- List the Loss Functions (+formula) used to evaluate LM models? Motivate each:
- Which application of LM modeling does each loss work best for?
- Why Cross-Entropy:
- Which setting it used for?
- Why Perplexity:
- Which setting used for?
- If no surprise, what is the perplexity?
- How does having a good LM relate to Information Theory?
- LM DATA:
- How does the fact that LM is a time-series prediction problem affect the way we need to train/test:
- How should we choose a subset of articles for testing:
- List three approaches to Parametrizing LMs:
- Describe “Count-Based N-gram Models”:
- What distributions do they capture?:
- Describe “Neural N-gram Models”:
- What do they replace the captured distribution with?
- What are they better at capturing:
- Describe “RNNs”:
- What do they replace/capture?
- How do they capture it?
- What are they best at capturing:
- What’s the main issue in LM modeling?
- How do N-gram models capture/approximate the history?:
- How do RNNs models capture/approximate the history?:
- The Bias-Variance Tradeoff of the following:
- N-Gram Models:
- RNNs:
- An Estimate s.t. it predicts the probability of a sentence by how many times it has seen it before:
- What happens in the limit of infinite data?
- What are the advantages of sub-word level LMs:
- What are the disadvantages of sub-word level LMs:
- What is a “Conditional LM”?
- Write the decomposition of the probability for the Conditional LM:
- Describe the Computational Bottleneck for Language Models:
- Describe/List some solutions to the Bottleneck:
- Complexity Comparison of the different solutions:
Regularization
- Define Regularization both intuitively and formally:
- Define “well-posedness”:
- Give four aspects of justification for regularization (theoretical):
- From a philosophical pov:
- From a probabilistic pov:
- From an SLT pov:
- From a practical pov (relating to the real-world):
- Describe an overview of regularization in DL. How does it usually work?
- Intuitively, how can a regularizer be effective?
- Describe the relationship between regularization and capacity. How does regularization work in this case?
- Describe the different approaches to regularization:
- List 9 regularization techniques:
- Describe Parameter Norm Penalties (PNPs):
- Describe the parameter \(\alpha\):
- How does it influence the regularization:
- What is the effect of minimizing the regularized objective?
- How do we deal with the Bias parameter in PNPs? Explain.
- Describe the tuning of the \(\alpha\) HP in NNs for different hidden layers:
- Formally describe the \(L^2\) parameter regularization:
- AKA:
- Describe the regularization contribution to the gradient in a single step.
- Describe the regularization contribution to the gradient. How does it scale?
- How does weight decay relate to shrinking the individual weight wrt their size? What is the measure/comparison used?
- Draw a graph describing the effects of \(L^2\) regularization on the weights:
- Describe the effects of applying weight decay to linear regression
- Derivation:
- What is \(L^2\) regularization equivalent to?
- What are we maximizing?
- Derive the MAP Estimate:
- What kind of prior do we place on the weights? What are its parameters?
- List the properties of \(L^2\) regularization:
- Formally describe the \(L^1\) parameter regularization:
- AKA:
- Whats the regularized objective function?
- What is its gradient?
- Describe the regularization contribution to the gradient compared to L2. How does it scale?
- List the properties and applications of \(L^1\) regularization:
- How is used as a feature selection mechanism?
- Derivation:
- What is \(L^1\) regularization equivalent to?
- What kind of prior do we place on the weights? What are its parameters?
- Analyze \(L^1\) vs \(L^2\) regularization:
- For Sparsity:
- For correlated features:
- For optimization:
- Give an example that shows the difference wrt sparsity:
- For sensitivity:
- Describe Elastic Net Regularization. Why was it devised?
- Motivate Regularization for ill-posed problems:
- What is the property that needs attention?
- What would the regularized solution correspond to in this case?
- Are there any guarantees for the solution to be well-posed? How/Why?
- What is the Linear Algebraic property that needs attention?
- What models are affected by this?
- What would the sol correspond to in terms of inverting \(X^TX\):
- When would \(X^TX\) be singular?
- Describe the Linear Algebraic Perspective. What does it correspond to? [LAP]
- Can models with no closed-form solution be underdetermined? Explain. [CFS]
- What models are affected by this? [CFS]
- Define the Moore-Penrose Pseudoinverse:
- What can it solve?
- What does it correspond to in terms of regularization?
- What is the limit wrt?
- How can we interpret the pseudoinverse wrt regularization?
- Explain the problem with Logistic Regression:
- What are the possible solutions?
- Are there any guarantees that we achieve with regularization?
- Describe dataset augmentation and its techniques:
- When is dataset augmentation applicable?
- When is it not?
- Motivate Noise Robustness property:
- How can Noise Robustness motivate a regularization technique?
- How can we enhance noise robustness in NN?
- Where can noise be injected?
- Give Motivation, Interpretation and Applications of injecting noise in the different components (from above):
- Motivate the injecting of noise:
- Give an interpretation for injecting noise in the Input layer:
- Give an interpretation for injecting noise in the Hidden layers:
- What is the most successful application of this technique:
- Describe the Bayesian View of learning:
- How does it motivate injecting noise in the weight matrices?
- Describe a different interpretation of injecting noise to matrices. What are its effects on the function to be learned?
- Whats the biggest application for this kind of regularization?
- Motivate injecting noise in the Output layer:
- What is the biggest application of this technique?
- How does it compare to weight-decay when applied to MLE problems?
- Define “Semi-Supervised Learning”:
- What does it refer to in the context of DL:
- What is its goal?
- Give an example in classical ML:
- Describe an approach to applying semi-supervised learning:
- How can we interpret dropout wrt data augmentation?
- When is Ridge regression favorable over Lasso regression? for correlated features?
Misc.
- Explain Latent Dirichlet Allocation (LDA)
- How to deal with curse of dimensionality
- How to detect correlation of “categorical variables”?
- Define “marginal likelihood” (wrt naive bayes):
- KNN VS K-Means
- When is Ridge regression favorable over Lasso regression for correlated features?
- Capturing the correlation between continuous and categorical variable? If yes, how?
- Random Forest VS GBM?
- What is convex hull ?
- What cross validation technique would you use on time series data set?
- How to deal with missing features? (Imputation?)
- Describe the different algorithms for recommendation systems:
- Do you suggest that treating a categorical variable as continuous variable would result in a better predictive model?
- OLS vs MLE
- What is the difference between inductive and deductive learning?
- What are collinearity and multicollinearity?
- What are the two paradigms of ensemble methods?
- Describe Label Smoothing as a regularization technique:
- Give its motivation:
- What is data normalization and why do we need it?:
- Weight initialization in neural networks?:
- How to improve Generalization
- How to prevent Overfitting
- How to control the capacity
- Why small weights in NN lead to lower capacity:
- Give its motivation:
INTERVIEWS
- Can they derive the back-propagation and weights update?:
- Extend the above question to non-trivial layers such as convolutional layers, pooling layers, etc.:
- How to implement dropout:
- Their intuition when and why some tricks such as max pooling, ReLU, maxout, etc. work. There are no right answers but it helps to understand their thoughts and research experience.:
- Can they abstract the forward, backward, update operations as matrix operations, to leverage BLAS and GPU?:
- What is an auto-encoder? Why do we “auto-encode”? Hint: it’s really a misnomer.:
- What is a Boltzmann Machine? Why a Boltzmann Machine?:
- Why do we use sigmoid for an output function? Why tanh? Why not cosine? Why any function in particular?:
- Why are CNNs used primarily in imaging and not so much other tasks?:
- Explain backpropagation. Seriously. To the target audience described above.:
- Is it OK to connect from a Layer 4 output back to a Layer 2 input?:
- A data-scientist person recently put up a YouTube video explaining that the essential difference between a Neural Network and a Deep Learning network is that the former is trained from output back to input, while the latter is trained from input toward output. Do you agree? Explain.:
- Interview Qs (Quora)
- NLP-Interview
- Robin-Interview
- Robin
- CV-Inter
- Polarr-Inter
FeedForward Neural Network
- What is a “FeedForward” Neural Network:
- What is the Architecture of an FFN (components and how they work together):
- List two examples of FFNs:
- Describe the “Single-Layer Perceptron”:
- Describe the “Multi-Layer Perceptron” (vaguely describe the components of the architecture and how they fit together):
Multilayer Perceptron
- What model class does the “Multi-Layer Perceptron” belong to:
- What is the Architecture of an MLP:
- What are the Layers names/types:
- What do the Connections between the nodes represent:
- What else is important to make it multi-layer? why/motivation (biologically and mathematically)?
- Describe “Learning” of an MLP (Learning Algorithm and brief description of the procedure and optimization):
- List the properties of the MLP:
Deep Feedforward Neural Networks
- Describe the Deep Feedforward Neural Networks:
- As a “Classifier” (from what does it learn and what does it define?):
- What is its function?
- How does it model the targets? (describe the underlying model and what it learns)
- What does it learn?
- What is its goal (besides trying to approximate the function on the training data)?
- Why are they called “networks”/how are they represented?:
- How are the Functions composed together?
- How is this composition described?
- What is the common structure for connecting the functions (from layer to layer)?
- How do we define Depth:
- What does the Training Data provide? and how do we learn from it?
- Describe the Motivation for Deep FFNs:
- topic:
- How can we interpret Deep Neural Networks (in SLT):
AutoEncoders
- What is an AutoEncoder? What is its goal? (draw a diagram)
- What type of NN is the Autoencoder?
- Give Motivation for AutoEncoders:
- Why Deep AutoEncoders? What do they allow us to do?
- List the Advantages of Deep AutoEncoders:
- List the Applications of AutoEncoders:
- Describe the Training of Deep AutoEncoders:
- What are the challenges if any?
- What are the main methods for training Deep AutoEncoders?
- Which one is the most superior method?
- How is Joint Training better:
- Why is Joint Training better:
- Describe the Architecture of AutoEncoders:
- What is the simplest form of an AE:
- What realm of “Learning” is employed for AEs?
-
Mathematical Description of the Structure of AutoEncoders:
- How do we define the “Encoder” and “Decoder”?
- The Encoder maps what to what?
- The Decoder maps what to what?
- What is the type of loss?
- What are “Transition Functions”?
- Compare AutoEncoders and PCA (wrt what they learn):
- List the different Types of AEs
- How can we use AEs for Initialization?
- Describe the Representational Power of AEs:
- (wrt Layer Size and Depth):
- Why is Depth Important?
-
Describe the progression (stages) of AE Architectures in CV:
- What are Undercomplete AutoEncoders?
- What’s the motivation behind Undercomplete AEs?
- List the Challenges of Utilizing Undercomplete AEs:
- What is the Main Method/Approach of addressing the Challenges above (Training AEs)?
- Define Regularized Autoencoders:
- What does it allow us to do?
- How does it address the Challenges?
- What other Properties does it encourage to be learned?
- What kind of technique (also type) of AEs can be “non-linear” and still learn useful codes?
- What kind of technique-needed for (also type-of) AEs can be “overcomplete” and still learn useful codes?
- What kind of technique-needed for (also type-of) AEs can be “nonlinear” AND “overcomplete” and still learn useful codes?
- What are the ways to learn useful encodings/representations?
Defining an appropriate Objective and Objective Function.- What types of objectives help learn useful encodings/representations?
(regularized/approximate) Auto-Encoding - Maximizing the Probability of training Data (NLL)
Further Info
- What types of objectives help learn useful encodings/representations?
- Describe the Relationship between Generative Models and AEs:
- What are the components needed for the Generative Model?:
- What notable types? List:.
- Compare Generative Models & AEs in how they learn codings/representations:
- Why are their representations “naturally” useful?
- List the Different Types of Regularized Autoencoders:
- Define Sparse Autoencoders (w/ equation):
- How can we interpret Sparse AEs? (Hint: 3 interpretations)
- Give the “Regularization” Interpretation of Sparse AEs:
- Give the “Bayesian” Interpretation of Regularized AEs:
- Give the “Latent Variable” Interpretation of Sparse AEs:
- What do Sparse AEs approximate?
- How do they (does that) relate to MLE?
- Define Denoising Autoencoders:
- What do they minimize? (canonical loss)
- What do they learn? How? (compare)
- How do we generate the inputs?
- What does the “Corruption Process” represent/define?
- How do we generate the training examples (input-output pair)? (process)
- What does the Denoising AE learn specifically? (mathematically)
- What do we use as an estimate for the “Reconstruction Distribution”?
- What is the output of the encoder \(f\)?
- What is the output of the decoder \(g\)?
- What is the “Reconstruction Distribution” equal to?
- How do we Train the Denoising AE?
- What is the Loss?
- What is the Optimization Method?
- What is the Training similar to?
- Is the Encoder Deterministic?
- Would change if it was one or the other?
- How can we view the function of DAEs (wrt learning/training) from a Probabilistic pov?
- What Expectation is it minimizing? Over what?
- Can we re-write the Objective/Loss wrt the Empirical Distribution?
- What other ways exist for learning/training DAEs?
-
How do DAEs and VAEs relate to each other?
- Define Contractive Autoencoders
- What is the regularizer/penalty used?
- What does it encourage the system to do?
- How is the Contractive AE connected to the DAE:
- Why is the CAE called “Contractive”?
- Is it contractive locally or globally or both?
- Give the Interpretation of the CAE as a Linear Operator:
- List the Issues associated with using a “Contractive Penalty”:


{#include internalheader title="Sales" /}{|
|
|
choose "coffee latte" above to see how a product specific ui-widget is used rather than a generic one, and how rules are executed in the UI |
| Action | Path | Parameters |
|---|---|---|
| {{ userAction.action }} | {{ userAction.path }} |
{{ param }}: {{ userAction.params[param] }}
|


--- title: log sidebar: function_reference_sidebar permalink: orientation.log.html folder: function_reference toc: false ---
misorientation vector between two orientations
The misorientation vector can also be seen as the projection of an orientarion onto the tangential space of the orientation space centered at the orientation ori_ref
. The inverse mapping from the tantential space onto the orientation space is the exponential map exp
.
| mori | misorientation |
| ori | orientation |
| ori_ref | orientation |
| m | Miller |
| v | vector3d |


{% extends "tutorial.html" %} {% load mixin from templatefilters %} {% block pagebreadcrumb %}{{ tut.title }}{% endblock %} {% block head %} {% endblock %} {% block iscompatible %} return Modernizr.regions; {% endblock %} {% block html5badge %} {% endblock %} {% block content %}
{% include "warning.html" %}
The web is an extremely powerful platform for text, an area where Adobe has a great deal of experience and expertise. When Adobe was looking for ways to help move the web forward, therefore, advancing the web's text capabilities even further seemed like an obvious place for us to start. The web generally assumes a single column, vertical orientation for text. Although it's possible to flow text around graphics, and even to format text into multiple columns with CSS, it's still very difficult to achieve true magazine-like layout on the web. With CSS Regions and CSS Exclusions, Adobe is spearheading the effort to bring the power of desktop publishing to modern browsers. For instance, in the screenshot below, CSS Exclusions is being used to flow text along the contour of the mountain:
The document in the screenshot below also uses CSS Exclusions to allow the text to wrap around shapes in the images, as well as CSS Regions to format text into columns and around a pull quote:
Before getting into the details of CSS Regions, I'd like to cover how regions can be enabled in Google Chrome. Once you have CSS Regions enabled, you can try out some of the samples referenced in this article, and create your own.
As of version 20 of Chrome (version 20.0.1132.57, to be exact), CSS Regions is enabled through the chrome://flags
interface. To enable CSS Regions, follow these steps:
chrome://flags
in the location bar.For more information on Chrome's flags, see my blog post on All About Chrome Flags.
Once you've relaunched your browser, you're free to start experimenting with CSS Regions.
CSS Regions allows a block of semantically marked-up text to automatically flow into "boxes" (currently elements). The diagram below demonstrates the separation of text (the flow) and boxes (the regions the text flows into):
Let's take a look at an actual CSS Regions use case. In addition to being a developer at Adobe, I'm also a science fiction writer. I frequently publish my work online under a Creative Commons license, and in order to allow it to work across the maximum number of devices and browsers, I frequently use an extremely simple format similar to this:
Using CSS Regions, I was able to create an experience that is both more visually interesting, and much more functional since it's easier to navigate and more comfortable to read:
For demonstration purposes, I added the ability to reveal CSS Regions in this prototype. The screenshot below shows how the regions are arranged such that they give the impression of being columns that wrap around a graphic and a pull-quote in the center:
You can experiment with this prototype (as well as view the source code) here. Use your arrow keys to navigate, and press the Esc
key to reveal regions. Earlier prototypes are also available here.
The CSS required to get a block of text to flow through regions is extremely simple. The snippet below assigns a named flow called "article" to a div with the id "content," and assigns that same "article" named flow to any element with the class "region." The result is that text contained inside the "content" element will automatically flow through any element with the class "region."
<!DOCTYPE html>

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Praesent eleifend dapibus felis, a consectetur nisl aliquam at. Aliquam quam augue, molestie a scelerisque nec, accumsan non metus. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin cursus euismod nisi, a egestas sem rhoncus eget. Mauris non tortor arcu. Pellentesque in odio at leo volutpat consequat....

The result looks like this:
Note that the text inside the "content" div doesn't have any knowledge of its presentation. In other words, it can remain entirely semantically intact even as it's flowing through various regions. Additionally, since regions are just elements, they are positioned and sized using CSS just as any other element, and are therefore perfectly compatible with responsive design principles. Designating elements as part of a named flow simply means that the specified text automatically flows through them.
To be concise, this section uses only one vendor prefix (webkit
),
but you should write code that works across [browsers that support](http://html.adobe.com/webplatform/enable/) this feature!
The CSS Object Model, or CSSOM, defines JavaScript APIs for working with CSS. Below is a list of the new APIs related to CSS Regions:
document.webkitGetNamedFlows()
: A function that returns the collection of named flows available in the document.document.webkitGetNamedFlows().namedItem("article")
: A function that returns a reference to a specific named flow. The argument corresponds to the name specified as the value of the flow-into
and from-from
CSS properties. To get a reference to the named flow specified in the code snippet above, you would pass in the string "article."WebKitNamedFlow
: An object representation of a named floe with the following properties and functions:
firstEmptyRegionIndex
: An integer value that points to the index of the first empty region associated to the named flow. See getRegions()
below to learn how to get the collection of regions.name
: A string value with the name of the flow.overset
: A boolean property that is:
false
when the content of the named flow fits in the associated regionstrue
when the content does not fit and more regions are required to contain all the content.getContent()
: A function that returns a collection with references to the nodes that flow into the named flow.getRegions()
: A function that returns a collection with references to regions that hold the content of the named flow.getRegionsByContentNode(node)
: A function that returns a reference to the region containing the specified node. This is especially useful for finding regions containing things like named anchors.webkitregionoversetchange
event. This event is triggered on a WebkitNamedFlow
whenever the layout of the associated content changes for any reason (content is added or removed, the font size changes, the shape of the region changes, etc.) and causes the webkitRegionOverset
property of a region to change. This event is useful for listening to coarse layout changes. It is an indicator that something important happened and the layout might need attention, such as: more regions are required, some regions might be empty, etc.webkitregionfragmentchange
event. Not implemented at the time of this edit. This event is triggered on a WebkitNamedFlow
whenever the layout of the associated content changes for any reason, similar to webkitregionoversetchange
, but regardless of any change in webkitRegionOverset
properties. This event is useful for listening for fine-grained layout changes which don't necessarily impact the whole layout of the named flow, for example: content moves from one region to another, but the overall content still fits in all the regions.Element.webkitRegionOverset
: Elements become regions when they have the flow-from
CSS property assigned. These elements have a webkitRegionOverset
property which, if they are part of a named flow, indicates whether or not content from a flow is overflowing the region. The possible of values webkitRegionOverset are:
One of the primary uses for the CSSOM is listening for webkitregionoversetchange
events and dynamically adding or removing regions in order to accommodate varying amounts of text. For instance, if the amount of text to be formatted is unpredictable (perhaps user-generated), if the browser window is resized, or if the font size changes, it might be necessary to add or remove regions to accommodate the change in the flow. Additionally, if you want to organize your content into pages, you will need a mechanism for dynamically modifying the DOM as well as your regions.
The following snippet of JavaScript code demonstrates the use of the CSSOM to dynamically add regions as necessary. Note that for the sake of simplicity, it does not handle removing regions or defining the size and positions of regions; it is for demonstration purposes only.
var flow = document.webkitGetNamedFlows().namedItem("article")
flow.addEventListener("webkitregionoversetchange", onLayoutUpdate);
function onLayoutUpdate(event) {
var flow = event.target;
// The content does not fit
if (flow.overset === true) {
addRegion();
} else {
regionLayoutComplete();
}
}
function addRegion() {
var region = document.createElement("div");
region.style = "flow-from: article";
document.body.appendChild(region);
}
function regionLayoutComplete() {
// Finish up your layout.
}
More demos are available on the CSS Regions samples page.
This section discusses future concepts not yet implemented in any browser.
Leveraging the CSSOM is probably the most powerful and flexible way of implementing things like paging and responsive layout, but Adobe has been working with text and desktop publishing tools long enough to know that designers and developers are also going to want an easier way to get relatively generic paging capabilities. Therefore we are working on a proposal called CSS Page Templates which allows paging behavior to be defined entirely declaratively.
Let's take a look at a common use case for CSS Page Templates. The code snippet below shows the use of CSS to create two named flows: "article-flow" and "timeline-flow." Additionally it defines a third selector called "combined-articles" inside of which the the two flows will be contained. The simple inclusion of the overflow-style
property inside the "combined-articles" selector indicates that the content should automatically be paged along the x axis, or horizontally:

Now that the flows have been defined and the desired overflow behavior has been specified, we can create the page template itself:
@template {
@slot left {
width: 35%;
float: left;
{% mixin flow-from: article-flow; %}
}
@slot time {
width: 25%;
float: left;
{% mixin flow-from: timeline-flow; %}
}
@slot right {
width: 35%;
float: left;
{% mixin flow-from: article-flow; %}
}
}
Page templates are defined using the new "at" syntax. In the code snippet above, we define three slots, each corresponding to a column. The text from the "article-flow" will flow through the columns on the left and right, and text from the "timeline-flow" will populate the column in the middle. The result might look something like this:
Note that the article text -- the text in the left- and right-hand columns -- is English, and the timeline in the center is German. Additionally, the document pages horizontally without the need for any JavaScript code. Everything was done entirely declaratively in CSS.
CSS Page Templates are still a proposal, however we have a prototype which uses a JavaScript "shim" (a.k.a polyfill) in order to allow you to experiment with them now.
To learn more about CSS Regions in general, check out the CSS Regions page on html.adobe.com.
In order to achieve true magazine-like layout, it's not enough to be able to flow text through regions. A critical element of high-quality and visually interesting desktop publishing is the ability to make text flow either around or inside of irregular graphics and shapes. CSS Exclusions is bringing this level of production quality to the web.
The screenshot below is from a CSS Exclusions prototype, and shows text dynamically flowing around a path that matches the contour of a large rock formation:
The inverse is illustrated in the next screenshot: text flowing inside of irregularly shaped polygons:
The first step to being able to flow text around or inside of arbitrary shapes is to develop and optimize the required algorithms. Adobe is currently working on implementations which will be contributed directly to WebKit. Once these algorithms have been optimized, they will become the foundations on top of which the remainder of CSS Exclusions are built.
For more information on CSS Exclusions, see the CSS Exclusions page on html.adobe.com, and for a more detailed look at Adobe's work on the underlying technology for CSS Exclusions, see Hans Muller's blog post entitled Horizontal Box: Polygon Intersection for CSS Exclusions.
The first time I talked about CSS Regions and CSS Exclusions publicly was at the Adobe Developer Pod at Google I/O 2011. At the time, I was showing demos in our own custom prototype browser. The reception was extremely enthusiastic, however there was a palpable sense of disappointment when onlookers discovered that none of the functionality I was showing was available in any of the major browsers yet.
I was at Google I/O again this year (2012), this time as a presenter along with my coworker Vincent Hardy and Alex Danilo from Google (you can watch the presentation here). Just one year later, about 80% of the CSS Regions specification has been implemented in WebKit, and is already in the most recent version of Google Chrome (note that CSS Regions currently has to be enabled through chrome://flags
). Preliminary support for CSS Regions has even landed in Chrome for Android:
Additionally, both CSS Regions and CSS Exclusions are implemented in the Internet Explorer 10 preview, and are currently on Mozilla's 2012 roadmap for Firefox. The next major version of Safari should support the majority of the CSS Regions specification, and subsequent updates should include the remainder.
Below is a detailed timeline of the progress we've made with CSS Regions and CSS Exclusions since our initial proposal to the W3C in April of 2011:
Adobe has a huge amount of experience with text, fonts, and with desktop publishing in general through tools like InDesign. Although the web is already a very powerful platform for text, we want to use our knowledge and experience to push text presentation even further. CSS Regions and CSS Exclusions are allowing content to remain semantically structured while also enabling true magazine-like layout, and ultimately a much more expressive web.
{% endblock %}


A verifcation email has been requested for the following
Email: email_label
To verify your email, visit the following address:


---
layout: talk_reveal3
title: Data integration, real-time pipelines and visualization strategies
venue: University of Edinburgh
event: ARTIC Network Meeting
author: Trevor Bedford
---
{{ page.title }}
Trevor Bedford (@trvrb)
{{ page.date | date: "%-d %b %Y" }}
{{ page.event }}
{{ page.venue }}
Studies of Ebola phylogenetics published alongside outbreak
Carroll et al. 2015. Nature., Park et al. 2015. Cell.,
Arias et al. 2016. Virus Evol., Quick et al. 2016. Nature.
Difficult to extract a comprehensive picture from these studies
Comprehensive analysis published in Apr 2017 (on bioRxiv Sep 2016)
There have also been publications on the ongoing Zika epidemic
Metsky et al. 2017. Nature., Grubaugh et al. 2017. Nature.,
Faria et al. 2017. Nature.
There currently does not exist a comprehensive Zika phylogeny
in the literature (or bioRxiv)
- Trees in these papers used 174, 104 and 200 genomes, respectively
- There are now 542 genomes in Genbank
Even if these genomes did not change the story told by these papers,
they could improve credible intervals and connect dots not available
to the original papers
Outline
- What we're trying to do
- Brief overview of approach
- Design choices we've made
Key challenges
- Timely analysis and sharing of results critical
- Dissemination must be scalable
- Integrate many data sources
- Results must be easily interpretable and queryable
Rethink database of virus and titer data
- Harmonizes data from different sources
- Integrates different types of data (serology, sequences, case details)
- Provides an interface for downstream analysis
Build scripts to align sequences, build trees and annotate
- Flexible build scripts to incorporate different viruses and analyses
- Constructs time-resolved phylogenies
- Annotates with geographic transitions and mutation events
Example augur pipeline for 1600 Ebola genomes
- Align with MAFFT (34 min)
- Build ML tree with RAxML (54 min)
- Temporally resolve tree and geographic ancestry with TreeTime (16 min)
- Total pipeline (1 hr 46 min)
Web visualization of resulting trees
- Interactive data exploration and filtering
- Framework through React / D3
- Connects phylogeny, geography and genotypes
Analysis targets
- Phylogeny
- Mutations present
- Geographic transitions
- Root-to-tip plot
Example from Faria et al
Example from Metsky et al
Metsky et al. 2017. Nature.
Viz strategies
Core of visualization is the ability to make comparisons
Color to link attributes across panels
Transitions to maintain object constancy
Filtering time, space and other attributes
Viz challenges
- Recombination / reassortment
- Combining fragments with full genomes
- Combining metadata of varying resolution
- Conveying uncertainty
Importance of curation by domain experts
Public dissemination vs on-site investigation
Acknowledgements
Nextstrain software development: Richard Neher, James Hadfield, Colin Megill, Sidney Bell,
Charlton Callender, Barney Potter, John Huddleston
Advice / support: Andrew Rambaut, Nick Loman, Ian Goodfellow, Matt Cotten, Paul Kellam,
Kristian Andersen, Nathan Grubaugh, Pardis Sabeti


Clases
Mondays 6:00-8:00 pm y Wednesday 4:00-6:00 pm.Literature
Combinatorics: The art of counting. Bruce Sagan.Preliminary version available in https://users.math.msu.edu/users/bsagan/Books/Aoc/aoc.pdf
A First Course in Discrete Mathematics. Ian Anderson.
Lecture notes in Spanish ( PDF).
Course Contents
Combinatorics is the area of mathematics that studies the enumeration and structure of families of discrete objects.This course will be comprised of two parts:
In the first part of the course we will give an introduction to the theory of combinatorial enumeration, the theory of partially ordered sets (posets) and some basic concepts in graph theory. From the enumerative point of view we will cover the basic enumeration principles, permutations and factorial numbers, subsets and binomial coefficients, compositions and weak compositions, set partitions and Stirling numbers, Fibonacci numbers and Catalan numbers, recurrences, generating functions, and the Principle of Inclusion-Exclusion (PIE). From the theory of partially ordered sets, we will cover basic definitions, lattices, Möbius functions, the Möbius Inversion Theorem. We will also cover the basic definition of a graph, the graph coloring problem and the chromatic polynomial. The first part of the course will be in English, however, we will only assume a basic level in the language. The main goal is to provide the students with the skill to have access to the literature that in general is published in English.
The second part of the course will be centered on giving an introduction to how research is done in Combinatorics. Here the students will have the opportunity to work in small parts of a current research project where we will study an application of the concepts previously studied in class. The students will have the opportunity to make computational experiments, propose conjectures and work towards proving such conjectures.
Examination and Grading
Tests (40%)
There will be 2 tests of 20% each. These will be announced at least one week in advance.Homework (30%)
There will be three problem sets (each worth 10%) to be handed in at the end of each term. To work on the homework problems is crucial for your understanding of the material presented in class. Be sure to separate enough time each week to think and write your solutions. It is recommended that you think and attempt every problem on your own before seeking any help. You are encouraged to discuss the material of the course with your classmates, however you must write your own solutions using your own words. Each homework will be graded by a random selection of a few problems (5%) and by a quiz (5%) where you should write your own solution for a randomly selected problem from the set.Final Research Project (30%)
In the final project we will select one or two problems that we will work as a group. Specific parts of the project will be then assigned to smaller subgroups. The goal of the subgroup is to understand the problem, generate computational data and draw conclusions that might allow you to propose conjectural statements. You will try to prove some of these statements using the skills acquired in the first part of the course.Problem Sessions
There will be various in-class problem sessions during the semester whose goal is to reinforce the concepts learned during a given week. During the problem sessions you are strongly encouraged to share what you have learned and to learn from your fellow class mates (share and learn).Syllabus
This is an approximate schedule of the course containing the syllabus:| Fecha | Tema |
|---|---|
| Mon 01/20 | What is combinatorics? |
| Wed 01/22 | Basic enumeration principles. Permutations and factorial numbers |
| Mon 01/27 | Subsets and binomial coefficients |
| Wed 01/29 | Compositions and week compositions |
| Mon 02/03 | Compositions and week compositions |
| Wed 02/05 | Selecciones con repeticiones y composiciones |
| Mon 02/10 | Selecciones con repeticiones y composiciones |
| Wed 02/12 | Recurrences |
| Mon 02/17 | Recurrences |
| Wed 02/19 | The method of the auxiliary equation to solve recurrences |
| Mon 02/24 | The method of the auxiliary equation to solve recurrences |
| Wed 02/26 | Test 1 |
| Mon 03/02 | Generating functions |
| Wed 03/04 | Generating functions |
| Mon 03/09 | Catalan numbers |
| Wed 03/11 | Set partitions and Stirling numbers |
| Mon 03/16 | The Principle of Inclusion-Exclusion (PIE) |
| Wed 03/18 | Basic concepts in the theory of partially ordered sets (posets) |
| Wed 03/25 | Operations between posets |
| Mon 03/30 | Lattices |
| Wed 04/01 | Lattices |
| Mon 04/13 | Incidence algebras and the Möbius function |
| Wed 04/15 | The Möbius inversion formula |
| Mon 04/20 | Techniques to compute the Möbius function. Labelings and shellability |
| Wed 04/22 | Test 2 |
| Mon 04/27 | REU section. Basic notions in graph theory. Graph coloring and the chromatic polynomial |
| Wed 04/29 | REU section |
| Mon 05/04 | REU section |
| Wed 05/06 | REU section |
| Mon 05/11 | REU section |
| Wed 05/13 | REU section |


{{product.title}}
{{product.description}}
Price: ${{product.price}}
Come see the most magnificent sites of our beautiful red home away from home ...
Olympus Mons, a shield volcano the size of Arizona!
The Medusae-fossae, bizarre impressions along a rugged landscape!
The Valles-marineris, a vast canyon system five times the size of the Grand Canyon!
Call Martian Getaways Tour Director Federica Federbaum at 03-555-5555 for details!


grid based design is a structure used to help people easily follow the information \ on the page. its used in newspapers and on most webpages. it lays out the information from left to right and usually starts with a title followed by a heading then sometimes an image and last but not least the content/ paragraph
responsive webpages are very neccesary in this day and age as people are using all sorts of different sized screens. from phones to tablets to large p.c monitors. responsiveness allows the page to adapt to new sizes while still portraying the same information.
semantic tags are used to make things stand out i.e with the header tags. you can also use them to add images. semantic elements accurately describe the meaning of the tag.


Use chromevox key + N and H to move to next header, chromevox key + P and H to move to previous header


{% extends "base.html" %} {% block title %} Mobiauth - 500 Error {% endblock title %} {% block content %}
Mobiauth has encountered an error. Admins have been notified.


[gecode-users] Value selection when branching
Lars Otten
ottenl at student.chalmers.se
Fri Feb 10 16:22:30 CET 2006
On 02/09/06 18:49, Lars Otten wrote:
> Things worked out quite well. [...]
> And, lo and behold, now it seems to work!
Turns out it wasn't easy as it seemed:
For a start I forgot to adapt the description() method for my
ViewValRandBranching class, as it involves value selection as well.
But, more importantly, I just realized that the constructor for the
Branching class is usually only called once, upon invoking the
Gecode::branch(...) method in the example -- thus the seeds for the random
number generator are only fixed once and the same sequence of random numbers
is used over and over again -- which in effect seriously limits the randomness.
 :-/
Have a nice weekend,
/Lars
More information about the gecode-users
mailing list


Open Project Community (OPC) is an open source community founded by the TAFECorp which raised a project called Personal_Organizer and call for members to develop further from the initial development. The application started initially on the Start_Finance. The application is not a complete product. The project is developed using MS Visual Studio 2015 UWP – C# accessing to the SQLite database. The codes are version controlled and deposited in the repository using a git server.