Hi Guys, Thanks for checking out our website. We are happy you are going to be celebrating with us. check out how we met and some of the awesome pictures we've taken over the years and don't forget to RSVP!!!
See Our StoryJanessa has a very different idea on how we met but I believe we met through a mutual friend of ours and at the time I just thought she was the weirdest child I had ever met. She was quite funny and charming and we easily became friends. Even as friends everyone always knew we would end up together and we have always enjoyed each others company. We were always together getting into crazy adventures like trying to find a Walmart in the middle of the night or trying to walk to a gas station in -40C.
No matter what the adventure was and still is, if she called for my help, I would always be there for her and those were the moments that made me realize I wanted to spend every moment with this girl who I knew I was in love with. It took me quite a while to get the nerve to ask her to even go out with me and even longer to get the nerves to ask her dad for his permission. FYI Daryl is super nice but he scares me. Fortunately for me, he said yes and I was more than delighted to ask the love of my life to spend the rest of her life with me. She said yes and fast-forward 5 months and here we are.
You have to make your websites with love these days and a lot of help from Bootstrap!


---
layout: post
title: Faces Cosmetics Long Wear Eye Pencil Gray
tags:
- Eye Liner
- Eye Pencil
- Faces Cosmetics
- Gray
- Kohl
status: publish
type: post
published: true
meta:
_yoast_wpseo_linkdex: '76'
_edit_last: '2'
_yoast_wpseo_focuskw: Faces Cosmetics Long Wear Eye Pencil
_yoast_wpseo_title: ''
_yoast_wpseo_metadesc: Faces Cosmetics Long Wear Eye Pencil Gray
_yoast_wpseo_metakeywords: ''
_yoast_wpseo_meta-robots-noindex: '0'
_yoast_wpseo_meta-robots-nofollow: '0'
_yoast_wpseo_meta-robots-adv: none
_yoast_wpseo_sitemap-include: ! '-'
_yoast_wpseo_sitemap-prio: ! '-'
_yoast_wpseo_canonical: ''
_yoast_wpseo_redirect: ''
_thumbnail_id: '8305'
---
Faces Cosmetics Long Wear Eye Pencil Gray
I am a big Faces Cosmetics Long Wear Eye Pencil fan. I was on a lookout for a perfect grey for subtle eye and hence picked up this pencil.
You can see the complete swatch gallery here Faces Long Wear Eye Pencil...
Price: Rs.349 (earlier same pencil was priced Rs.250)
I love,
- Its creamy and just glides without tugging,
- Intensely pigmented,
- Long lasting on the lids,
- Can be blended on the lids when freshly applied,
Where I struggled,
- Smudges on waterline after 2-3 hours, so as kohl not that really effective,
- I could never get perfect tip after sharpening,
I love this shade to bits, I sometimes prefer subtle eyes instead of sharp eyes with black kohl. How about you ?
Do you also love Faces Long Wear eye pencil ?
Some shades reviewed here,


Choose a seed to assess reliability.You can filter the list of seeds by using the Network Selector below.
IOU webgl canvas with selected seed on surface


I've become managing editor of Senti Chi Parla in February 2018 and we launched it in three weeks. There other than managing the newsroom, I also write and curate our social media profiles.
View ArticlesI've collaborated with Wired Italia from 2010 to 2015. On wired.it I wrote mostly about science, but I've also covered tech and lifestyle news
View ArticlesI've covered science news for Il Venerdì from December 2008 until the beginning of 2016. Between 2013 and 2015, besides writing Science news I've curated a section dedicated to Science in Social Media.
I've begun collaborating with L'Espresso through Galileo Servizi Editoriali. On this magazine again I've written mostly about science and health. Clicking on the image you find those articles that have been published both on the printed version of the magazine and on the website.
View ArticlesI've worked for Galileo Servizi Editoriali from April 2009 to February 2013. During these years I've written articles for several printed and online magazines (some of the above and others like Le Scienze and Mente e Cervello, which today has been renamed as "Brain"). At Galileo I had several roles such as reporter, web content editor, social media manager, but I also was the managing editor for their online magazine Galileo - Giornale di Scienza . I've also been co-lecturer Master “Science of Life in Journalism and in Political-Institutional Communications”, Sapienza - the University of Rome for the Academic Years 2009-10, 2010-11, 2011-12.
View Articles


Flashcards
Asynchronous
1. What are the arguments that the setTimeout
and setInterval
methods can accept?
- a callback function
- a delay time in milliseconds
- any number of additional arguments to be passed to the callback
2. What does the setTimeout
method return in the Node environment?
- The
setTimeout
method returns a Timeout object that can be passed to clearTimeout
to cancel the timeout.
3. What does the setTimeout
method return in the browser environment?
- The
setTimeout
method returns a number representing the unique ID associated with that timeout. The ID number can be passed to clearTimeout
to cancel the callback from running.
4. Is JavaScript single-threaded or multi-threaded?
5. What is the difference between single-threaded and multi-threaded execution?
- Single-threaded execution means that only one command can be processed at a time. In multi-threaded execution, more than one command can be processed at a time.
6. What are the two main data structures that comprise JavaScript’s event loop?
- The call stack and event queue.
7. When a function is called, what occurs on the call stack?
- A new stack frame that corresponds to that function call is pushed to the top of the stack.
8. When a function returns, what occurs on the call stack?
- The stack frame on top will be popped from the stack.
9. In the JavaScript event loop, what is the message queue used for?
- The message queue is used to track events that have occured but cannot be processed yet because the stack is already busy processing other commands. Once the stack is available, the “message” or event handler that is at the front of the queue will be moved to the stack for evaluation.
10. When an event triggers, what occurs in the JavaScript runtime’s message queue?
- A new message that corresponds to that event is enqueued (added to the back of the queue).
11. In what order will the following code print to the console?
12. What must occur for items to be dequeued (removed) from the JavaScript runtime’s message queue?
- The call stack must become empty. This happens when current task is finished executing.
13. What is the difference between synchronous and asynchronous code?
- In synchronous code, the commands execute one after the other in order. This means that completion of a “slow” function will block execution of further functions. In asynchronous code, the commands are not guaranteed to occur one after the other; an asynchronous function will not block execution of further functions.


Warnings issued over deadly fake Viagra tablets being sold online
Ingredients found in counterfeit pills include, drywall, road paint, and anti-fungal medication.
by Katie Timms, Danny ThompsonPeople who use Viagra are being warned about deadly fake versions of the drug being sold online.
Pfizer, the company behind the erectile dysfunction treatment, warn there are many websites claiming to sell Viagra, but only around 20 per cent of these are genuine - counterfeits pills are illegal, and can also be unsanitary, toxic and even lethal.
Ingredients found in these fake Viagra can include road paint, drywall, detergent, anti-fungal medication, talcum powder and amphetamines, report Plymouth Live.
David Massie, registered pharmacist at Dr Andrews Online Pharmacy, said: "The number of dangerous things found in fake Viagra is staggering. The individuals behind the propagation of these counterfeit pills do not consider your health when producing them, only their profits.
“When a doctor or pharmacist prescribes you Viagra, they consider all the other medications you might taking. Unlicensed sites are concerned only with their financial gain and not with drug interactions – mixing inappropriate medications together can often result in death.
"At Dr Andrews, we encourage you to be vigilant in ensuring what you are taking is real, approved and regulated Viagra from a registered source.”
Here are some ways to ensure what you have is the real deal:
- It has smooth edges. Fake Viagra will have rough edges.
- Viagra only comes in packs of four. Any more than four pills to a pack are counterfeit.
- There should be no variations in colour. Viagra will always be solid blue.
- The f in Pfizer should not narrow until the top. In fake Viagra the ‘f’ narrows just past the letter ‘i’.
- A package without an expiration date or a poorly printed expiration date is a fake.
- Pfizer always have a hologram on the boxes. No hologram – not genuine.
If you have any doubts about the Viagra you received, do not use it - if you have taken what could be counterfeits, contact your doctor straight away.


Call us toll free : +1324 353 4689
30 New Mega Sales. Upto 80% Off. Starting Everyday at 9 AM.
make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing
make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing
make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged.
The release of Letraset make a type specimen book
Lorem Ipsum passages, and more
Essentially unchanged.desktop publishing
desktop publishing packages and web page editors now use Lorem Ipsum as their default model web sites
desktop publishing packages and web page editors now use Lorem Ipsum as their default model web sites
desktop publishing packages and web page editors now use Lorem Ipsum as their default model web sites
desktop publishing packages and web page editors now use Lorem Ipsum as their default model web sites


Visualization 1
The Amount donated and received by countries.
Question: How do the How do the countries compare in terms of how much they receive and donate from other countries? Are there countries that donate much more than they receive or receive much more than they donate?
Explanation: In this visualization I have considered the top 30 countires that donated and top 30 countires that receive.
We see that developing countries like India, Brazil, Indonesia, China, etc. receive the maximum amount of aid.
Whereas developed nations like United States, Germany, Japan, France, etc. give more donations.
The comparison between countries that donate more and that receive more is easy in this graph as there are 2 axis, one for donated
amount and one for received amount. This allows us to compare large number of countries in a single chart.
The diverging bars, along with different color for donated amount and received amount help to easily distinguish between the countries
and answer the question. I have not considered all the countries as the amount scale is in billions and some of the
countries have received or donated in millions which would not have a visible bar on the chart.
So to maintain relevance and answer the question effectively, I have only considered the top 30 donating and receiving countries.
So counntries like India, Brazil, Indonesia, Mexico, China, Turkey receive much more than they donate and USA, Japan
France, Germany, United Kingdom donate much more than they receive.


November 23 2015
This Is My First Article
Bacon ipsum dolor amet beef ribs shankle hamburger alcatra jerky spare ribs turkey drumstick pork chop. Tail frankfurter sausage fatback, bacon ham hock shoulder filet mignon biltong picanha ribeye.  Tongue brisket buffalo turkey short ribs, tenderloin meatball salami kielbasa biltong sausage fatback alcatra drumstick. Short loin frankfurter bresaola corned beef cupim beef ground round boudin tri-tip ball tip t-bone strip steak. Rump doner venison cow boudin meatloaf kevin ball tip chicken fatback turducken capicola.
 Jerky capicola tenderloin beef ribs salami, fatback andouille bacon meatball. T-bone biltong jowl cupim, pork shank hamburger buffalo. Bacon tail jowl landjaeger salami pork pastrami sausage frankfurter tongue tenderloin meatloaf turkey prosciutto. Biltong frankfurter flank boudin jowl landjaeger beef porchetta ball tip ribeye venison. Buffalo meatloaf venison bresaola. Tongue beef fatback, chicken meatball ground round rump bacon leberkas alcatra.
