\[ \newcommand{\epe}{\text{EPE}} \newcommand{\E}{\text{E}} \newcommand{\mse}{\text{MSE}} \newcommand{\tdata}{\mathcal{T}} \newcommand{\bias}{\text{Bias}} \newcommand{\var}{\text{Var}} \newcommand{\cov}{\text{Cov}} \newcommand{\corr}{\text{Corr}} \newcommand{\rss}{\text{RSS}} \newcommand{\tr}{\text{tr}} \newcommand{\ridge}{\text{ridge}} \newcommand{\pcr}{\text{pcr}} \newcommand{\ls}{\text{ls}} \newcommand{\tr}{\text{tr}} \newcommand{\df}{\text{df}} \newcommand{\FS}{\text{FS}} \]
This is similar to LAR but they are not the same. The algorithm is as follow (start with standardized features).
It is a generalized version of forward stagewise regression (\(\FS_1\)). We call it \(\FS_\epsilon\).
And \(\FS_0\) is the case when \(\epsilon \rightarrow 0\) (infinitesimal forward stagewise regression).
LAR algorithm with \(\FS_0\) modification can solve \(\FS_0\) problem.
\(\FS_0\) optimizes a complex problem evolving differential. In simple word, \(\FS_0\) is more constrained that the lasso so it has less variance than the lasso especially when \(p >> N\).
LAR uses the piecewise-linear nature of lasso solution path. Similarly, path-based algorithms can be used for other problems with piecewise-linear solution path.
Suppose we want to solve \[\begin{aligned} \beta &= \arg\min_\beta [R(\beta) + \lambda J(\beta)] \\ R(\beta) &= sum_{i = 1}^N L(y_i, \sum_j x_{ij} \beta_j) \end{aligned}\] , where \(R\) and \(J\) should be convex. The followings are sufficient conditions to ensure that the solution path is piecewise-linear.
In this case, the solution can be efficiently computed. Examples are:
I paste the problem here without going into more details. The problem is similar to lasso but it is much less popular.
The penalty term is
\[\begin{aligned} \lambda \sum_l \sqrt{p_l} \|\beta_l\|_2 \end{aligned}\] with \(l\) indexes group and \(p_l\) indicates the size of the group. This criteria encourages all coefficients belonging to a group \(l\) to be zero. A generalized version is \(\|\eta\|_K = (\eta' K \eta)^{\frac{1}{2}}\). Furthermore, allowing overlapping groups.
Many studies have focused on the performance of the lasso with \(N\) and \(p\) get large. One of the assumptions are about the correlation between \(X_S\) and \(X_S^c\) where \(S\) is the set of features with non-zero coefficients in the true model. For instance, the condition could be \[ \max_{j \in S^c} \| x_j' X_S (X_S' X_S)^{-1} \|_1 \le 1 - \epsilon, ~\epsilon \in (0, 1] \] In short, in order for the lasso to have good performance, the non-true features should not be too correlated with the true features.
One of the downside of the lasso is that it shrinks the non-zero coefficient to zero which makes it inconsistent (as sample size approaches infinity, it does not converge to the true value). To solve this problem, one could use the lasso as a way of feature selection and re-fit the model using non-zeros only. In practice, this approach may be computationally demanding (to fit a large number of features simultaneously is not easy). In this case, one could use two round of CVs. In the first round CV, we do feature selection to select the related features. In the second round of CV, we use the selected features only and re-fit the hyper-parameter. The intuition is that with a small feature set to begin with, we could use a smaller penalty term which gives less severe shrinkage. (Note: The large penalty is to balance the number of features and the number of samples along with the amont of error)
Furthermore, The smoothly clipped absolute deviation (SCAD) is proposed in place of the lasso. It shrinks less on large coefficients (see figure below).
But the cost is that the penalty is not convex anymore which makes it hard to fit. Along this line, the adaptive lasso is proposed which is a weighted version of the lasso, \(\sum_k w_i |\beta_k|\) with \(w_k = 1 / |\hat\beta_k|^{\nu}\) where \(\hat\beta\) is from OLS. This is an approximation of \(\|\beta\|^{1 - \nu}\) penalty.
This is an alternative algorithm to solve the lasso (other than the LARS) and this approach is based on simple coordinate descent. Fixing \(\lambda\), we loop over \(\beta_k\) and update them one at a time. The objective at each iteration is \[\sum_{i = 1}^N (y_i - \sum_{j \ne k} x_{ij} \tilde\beta_j - x_{ik} \beta_k)^2 + \lambda \sum_{j \ne k} |\beta_j| + \lambda |\beta_k|\] The update rule for this objective is analytical, simply by soft-thresholding: \[\tilde\beta_k \leftarrow S(y_i - \sum_{j \ne k} x_{ij} \tilde\beta_j, \lambda)\] where \(S(t, \lambda) = \text{sign}(t)(|t| - \lambda)_+\).
In practice, we could start with \(\lambda_\max\) such that \(\tilde\beta_j = 0, ~\forall j\) and we gradually decreases \(\lambda\) with the previous solution as warm-start. This algorithm is faster than LARS when the problem is large. We don’t get the whole solution path but the solution on a grid of \(\lambda\)’s. This algorithm can also be applied to the elastic net and the grouped lasso (in case where the penalty is the sum of functions of the individual parameters). It can also be applied to the fused lasso with substantial modification.
The least squares is done by Cholesky decomposition of \(X'X\) or QR decomposition of \(X\). For \(X \in \mathbb{R}^{N \times p}\), Cholesky decomp. needs \(p^3 + Np^2 / 2\) operations and QR decomp. needs \(Np^2\) operations.
Sometimes, Cholesky decomp. is faster but it could be less numerically stable. The lasso via LAR algorithm has the same complexity as least squares fits.


Harris: Transcripts Show Trump Using Power Solely for 'Self-Service' | Breitbart
by Ian HanchettOn Monday’s broadcast of CNN’s “Situation Room,” 2020 presidential candidate Senator Kamala Harris (D-CA) reacted to the release of the transcripts of former U.S. Ambassador to Ukraine Marie Yovanovitch’s and former aide to Secretary of State Mike Pompeo Michael McKinley’s depositions by stating that the transcripts show a further example of President Trump using his power to further his self-interest.
Harris said, “[T]his is yet again another example of Donald Trump exercising his power in a way that is completely about self-service, and not in the best interest of our nation, not in — certainly not in the best interest of truth, not in the best interest of justice, and not in the best interest of our national security.”
Follow Ian Hanchett on Twitter @IanHanchett


|
CCfits
2.4
|
Class Representing Binary Table Extensions. Contains columns with scalar or vector row entries. More...
#include <BinTable.h>
Public Member Functions | |
| virtual void | addColumn (ValueType type, const String &columnName, long repeatWidth, const String &colUnit=String(""), long decimals=0, size_t columnNumber=0) |
| add a new column to an existing table HDU. | |
| virtual BinTable * | clone (FITSBase *p) const |
| virtual copy constructor | |
| virtual void | readData (bool readFlag=false, const std::vector< String > &keys=std::vector< String >()) |
| read columns and keys specified in the input array. | |
Protected Member Functions | |
| BinTable (FITSBase *p, const String &hduName=String(""), bool readFlag=false, const std::vector< String > &keys=std::vector< String >(), int version=1) | |
| reading constructor. | |
| BinTable (FITSBase *p, const String &hduName, int rows, const std::vector< String > &columnName=std::vector< String >(), const std::vector< String > &columnFmt=std::vector< String >(), const std::vector< String > &columnUnit=std::vector< String >(), int version=1) | |
| writing constructor | |
| BinTable (FITSBase *p, int number) | |
read BinTable with HDU number number from existing file represented by fitsfile pointer p. | |
| ~BinTable () | |
| destructor. |
Class Representing Binary Table Extensions. Contains columns with scalar or vector row entries.
BinTable (re)implements functions prescribed in the Table abstract class. The implementations allow the calling of cfitsio specialized routines for BinTable header construction. functions particular to the BinTable class include those dealing with variable width columns
Direct instantiation of BinTable objects is disallowed: they are created by explicit calls to FITS::addTable( ... ), FITS::read(...) or internally by one of the FITS ctors on initialization. For addTable, creation of BinTables is the default.
| CCfits::BinTable::BinTable | ( | FITSBase * | p, |
| const String & | hduName = String("") , |
||
| bool | readFlag = false , |
||
| const std::vector< String > & | keys = std::vector<String>() , |
||
| int | version = 1 |
||
| ) | [protected] |
reading constructor.
Construct a BinTable extension from an extension of an existing disk file. The Table is specified by name and optional version number within the file. An array of strings representing columns or keys indicates which data are to be read. The column data are only read if readFlag is true. Reading on construction is optimized, so it is more efficient to read data at the point of instantiation. This favours a "resource acquisition is initialization" model of data management.
| p | Pointer to FITSBase class, an internal implementation detail |
| hduName | name of BinTable object to be read. |
| readFlag | flag to determine whether to read data on construction |
| keys | (optional) a list of keywords/columns to be read. The implementation will determine which are keywords. If none are specified, the constructor will simply read the header |
| version | (optional) version number. If not specified, will read the first extension that matches hduName. |
| CCfits::BinTable::BinTable | ( | FITSBase * | p, |
| const String & | hduName, | ||
| int | rows, | ||
| const std::vector< String > & | columnName = std::vector<String>() , |
||
| const std::vector< String > & | columnFmt = std::vector<String>() , |
||
| const std::vector< String > & | columnUnit = std::vector<String>() , |
||
| int | version = 1 |
||
| ) | [protected] |
writing constructor
The constructor creates a valid HDU which is ready for Column::write or insertRows operations. The disk FITS file is update accordingly. The data type of each column is determined by the columnFmt argument (TFORM keywords). See cfitsio documentation for acceptable values.
| p | Pointer to FITSBase class, an internal implementation detail |
| hduName | name of BinTable object to be written |
| rows | number of rows in the table (NAXIS2) |
| columnName | array of column names for columns to be constructed. |
| columnFmt | array of column formats for columns to be constructed. |
| columnUnit | (optional) array of units for data in columns. |
| version | (optional) version number for HDU. |
The dimensions of columnType, columnName and columnFmt must match, but this is not enforced.
| void CCfits::BinTable::addColumn | ( | ValueType | type, |
| const String & | columnName, | ||
| long | repeatWidth, | ||
| const String & | colUnit = String("") , |
||
| long | decimals = 0 , |
||
| size_t | columnNumber = 0 |
||
| ) | [virtual] |
add a new column to an existing table HDU.
| type | The data type of the column to be added |
| columnName | The name of the column to be added |
| repeatWidth | for a string valued, this is the width of a string. For a numeric column it supplies the vector length of the rows. It is ignored for ascii table numeric data. |
| colUnit | an optional field specifying the units of the data (TUNITn) |
| decimals | optional parameter specifying the number of decimals for an ascii numeric column |
| columnNumber | optional parameter specifying column number to be created. If not specified the column is added to the end. If specified, the column is inserted and the columns already read are reindexed. This parameter is provided as a convenience to support existing code rather than recommended. |
Reimplemented from CCfits::ExtHDU.
| void CCfits::BinTable::readData | ( | bool | readFlag = false , |
| const std::vector< String > & | keys = std::vector<String>() |
||
| ) | [virtual] |
read columns and keys specified in the input array.
See Table class documentation for further details.
Implements CCfits::ExtHDU.


| convertTheme {rstudioapi} | R Documentation |
Converts a tmTheme
to an rstheme
and optionally adds and
applies it to RStudio and returns the name of the theme.
convertTheme( themePath, add = TRUE, outputLocation = NULL, apply = FALSE, force = FALSE, globally = FALSE )
themePath |
A full or relative path to the |
add |
Whether to add the newly converted theme to RStudio. Setting this
to true will have the same impact as running |
outputLocation |
A full or relative path where a copy of the converted
theme will be saved. If this value is |
apply |
Whether to immediately apply the newly added theme. This
paramater cannot be set to |
force |
Whether to force the operation and overwrite an existing file
with the same name. |
globally |
Whether to install this theme for the current user or all
users. If set to |
The convertTheme
function was introduced in RStudio 1.2.879.


Sideshow — minimal XHTML5/JS/CSS presentations
- Sideshow turns webpages into presentations
- You can use it to write presentations, too
- You can find/fork the code on github (BSD/MIT/X11 license):
- http://github.com/wcmaier/sideshow/
- See the next slide for an example
- Press spacebar or page down
- Move your mouse to the right side of the slide and click (or tap) the →
- Switch to the alternate "sideshow print" stylesheet using your browser to see the slides all at once
- Start with a (X)HTML5 document with

and

tags
- Load sideshow.css and sideshow.js
- Add a


Show me only if run in Android.
Show me only if run in iOS.
Show me only if run in BlackBerry.
Show me only if run in Chrome.
Show me only if run in Safari.
Show me only if run in Firefox.
Show me only if run in Opera.


--- layout: post date: 2011-02-14 time: "09:00:00" authors: ["Greg Wilson"] title: Audio for Three Software Engineering Episodes tags: ["Content"] ---
We've added audio (and a few images) for three of the episodes on software engineering (the introduction, agile development, and the principles of computational thinking). It's a slightly different format than most of our previous episodes, and we need to choose a better way of embedding MP3 audio in web pages, but we hope it's useful as is.


cipher v1.2.2 Cipher
Helpers to encrypt and decrypt data.
Summary
Functions
Returns the JSON converted and encrypted version of given data
Returns decrypted string contained in given crypted
string
Returns encrypted string containing given data
string
Returns the JSON parsed data of the given crypted string,
with labeled tuples: {:ok, data}
or {:error, reason}
Gets signature for given base
and appends as a param to url
.
Returns url
with appended param.
Given payload
is contained within the signature and will be returned
by validate_signature/3
An URL is signed by getting a hash from it, ciphering that hash, and appending it as the last query parameter
The URL is signed by getting a MD5 hash from the sorted data values, ciphering that hash, and appending it as the last query parameter of the URL
The URL is signed by getting a MD5 hash from the sorted data values, ciphering that hash, and appending it as the last query parameter of the URL
Decrypts ciphered
, and compare with an MD5 hash got from base.
Returns {:error, reason}
if decryption failed, or if comparison failed.
{:ok, payload}
otherwise
Validate given signed URL + body.
If body is a binary, it will be validated as if signed using sign_url_from_body/2
.
Else it will be validated as if signed using sign_url_from_mapped_body/2
Validate given signed URL
Functions
Returns the JSON converted and encrypted version of given data:
%{"hola": " qué tal ｸｿ"}
|> Cipher.cipher # "qW0Voj3h4nglx4NPy8aLXVY5ze5V3OBu5IoaQTMUUbU%3D"
|> Cipher.parse # {:ok, %{"hola" => " qué tal ｸｿ"}}
Returns decrypted string contained in given crypted
string
"secret"
|> Cipher.encrypt # "KSHHdx0uyveYGY5PHqLAKw%3D%3D"
|> Cipher.decrypt # "secret"
Returns {:error, "Could not decode string 'yourstring'"}
if it failed in
the first stage of decryption (unescaping and decoding given string). That
means someone tampered your crypted data, or maybe the crypted string was
not transferred properly.
Returns {:error, "Could not decrypt string 'yourstring'"}
if it failed in
the last stage, the decryption itself. Usually means your decryption keys are
not the same that were used to encrypt. But may also be some cases were a
tampered or wrongly transferred string can be actually unescaped and decoded
successfully. They will fail in the decryption stage.
Returns encrypted string containing given data
string
"secret"
|> Cipher.encrypt # "KSHHdx0uyveYGY5PHqLAKw%3D%3D"
|> Cipher.decrypt # "secret"
Returns the JSON parsed data of the given crypted string,
with labeled tuples: {:ok, data}
or {:error, reason}
%{"hola": " qué tal ｸｿ"}
|> Cipher.cipher # "qW0Voj3h4nglx4NPy8aLXVY5ze5V3OBu5IoaQTMUUbU%3D"
|> Cipher.parse # {:ok, %{"hola" => " qué tal ｸｿ"}}
Gets signature for given base
and appends as a param to url
.
Returns url
with appended param.
Given payload
is contained within the signature and will be returned
by validate_signature/3
.
Be aware that payload
must be a Map
, and that some keys, such as
md5
or deny
, will be used internally. Keep things namespaced in there
and there will be no collisions.
An URL is signed by getting a hash from it, ciphering that hash, and appending it as the last query parameter.
"/bla/bla?p1=1&p2=2"
|> Cipher.sign_url # "/bla/bla?p1=1&p2=2&signature=4B6WOiuD9N39K7p%2BnqNIljGh5F%2F%2BnHRQGZC9ih%2Bh%2BHGZc8Tz0KdRJXC%2B5M%2B8%2BHZ2mAXPh3jQcSRieTq4dGm5Ng%3D%3D"
The URL is signed by getting a MD5 hash from the sorted data values, ciphering that hash, and appending it as the last query parameter of the URL.
The URL is signed by getting a MD5 hash from the sorted data values, ciphering that hash, and appending it as the last query parameter of the URL.
The given mapped_body must be a map.
Decrypts ciphered
, and compare with an MD5 hash got from base.
Returns {:error, reason}
if decryption failed, or if comparison failed.
{:ok, payload}
otherwise.
Validate given signed URL + body.
If body is a binary, it will be validated as if signed using sign_url_from_body/2
.
Else it will be validated as if signed using sign_url_from_mapped_body/2
.
{:ok, payload}
or {:error, reason}
are returned.
Validate given signed URL.
"/bla/bla?p1=1&p2=2&signature=4B6WOiuD9N39K7p%2BnqNIljGh5F%2F%2BnHRQGZC9ih%2Bh%2BHGZc8Tz0KdRJXC%2B5M%2B8%2BHZ2mAXPh3jQcSRieTq4dGm5Ng%3D%3D"
|> Cipher.validate_signed_url # {:ok, %{"md5" => "86e359da7ab4886f3525ac2b9c5edc5b 613146"}}
{:ok, payload}
or {:error, reason}
are returned.


__init__(self,
infra_model_inst=None,
provisioner=None,
namespace_model_inst=None,
config_model_inst=None,
log_level=20,
no_delay=False,
num_threads=5,
post_prov_pause=60)
(Constructor)
| source code
|
Create an instance of the orchestrator to operate on the supplied
models/provisioner
This method creates a new orchestrator, which is then ready to
initiate the system described by the models provided to it. Some
reasonableness checks are done on the arguments to ensure that there are
no conflicting semantics being requested, otherwise the method simply
returns an orchestrator ready to go.
- Parameters:
infra_model_instance - Optional; an instance of a subclass of actuator.infra.InfraModel. If absent, all host
information must be contained as values for host_refs in the
NamespaceModel that resolve to either an IP address or a
resolvable host name.
provisioner - Optional; an instance of a subclass of actuator.provisioners.core.BaseProvisioner, such
as the Openstack provisioner. If absent and an infra model has
been supplied, then all resources in the model must be
StaticServers, or else the resource will not get provisioned.
namespace_model_inst - Optional; an instance of a subclass of actuator.namespace.NamespaceModel. If absent,
then only infra model processing will be possible (if one was
supplied).
config_model_instance - Optional; an instance of a subclass of actuator.config.ConfigModel. If absent, no
configuration will be carried out, but the namespace can be
interrogated after orchestration to determine values from any
provisioned infra
log_level - Optional; default is LOG_INFO. One of the symbolic log constants
from the top level actuator package. These are LOG_CRIT,
LOG_ERROR, LOG_WARN, LOG_INFO, and LOG_DEBUG. The default
supplies progress on each provisioning and configuration task.
no_delay - Optional; boolean, default is False. Flags if a short, random
delay of up to 2.5 seconds should be inserted prior to performing
a task. May be desirable in cases where many tasks may hit a
single host at one time, which spreads out the load of
establishing ssh connections, helping to avoid timeouts.
num_threads - Optional; int, default is 5. Each task, whether resource
provisioning or configuration, is carried out in a separate
thread. The more parallel tasks your model has the higher this
number can be to have a positive impact on the overall task
completion rate. There is no value in making this larger than the
largest number of tasks you may have running in parallel.
post_prov_pause - Optional: int, default is 60. The number of seconds to pause
after provision is done before starting on configuration. The
reason this is useful is because virtual/cloud systems may
complete provisioning, but they may not have all route
information propagated for newly provisioned hosts/floating ips
right away. This pause gives virtual/cloud systems a chance to
stabilize before starting on configuration tasks. If no
provisioning was done (a static infra model or simply no
infra/provisioner), then the pause is skipped.
- Returns:
- initialized orchestrator instance
- Raises:
ExecutionException - In the following circumstances this method will raise
actuator.ExecutionException:
- Overrides:
object.__init__
|


Flash and JavaScript are required for this feature.
Download the video from iTunes U or the Internet Archive.
Description: In this lecture, we build an identification tree based on yes/no tests. We start by arranging the tree based on tests that result in homogeneous subsets. For larger datasets, this is generalized by measuring the disorder of subsets.
Instructor: Patrick H. Winston
Lecture 11: Learning: Ident...
PATRICK WINSTON: Ladies and gentlemen, the Romanian national anthem.
I did not ask you to stand, because I didn't play it as a symbol of Romanian national identity.
But rather, to celebrate the end of the Cold War, which occurred about the time that you were born.
Before that, no one came to MIT from Eastern Europe.
But since that time, we've been blessed by having in our midst Lithuanians, Estonians, Poles, Czecs, Slovaks, Bulgarians, Romanians, Slovenians, Serbs, and all sorts of people from regions of the world formally excluded to us.
Believe me, you are all welcome in our house.
Almost all, that is to say.
Because you may recall that Romania is the traditional home of vampires.
And since the end of the Cold War, vampires have had new vectors for emerging from their traditional places and penetrating into the world at large.
You may have vampire in your suite, or on your floor.
And it's important to know how to recognize them, and take the necessary precautions.
So if you have this concern, I would expect that the first thing you would do would be to look at some data concerning the characteristics of vampires.

And our task today-- and what you'll understand how to do by the end of the hour-- is to use data like this to build a recognition mechanism that would help you to identify whether someone is a vampire or an ordinary person.
So this is a little different from the kind of problem we worked with neural nets.
Right?
So what's the most conspicuous difference between this data set and anything you could think to work on with nearest neighbors, which we studied last time.
Katie, do you have any thoughts about why it would be difficult to use nearest neighbors with data like this?
The question mark is there because this is MIT, and a lot of people are completely nocturnal.
So you can't tell whether they cast a shadow or not.
We want to take that into account.
So what's different about this from the electrical cover data set?
STUDENT: [INAUDIBLE] PATRICK WINSTON: Could you use the nearest neighbor technique to identify vampires with this data?
STUDENT: [INAUDIBLE] PATRICK WINSTON: So obviously-- Yes, Lana?
STUDENT: [INAUDIBLE] STUDENT: You cannot really quantify-- PATRICK WINSTON: Oh, that's the problem.
This is not numerical data.
This is symbolic.
So we're not saying that your ability to cast a shadow is 0.7.
You either cast a shadow, down cast a shadow, or we can't tell.
It's a symbolic result.
So problem number one we have to face with data of this kind is that it's not numeric.
And there are other characteristics, as well.
For example, it's not clear that all of these characteristics actually matter.
So some characteristics don't matter.
And a corollary to that is that some characteristics do matter, but they only matter part of the time.
And finally, there's the matter of cost.
Some of these tests may be more expensive to perform than others.
For example, if you wanted to determine whether someone casts a shadow, you'd have to go to the trouble of getting up during daylight.
That might be an expensive operation for you.
You'd have to go find some garlic and ask them to eat it.
That might be expensive.
So some of these tests might be expensive relative to other tests.
But once you realize that we are talking in terms of tests, and not a vector of real values, then what you do is clear.
You build yourself a little tree of tests.
So who knows how this problem will turn out?
But you can imagine a situation where you have one test up here which might have three outcomes.
And one but only one of those outcomes might require you to perform another test.
And only when you've created the tree of tests that look like this are you finished.
So given this set of tests and a set of samples, the question becomes, how do you arrange the tests in a tree like that so as to do the identification that you want to do?
So since we're talking about identification, it's not surprising that this kind of tree is called an identification tree.
And there's a tendency-- and I may slip into it myself-- to call this a decision tree.
But a decision tree is a label for something else.
This is an identification tree.
And the task is to create a good one.
So what is a good one versus a not so good one?
What characteristic would you like for a decision tree-- for an identification trade to have, if you're going to call it good identification tree?
What do you think, Krishna?
What would be a good characteristic?
STUDENT: Maybe the minimum number of levels?
PATRICK WINSTON: Yeah.
He said minimum number of levels.
What's another way you could say what a good one is?
Each test costs something, right?
So what's another way of thinking about what a good tree would look like?
STUDENT: Minimum cost.
PATRICK WINSTON: The minimum cost.
And if they all have the same cost, then it's the number of tests.
So overall, what you like is a small tree rather than a big one.
So you might be able to take your sample data and divide it up, so that at the bottom of the tree, at the leaves, all of the sets that are produced by the tests are uniform, homogeneous.
We'd like that tree to be the simplest possible tree you can find, not some big complicated one that also divides up all the data into uniform subsets.
By uniform subset-- at the bottom of the tree, you have all of the vampires together, and all the non-vampires together.

So why not just go all the way and do British Museum, and calculate all possible trees?
Well, you can do that, but it's one of those NP problems.

And so you don't want to do that.
You want to have some kind of heuristic mechanism for building a small tree.
And we want a small tree because-- Why do we want a small tree?
Because of the cost.
but there's another, more important reason why we want a small tree.
Let me give you a hint.
It's Occam's Razor.
The simplest explanation is often the best explanation.
So if you have a big, complicated explanation, that's probably less good than a simple, small explanation.
Occam's Razor.
Spelled so many ways it doesn't matter how I spell it.
And that's good, because I can't spell.
So how are we going to go about finding the best possible arrangement of those four tests in a tree like that?
Well, step one will be to see what each test does with the data.
And by the way, before I go a step further, you know and I know that this is a sample data set that's very small, suitable for classroom manipulation.
You'd never bet your life on a data set this small.
We use it only for classroom illustration.
But imagine that these rows are multiplied by 10.
So instead of eight samples, you've got 80.
Then you might begin to believe the results that are produced.
So I'm just going to pretend that each one of those represents 10 other samples that I haven't bothered to show.
But we can work with this one in the classroom, because it's pretty small.
And we can say, well, what does this shadow test do?
Well, the shadow test divides the sample population into three groups.
There's the I Don't Know group of people who are nocturnal.
There are the people who do cast the shadow, the Yes people.
And the people who do not cast a shadow, the No people.
So if I look at those rows up there and see which ones are vampires, it looks to me that if there's no shadow cast-- there's only one that doesn't cast a shadow-- and that is a vampire.
So that's a plus over there.
Vampire.
Now, if we look at the ones who do cast a shadow, all those are not vampires.
They're all OK.
And now there're 8.
Three are vampires.
So that means that two of these must be vampires.
And I've got three, four, five, six so far.
So there must be two left.
So that's the way the shadow test divides up the data.
Now let's do garlic.
Vampires traditionally don't eat garlic.
I don't know why.
So we look at the garlic test, and we see that all of the Nos-- well, there're three Yeses, and they all produce a No answer.
So if somebody eats garlic, they're not vampires.
That means the three vampires must be over here.
Then there are two left.
So that's what the garlic test does.
See what we're trying to do?
We're trying to look at all these tests to see which one we like best on the basis of how it divides up the data.
So now we've got complexion.
And there are three choices for this.
You can have an average complexion.
But a lot of vampires, in my experience, are rather pale.
So pale is a possibility.
And then the other option is that just after gorging themselves with blood, they tend to get a little red in the face.
So we'll have a ruddy over here.
Once again, we have to go back to our data set to see how this test divides things up.
So there are three ruddies, and one's a No, one's a No, and one's a Yes.
So two Nos and a Yes.
Two Nos and a Yes.
Now we can try for pale complexion people.
There are only two of those.
A No and a No.
That must mean that there are two pluses over here, because there are three vampires altogether.
Two, four, six, seven, eight, nine.
Eight, sorry.
Eight.
Only eight.
Just one more to go, and that's the accent.
Historically, vampires go to great length to protect their accent and not betray their origins.
But nevertheless, we can expect that if they've just arrived-- if they're just in from Transylvania, part of Romania-- they may still have an accent.
So there's a normal, some still have a heavy accent, and some persist in having odd accents.
So let's see.
Accent.
Four of them, right at the top, have no accent.
Two Nos and a Yes.
Heavy accent.
Three of those.
A Yes and two Nos.
That means we must have a plus here.
3, 6, plus and a minus.
So we can look at this data and say, well, what will be the best test to use?
And the best test to use would surely be the one that produces sets here, at the bottom of the branches, that correspond to the outcomes of the test.
We're looking for a test that produces homogeneous groups.
So just for the sake of illustration, I'm going to suppose that we're going to judge the quality of the test by how many sample individuals it put into a homogeneous set.
So ideally, we'd like a test that will put all the vampires in one group and all the ordinary people in another group right off the bat.
But there are no such tests.
But we can add up the number of sample individuals who are put in to at least homogeneous sets.
So when we do that, this guy has 3 in a homogeneous set here.
A fourth.
But these are not a homogeneous set.
So the overall score for this guy will be 4.
This one, well, not quite as good.
It only puts 3 individuals in a homogeneous set.
This one here, 2 individuals into a homogeneous set.
Everybody else is all mixed up with some other kind of person.
And over here, how many samples are in a homogeneous set?
0.
So on the basis of this analysis, you would conclude that the ordering of the test with respect to their quality is left to right.
So the best test must be the shadow test.
So let's pick the shadow test first, see what we can do with that.
If we pick the shadow test first, then we have this arrangement.
We have question mark, and we have Yes, casts a shadow, and No, doesn't.
We have 3 minuses here.
We have a plus here.
And unfortunately, over here, we have plus, plus, minus, minus.
So we need another test to divide that group up.
Yes.
STUDENT: How did you get the 4 on the shadow test again?
Why was it 4?
PATRICK WINSTON: Well, if I look at the data and I see who-- the question is, what about that shadow test?
If you look at the shadow test, and you say, well, there are 4 question marks.
And if we look and see what kind of people belong to those 4 question marks, there are 2 vampires and 2 non-vampires.
That's why it's 2 pluses and 2 minuses.
STUDENT: No, I understand that.
The question is, how did you get to the score of 4?
PATRICK WINSTON: Oh, yeah.
The question is how did I get this number 4?
It has nothing to do this, because this is a mixed set.
In fact, I've got three guys in a homogeneous set here, and one guy in a homogeneous set here, and I'm just adding them up.
STUDENT: OK.
PATRICK WINSTON: So very simple classroom illustration.
Wouldn't work in practice.
Yes.
STUDENT: How do you adjust this for larger data sets where it's unlikely you're going to have any [INAUDIBLE]?
PATRICK WINSTON: The question is, how do I adjust this for larger data sets?
You're one step ahead.
Trust me, I'll be doing large data sets in a moment.
I just want to get the idea across.
And I don't want there to be any thought that the method we use for larger data sets has got anything magic about it.
OK, so we're off and running.
And now we have to pick a test that will divide those four guys up.
So we're going to have to work this a little harder, and repeat the analysis we did there.
But at least it'll be simpler, because now we're only considering 4 samples, not 8.
Just the 4 samples that we still have to divide up that have come down that left branch.
So I have the shadow test.
It has 3 outcomes.
We have the garlic test.
It has 2 outcomes.
Yes and No.
We have the complexion test.
There's 3 outcomes.
Average, pale, and ruddy.
And we have finally the accent test.
And that comes out to be either normal, heavy, or odd.
And now, it's a little awkward to figure out what the results are for this data set as shown.
So let me just strike out.
The ones that we're no longer concerned with, and limit our analysis to the samples for which the outcome of the shadow test is a question mark.
This is exactly the four people we still need to separate, right?
So switching colors, keeping the color the same.
We actually don't want to do the shadow test anymore, right?
Because we've already done that.
There's no point in doing that again.
We don't have to look at that.
It's already done all the division of data that it can.
So the garlic test.
Well, let's see.
Garlic.
2 Yeses, 2 Nos.
The Yeses produce Nos and the Nos produce Yeses.
So if the person does eat garlic, they're OK.
And if they don't eat garlic, bad news-- they're vampires.
Well, that looks like a pretty good test.
But just for the sake of working it all out, let's try the others.
Complexion.
2 Ruddies, a Yes, and a No.
1 pale, and that's a No.
1 pale, and that's a No.
And we must have 1 average, and sure enough, that's a Yes.
Now we can do accent, the one on the far right, and look at how that measures up against the people who are still under consideration as samples.
Accent.
Let's see.
2 Nones, a Yes and a No.
No Heavies.
2 Odds, a Yes and a No.
All right.
So now we can do the same thing we did before, and just say, for sake of classroom illustration, how many individuals are put into a homogeneous sets.
And here we have 4.
And here we have 2.
And here we have 0.
So plainly, the garlic test is the test of choice.
So we go back over here, and we've completed the work that we needed to do.
So that's the garlic test.
And that produces 2 pluses.
Let's see.
Eats garlic, Yes.
Eats garlic, No.
I guess the pluses go over here like so.
And these are the two ordinary people.
And we're done with our task.
And now you can quickly run off and put this into your PDA, and forever be protected against the possibility that one of those vampires got out in the flood of people that came in from Eastern Europe.
Except what do we do a large data set?
Well, the trouble is, a large data set's not likely to produce-- if you have a large data set, no test is likely to put together any homogeneous set right off.
So you never get started.
Everything would be 0.
Every test would say, oh it doesn't put anybody into homogeneous sets.
So you're screwed.
You need some other, more sophisticated way of measuring how disordered this data is.
Or how disordered these sets are that you find at the bottom of the tree branches.
That's what you need.
You need a way of measuring disorder of these sets that you find at the bottom of these branches, so you can find a kind of overall quality to the test based on your measurement of disorder.
Now, the first heuristic of a good life is, when you have a problem to solve, ask somebody who knows the answer.
It's the least amount of work.
It's not even as hard going to Google.
So who would you ask about ways of measuring disorder in sets?
There are two possible answers.
STUDENT: You could just do entropy.
PATRICK WINSTON: What?
STUDENT: Find the entropy of the set.
PATRICK WINSTON: Who studies entropy?
STUDENT: Probability.
PATRICK WINSTON: What kind of classes?
STUDENT: Physics.
STUDENT: Thermodynamics.
PATRICK WINSTON: Thermodynamics!
The thermodynamicists are good at measuring disorder, because that's what thermodynamics is all about.
Entropy increasing over time, and all that sort of stuff.
There's another equally good answer.
STUDENT: Statisticians?
PATRICK WINSTON: Statisticians.
Perhaps, but it's not the second best answer.
It's actually not even the best answer.
That's the best answer.
What's your name?
STUDENT: Leo.
PATRICK WINSTON: Oh, yeah.
[LAUGHTER] PATRICK WINSTON: Leonardo has got his finger on it.
The information theorists are pretty good at measuring disorder, because that's what information is all about, too.
So we might as well borrow a mechanism for measuring the disorder of a set from those information theory guys.
So what we're going to do is exactly that.
Let's put it over here, so we'll have it handy when we want to try to measure those things.
The gospel according to information theorists is that the disorder, D, or some set is equal to-- now let's suppose that this is a set of binary values.
So we have positives and then we have negatives.
Pluses and minuses.
But pluses, they don't go very well in an algebraic equation, because they might be confused with adding.
So I'm going to say P and N. And then it'll be the total, which is P plus N. We only have two choices, positive and negative.
So the disorder of set, according those guys, is equal to minus the number of positives over the total number, times the log to the base 2 of the positives over the total, minus the negatives over the total, times the log 2 of the negatives over the total.

But that's not going to be true, right?
Because these ratios are all less than 1, and the logarithm of something that's less than 1 is negative.
So we're OK.
So that's a lovely way of measuring disorder.
And then we ought to draw a graph of what that curve looks like.
And what we're going to graph it against is the ratio of positives to the total number.
So that's going to be an axis where we go from 0 to 1.
So let's just find a couple of useful values.
And by the way, it pays to pay attention to these curves, because if you pay attention to this stuff, you can work the quiz questions on this very rapidly.
Otherwise, we see people getting out their calculators and quickly becoming both lost and screwed.
OK so let's see.
Let's suppose that the number of positives is equal to the number of negatives.
So we've got a completely mixed-up set.
It has no bias in either direction.
So in that case, if P over T is equal to 1/2, then this is equal to minus 1/2, times the logarithm of 1/2.
And I guess, since they're both the same, we can multiply by two.
And what's that value?
[INAUDIBLE], what does that calculate out to?
STUDENT: Minus [INAUDIBLE] PATRICK WINSTON: Minus [INAUDIBLE].
Well, with a minus sign, you just turn the argument upside down, so it's log(2).
So what's log(2)?
Logarithm of base 2 of 2?
1!
So this whole thing is-- STUDENT: 1.
PATRICK WINSTON: 1.
So [INAUDIBLE], in her soft way, says, well, let's see.
2 times 1/2.
That cancels out.
The minus, that flips the arguments so it's log to the base 2 of 2, and that's 1.
So this whole thing, You work out the algebra, it gives you 1.
So that's cool.
So right here in the middle where they're equal, we get a value of 1.
Next thing we need to do is let's calculate what happens if P over T is equal to 1.
That is to say, everything is a positive.
Any guesses?
Maybe 10, 20, minus 15?
Let's work it out.
So if P over T equal 1, that would be minus 1 times the log to the base 2 of 1.
What's that?
STUDENT: [INAUDIBLE] PATRICK WINSTON: A 0?
Oh, yeah.
Because 2 raise to the 0 is one.
So this part is 0.
Now, what about this other part?
If everything's a P, then nothing's an N.
So we've got 0.
And we can quit already.
Well, not quite.
We ought to work it out.
Log 2 to the base 2 of 0.
What's that?
STUDENT: [INAUDIBLE] PATRICK WINSTON: Who?
Minus infinity?
Uh oh.
0 times minus infinity is What I didn't get that when I was in high school.
Finally, 1801 makes a difference.
Finally.
What's the answer.
We're interested in the limit as N over T goes to 0, right?
And when you have a deal like this, what do you do?
You use that famous rule, that we all mispronounce when we see it written, right?
We use the good old El Hospital's rule.
OK, it's L'Hopital.
L'Hopital's Rule.
You have to differentiate the-- I guess we differentiate this guy as a ratio or something, and see what happens when it goes to 0.
And what we get when we use L'Hopital's Rule is that, oh thank God, this is still zero.
So now we know that we have a point up there and a point down there.
So now we've got three points on the curve, and we can draw it.
It goes like that.
No, it doesn't go like that.
It's obviously a Gaussian, right?
Because everything in a nature is a Gaussian.
Can you put that laptop away, please?
Everything in nature is a Gaussian, so it looks like this.
That right?
No, actually, not everything in nature is a Gaussian.
And in particular, this one isn't a Gaussian either.
It looks more like one of those metal things they used to call quonset huts.
That's what it looks like.
Boom, like so.
So that is the curve of interest.
Now, did God say that using this way of measuring disorder was the best way?
No, Got has not indicated any choice here.
We use this because it's a convenient mechanism, it seems to make sense, but in contrast to the reason it's used information theory, it's not the result of some elegant mathematics.
It's just a borrowing of something that seems to work pretty well.
Any of those curves would work just about the same, because all we're doing with it is measuring how disordered a set is.
So one thing to note here is that in this situation, where we're dealing with two choices-- P and N, positives and negatives-- we get a curve that maxes out at one.
And notice that it kind of gets up there pretty fast.
In fact, if you're down here at 2/3, are you're up here, this is about 0.9.
So it gives you a large number for quite a bit of that area in the middle.
So that, unfortunately, still doesn't tell us everything we need to know.
That tells us how to measure a disorder in one of these sets.
But we want to know how to measure the quality of the test overall.
So we need some mechanism that says, OK, given that this test produces three different sets, and we now have a measure of the disorder in each of these sets, how do we measure the overall quality of the test?
Well, you could just add up the disorder.
Let's write that down, because that sounds good.
So you can say that the quality of a test is equal to some sum over the sets produced.
And what we're going to do is we're going to add up the disorder of each of those sets.
I'm almost home, except that this means we're going to give equal weight to a branch that has almost nothing down it-- we're going to give the same weight to that as a branch that has almost everything going down it.
So that doesn't seem that make sense.
So one final flourish is we're going to weight this sum according to the fraction of the samples that end up down that branch.
So it's, as usual, easier to write it down than to say it.
So we're going to multiply that times the number of samples in the set, divided by the number of samples handled by test.
So if half the samples go down a branch, and if that branch has a certain disorder, then we're going to multiply that disorder times 1/2.
All right.
So now let's see how it works with our sample problem.
Well, here is our sample data.
And we didn't need anything fancy for it.
But let's pretend it was a large data set.
Well, let's see.
What would we do?
Well, go down this way, there are 4 samples down that direction.
That's half of the total number of samples.
So whatever we find down there, we're going to multiply by 1/2.
This one we're going to multiply by 3/8.
And this one we're going to multiply by 1/8.
Now, what do we actually find at the bottom of these things?
Well, here's a homogeneous set.
Everything's the same.
So we go to that curve and say, what is the disorder of a homogeneous set?
It's zero.
Let's see, they're all the same.
I guess that means it's 0 over there.
So the disorder of this set of three samples is zero.
The disorder of this set of one sample, all the same, is zero.
The disorder of this set-- well, let's see.
Half of the samples there are plus, and half are minus, so we go over to our curve, and we say, what's the disorder of something with equal mixture of pluses and minuses?
And that's one.
So the disorder of this guy is one.
So now we've got 1/2 times 1, and 3/8 times 0, 1/8 times 0.
So the quality of this particular test, as determined by the disorder of the sets it produces, is 1/5.
0.5.
Let's do this one.
So we have 3/8 coming down this way, 5/8 coming down this way.
3/8 is multiplied by the disorder of a set of uniform things.
That's disorder 0.
So this guy over here, let's see.
That's 2/5 and 3/5 multiplied-- You know, this is one of those deals where if you look at the curve, you're pretty close to the middle.
And that curve goes all the way up to about 0.9 there.
So you can kind of just look at this, and eyeball it, and say, well, whatever it is, the overall, this is going to be something multiplied times 5/8.
Something like 0.9 times 5/8.
So let's just say, for the sake of discussion, that that's going to be about 0.6, which is within a hundredth, I think, of being right.
Just kind of guessing.
OK, well now we're on a roll.
Here, we have 3/8 coming down this branch, 3/8 coming down this branch, 1/4 coming down this branch.
This is 0.
And this is one of those deals where these two are about 0.9.
So it looks like it's going to be 3/8 plus 3/8 is 3/4.
Times about 0.9.
So that's going to turn out to be about 0.7.
So one last go here.
3/8, 3/8, and 1/4.
Oh, that's interesting.
Because these two are what we got contributed up to that 0.7.
This one is 0.4 times-- this is evenly divided, so that's going to have disorder of 1.
So that's going to be 0.25 bigger than the number we got over here.
So that's going to end up being about 0.95.
So thanks god our answer is the same as we got with our simple classroom measurement of disorder.
Except this is measuring how disordered stuff is, we want the small number, not the big number.
So once again, based on this analysis, you'll be sure to pick the shadow cast, because 0.5 is less than 0.6, which is less than 0.7, which is less than 0.95.
So that accent test is really horrible.
Don't use it.
Just because somebody has a heavy accent doesn't mean they're a vampire.
In fact, most vampires have worked very hard on their accent, as I mentioned before.
All right, so now we know that we're still going to pick the shadow test as our first go.
So that's good.
Now, let's see if we can repeat the exercise with our second selection, the one we have to have to pick those guys apart.
And this is going to be easier, because there are fewer things to work with.
Ooh, wow, look.
That's 0.
That's 0.
That's 1/2.
That's 1/2.
So the disorder of this guy is 0.0.
So this is 1/4, 1/4, 1/2, 0, 0.
1/2 times 1.
Ooh, that's 0.5.
That was easy.
How about this one?
Oh, he says 1.
Let's see.
That's 1.
That's 1.
That's 1/2.
That's 1/2.
Yeah, it is one.
So sure enough, the answer also comes out to be the same as before, when we did our just simple intuition exercise.
So I don't know.
Christopher, is this all about using information theory?
STUDENT: No.
PATRICK WINSTON: No, no, no.
See, it's not about the math.
It's about the intuition.
And the intuition is that you want to build a tree that's as simple as possible.
And you can build a tree that's as simple as possible if you look at the data, and say, well, which test does the best job of splitting things up?
Which test does the best job of building subsets underneath it that are as homogeneous as possible?

OK?
It's not about information theory.
It's about a sound intuition.
Oh, by the way.
Does this kind of stuff ever get used in practice?
10s of thousands of times.
This is a winning mechanism that's used over and over again, even when the data is numeric.
How would it work if it's numeric data?
Well, let's think about that for a little bit.
So let's suppose that we have an opportunity.
We're an EMT or something, we work in the infirmary.
What do they call it these days?
Something else.
But anyhow, you work in that kind of area, and you have the opportunity to take people's temperature.
And so over time, you've accumulated some data on the temperature of people.
And maybe you've found that there's a vampire here at about 102.
There's a normal person here, about 98.6.
But then they're scattered around.
Some people have fevers when they come in.
So the question is, is there a way of using numerical data-- things that you can put real numbers-- is there a way of using that with this mechanism?
And the answer is yes.
You just say, is the temperature greater than or less than some threshold?
And that gives you a test, a binary test, just like any of these other tests.
[? Krishna? ?] Right?
But where would I put the threshold?
I suppose I could just put it at the average value.
But that might not be the place that does the best job of splitting the samples into homogeneous groups.
Christopher?
STUDENT: So you run this numerical analysis on different places with different thresholds.
PATRICK WINSTON: So you try different places, he says.
And he's right.
Because this is a computer, this is our slave.
We don't care how much it works to figure out the right threshold.
So what we do is we say, well, maybe the threshold's halfway between those two guys, or halfway between those two guys, or those two guys, or those two guys, or those two guys.
So we can try one less threshold than we have samples.
And we don't care if there are 10,000 samples, because this is a computer, and we don't care if it works all night.
So that's how you find the threshold for a numeric test.
By the way, I assured you earlier on you would never use the same test twice.
Is that true for this?
Yes, you would still never use the same test twice.
But what you might do is you might use a different threshold on the same measurement the next time around.
So when you start having numerical data, you may find yourself using the same test with the same axis but with a different value.
All right.
So now that we have this, then we can go back and compare how this method would look when we put it up against the sort of stuff we were talking about last time, with the electrical covers.
So with the electrical covers, we had a situation like this.
I don't know.
We had samples that were places like this, and we had a division of the space that look pretty much like that.
Not quite exactly in the right spots, but pretty close.
So these are the decision boundaries for the situation where we are using nearest neighbors to divide up the data.
What would the decision boundaries look like if these were four different kinds of things, and we were using this kind of mechanism?
And maybe there's a lot of samples all clustered around places like that.
What would the decision boundaries look like?
Would they be the same as this?
god, I hope not.
Why?
Because what we're going to do is we're going to use a threshold on each axis.
So therefore, the decision boundaries are going to be parallel to one axis or the other.
So we might decide, for example-- Oh, shoot.
I think I'll draw it again, because it'll get confused if I draw it over the other one.
So it looks like this.
And that's how nearest neighbors does it.
But a identification tree approach will pick a threshold along one axis or the other.
Let's say it's this axis.
It's only got one choice there.
So it's going to put a line there.
And now, what's the next thing it does?
Well, it still has these two different kinds of things to separate.
We're going to assume we've got four different kinds of things.
So it's going to say, oh!
I've Come down the negative side, so I need a threshold on the remaining data.
And these are the only two things that are now remaining.
So my only choice is to put a threshold in there.
Now I guarantee this, absolutely guaranteed-- on the quiz, somebody-- presumably somebody who doesn't go to lectures-- will draw that line all the way across.
And that's desperately wrong.
Because we've already divided this data set in half.
Now the choice of what we do over here is governed only by the remaining samples that we see, these two.
And so the threshold is going to go in there like that.
So that's what happens when you go back.
This is used 10s of thousands of times.
Always used.
What are the virtues of it?
Number one, you don't use all the tests.
You use only the test that seem to be doing some useful work for you.
So that means that you do a better job, because your measurement technique is simpler.
And it costs less, because you're not going to the expense of doing all of the testing.
So it's a real winner.
But you know what?
Some classes of people-- not scientists, but I mean people like doctors and stuff.
They don't like to look at these tress.
They're kind of rule-oriented.
So they look a tree like this for determining what kind of thyroid disease you have, and it would have maybe 20 or so tests in it of various kinds of hormones, like thyroxine and this and that.
And they say, ah, we can't deal with that.
So we have to work with them.
So what we do is we convert the tree into a set of rules.
How do we convert the tree into a set of rules?
Oops, wrong one.

Here's what I want.
Yeah, good.
How would we convert this tree into a set of rules?
It's straightforward.
[INAUDIBLE], what do we do?
STUDENT: You'd basically just look down each branch-- PATRICK WINSTON: You'd basically just go down each branch to a leaf.
So you say, for example, here's one rule.
If shadow equals question mark, and garlic equals oh, [INAUDIBLE] want to choose No.
Doesn't eat garlic.
No.
I think I'll say Yes.
Yes.
That changes the answer.
Then if it eats garlic, it's not a vampire, right?
That's one of four possible rules, because there are four leaf nodes.
Now, almost done.
We are done, except for one thing.
We can actually take these four rules, and start thinking about how to simplify them.
You can ask questions like, if I have a rule that tests both the shadow and the garlic, do I actually need both of those antecedents?
And the answer is, in many cases, no.
And in particular, in this case, no.
Because if we look at our data set, what we discover is that in the event that we're talking about a shadow question mark-- oh, I guess I had a better choice the other way.
Oh, no.
If you look at the garlic, all the garlics-- Yes, Yes, and Yes-- it turns out that the answer is no, independent of what the shadow condition is.
So we can look at the rules, and in some cases, we'll discover that our tree is a little bit more complicated than it needs to be.
We can actually get rid of some of the clauses.
So in the end, we can develop a very simple mechanism based on good old fashioned rule-based behavior, like you saw almost in the beginning of the subject, that does the job.
And now, without any royalty, you're all free to put this in your PDA and use it to protect yourself in the days to com, especially since Halloween's just around the corner.


{% extends 'flamingo/base.html' %} {% block content %}
ERROR(S):
- {{ error }}
Cancel Save Changes
Are you sure you want to add this course?


Responsive page
Title
English texts for beginners to practice reading and
comprehension online and for free. Practicing your
comprehension of written English.
Title
English texts for beginners to practice reading and
comprehension online and for free. Practicing your
comprehension of written English.
Title
English texts for beginners to practice reading and
comprehension online and for free. Practicing your
comprehension of written English.


Vaping can be defined as the act of inhaling water vapor through a personal vaporizer (the vaper’s
tobacco-free version of the traditional cigarette).
Vaping is an alternative to smoking.
In short, vaping is the name given to the use of a vaporizer. The process involves applying heat to a liquid
which generates vapor. The user, called a vaper (smoker in traditional cigarette circles) gets their nicotine
hit through inhaling the almost odorless vapor (smoking equivalent of ‘smoke’).


The Modern MERN Stack Developer's Platform
MERN Stack Boilerplate provides starter kits for building web, desktop and mobile apps in pure JavaScript. MERN Documentation.
npx create-mernjs-app my_new_app
MERN Stack Boilerplate provides starter kits for building web, desktop and mobile apps in pure JavaScript..
MERN Stack Boilerplate allows you to create a new MERN app within seconds. It is officially maintained by the creators of MERN Stack Boilerplate
Before downloading the source code, go over the official documentation of NodeJs, ExpressJs, ReactJs, NextJs, React Native and MongoDB then continue with the MERN Documentation.
©2021 MERN Stack Boilerplate


Meal-sharing
Meals
Reservations
Reviews
Log in
Sign up
Search
Latest meals
5 Bean Chili Stew
Recipe by Mario
Most Popular
Load more


Address:00177 Rome, Italy
Email<EMAIL_ADDRESS>Phone: (0039)<PHONE_NUMBER>
Nationality: Italian
I'm a curious and creative person. I have been working in the game industry since 2012, starting as an artist and later becoming a programmer. Because of that, I have an eye for details and enjoy finding creative solutions to problems. In my spare time, I like to contribute to open-source projects on GitHub to improve my programming skills. I'm also a Game Jam enthusiast, having made more than two dozen games in these events.
Game Programmer (Unity) at Digitalmoka
June 2022 - Present
Working on card games for iOS and Android licensed by Dal Negro.
Game Programmer (Unity) at Third Kind Games
March 2020 - March 2022
Working on Blankos: Block Party, a MMO where you collect and create custom characters based on toy figurines. I mainly focused on UI and audio implementation.
Teacher, Tutor and Tools Programmer at Accademia Italiana Videogiochi
October 2018 - September 2019
Teaching history of Videogames, Lua scripting and Unreal Engine. Worked individually with more than 80 students between two different courses.
Lead Programmer (Unity) at 101%
November 2015 - July 2017
Worked on Fury Roads Survivor (6+ million downloads on iOS/Android), Lino Freddolino (Poste Italiane), Platform Discovery (Eni).
Unity Developer at IV Productions
January 2015 - July 2015
Worked on Audio Rally Racing for PC/Mac/iOS and Riot Civil Unrest.
Unity Developer at redBit Games
November 2013 - April 2014
Worked on 3 advert-games with Unity: Advent Calendar 2013, Easter Calendar 2014, Caxi & Roll. 2+ million downloads on iOS/Android.
Freelance Developer & Public Speaker
2012 - Present
Clients: Philip Morris Italy, Interactive Project, Gamepix,
Canvace, Just Funny Games, Lisari.
Been a speaker a Codemotion Rome, LEVEL UP,
GameRome
and Facebook
Developer Group.
Game Programming Course, Accademia Italiana Videogiochi
2017 - 2018
Low-level Game Programming with C, C++ and GLSL. Fundamentals of OpenGL, Unreal Engine 4, Arduino, Python, Lua.
3D Graphics Course, Accademia Italiana Videogiochi
2011 - 2013
Realtime 3D Graphics with Maya, Mudbox, Photoshop, ZBrush.
Unity Certified Developer
2017 - 2019
Certificate ID: 201708UCD2713.


Home
New Page
Example page
This page exists to demonstrate the barebones code of a new page in Kickstrap.
© Global Top Media BV
Powered by
Kickstrap


SAMPLE Header Text
Info
Products
Contact us
Extra
H2 in hgroup
H3 in hgroup
MTB
First content
Second content
third content


MODEL UNITED NATIONS
POINTS SYSTEM
Country
Motion
Points
MADE BY TANEISHQ MUHUNTHAN
HEAD OF INFORMATION TECHNOLOGY


Train Scheduler!
Current Train Schedule
Train Name
Destination
Frequency (min)
Next Arrival
Minutes Away
Name
Age
Email
Comment
Submit
Add Train
Train Name
Destination
First Train Time (HH:mm - military time)
Frequency (min)
Submit


We rented an RV.
We pointed its nose east.
We drove.
We saw the world's largest Yo-Yo and a statue of Kevin Costner carved out of a single log.
It was wonderful.
The next year, we had no bachelor party to plan. Then we realized we didn't need an excuse for an awesome roadtrip with friends!
The annual RV trip was born.
Every year we discuss how to make the RV Trip even more fun. This year our big experiment is multiple RVs.
Before, attendance was limited by the number of people we could legally cram into an RV. This year, we’re opening up the headcount for everyone who wants to join the adventure.
We'll rent as many RVs as we need.
The nature of the RV Trip makes it hard to give a lot of specifics about what we'll be doing. A big part of the fun is to only have some basic ideas of what to do, and even those only get half done. There are some constants though:
Best put, it's a 5-day party bus.
We drink, we play games, we stop at crazy places, we gamble in casinos, we eat at questionable highway restaurants, we swim in strange lakes.
This year, we are pointing the caravan in the general direction of Bend, OR. We're going to punch up to the Bend area the first night, and then spend the rest of the days exploring all sorts of places in that part of the state.
On average, past RV Trips have cost about $600 per person for everything. This includes all food for 5 days, the RV rental, gas, activities, etc etc.
This year, we're requiring everyone to kick in a non-refundable deposit of $200. This is to ensure we are getting an accurate headcount of attendees so we can plan logistics, rent RVs well in advance, etc.
Send the deposit to Greg. Deposits will be tracked in the group Splitwise along with all other RV Trip expneses so we can easily settle up after the trip is over.
We leave on October 4th and return late on October 8th. You'll need Wed-Fri off work.


Young Andee was foolish enough to believe she would be happy at a standard 9-5 job. So much other time to do things! Many cats on the internet to see!
Andee codes on the job for the first time ever and discovers she likes it! How can this be?
After careful contemplation and research, Andee decides to switch into Computer Science!
Andee manages Microsoft's Partner Program, working with interal and external teams (marketing & operations, legal, and privacy) to deliver a better Partner experience.
Andee builds tools to help measure campaign effectiveness, and display collected data in a user friendly manner.
Andee delves into the product management: designing simple, clean interfaces for all types of users, collaborating with engineering teams to build and ship products, analyzing features use and investigating potential features and managing the entire product cycle (design/build/test/release).
Andee and Xenia build pocketKevinLau for Kevin's birthday, modelled after his AMAZING catchphrase.
Andee helps build features for EmoDB, an open source database built on Apache Cassandra. Andee also helps build EMOtions, a GUI to access EmoDB, which had previously only been available via CLI.
Led, motivated and aided first years in Math Orientation activities. Enabled first year and upper year bonding.
Imagined, planned and directed exciting and engaging Math Orientation events.
Lead Math Orientation vision, manage event risk profiles and allocated funds and resources to ensure event success.


PLANET SICK-BOY: http://www.sick-boy.com "We Put the SIN in Cinema"
Call it The Full Monty 2. You can even call it Rocky VI - I don't really care. Billy Elliot is the `Feel Good Movie of the Year' in a time when four of the last five Best Picture winners featured main characters that died in the final reel.
While Elliot's story isn't particularly groundbreaking, the film manages to avoid the gimmicky devices and relentless button-pushing that usually derail FGMOTY wannabes. Instead, it relies on terrific acting performances, highlighted by 13-year-old newcomer Jamie Bell, who plays the titular Elliot. I haven't found myself rooting for a character this fiercely in a long, long time, and if this film doesn't put a smile on your face and a lump in your throat, there's something very wrong with you.
Elliot is set in a small town in northeast England during a coal miners' strike in 1984. The film opens with 11-year-old Billy jumping up and down on his bed to his brother's record collection (the soundtrack is loaded with T-Rex tunes). Billy shares his bedroom with older brother Tony (Jamie Draven), who, like their father (Gary Lewis, East is East), spends his time on the picket line throwing produce at the scabs who have taken their jobs.
Although money is tight, Billy's father gives him a stipend for weekly boxing lessons. He's awful at it, and one night after practice, Billy sticks around and watches a group of young girls learn ballet. Infatuated by the dancing, Billy joins in and finds that he's quite good at it, despite worrying that he'll become `a right sissy.' The teacher, Mrs. Wilkinson (Julie Walters, Titanic Town), is a crass, chain-smoking teacher who could be a cousin to Brenda Blethyn's character in Little Voice, but she recognizes Billy's talent and suddenly finds herself with a new interest in her work.
The rest of the film follows a fairly predictable trajectory, with Billy struggling to perfect his craft for an audition at the Royal Ballet School in London. Mrs. Wilkinson becomes somewhat of a mother figure to him, and his father and brother hit the roof when they find out that their own blood is dabbling in poofy dancing (these are the kind of blue-collar Englishmen that think Mikhail Barishnikov is a striker for Dynamo Kiev).
The film does have a couple of minor hitches, like the inclusion of a subplot featuring Billy's cross-dressing best friend (Stuart Wells, in his film debut) and the failure to beef up the sweet but neglected subplot involving Billy and Mrs. Wilkinson's daughter, Debbie (Nicola Blackwell –a dead ringer for Patricia Clarkson). But the picture is held together by a truly inspirational performance from young Bell, who does an extremely good job of towing the delicate line between childhood and adulthood.
Elliot is the feature film directorial debut of Stephen Daldry, whose short film Eight was nominated for a British Academy Award in 1998. The script was written by Lee Hall, who is also making his feature film debut with this film festival favorite that has fared well in the early rounds of year-end accolades. Comparisons to the out-of-left-field hit The Full Monty are going to be inevitable, as each film features working-class stiffs who become unlikely local heroes. And I wouldn't be surprised to see Elliot land a Monty-esque load of Oscar nominations, either.
1:48 – R for adult language, violence and underage drinking
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


Overview User interface Main window Menu ↑ |
Features for coarse-grained structural dynamics are currently under development. They are not included in public release of MMM 2010. The corresponding menu items are thus disabled.
Computes a residue-level Gaussian network model with nodes at coordinates of the Cα atoms. Dependence of force constants on Cα-Cα distance is optimized for obtaining good agreement of computed and experimental B factors and for providing a well resolved covariance matrix.
On 32-bit Matlab, the structure must not have more than 3600 residues. Network computation may take minutes for large protein complexes. Computation time scales with the cube of the number of residues.
See GNM window for further information.
Computes a residue-level anisotropic network model with nodes at coordinates of the Cα atoms. Dependence of force constants on Cα-Cα distance is optimized for obtaining a good description of large-scale domain movements.
On 32-bit Matlab, the structure must not have more than 1200 residues. Network computation may take tens of minutes for large protein complexes. Computation time scales with the cube of the number of residues.
See ANM window for further information.


Reactor Core is a succinct and powerful foundational library for building reactive and efficient applications on the JVM. More detailed documentation is available on the reference guide.


Hook up a MIDI controller and reload the page. If you get no alerts: you're good to go, go start playing and slide some sliders and tweak some knobs on your controller, see what happens! Don't see anything happen when you slide those faders or twist those pots? Click on a slider's label to teach it to listen to your controller instead of the default, similar to using "CC learn" in any regular old VST instrument. Then see what happens v2!
Just want to see it play something? Hit the "demo" button and press play. Then start messing around with that, because why wouldn't you?
This "demo" relies on the Web Audio and Web MIDI APIs. The first just lets your browser make sounds. So you can make it generate random noise, or synth your way to a well crafted kick drum, fat snare, or even a ridiculously accurate grand piano sample. In this case, we're modelling a drawbar organ syntehsizer: each note triggers 8 sine oscillators, and each oscillator's gain (loosely, it's volume) is tied to a slider. Slider the slider up, reduce its gain (because that's how real drawbar organs work), slide it all the way down, and get its full effect.
That sounds simple, and it is! There is nothing conceptually hard about a drawbar synth, but implementing one is still tricky (and fun) so I made one so you don't have to, and then hooked it up to the Web MIDI API so that if you have a browser that supports it, you can literally just hook up your MIDI controller, program that to "play stuff", and have it drive this synth. Because again, that's fun!
As little as you'll have heard about it: yes, actually. Web MIDI works out of the box in Chrome, and while Firefox currently requires an extension to work, work is underway to (finally) add Web MIDI support. In the mean time, said extension works just fine.
It's not implemented in Edge, but... I don't know, do we take Edge seriously when it comes to this kind of stuff? I mean, it's a decent browser, some people I respect work on it these days, but it's doesn't strike me as a browser whose team is allowed to put "the cool stuff(tm)" in until all the boring issues have been closed. That said, if you know of a plugin/addon that makes Web MIDI work in Edge, let me know, and I'll add it here!. As for any of the other browsers: no idea! Thankfully, caniuse.com does!
I am down with opinions, shoot me yours on Twitter or Mastodon, but if you have a deeper issue that requires we engage in an actual conversation (say, you find a bug, or have an idea for a feature that'll work well as part of this project, or you have questions about the code or concepts) I would strongly recommend hitting up the github repository, and filing an issue so we can have a solid back-and-forth.
MIT. Most of my small stuff is released as "public domain except in jurisdictions that don't recognize PD, in which case it's MIT" but this was fun to make and I like it enough to keep my name associated with it.
- Pomax


 You could say it was.. hydejacked.
Features
Unlike Hyde, it’s opinionated about how you are going to use it (as a blog!) Features included are:
- Touch-enabled sidebar / drawer for mobile, including fallback when JS is disabled.
- Github Pages compatible tag support based on this post.
- Customizable link color and sidebar image, per-site, per-tag and per-post.
- Optional author section at the bottom of each post.
- Posts grouped by year on front and tag page.
- Social media icons (github, twitter) on sidebar.
- Optional comment section powered by Disqus.
- Math blocks via KaTeX.
Download
Hydejack is developed on and hosted with GitHub. Head to the GitHub repository for downloads, bug reports, and feature requests.
Sidebar
I love the original Hyde theme, but unfortunately the layout isn’t as great on small screens. Since the sidebar moves to the top, the user has to scroll just to read the title of a blog post.
By using a drawer component I was able to retain the original two column layout. It’s possible to move the drawer via touch input (with the help of a little JavaScript).
Since the background image contributes to the feel of the page I’m letting it peek over the edge a bit. This also provides a hint to the user that an interaction is possible.
Preview
Manual
Configuration
You can configure important aspects of the theme via _config.yml
. This includes:
- the blog description in the sidebar
- the (optional) author description and photo
- default image and link color of the blog
- the github and twitter usernames
How to Change the Image and Color of a Post
In the manifest of a blog post, simply add an url as image
and a CSS color as color
:
layout: post
title: Introducing Hydejack
image: http://qwtel.com/hydejack/public/img/hyde.jpg
color: '#949667'
How to Add a New Tag
Tags are not meant to be used #instagram #style: #food #goodfood #happy #happylife #didimentionfood #yougetthepoint, as each tag requires some setup work. I tend to think of it as categories that can be combined.
-
Add an entry to
_data/tags.yml
, where the key represents a slug and provide at least aname
value and optionallyimage
,color
anddescription
.Example
/_data/tags.yml
:mytag: name: My Tag
-
Make a new file in the
tag
folder, using the same name you’ve used as the key / slug and change thetag
andpermalink
entries.Example
/tag/mytag.md
:layout: blog_by_tag tag: mytag permalink: /tag/mytag/
-
Tag your blog posts using the
tags
key (color and image will only depend on the first tag).layout: post title: Introducing My New Tag tags: [mytag, othertag]
-
(optional) Add the tag to the sidebar, by adding it to
sidebar_tags
in_config.yml
. They will appear in the listed order.sidebar_tags: [mytag, othertag]


{% extends "personal/header.html" %} {% block content %}
Hello this is Free Pet project, feel free to join our worldwide community!