Sirloin cow picanha ham. Bacon boudin tri-tip, short ribs tongue kielbasa picanha sirloin short loin capicola frankfurter strip steak jowl flank pork. Meatball chuck cupim frankfurter pancetta short ribs t-bone bresaola jerky meatloaf biltong short loin drumstick ground round shankle. Pork chop filet mignon porchetta drumstick bacon leberkas ham, shank chicken. Frankfurter tenderloin strip steak cupim swine. Jerky beef ribs tongue t-bone.
December 11 2015
This Is Another Article
Bacon ipsum dolor amet beef ribs shankle hamburger alcatra jerky spare ribs turkey drumstick pork chop. Tail frankfurter sausage fatback, bacon ham hock shoulder filet mignon biltong picanha ribeye.  Tongue brisket buffalo turkey short ribs, tenderloin meatball salami kielbasa biltong sausage fatback alcatra drumstick. Short loin frankfurter bresaola corned beef cupim beef ground round boudin tri-tip ball tip t-bone strip steak. Rump doner venison cow boudin meatloaf kevin ball tip chicken fatback turducken capicola.
 Jerky capicola tenderloin beef ribs salami, fatback andouille bacon meatball. T-bone biltong jowl cupim, pork shank hamburger buffalo. Bacon tail jowl landjaeger salami pork pastrami sausage frankfurter tongue tenderloin meatloaf turkey prosciutto. Biltong frankfurter flank boudin jowl landjaeger beef porchetta ball tip ribeye venison. Buffalo meatloaf venison bresaola. Tongue beef fatback, chicken meatball ground round rump bacon leberkas alcatra.
Sirloin cow picanha ham. Bacon boudin tri-tip, short ribs tongue kielbasa picanha sirloin short loin capicola frankfurter strip steak jowl flank pork. Meatball chuck cupim frankfurter pancetta short ribs t-bone bresaola jerky meatloaf biltong short loin drumstick ground round shankle. Pork chop filet mignon porchetta drumstick bacon leberkas ham, shank chicken. Frankfurter tenderloin strip steak cupim swine. Jerky beef ribs tongue t-bone.


FATHERS' DAY A film review by James Berardinelli Copyright 1997 James Berardinelli
RATING (0 TO 10): 2.5 Alternative Scale: * out of ****
United States, 1997 U.S. Release Date: 5/9/97 (wide) Running Length: 1:45 MPAA Classification: PG-13 (Profanity, sexual innuendo) Theatrical Aspect Ratio: 2.35:1
Cast: Robin Williams, Billy Crystal, Charlie Hofheimer, Bruce Greenwood, Nastassja Kinski, Julia Louis-Dreyfus Director: Ivan Reitman Producers: Ivan Reitman and Joel Silver Screenplay: Lowell Ganz and Babaloo Mandel, based on the film LES COMPERES by Francis Veber Cinematography: Stephen H. Burum Music: James Newton Howard U.S. Distributor: Warner Brothers
FATHERS' DAY simply has to be seen to be believed. It's beyond my comprehension how a motion picture with so much talent associated with it -- actors Robin Williams and Billy Crystal, super-producer Joel Silver, and director Ivan Reitman -- can be such a complete waste of time. FATHERS' DAY isn't just bad, it's awful. Without a doubt, this is one of 1997's most disappointing motion pictures.
On the surface, the film looks like it could be good. The comic pairing of Robin Williams and Billy Crystal would seem to be a dream match belonging alongside such other recent high-profile couplings as Steve Martin and John Candy (PLANES, TRAINS, AND AUTOMOBILES) and Martin and Michael Caine (DIRTY ROTTEN SCOUNDRELS). In fact, Williams and Crystal might not even need a script -- just the two of them on camera together should be enough to garner laughs. As it turns out, that would have been a better approach, because the screenplay for FATHERS' DAY, written by feel-good scribes Lowell Ganz and Babaloo Mandel (MULTIPLICITY, CITY SLICKERS), saps all life and humor from the leads' performances. The painful, predictable result is a dearth of mirth. If you see FATHERS' DAY and laugh more than once, consider yourself lucky.
The plot, which is based on a early-'80s French film called LES COMPERES, tells the story of one mother, one son, and three fathers. It seems that the mother, Collette (Nastassja Kinski), used to get around a little back in the late-'70s and early-'80s. Sometime in that period, right before she married her true love (Bruce Greenwood), she slept with both Dale (Robin Williams) and Jack (Billy Crystal). Nine months later, a child was born, and she didn't know which of the three men was the biological dad. That didn't matter until 1997, when 16-year old Scott (an unpromising Charlie Hofheimer) decides to run away from home. Desperate to get him back, Collette calls up Dale and Jack, surprises them with the news about their paternity, and implores them to look for Scott. And, although the two start separately, they end up together on a chase that goes from San Francisco to Sacramento to Reno.
FATHERS' DAY wants to be a hilarious, screwball comedy that doubles as a buddy film, with a dash of family values thrown in for good measure. Unfortunately, these concepts got lost somewhere in the translation (maybe Ganz and Mandel don't know French). FATHERS' DAY is a one-hundred minute bore without a single character worth caring about. Crystal and Williams generate no chemistry, and both look like they're on hand solely to pick up a paycheck. The feel-good moments, which are available in embarrassing abundance, border on nauseating. However, perhaps the most disheartening thing about FATHERS' DAY is its complete lack of energy -- even Williams' patented manic impressions come across as more scripted than spontaneous.
With the addition of FATHERS' DAY to his uneven resume, film maker Ivan Reitman can now boast "the ugly" in addition to "the good" and "the bad." As a director, Reitman has been responsible for several entertaining movies, including GHOSTBUSTERS and DAVE, and an even larger number of mediocre-to-poor offerings, such as the Arnold Schwarzenegger comedies (TWINS, KINDERGARTEN COP, JUNIOR). But nothing he has previously accomplished equals this travesty. Hopefully, FATHERS' DAY will be nothing more than an unpleasant memory by the time the third Sunday in June rolls around.
- James Berardinelli e-mail<EMAIL_ADDRESS>ReelViews web site: http://www.cybernex.net/~berardin
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.html" %} {% block content %}
Shop with ease at the comfort of your home or office.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. consectetur adipiscing elit. consectetur adipiscing elit.
From 1000 ksh


| Programming with Ophis | ||
|---|---|---|
| <<< Previous | The basics | Next >>> |
Now that we have our header information, let's actually write the "Hello world" program. It's pretty short—a simple loop that steps through a hardcoded array until it reaches a 0 or outputs 256 characters. It then returns control to BASIC with an RTS statement.
Each character in the array is passed as an argument to a subroutine at memory location $FFD2. This is part of the Commodore 64's BIOS software, which its development documentation calls the KERNAL. Location $FFD2 prints out the character corresponding to the character code in the accumulator.
ldx #0 loop: lda hello, x beq done jsr $ffd2 inx bne loop done: rts hello: .byte "HELLO, WORLD!", 0 |
The complete, final source is available in the tutor1.oph file.
| <<< Previous | Home | Next >>> |
| Related commands and options | Up | Assembling the code |


Recently, box offices have struggled to stay afloat. Revenues have declined as a result of services like Netflix and Hulu.
A CNN Money article published August 2 read:
Despite big hits like "Wonder Woman," "Guardians of the Galaxy Vol. 2," and "Spider-Man: Homecoming," movie grosses are down 2% from a year ago, according to figures from Box Office Mojo, which tracks the industry.
Despite recent struggles, theater companies are cautiously optimistic about the outlook for the rest of the year. The following highly-anticipated films might just lift the industry's profits to success:
Click here to jump to the comments section.
| Rating | Want to see | |
|---|---|---|
| Kingsman | R | 99% |
| Star Wars | Not yet rated | 99% |
Please use the following form for correspondence:
Name:
Email:
Comment:


--- layout: archive title: Zulip Chat Archive permalink: /stream/113489-new-members/topic/cubic.20equation.html ---
I try to definite a cubic equation as a polynomial function .
My first test start with
open polynomial variable X: polynomial ℝ def test (a:ℝ ):polynomial ℝ := C a * X
The problem here is that I can't use the indeterminant X
available in the module polynomial.lean and that it don't accept C a*X
as a polynomial. Would someone help me with this? Thank you.
You will need to open polynomial
to write just C
and X
as opposed to polynomial.C
and polynomial.X
. You don't want variable X
because then you are making X
refer to an arbitrary polynomial rather than the indeterminate
@Mario Carneiro I already did this in my test
Do you have open polynomial
in your file?
I mean
open polynomial def test (a:ℝ ):polynomial ℝ := C a * X
yes, this is my test
no variable
line
that is shadowing the real X
Screen-Shot-2019-04-16-at-11.27.14.png
Remove those variable
lines
Screen-Shot-2019-04-16-at-11.28.22.png
always this problem
What is the reported error?
definition 'test' is noncomputable, it depends on 'real.discrete_field'
@Johan Commelin
add noncomputable
to the definition
Ok, so write noncomputable
before the def
@Mii Nguyen This problem is specific to working with real polynomials. If your field of coefficients was \Q
you wouldn't see the problem.
Last updated: Apr 24 2020 at 19:02 UTC


class: center, middle ### W4995 Applied Machine Learning # Trees, Forests & Ensembles 02/17/20 Andreas C. Müller ??? FIXME missing value treatment in trees FIXME: saw 1d tree explanation somewhere that was really neat? regression? FIXME show how everything is axis parallel and how that makes it hard to learn linear things FIXME show that only rank is important FIXME bullet points! FIXME oblique trees? animation searching for split in tree? predition animation tree? extra tree: only one thereshold per feature? FIXME: bias variance plot replace by two kinds of error (approximation, generalization) FIXME: length actually good. so more of a note than fixme lol FIXME: test curve mislabeled warm start FIXME explain "values" in figure in slide notes FIXME plots sometimes say values and sometimes samples, make sure it's consistent! FIXME some plots say entropy but actually use gini?! wtf, redo plots FIXME add graphviz back in as it's a bit higher quality? FIXME add example of subset splits with categorical features FIXME don't do warm starts and OOB and do better explanations of rest FIXME entropy calculation for tree, maybe do it once explicitly? FIXME Go over finding a single split in some toy data! 1d regression? FIXME order is a bit weight FIXME better example of CCP helping FIXME show averaging in forest on regression example? --- class: spacious, middle # Why Trees? ??? Trees are really very powerful models both for classification and regression, they're very commonly used. Trees are very popular in the industry. Only beaten by deep neural networks. Tree-based models are one of the main tools in the toolbox of most machine learning practitioners. Trees really don't care about the scale of the data so you don't really have to do a lot of preprocessing. Trees don't care about the distribution of your data. There are versions of trees that can deal with categorical variables and with missing values. By combining multiple trees you can build stronger models. - Very powerful modeling method – non-linear! - Doesn’t care about scaling of distribution of data! - “Interpretable” - Basis of very powerful models! - add stacking classifier from PR? --- class: centre,middle # Decision Trees for Classification ??? --- # Idea: series of binary questions .center[ ![:scale 70%](images/tree_illustration.png) ] ??? Binary classification trees are binary trees, where each node corresponds to a question asked about the data. This example is a fictional task where you want to distinguish hawks, penguins, dolphins, and bears. You ask a series of binary questions that will lead to which animal it might be. Depending on what the answer is for a particular question, you could ask another question. This way you can narrow it down for possible outcomes. Usually, when we are doing classification we have continuous features and so the questions are thresholds on single features. --- # Building Trees .left-column[ ![:scale 100%](images/tree_building_iteration_1.png)
Continuous features: - “questions” are thresholds on single features. - Minimize impurity ] .right-column[ ![:scale 100%](images/tree_building_iteration_2.png) ![:scale 100%](images/tree_building_iteration_9.png) ] ??? Here is an example of a tree with depth one, that's basically just thresholding a single feature. In this example, the question being asked is, is X1 less than or equal to 0.0596. The boundary between the 2 regions is the decision boundary. The decision for each of the region would be the majority class on it. This decision tree of depth one would classify everything that is below the horizontal line as class red since there are more red points (32>2) and everything above as blue since there are more blue points (48>18). The way this threshold was chosen, the way that tree of depth one was learned was to find the best feature and the best threshold to minimize impurity. Which means it tries to make the resulting subsets, the top half and the bottom half here, to be as pure as possible (to consist mostly of one class) Basically, we're searching over all possible features and all possible thresholds. Possible thresholds are all values of the feature that we're observing. So I would start iterating over the first feature and for the first feature, I would look at all possible thresholds and see if this is a good question to ask, i.e. is this a good way to split the data set into two classes. If you search over all possible features, then the best split is found. Once we find this split, we can then basically apply this algorithm recursively to the two areas that the split created. For top area here, we can ask what the best feature is and what the best threshold for this feature is to make the resulting regions as pure as possible. Here in the bottom, it asks is X0 less or equal than minus 0.4? The model will predict accordingly, either blue or red. If only one class remain after a split, the tree will not add any splits since the regions have become pure. Each node corresponds to a split and the leaves correspond to regions. All tree building algorithms start greedily building a tree, so they don't really go back and revisit because it would be too computationally expensive. Does the layout look okay?? --- # Criteria (for classification) - Gini Index: `$$H_\text{gini}(X_m) = \sum_{k\in\mathcal{Y}} p_{mk} (1 - p_{mk})$$` - Cross-Entropy: `$$H_\text{CE}(X_m) = -\sum_{k\in\mathcal{Y}} p_{mk} \log(p_{mk})$$` $X_m$ observations in node m $\mathcal{Y}$ classes $p_{m\cdot}$ distribution over classes in node m ??? For classification, there are two common criteria to preserve the purity of the leaf. One is called the Gini Index and the other one is Cross-Entropy. Gini Index works well in practices. Cross-Entropy is the entropy of the distribution over classes. You want to minimize the entropy over the classes, you want to have a very spike distribution in the classes, you want mostly to be one class and less of the others so that the trees are very certain about what the class is for each leaf. --- # Prediction .center[ ![:scale 80%](images/tree_prediction.png) ] ??? To make a prediction, I traverse the tree I ask all the questions in the node that I encounter and then I can predict the majority class in the leaf. One thing that's nice about this is this prediction is really, really fast since this tree is not very deep. - Traverse tree based on feature tests - Predict most common class in leaf --- # Regression trees `$$\text{Prediction: } \bar{y}_m = \frac{1}{N_m} \sum_{i \in N_m} y_i $$` Mean Squared Error: `$$ H(X_m) = \frac{1}{N_m} \sum_{i \in N_m} (y_i - \bar{y}_m)^2 $$` Mean Absolute Error: `$$ H(X_m) = \frac{1}{N_m} \sum_{i \in N_m} |y_i - \bar{y}_m| $$` ??? You can do the same thing also for regression. In regression, the prediction is usually the mean over the target targets in a leaf. The impurity criteria that I minimized is usually the mean squared error. Basically, you look at how good of a prediction is the mean if I split like this. For each possible split, you can compute the mean for the two resulting nodes and you compute how well the mean in this leaf predicts.  One thing about the regression trees is that they have more tendency to get very deep if you don't restrict them. Because usually in regression, all targets are distinct, they’re distinct float numbers. So if you want all leaves to be pure, then all of these will have only one node in them, unless you have a special case where you have equal flow numbers as a target, which is not common. Another thing that's really nice about trees is that you can visualize them and you can look at them, and you can possibly even explain to your boss what they mean. - Without regularization / pruning: - Each leaf often contains a single point to be “pure” --- # Visualizing trees with sklearn .smaller[ ```python from sklearn.datasets import load_breast_cancer cancer = load_breast_cancer() X_train, X_test, y_train, y_test = train_test_split(cancer.data,cancer.target, stratify=cancer.target, random_state=0) from sklearn.tree import DecisionTreeClassifier tree = DecisionTreeClassifier(max_depth=2) tree.fit(X_train, y_train) ``` ] ??? The first way to visualize tree in scikit-learn is a little bit tricky. The second one is a one I hacked. I'm going to use the breast cancer data center, which does the classification of breast tissues. So trees can do much more complicated things than multiclass. For the ease of visualization, I'm going to do binary. I can build the decision tree classifier, and there's a method in scikit-learn called export _graphviz, which is basically a file format and the layout engine for showing graphs. So you can take the tree, the estimator that’s the tree. You can also give it the feature names if you want. You can either write this to a file, or you can get back to string in this dot language. And that's what it looks like. This is a tree of depth 2 and I gave it the feature names. --- # Visualizing trees with sklearn ```python from sklearn.tree import plot_tree tree_dot = plot_tree(tree, feature_names=cancer.feature_names) ``` .center[ ![:scale 80%](images/mpl_tree_plot.png) ] ??? The other thing that I like to use which is easier is this pull request or there’s a gist that you download, it’s a single file called the tree_plotting. And that uses math plot to plot the trees. Here, at the top you can see the test, then you can see the criteria, then the number of samples in this node and then which class the samples belong to. In the original breast cancer dataset, the top node corresponds to the whole dataset. The tree gets purer and purer as you move down the tree. --- class:some-space # Parameter Tuning - Pre-pruning vs post-pruning - Pre-pruning: Limit tree size (pick one, maybe two): - max_depth - max_leaf_nodes - min_samples_split - min_impurity_decrease - ... ??? I want to talk a little bit about the different parameters that you can choose. Most of the tree growing algorithms are greedy. There are two ways to restrict the growth of the tree after you train them. There are pre-pruning and post-pruning. In pre-pruning, you restrict while you're growing. In post-pruning, you build the whole tree (greedily) and then you possibly merge notes. So you possibly undo sort of bad decisions that you made, but you don't restructure the tree. In scikit-learn right now, there's only pre-pruning. The most commonly used criteria are the maximum depth of the tree, the maximum number of leaf nodes, the minimum samples in a node split and minimum decrease impurity. --- class:spacious # No pruning .center[ ![:scale 100%](images/no_pruning.png) ] ??? Here’s the full tree for the same dataset. --- class:spacious # max_depth = 4 .center[ ![:scale 100%](images/max_depth_4.png) ] ??? Maximum depth of the tree restricted to 4. This is like a very simple way. If you are actually building just a single decision tree, this might not be the best way because for example, here you split away the single point which might not be great and other leaves are very mixed. So you can't make a good prediction here. Since it puts the same depth limit on everywhere in the tree, this is not very fine grained. What it does is it means that your predictions will be very fast because you never have to go very deep in the tree. It also makes the tree size very small. If you built a lot of trees, you might get issues with the RAM. If you have a lot of very deep trees, they will at some point be bigger than your RAM, and you'll run into troubles, or if they're very deep, it might be very slow to predict at some point. So this is a way to restrict how much memory and how much prediction time you're willing to give. --- # max_leaf_nodes = 8 .center[ ![:scale 50%](images/max_leaf_nodes_8.png) ] ??? If you use max_leaf_nodes, it will always put the one that has the greatest impurity decrease first. You can see that in different parts of the trees, there's different depth. It will prioritize the ones that decrease the impurity the most. --- class:spacious # min_samples_split = 50 .center[ ![:scale 70%](images/min_samples_split_50.png) ] ??? Min_samples_split is quite simple, it just says only split nodes that have this many samples on them. What I don't like about this criterion set here, for example, it splits off a single point, which I don't think is really great, because it's not going to improve the prediction very much. So both the max leaf nodes and the minimum impurity decrease will allow you to basically get rid of these very small leaves that don't really add anything to the prediction. Impurity decrease will only make splits that decrease the impurity by X amount. If you want to tune this, you pick one of these and then you just tune this one parameter. --- .smaller[ ```python from sklearn.model_selection import GridSearchCV param_grid = {'max_depth':range(1, 7)} grid = GridSearchCV(DecisionTreeClassifier(random_state=0), param_grid=param_grid, cv=10) grid.fit(X_train, y_train) ``` ] .center[ ![:scale 70%](images/grid_max_depth.png) ] ??? So for example, if you want to tune max depth and restricted the depth of the tree. So run a grid search over max depth and you can do the parameter curves as we did before and you can see that maybe depth of five is good on this dataset. Again, you can see the typical curve with the more complexity you allow in your classifier, the better you get the training set, but possibly you overfit on a test set. So, here, you could say maybe it's overfitting a little bit, but it's not very visible. --- .smaller[ ```python from sklearn.model_selection import GridSearchCV param_grid = {'max_leaf_nodes':range(2, 20)} grid = GridSearchCV(DecisionTreeClassifier(random_state=0), param_grid=param_grid, cv=10) grid.fit(X_train, y_train) ``` ] .center[ ![:scale 70%](images/grid_max_leaf_nodes.png) ] ??? Here is if you tune a maximum number of leaf nodes, you can see it’s slightly more overfitting happening but generally, there's not a big difference on this toy dataset between building the full tree or having a smaller tree. Obviously, if you have a small tree, predictions are going to be faster and need less memory to store and you can explain it better. So the thing with being able to explain is, if you have a tree up depth 14, then it's not really explainable anymore, no human can look at all of this and say “Oh, I understand exactly what's going on”. If you have 8 leaves, it's a very good chance you can draw this, and you can think about it, and you can understand that. I wouldn't really say trees are interpretable but small trees are interpretable. So that's also the reason why you might want to restrict the rows of the tree. So you can easily communicate and easily explained. --- # Cost Complexity Pruning .padding-top[ .larger[ $$ R_\alpha(T) = R(T) + \alpha|T| $$ ] ] $R(T)$ is total leaf impurity $|T|$ is number of leaf nodes $\alpha$ is free parameter. --- .smaller[ ```python from sklearn.model_selection import GridSearchCV param_grid = {'ccp_alpha': np.linspace(0., 0.03, 20)} grid = GridSearchCV(DecisionTreeClassifier(random_state=0), param_grid=param_grid, cv=10) grid.fit(X_train, y_train) ``` ] .center[ ![:scale 70%](images/grid_ccp_alpha.png) ] --- # Efficient pruning ```python clf = DecisionTreeClassifier(random_state=0) path = clf.cost_complexity_pruning_path(X_train, y_train) ccp_alphas, impurities = path.ccp_alphas, path.impurities ``` .center[ ![:scale 55%](images/pruning_alpha.png) ] --- # Best post-pruned vs pre-pruned .left-column[ ## Cost-complexity pruning ![:scale 70%](images/tree_pruned.png) ] .right-column[ ## Max leaf nodes search ![:scale 80%](images/max_leaf_nodes_8.png) ] --- #Extrapolation .center[ ![:scale 80%](images/ram_prices.png) ] ??? Trees are actually quite similar to nearest neighbors in some sense because both nearest neighbors and trees pick the average of their neighbors or delete the neighbors’ votes (depending on classification or regression) In KNearest Neighbors or epsilon nearest neighbors, where you have a radius around the data point in which you look for neighbors. In trees, you look at the same leaf, and you basically let the other point in the leaf vote what the output should be. Trees are consistent if you give them enough data and they will eventually learn anything because eventually, they're just like nearest neighbors. Nearest neighbors are very slow to predict because you need to compute the distances to all training points while trees very fast to predict because you just need to traverse the binary tree. One thing that you should keep in mind is that both can't extrapolate. --- #Extrapolation .center[ ![:scale 80%](images/ram_prices_train.png) ] ??? --- #Extrapolation .center[ ![:scale 80%](images/ram_prices_test.png) ] ??? This is the RAM prices in dollar per megabyte historically. This is an instance of Moore's law. On log scale, it’s pretty linear because of the ram prices half every 18 months or something. Let's say I want to build the prediction model for this. And I want to build it up to 2000, and I want to make predictions about the future. Now I'm going to compare a linear model in a tree-based model. The linear model, I kind of cheated a little bit because I did the log transform so that linear model can actually model it. I didn't restrict the tree model so it'll basically learn the training data set perfectly. Now the question is, if I want to do prediction, what are we going to predict? You probably are not going to be surprised by the linear prediction but you might be by the tree prediction. The tree predicts just a constant and the constant is basically the last point observed. This is the same thing that the nearest neighbor base model would do. So if you want to predict here, basically, you traverse the tree and you find basically the closest data point to it, the one or the other data point that is in the same leaf, and the ones that will share the leaf with are the ones on the very right. And then it will computer mean of these data points. And the mean is going to be just the value if the leaf is pure. If I did like coarser split level, it will tune the mean of all of these, but it’ll always compute the mean of some data points on the training set. So it'll never be able to predict these values that are not seen in a training set. In practice, this is usually not really a big issue. For example, if you want to do like extrapolation like this, you could instead of trying to predict the value, you could use the tree to predict the difference to the last day or to the last year or something like this, and then it would work. But it's definitely something you should keep in mind. Basically, outside of where you’ve observed training data, it'll just be a constant prediction. Basically falling back to what it was last seen. That might be a little bit surprising sometimes. Generally, extrapolation in machine learning is hard. And if you need to extrapolate, there's a chance you're not going to be able to do with any model. But in particular, for tree-based and nearest neighbor based models, you should keep in mind that they can't do that. --- class:spacious # Relation to Nearest Neighbors - Predict average of neighbors – either by k, by epsilon ball or by leaf. - Trees are much faster to predict. - Both can’t extrapolate ??? FIXME plots --- # Instability .left-column[ .tiny-code[ ```python X_train, X_test, y_train, y_test = train_test_split( iris.data, iris.target, stratify=iris.target, random_state=0) tree = DecisionTreeClassifier(max_leaf_nodes=6) tree.fit(X_train, y_train) ``` ] ![:scale 70%](images/instability_1.png) ] .right-column[ .tiny-code[```python X_train, X_test, y_train, y_test = train_test_split( iris.data, iris.target, stratify=iris.target, random_state=1) tree = DecisionTreeClassifier(max_leaf_nodes=6) tree.fit(X_train, y_train) ``` ] .center[![:scale 70%](images/instability_2.png) ]] ??? Another weakness of trees that I want to mention is that they are very unstable. Using the iris dataset, let's say I want a small tree. So I say I want a maximum of six leaves nodes and I split my Iris dataset, and I build the tree, and then I split the same data set again, and take a different random state. Hopefully, I would assume that if it's the same dataset, and I split randomly, then the models should be similar. However, if you look at these models, even in the root note, the very first decision it made is different. One compares petal length to 2.45 while the other compares pedal width to 0.8. And the number of points that are split off are different too. So there's not really an easy correspondence between these two trees. So this is sort of a caveat about interoperability. You can interpret the tree but maybe if the dataset was only slightly different, the tree might look completely different. So this tree structure is really something that's very unstable. --- # Feature importance .left-column[ .tiny-code[```python X_train, X_test, y_train, y_test = train_test_split( iris.data, iris.target, stratify=iris.target, random_state=0) tree = DecisionTreeClassifier(max_leaf_nodes=6) tree.fit(X_train,y_train) ```] .center[![:scale 60%](images/instability_1.png) ] ] .right-column[ .tiny-code[ ```python tree.feature_importances_ array([0.0, 0.0, 0.414, 0.586]) ``` ] ![:scale 80%](images/tree_importances.png) ] ??? Another interesting feature of trees that I want to mention is feature importance. While looking at the trees, a nice way to inspect the tree if it's small, if your trees very big, it's very hard to understand what's happening in the tree. So what you can get out is how important each feature is for the tree. This is similar to the coefficients in the linear model, where you can see that “this feature influences the model in this way”. And the way this is done is basically each time a particular feature was chosen in a tree, you accumulate how much it decreased the impurity. It'll give more importance to features that were used often and where to use of it, than decreased impurity. Problem with the importance is you have the same issues with instability. Because the tree structures unstable, the features picked is unstable and so the importance will be unstable. Similar to L1 norm, if you have too many correlated features, it might pick one or the other. If you have very correlated features, basically, the feature importance could be anything. Any linear combination of the two is completely equivalent. So keep that in mind when looking at feature importance. But they’re a very nice way to summarize what the tree does if you're in reasonably low dimensions and your tree is big. Obviously, if you're in super high dimensions, you might not be able to look at them, you might be able to look at the most important features. The question was if use a feature multiple times, do I add up the degrees in purities and the answer is yes. Question is can I explain the difference between extrapolating and generalizing. In generalizing, usually you make this IID assumption that you draw data from the same distribution, and you have some samples from the distribution from which you learn, and other samples from a distribution which you want to predict. And if you're able to predict well, then it is generalizing. Here in the extrapolation example, the distribution that I want to try to predict on was actually different from the distribution I learned on because they’re completely disjoint. The years I trained on and the years that I'm testing on are completely disjoint and the target range is also completely disjoint. So this is not an IID task. In particular, even if it was IID, extrapolation sort of means looking at things outside the training set. One more comment about feature importance is that they give you the importance of a feature, but not the direction. If you look at the linear model and you say that a coefficient is large, or a coefficient is very small, this means for regression, if it's larger than it has a positive influence on target, or if it's classification, this feature has a positive influence to being a member of this class. For trees, you don't have the directionality, here you only get this is important only to make a decision. And the relationship with the class might not be monotonous. So you only have a magnitude you don't have a direction in the importance. - Unstable Tree $\rightarrow$ Unstable feature importances. - Might take one or multiple from a group of correlated features. --- # Categorical Data - Can split on categorical data directly - Intuitive way to split: split in two subsets - 2 ^ n_values many possibilities - Possible to do in O(n_values . log(n_values)) exactly for gini index and binary classification. - Heuristics done in practice for multi-class. - Not in sklearn yet ??? You can use categorical data in trees, and you can do this in R up to a couple of hundred different values. In scikit-learns, unfortunately, it’s not there yet. The cool thing about it working with categorical data is that it allows you to split into any subsets of the categories. So if you have, let's say have one categorical variable with five levels, or five different values, you could split it in a tree in all possible ways. So in three, two, four, one and with all of the possible combinations. Usually, if you would want to do that you will need to try out two to the power number of values many possibilities for the splits, two to the power five in this example. That might not be feasible. But actually, for some criteria, for example, for Gini index you can do this efficiently in linear time. So in scikit-learn right now, you have to use one hot encoding, which is not powerful because one hot encoding can only split one feature at a time. So you would need to grow a much deeper tree to split categorical variable in all possible ways. There's also I think in R there's a bunch of tree implementations that work with missing values and there are several different strategies to deal with missing values. But it's also not entirely clear which strategy to deal with a missing value in trees is the best. So one strategy is, if you have a missing value, you can basically go down both sides at once, if the question is about the value that's missing, just go down both things. But that's kind of slow. The other thing that it's actually just another value you can split on and you can say, “if I split on a missing value, I have a separate branch just for missing values.” But you can easily emulate this by replacing it with a binary feature which says missing or not missing. --- class:spacious # Predicting probabilities - Fraction of class in leaf. - Without pruning: Always 100% certain! - Even with pruning might be too certain. ??? You can also predict probabilities with trees. Although, I would recommend against it. The issue with trees is that they are very good at overfitting, they can fit anything if I grow them deep enough. If I grow them to the full depth, they will always be 100% certain. Because the probability is the fraction of the number of points in the leaves that belong to this class. So if I have a leaf with like 10 data points, and 7 of them belong to class A, then it will say, with 70% probability a point here is class A. But if you split until everything's pure, it will always be 100% certain, which is pretty meaningless. So you can do some pruning, and you can restrict the rows of the tree, but it still might be certain, and so the probability estimates that come out of a tree might not be very good. FIXME PLOT --- class:spacious # Conditional Inference Trees - Select “best” split with correcting for multiple-hypothesis testing. - More “fair” to categorical variables. - Only in R so far (party) ??? --- # Different splitting methods .center[![:scale 80%](images/splits_kinect.png)] .smaller[(taken from Shotton et. al. Real-Time Human Pose Recognition ..)] ??? Another reason why trees are very popular is since they're very flexible. This is actually from a paper about the Kinect version one.  They used decision trees in a quite clever way to find where different parts of the body are. Here you have a depth image of a person. The questions that are asked are not looking at single pixels but if you want to decide for a particular pixel, you can ask questions about pixels that are somewhere else. So you can ask, how deep is the pixel five above me? How deep is the pixel five below me? And so on. And it can also do comparisons in saying, what's the difference between the value here and there? And so basically, you can come up with more complex ways to ask questions. And this leads to more powerful tree models. That's quite common in computer vision to ask either about comparing pixels or comparing regions of pixels or something like that.  I also know models where each node is like….linear model, for example, and the test is what the response of the linear model is? Shortcomings of the trees are they very unstable, they can’t extrapolate and they tend to overfit a lot. - Could use anything as split candidate! - Linear models used if extrapolation is needed. - Computer vision: pixel comparisons - Kinect (first generation): depth comparison --- class: centre,middle # Ensemble Models ??? One way to get rid of these problems is to actually use multiple trees and Ensemble. Ensemble is a general term that captures any way you combine multiple models into one. There's like a lot of different kinds of ensemble models that work in many different ways. We're going to talk particularly about random forest. But that's only one association of this more general framework. --- # Poor man’s ensembles - Build different models - Average the result - Owen Zhang (long time kaggle 1st): build XGBoosting models with different random seeds. - More models are better – if they are not correlated. - Also works with neural networks - You can average any models as long as they provide calibrated (“good”) probabilities. - Scikit-learn: VotingClassifier hard and soft voting ??? If you do computation, we'll see poor man’s ensembles which is just build the same model multiple times with different random seeds and average them. Owen Zhang who used to be in the first place in kaggle for five years, he just builds XGBoost models, which are off the tree based models with different random seeds, and then he just averaged all of them. And if you averaged multiple good models, it will get better. This is ideal for competitions. These are not usually done in practice because it makes the model hard to understand, it takes more RAM, it takes more time to predict because you have to do it like number of models many times. In scikit-learn, there’s this voting classifier which just takes the list of models of different types or be the same model type with different visualizations. And it will train all of them and average the results. You can either do soft voting or hard voting. Soft voting means averaging the probabilities and take the arg max.  --- # VotingClassifier .smaller[ ```python voting = VotingClassifier( [('logreg', LogisticRegression(C=100)), ('tree', DecisionTreeClassifier(max_depth=3, random_state=0))], voting='soft') voting.fit(X_train, y_train) lr, tree = voting.estimators_ tree.score(X_test, y_test), lr.score(X_test, y_test), voting.score(X_test, y_test) ``` ``` 0.80 0.84 0.88 ``` ] .center[![:scale 80%](images/voting_classifier.png)] ??? It looks like this. Here is the logistic regression model on this 2D data set. This is the decision tree based model and the voting classifier weights - probability estimates by most of them. And if you want, you can do that. Again, mostly done in competitions. The easiest way to do ensembles is to just average models. Problem is, if they overfit in the same way, you're not going to get rid of the overfitting. So what you really want to do is you want to make sure you have models that are quite different from each other and you averaged the models that are different. --- class: spacious # Bagging (Bootstrap AGGregation) .left-column[ - Generic way to build “slightly different” models - BaggingClassifier, BaggingRegressor ] .right-column[ .center[![:scale 100%](images/bootstrap_sample.png)] ] ??? One way to do this is called Bagging or Bootstrap Aggregation. And the idea in bagging is, imagine that these are your data points, you have five data points and so you want to make sure that you built similar but slightly different models. And you want to do more than just change the random seed. One way is to take bootstrap samples of your dataset. Bootstrap samples mean sampling with replacement, number of samples many points. So here in this example, from these five data points, I would sample a new dataset that again has five data points (sample with replacement). On average this will mean that each dataset will have about 66% of the original data points, and the other data points will be just duplicates. So you leave out some data, duplicate some other data, and you end up with a slightly different dataset. You can do this obviously, as often as you want. If you average these models, if the model was prone to overfitting, then the average might not overfit as much. - Draw bootstrap samples from dataset - (as many as there are in the dataset, with repetition) --- class: spacious # Bias and Variance .center[![:scale 40%](images/bias_vs_variance.png)] .left[ .smaller[http://scott.fortmann-roe.com/docs/BiasVariance.html] ] ??? What you often hear in this context is talking about bias and variance, which is not entirely the same thing as underfitting and overfitting but quite related to it. The idea is that the errors you make on the test set are basically combinations of the error you make in modeling plus the uncertainty in the modeling. The idea is that you can have models that are very consistent, but off. So that would be a high bias low variance model. So this would be, for example, a low dimensional linear model that is mixed inconsistent predictions, but it might not be able to capture the target very well since it's not powerful enough. You want ideally a model that has low bias and low variance. So that's sort of captures the data concept very well and also has very little variance in the predictions it makes. A high variance model is one that on average captures the predictions but has very high variance in the prediction it makes. The idea of bagging is that you can take multiple high variance models and if you average them, then it will reduce the variance of the average. If the predictions are not very correlated, then there's like a very nice, easy proof to say that if I average multiple high variance estimators, I get a low variance estimator. They need to be sort of good enough, on average, if they're all really, really bad, and if you average then it will still be pretty bad. --- class: spacious # Bias and Variance in Ensembles - Breiman showed that generalization depends on strength of the individual classifiers and (inversely) on their correlation - Uncorrelating them might help, even at the expense of strength ??? There’s this proof that shows that if you have decorrelated errors, then averaging will help. Basically, the correlation between the errors that you make shows up there. And so the idea is to make the errors as different as possible. Maybe even go further than the bagging in trying to make sure the different models that you build are as different from each other as possible, while still being reasonably good models. This leads to the idea of random forests, which basically tries to randomize trees, even more than you would do with bagging, and then average results of these trees. FIXME worst slide! --- class: spacious # Random Forests .center[![:scale 90%](images/random_forest.png)] ??? Here example of a random forest on a 2-dimensional dataset. - Smarter bagging for trees! --- # Randomize in two ways .left-column[ - For each tree: - Pick bootstrap sample of data - For each split: - Pick random sample of features - More trees are always better ] .right-column[ ![:scale 100%](images/bootstrap_sample.png) ![:scale 100%](images/feature_sample.png) ] ??? The way that random forest work is they randomize tree building in two ways. As with bagging if you do a bootstrap sample of the dataset, so each tree you take a bootstrap sample of the data set and then for each split in the tree, you take a sampling without replacement of the features. So let's say you have this representation of the dataset again. And for each node where you want to make a splitting decision before you want to scan all over the features and all the thresholds, you select just the subset of the number of features and just look for splits there. And this is done for each node independently. In the end, the tree will use all the features probably, if it's deep enough, eventually it might use all the features but you randomize the tree building process in a way that hopefully de-correlated the error of the different trees. And so this adds another hyperparameter in the tree building. --- class:some-space # Tuning Random Forests - Main parameter: max_features - around sqrt(n_features) for classification - Around n_features for regression - n_estimators > 100 - Prepruning might help, definitely helps with model size! - max_depth, max_leaf_nodes, min_samples_split again ??? Which are max features, which is the number of features that you want to look at each split. So the heuristic is usually for classification you want something like the square root of the number of features, whereas, for regression, you usually want something that is around the same size as the number of features. This basically, controls the variance of the model because if you set this to number of features, it will be just sort of the old decision tree. If you set this to one, it will pick a feature at random, and then it needs to split on that feature, basically. So this will be like a very, very random tree that probably would grow very deep because it can really make good decisions. This is the main parameter that you need to tune, although random forest is actually very robust to these parameter settings. Usually, if you leave this to the default, it will be reasonably well. By default, in scikit-learn, the number of trees in the forest is way too low. Usually, you want something like 100, or 500 but scikit-learn only gives you like 10. Sometimes people find that pre-pruning techniques like maximum depth or maximum leaf nodes help. Generally, the idea doesn't really matter that much, how good the vigil trees are as long as you have enough of them. But limiting the size of the tree will definitely help with model size. That said, if you randomize a lot, these trees will grow very deep. Because if you're unlucky, you'll always just split on bad feature so you will always not really get much further in getting pure leaves and so you need to do a lot of splits. So setting something like max depth will allow you to decrease RAM size and decrease prediction time. --- class:spacious # Extremely Randomized Trees - More randomness! - Randomly draw threshold for each feature! - Doesn’t use bootstrap - Faster because no sorting / searching - Can have smoother boundaries ??? Alright, so there's a slightly different variant of random forest that's also kind of interesting, which is Extremely Randomized Trees. They work very similarly except for the fact that you draw randomly a threshold for each feature. So here, you don't search over the thresholds, you just pick one at random. And usually, you don't use bootstrap. Since you don’t need to do sorting these are faster to build. You probably get smoother decision boundaries since the thresholds are drawn at random. Sometimes they aren’t as bad as random forest but they're definitely not commonly used as the default random forest. One of the nice things about extremely randomized trees and the random forests is they work without any preprocessing. If you set number of estimators large enough, they will just work. They will not be the best model but they will always work. --- # Warm-Starts .smaller[ ```python train_scores = [] test_scores = [] rf = RandomForestClassifier(warm_start=True) estimator_range = range(1, 100, 5) for n_estimators in estimator_range: rf.n_estimators = n_estimators rf.fit(X_train, y_train) train_scores.append(rf.score(X_train, y_train)) test_scores.append(rf.score(X_test, y_test)) ``` ] .center[ ![:scale 39%](images/warm_start_forest.png) ] ??? The more trees you use, the better it is since you decrease the variance more. Don't ever grid search the number of trees, because the higher will be better and you're just wasting your time. But there are diminishing returns. So maybe 100 trees are good enough and if you built 500 trees, again, you're wasting your time and you might not want to do that. In scikit-learn, when you use Warm-Starts, you basically iteratively add more and more trees to the forest and you can stop whenever you think it's good enough. Basically, the fit method will keep all the previous trees and add on more trees. I go from 1 feature to 100 features in steps of five. I set the number estimator. So I started with one tree and then increased by five every time. I fit the model. And then I look at training and test score. This is much better than grid searching it because in grid search I would do the same work over and over again, while here, I'm adding more and more trees and find out what is it good enough. Usually, I would double the search like 50, 100, and 200 and so on and find where it stabilizes, and then only I will stop adding more trees. If you don't want to do that, just picking large enough number and stick to that number. Then you don't need to fiddle around as much but you might be wasting computational resources that could be used otherwise for like parameter tuning, for example. --- # Out-of-bag estimates - Each tree only uses ~66% of data - Can evaluate it on the rest! - Make predictions for out-of-bag, average, score. - Each prediction is an average over different subset of trees .smaller[ ```python train_scores = [] test_scores = [] oob_scores = [] feature_range = range(1, 64, 5) for max_features in feature_range: rf = RandomForestClassifier(max_features=max_features, oob_score=True, n_estimators=200, random_state=0) rf.fit(X_train, y_train) train_scores.append(rf.score(X_train, y_train)) test_scores.append(rf.score(X_test, y_test)) oob_scores.append(rf.oob_score_) ``` ] ??? Another thing is looking at out of back estimates. This is something that's specific to random forest. That said, if you do bootstrap sampling, usually you get like 66% of your data for each estimator. That means there's about 33% of your data that you haven't used for each individual tree. So you can use that data as a test set for that particular tree. The out of back estimate in a random forest is for each tree, I individually predict on the 33% on which I haven't trained. And then for each data point, I look at all the trees that held out this particular data point and let them vote. So then for each data point, I only have a subset of the trees that makes a prediction but if I have enough trees overall, it'll still be fine. Let's say, I used 300 estimators, then basically, on average, for each data point, I will have 100 estimators that didn't use those data points. And so it can use this data point as a test set for this 100 estimators and can let them vote on what the prediction should be. And this way, basically, I get a test set score for free. In fact, it's like a bootstrap estimate of a test set score. And so basically, I don't need to use a test set, I can just use the out of bag estimate. So here, for example, using this to find the best number of features. I look for max number of features in a particular range in a random forest classifier. In this case, for illustration purposes, I use both the out of bag estimate and the test set scores to see how they compare. --- .center[ ![:scale 90%](images/oob_estimates.png) ] ??? You can see that since I didn’t prune the trees in any way, the training scores is always one because it's always perfect and you perfectly overfit everything. The test sets scores and the out of bag scores are at least somewhat similar in trend and also in magnitude because the out of bag estimate uses only one-third of the trees, it might be slightly worse. But basically, I got this for free without spending any additional data or any additional computation. And so both of these probably have a habit of uncertainty. I have no uncertainty estimate but theoretically, this is sort of an unbiased estimate of the test set accuracy. --- # Variable Importance .smaller[ ```python X_train, X_test, y_train, y_test = train_test_split( iris.data, iris.target, stratify=iris.target, random_state=1) rf = RandomForestClassifier().fit(X_train, y_train) rf.feature_importances_ plt.barh(range(4), rf.feature_importances_) plt.yticks(range(4), iris.feature_names); ``` ```array([ 0.126, 0.033, 0.445, 0.396])``` ] .center[ ![:scale 40%](images/forest_importances.png) ] ??? As for the trees, for the random forest, I can get variable importance. And these are more useful now because they're more robust. Again, they don't have directionality. But now, if you have two correlated features, probably if you build enough trees, and because of the way they’re randomized, both of these features will be picked some of the time. And so if you average over all of the trees, then both will have the same amount of importance. So this will basically just give you like a smoother estimate of the feature importance that will be more robust and will not fail on correlated features. --- class: center, middle # Questions ? ??? Question: Is there a statistical test where the variable is important? It's probably the wrong question to ask. Because these are like greedily trained and so trying to extract any statistical meaning out of that is probably not the best idea. So if you're trying to understand your dataset or your data generating process, I probably wouldn't use tree-based models. These are really good for predicting no matter what your input is. Question: How is the feature importance calculated? Whenever a particular feature was used in the tree, you look at the decrease in impurity, and you aggregate these and at the end, you normalize it sum to one.


Gamestack.js: The javascript library for 2D games
Download Gamestack.js
*Find Gamestack.js and Gamestack.min.js at
https://github.com/gamestack/gamestack-js/tree/master/client/dist/js
Examples


To provide native Chrome Web Animation features (Element.animate
and Playback
Control) in other browsers, use web-animations.min.js
. To explore all of the
proposed Web Animations API, use web-animations-next.min.js
.
Web Animations is a new JavaScript API for driving animated content on the web. By unifying the animation features of SVG and CSS, Web Animations unlocks features previously only usable declaratively, and exposes powerful, high-performance animation capabilities to developers.
For more details see the W3C specification.
The polyfill is a JavaScript implementation of the Web Animations API. It works on modern versions of all major browsers. For more details about browser support see https://www.polymer-project.org/resources/compatibility.html.
Here’s a simple example of an animation that scales and changes the opacity of
a <div>
over 0.5 seconds. The animation alternates producing a pulsing
effect.
Web Animations supports off-main-thread animations, and also allows procedural generation of animations and fine-grained control of animation playback. See http://web-animations.github.io for ideas and inspiration!
When the polyfill runs on a browser that implements Element.animate
and
Animation
Playback Control it will detect and use the underlying native
features.
Tracks the Web Animations features that are supported natively in browsers. Today that means Element.animate and Playback Control in Chrome. If you’re not sure what features you will need, start with this.
Contains all of web-animations.min.js plus features that are still undergoing discussion or have yet to be implemented natively.
A cut down version of web-animations-next, it removes several lesser used property handlers and some of the larger and less used features such as matrix interpolation/decomposition.
| web-animations | web-animations-next | web-animations-next-lite | |
|---|---|---|---|
| Size (gzipped) | 12.5kb | 14kb | 10.5kb |
| Element.animate | ✔ | ✔ | ✔ |
| Timing input (easings, duration, fillMode, etc.) for animation effects | ✔ | ✔ | ✔ |
| Playback control | ✔ | ✔ | ✔ |
| Support for animating lengths, transforms and opacity | ✔ | ✔ | ✔ |
| Support for animating other CSS properties | ✔ | ✔ | 🚫 |
| Matrix fallback for transform animations | ✔ | ✔ | 🚫 |
| KeyframeEffect constructor | 🚫 | ✔ | ✔ |
| Simple GroupEffects & SequenceEffects | 🚫 | ✔ | ✔ |
| Custom Effects | 🚫 | ✔ | ✔ |
| Timing input (easings, duration, fillMode, etc.) for groups | 🚫 | 🚫* | 🚫 |
| Additive animation | 🚫* | 🚫* | 🚫 |
| Motion path | 🚫* | 🚫* | 🚫 |
| Modifiable keyframe effect timing | 🚫 | 🚫* | 🚫* |
| Modifiable group timing | 🚫 | 🚫* | 🚫* |
| Usable inline style** | ✔ | ✔ | 🚫 |
* support is planned for these features. ** see inline style caveat below.
Some things won’t ever be faithful to the native implementation due to browser and CSS API limitations. These include:
Inline style modification is the mechanism used by the polyfill to animate properties. Both web-animations and web-animations-next incorporate a module that emulates a vanilla inline style object, so that style modification from JavaScript can still work in the presence of animations. However, to keep the size of web-animations-next-lite as small as possible, the style emulation module is not included. When using this version of the polyfill, JavaScript inline style modification will be overwritten by animations. Due to browser constraints inline style modification is not supported on iOS 7 or Safari 6 (or earlier versions).
The polyfill will automatically detect the correctly prefixed name to use when writing animated properties back to the platform. Where possible, the polyfill will only accept unprefixed versions of experimental features. For example:
var effect = new KeyframeEffect(elem, {“transform”: “translate(100px, 100px)”}, 2000);
will work in all browsers that implement a conforming version of transform, but
var effect = new KeyframeEffect(elem, {“-webkit-transform”: “translate(100px, 100px)”}, 2000);
will not work anywhere.
File an issue on GitHub: https://github.com/w3c/web-animations/issues/new. Alternatively, send an email to<EMAIL_ADDRESS>with subject line “[web-animations] … message topic …” (archives).
Report any issues with this implementation on GitHub: https://github.com/web-animations/web-animations-next/issues/new.
When we make a potentially breaking change to the polyfill’s API surface (like a rename) we will, where possible, continue supporting the old version, deprecated, for three months, and ensure that there are console warnings to indicate that a change is pending. After three months, the old version of the API surface (e.g. the old version of a function name) will be removed. If you see deprecation warnings you can’t avoid it by not updating.
We also announce anything that isn’t a bug fix on web-animations-changes@googlegroups.com.


Question 1
|
|
Question 2
Click here to view a randomized president picker!Question 3/4
Question 5
Question 6
Click here to view State/Capital table style togglesQuestion 8 (Development was done in Eclipse)
Click here to see screenshot of CheckValidator.java


--- active_crumb: Metrics & Tracing layout: documentation id: metrics ---
Both REST server and data probe come with OpenCensus instrumentation. NLPCraft bundles several built-in exporters for various OpenCensus trace and stats backends:
| Backend | Built-In Exporters | Stats or Trace? |
|---|---|---|
|
Jaeger
|
Server: NCJaegerExporter Probe: NCJaegerExporter |
Trace |
|
Zipkin
|
Server: NCZipkinExporter Probe: NCZipkinExporter |
Trace |
|
Prometheus
|
Server: NCPrometheusExporter Probe: NCPrometheusExporter |
Stats |
|
Grafana*
|
Server: NCPrometheusExporter Probe: NCPrometheusExporter |
Stats |
|
Stackdriver
|
Server: NCStackdriverStatsExporter Probe: NCStackdriverStatsExporter |
Stats |
|
Stackdriver
|
Server: NCStackdriverTraceExporter Probe: NCStackdriverTraceExporter |
Trace |
NOTE: (*) Grafana works through Prometheus integration.
All built-in exporters are a simple adaptation of the standard OpenCensus exporters to life cycle components for the REST server or the data probe. Each exporter has a few lines of code and you can create your own exporters for other backends.
OpenCensus exporters for the REST server are lifecycle components. Server lifecycle components are the implementations
of NCServerLifecycle
trait. Lifecycle components get callbacks for various stages of the server
lifecycle and thus can register and unregister "primordial" components such as OpenCensus exporters.
REST server lifecycle components are specified in nlpcraft.server.lifecycle
configuration property. For example, for file based configuration:
nlpcraft { server { ... lifecycle = [ "org.apache.nlpcraft.server.lifecycle.opencensus.NCPrometheusExporter", "org.apache.nlpcraft.server.lifecycle.opencensus.NCJaegerExporter" ] ... } }
Note that each server exporter has default configuration that can be overridden via configuration properties or environment variables. Note also that all built-in trace exporters use "always" sampling by default that is suitable only for demo or development purposes. For production usage you will need to modify the exporter to provide more effective sampling strategy.
Just like on the REST server OpenCensus exporters for the data probe are lifecycle components. Probe lifecycle components are the implementations of org.apache.nlpcraft.model.NCLifecycle interface. Lifecycle components get callbacks for various stages of the data probe lifecycle and thus can register and unregister "primordial" components such as OpenCensus exporters. For example, using file based configuration:
nlpcraft { probe { ... lifecycle = [ "org.apache.nlpcraft.model.opencensus.NCPrometheusExporter", "org.apache.nlpcraft.model.opencensus.NCJaegerExporter" ] ... } }
Just like with server exporters, each probe exporter has default configuration that can be overridden via configuration properties or environment variables. Note also that all built-in trace exporters use "always" sampling by default that is suitable only for demo or development purposes. For production usage you will need to modify the exporter to provide more effective sampling strategy. Please consult individual exporter classes:
When traces are exporter, there are two service names used for NLPCraft traces that will appear on UI backends:
nlpcraft-server
for traces from REST server.nlpcraft-probe
for traces from data probes.
All traces are extensively tagged with various information. Specifically, watch out for srvReqId
,
modelId
and userId
tags that will help you navigate across traces pertaining to specific
request, models or users.
When it comes to metrics each exporter has different set of configuration for either a namespace or name prefix on how these metrics will be available on the UI backends:
nlpcraft-server
and nlpcraft-probe
namespaces.
custom.googleapis.com/nlpcraft/server
and custom.googleapis.com/nlpcraft/probe
metric
name prefixes.
NOTE: default namespaces and service prefixes can be changed via configuration properties or environment variables
The following metrics are generated by the REST server:
| Name without prefix or namespace | Description |
|---|---|
{{api.name}}_latdist_bucket {{api.name}}_latdist_count {{api.name}}_latdist_sum
|
Histogram, count and sum of values for the {{api.description}} latencies. |
roundtrip_latdist_bucket roundtrip_latdist_count roundtrip_latdist_sum
|
Histogram, count and sum of values for the full server-probe-server round trip latencies. |
The following metrics are generated by the data probe:
| Name without prefix or namespace | Description |
|---|---|
{{api.name}}_latdist_bucket {{api.name}}_latdist_count {{api.name}}_latdist_sum
|
Histogram, count and sum of values for the {{api.description}} latencies. |


Functions to simplify the analysis and prediction of Antimicrobial Resistance (AMR) to work with microbial and antimicrobial properties by using evidence-based methods.
| Version: | 0.5.0 |
| Depends: | R (≥ 3.1.0) |
| Imports: | backports, curl, crayon (≥ 1.3.0), data.table (≥ 1.9.0), dplyr (≥ 0.7.0), hms, knitr (≥ 1.0.0), rlang (≥ 0.2.0), rvest (≥ 0.3.2), tidyr (≥ 0.7.0), xml2 (≥ 1.0.0) |
| Suggests: | covr (≥ 3.0.1), ggplot2, rmarkdown, rstudioapi, testthat (≥ 1.0.2) |
| Published: | 2018-11-30 |
| Author: | Matthijs S. Berends [aut, cre], Christian F. Luz [aut, rev], Erwin E.A. Hassing [ctb], Corinna Glasner [ths], Alex W. Friedrich [ths], Bhanu Sinha [ths] |
| Maintainer: | Matthijs S. Berends <m.s.berends at umcg.nl> |
| BugReports: | https://gitlab.com/msberends/AMR/issues |
| License: | GPL-2 | file LICENSE |
| URL: | https://gitlab.com/msberends/AMR |
| NeedsCompilation: | no |
| Materials: | README NEWS |
| CRAN checks: | AMR results |
| Reference manual: | AMR.pdf |
| Vignettes: |
Introduction to the AMR package Creating Frequency Tables |
| Package source: | AMR_0.5.0.tar.gz |
| Windows binaries: | r-devel: AMR_0.5.0.zip, r-release: AMR_0.5.0.zip, r-oldrel: AMR_0.5.0.zip |
| OS X binaries: | r-release: AMR_0.5.0.tgz, r-oldrel: AMR_0.5.0.tgz |
| Old sources: | AMR archive |
Please use the canonical form https://CRAN.R-project.org/package=AMR to link to this page.


Lead by Example
As a leader in your organization, you understand the importance of staying ahead of the curve.
That’s why we spend our days devoting exceptional care and research into crafting events that keep you up to date with your industry’s latest trends and wins.
Explore Our EventsForge Lasting Partnerships
WBR conferences are built around the belief that connecting with other leading minds is the best way to grow your career and your business.
Attendees come to us for content first. They come back because of the long-lasting connections they make each year.
Learn About the ExperienceGrow Your Business
Have a great product or service? Join our events and get in front of the decision makers who evaluate solutions for their business.
Our custom tailored marketing opportunities allow you to position your product in a way consistent with your brand.
View Sponsorship Options


Coraline Premiere notes, in which we watch the film, hit after-party, and meet the amazingly friendly @neilhimself http://tinyurl.com/ctplh4
2/17/2009, 11:47:35 PM
Favs: 0
Retweets: 0
link--- layout: tweet ---
Coraline Premiere notes, in which we watch the film, hit after-party, and meet the amazingly friendly @neilhimself http://tinyurl.com/ctplh4
2/17/2009, 11:47:35 PM
Favs: 0
Retweets: 0
link


Specific part of device memory is the constant memory, which allows to store limited amount (64KB) of constant symbols. Similarly to the texture memory, the accesses are cached but only reading is allowed. Constant memory should be used for small variables that are shared among all threads and do no require interpolation. It is declared by the host using the keyword __constant__, and its size is to be known at compile time. There are two main reason why reading from constant memory can save bandwidth:
A single read can be broadcasted to all thread of the same warp .
Constant memory is cached, so consecutive reads of the same address will not incur any additional traffic on off-chip DRAM.


Next: adjoin, Previous: remf, Up: Conses Dictionary
intersection
list-1 list-2 &key key test test-not ⇒ result-list
nintersection
list-1 list-2 &key key test test-not ⇒ result-list
list-1—a proper list.
list-2—a proper list.
test—a designator for a function of two arguments that returns a generalized boolean.
test-not—a designator for a function of two arguments that returns a generalized boolean.
key—a designator for a function of one argument, or nil.
result-list—a list.
intersection and nintersection return a list that contains every element that occurs in both list-1 and list-2.
nintersection is the destructive version of intersection. It performs the same operation, but may destroy list-1 using its cells to construct the result.
list-2 is not destroyed.
The intersection operation is described as follows. For all possible ordered pairs consisting of one element from list-1 and one element from list-2, :test or :test-not are used to determine whether they satisfy the test. The first argument to the :test or :test-not function is an element of list-1; the second argument is an element of list-2. If :test or :test-not is not supplied, eql is used. It is an error if :test and :test-not are supplied in the same function call.
If :key is supplied (and not nil), it is used to extract the part to be tested from the list element. The argument to the :key function is an element of either list-1 or list-2; the :key function typically returns part of the supplied element. If :key is not supplied or nil, the list-1 and list-2 elements are used.
For every pair that satifies the test, exactly one of the two elements of the pair will be put in the result. No element from either list appears in the result that does not satisfy the test for an element from the other list. If one of the lists contains duplicate elements, there may be duplication in the result.
There is no guarantee that the order of elements in the result will reflect the ordering of the arguments in any particular way. The result list may share cells with, or be eq to, either list-1 or list-2 if appropriate.
(setq list1 (list 1 1 2 3 4 a b c "A" "B" "C" "d") list2 (list 1 4 5 b c d "a" "B" "c" "D")) ⇒ (1 4 5 B C D "a" "B" "c" "D") (intersection list1 list2) ⇒ (C B 4 1 1) (intersection list1 list2 :test 'equal) ⇒ ("B" C B 4 1 1) (intersection list1 list2 :test #'equalp) ⇒ ("d" "C" "B" "A" C B 4 1 1) (nintersection list1 list2) ⇒ (1 1 4 B C) list1 ⇒ implementation-dependent ;e.g., (1 1 4 B C) list2 ⇒ implementation-dependent ;e.g., (1 4 5 B C D "a" "B" "c" "D") (setq list1 (copy-list '((1 . 2) (2 . 3) (3 . 4) (4 . 5)))) ⇒ ((1 . 2) (2 . 3) (3 . 4) (4 . 5)) (setq list2 (copy-list '((1 . 3) (2 . 4) (3 . 6) (4 . 8)))) ⇒ ((1 . 3) (2 . 4) (3 . 6) (4 . 8)) (nintersection list1 list2 :key #'cdr) ⇒ ((2 . 3) (3 . 4)) list1 ⇒ implementation-dependent ;e.g., ((1 . 2) (2 . 3) (3 . 4)) list2 ⇒ implementation-dependent ;e.g., ((1 . 3) (2 . 4) (3 . 6) (4 . 8))
nintersection can modify list-1,
but not list-2.
Should be prepared to signal an error of type type-error if list-1 and list-2 are not proper lists.
Traversal Rules and Side Effects
The :test-not parameter is deprecated.
Since the nintersection side effect is not required, it should not be used in for-effect-only positions in portable code.
Next: adjoin, Previous: remf, Up: Conses Dictionary


Rendering punctuated list items
List items are seperated by ',' and '&' characters using CSS psuedo classes & element.
I Love
9gag
Quora
Batman
Food


A group of desmosomal cadherins with cytoplasmic tails that resemble those of classical CADHERINS. (mesh:D051182)
| Synonym | Reference | Specificity |
| desmogleins | Exact | |
| desmoglein | Exact |
| Identifier | Name | Relation |
| HGNC:3049 | DSG2 | isa |
| HGNC:21307 | DSG4 | isa |
| HGNC:3050 | DSG3 | isa |
| HGNC:3048 | DSG1 | isa |


This page describes the CoreData serial connection protocol. To receive CoreData data through a serial connection on an unsupported platform, or by developing your own C code, you will need to understand the protocol used for serial transmission.
The sequence of bytes receives from the serial connection, can be resolved into a sequence of frames, by listening for a pair of frame separator flag byte sequence. The separator flag consists of a 2-byte sequence 0xAA 0x55 (hexadecimal byte values). All frames begin and end with this 2-byte sequence.
To avoid errors when the packet data contains the frame flag byte sequence, every 0xAA in the data has a 0x00 inserted after it (including the checksums). These “stuffed” bytes must be detected during frame reception and removed.
To ensure reliable transmission in a noisy environment, a CRC-16 checksum is calculated from the data (before stuffing occurs), and is then appended to the data. To check for errors when receiving a packet, first “unstuff” the data sequence, and then compute the CRC-16 checksum over the entire data sequence, including the CRC bytes. If the computed checksum is 0, then no errors have occurred. You can then discard the last 2 bytes of the sequence (the checksum). Refer to the methods SerialPort::makeCRC() and SerialPort::checkCRC()


{% extends theme('sections/section.html') %} {% macro carousel(imgs, captions) -%}
{%- endmacro %} {% block content %} {% set carousel_images = ['wizard_screenshot2', 'wizard_screenshot3', 'wizard_screenshot4', 'wizard_screenshot1', 'wizard_screenshot5'] %} {% set captions = ['Word like editing with CKEDITOR', 'Manage pages, sections and members easily', 'Automatically generated reference lists', 'Upload Wiki to iGEM servers', 'Select between different themes'] %} {{ carousel( carousel_images, captions) }} {{ super() }} {% endblock %}


The calendar module offers readonly and interactive calendar capabilities.
Both types of calendar are structured as data tables; each column representing a day of the week.
A readonly calendar has cells containing static text or hypertext.
The current date is conveyed using calendar__cell--current and clipped text.
NOTE: for the eagle-eyed BEM afionados, we are saying each span has an implicit class of calendar__cell.
Inactive/unavailable dates are conveyed using calendar__cell--disabled and offscreen text.
Date ranges are conveyed using calendar__cell--selected, calendar__range, calendar__range--start, calendar__range-end and clipped text.
| Su | Mo | Tu | We | Th | Fr | Sa |
|---|---|---|---|---|---|---|
| 1 - inactive | 2 - inactive | 3 - inactive | 4 - inactive | 5 - inactive | ||
| 6 - inactive | 7 - inactive | 8 - inactive | 9 - inactive | 10 - inactive | 11 - inactive | 12 - inactive |
| 13 - inactive | 14 - today | 15 | 16 | 17 - start of range | 18 - in range | 19 - in range |
| 20 - in range | 21 - in range | 22 - in range | 23 - in range | 24 - in range | 25 - end of range | 26 |
| 27 | 28 | 29 | 30 | 31 |
| Su | Mo | Tu | We | Th | Fr | Sa |
|---|---|---|---|---|---|---|
| 1 - inactive | 2 - inactive | 3 - inactive | 4 - inactive | 5 - inactive | ||
| 6 - inactive | 7 - inactive | 8 - inactive | 9 - inactive | 10 - inactive | 11 - inactive | 12 - inactive |
| 13 - inactive | 14 - today | 15 | 16 | 17 - selected - start of range | 18 - in range | 19 - in range |
| 20 - in range | 21 - in range | 22 - in range | 23 - in range | 24 - in range | 25 - selected - end of range | 26 |
| 27 | 28 | 29 | 30 | 31 |
An interactive calendar uses toggle buttons to allow the input of single dates or date ranges.
NOTE: a fully functional and accessible interactive calendar requires JavaScript and is outside the scope of a CSS library such as eBay Skin. The examples below are NOT fully functional and serve to demonstrate the necessary HTML semantics and styling hooks only.
A single date selection is conveyed using aria-pressed.
NOTE: in comparison to the readonly calendar, with buttons we can now leverage the disabled property and aria-current instead of clipped text.
| Su | Mo | Tu | We | Th | Fr | Sa |
|---|---|---|---|---|---|---|
| Su | Mo | Tu | We | Th | Fr | Sa |
|---|---|---|---|---|---|---|
Date ranges are bookended by two buttons with the aria-pressed property. All buttons in between these dates leverage clipped text for assistive technology.
| Su | Mo | Tu | We | Th | Fr | Sa |
|---|---|---|---|---|---|---|
| Su | Mo | Tu | We | Th | Fr | Sa |
|---|---|---|---|---|---|---|
The calendar module allows an optional header section for pagination between months.
Multiple instances of calendar__month can be rendered inside of the calendar__body.
| Su | Mo | Tu | We | Th | Fr | Sa |
|---|---|---|---|---|---|---|
| 1 | ||||||
| 2 | 3 | 4 | 5 | 6 | 7 | 8 |
| 9 | 10 | 11 | 12 | 13 | 14 | 15 |
| 16 | 17 | 18 | 19 | 20 | 21 | 22 |
| 23 | 24 | 25 | 26 | 27 | 28 | 29 |
| 30 | 31 |
| Su | Mo | Tu | We | Th | Fr | Sa |
|---|---|---|---|---|---|---|
| 1 | 2 | 3 | 4 | 5 | ||
| 6 | 7 | 8 | 9 | 10 | 11 | 12 |
| 13 | 14 - today | 15 | 16 | 17 | 18 | 19 |
| 20 | 21 | 22 | 23 | 24 | 25 | 26 |
| 27 | 28 | 29 | 30 | 31 |
| Su | Mo | Tu | We | Th | Fr | Sa |
|---|---|---|---|---|---|---|
| 1 | 2 | |||||
| 3 | 4 | 5 | 6 | 7 | 8 | 9 |
| 10 | 11 | 12 | 13 | 14 | 15 | 16 |
| 17 | 18 | 19 | 20 | 21 | 22 | 23 |
| 24 | 25 | 26 | 27 | 28 | 29 | 30 |


This website consists of several games that I built. Each game is played against a computer which has played each game millions of times in order to learn the best strategies for play. I have not taught the computer what to look for - it only knows when it has won, lost, or tied. There are no heuristic methods or identifying traits, so the computer stores each configuration and the decisions it made in that configuration. For games that require too much data to store each configuration, all possible decisions, and the results of those decisions, I use bit folding to shrink the data. Different bit folds play against one another and the more successful ones are used here.


You should sign up for a team to get the benefits of working with others! Combine your score, collaborate, and go for the coolest prizes!
You can create or join teams here , but you cannot change teams once you are on one!
Team Name
Passcode
If you're creating a new team, others have to type this in when joining. If you're joining, get someone on the team to give you the code.
Affiliation
Only type this in if you're creating a team.


Moving Cost Calculator (Demo)
Calculate the cost for your move
Doc
- Installation
Simply import MovingCostCalculator into your HTML.
<link rel="stylesheet" type="text/css" href="https://unpkg.com/moving-cost-calculator/MovingVolumeCalculator.min.css">
<script src="https://unpkg.com/moving-cost-calculator/MovingCostCalculator.min.js"></script>
- How to use
Create a new MovingCostCalculator
object with a query String or an Element as the first parameter :
let movingCostCalculator = new MovingCostCalculator('div.with[any="selector"]', options);
// OR
let element = document.querySelector('li.terally[any="thing"]');
let movingCostCalculator = new MovingCostCalculator(element, options);
- Options
{
}
- Methods
See the documentation for the method definitions.
- Example
See this JSFiddle for a working example
Authors
- Zenoo - Initial work - Zenoo.fr


PETSc algebraic solvers now run on GPU systems from NVIDIA and AMD. This sometimes provides an alternative high-performance, low-cost solution technique.
We recommend working with petsc master (git branch) if you wish to work witht his feature.
If you use the PETSc GPU code in your published work, please cite the following paper:@article{minden2010preliminary, title={Preliminary implementation of PETSc using GPUs}, author={Minden, V. and Smith, B.F. and Knepley, M.G.}, journal={Proceedings of the 2010 International Workshop of GPU Solutions to Multiscale Problems in Science and Engineering}, year={2010} }WARNING: Using GPUs effectively is difficult! You must be dedicated and willing to get into the guts of GPU usage if you are serious about using GPUs.
- Installing PETSc to use NVIDIA GPUs (CUDA)
- Installing PETSc to use GPUs independent of the vendor (OpenCL)
- How the GPU solvers are implemented in PETSc
- Example that uses CUDA directly in the user function evaluation
- Presentation on some aspects of GPU usage from PETSc
-
Quick summary of usage with CUDA (provided by the CUSP library):
-
The VecType
VECSEQCUDA
,VECMPICUDA
, orVECCUDA
may be used withVecSetType()
or -vec_type seqcuda,mpicuda, or cuda whenVecSetFromOptions()
is used. -
The MatType
MATSEQAIJCUSPARSE
,MATMPIAIJCUSPARSE
, orMATAIJCUSPARSE
maybe used with MatSetType or -mat_type seqaijcusparse,mpiaijcusparse, or aijcusparse whenMatSetOptions()
is used. - If you are creating the vectors and matrices with a DM, you can use -dm_vec_type cuda and -dm_mat_type aijcuda
-
The VecType
-
Quick summary of usage with OpenCL (provided by the ViennaCL library):
-
The VecType
VECSEQVIENNACL
,VECMPIVIENNACL
, orVECVIENNACL
may be used withVecSetType()
or -vec_type seqviennacl,mpiviennacl, or viennacl whenVecSetFromOptions()
is used. -
The MatType
MATSEQAIJVIENNACL
,MATMPIAIJVIENNACL
, orMATAIJVIENNACL
maybe used with MatSetType or -mat_type seqaijviennacl,mpiaijviennacl, or aijviennacl whenMatSetOptions()
is used. - If you are creating the vectors and matrices with a DM, you can use -dm_vec_type viennacl and -dm_mat_type aijviennacl
-
The VecType
-
General hints:
- It is useful to develop your code with the default vectors and then run production runs with the command line options to use the GPU since debugging on GPUs is difficult.
-
All of the Krylov methods except
KSPIBCGS
run on the GPU. -
The only preconditioners to run directly on the GPU are
PCJACOBI
,PCSACUSP
,PCSACUSPPOLY
, andPCAINVCUSP
. ThePCBJACOBI
andPCASM
are just containers, so if the subsolver runs on the GPU, they can also be considered to run on the GPU.
-
Some GPU systems (for example many laptops) only run with single
precision; thus, PETSc must be built with the
./configure option --with-precision=single
- We could use your help in further developing PETSc for GPUs; see PETSc Developers site.


Thanks a lot for playing the pilot of Ripple Effect, a game of resources and risks. We hope you found the experience enjoyable and instructive. Please let us know what you think via<EMAIL_ADDRESS>We will use all comments to improve the full version of the game, which will be longer and deeper, offering new events along the way.
Team ranking {{ team.get_rank }}
Points scored {{ team.victory_points }}
Resources produced {{ team.resources_collected }}
Longest Goal Zero streak{{ team.get_goal_zero_streak }}


An analogy to describe the differnce between HTML and CSS is that the HTML is think of HTML as a canvas that can have anything on the canvas. And think of CSS as the paint that is about to paint a picture on the CSS.
Control flow in a example of a everydays ssituation would be a process of straighting my hair. For example I would need to....
1. Wash my hair.
2. Dry my hair.
3. Heat protection gel
4. Straighten
5. Complete.
This shows a process and also a particular way this is done. This is the same for control flow. There is particular way that scripts are written with fuctions and obnjects that make can be controled in a way known as "Control Flow".
D.O.M stand for "Document object model". D.O.M is when the HTML , CSS and javascript come together as one. This whole flow is what the D.O.M stands for.
An example of how we interact with D.O.M is what we do everyday on a computer. And that would be through the the window browser. How this connects is that when you are on the window the process goes to the document ,HTML andit divided to two sub headers which is either a the head and body.
The difference between accessing data from array and from objects are that an array can hold more than one value in the at a time. An arry can hold many values unders a single name. And you can access them by referring them to a index number. Arrays are also objects as well through a operator called typeof where it returns object for arrays.
A object is the same as any object in our everday lives like a car , bike etc. But in javascript objects can be variables as well. To access an object you can
1. objectName.propertyName
2.objectName.["propertyName"]
A function is known a blocks of code that is used to desgined to carry out a partiicular task. So it pretty much is excuted when "something" calls it. Functions are real useful as functions are speacial type object. When declaring a function it actually same for calling an object.