"The image is more a way to understand how the seed is written with this number."
second chain is mirrored ... so this is how the seed is written related i think ...
but no problem to check with 6 or 12 blocks per 14 digits each ...
linuxcaptain04-Feb-19 02:19 PM
b1 b2 b3 b4 b5 b6 b7 b7 b6 b5 b4 b3 b2 b1 separated with phi or φ is the right form i think and each block has 6 or 7digits.. but .. lets wait for the next hint
Decker04-Feb-19 02:24 PM
i guess we miss something ...
third hint needed )
1
but don't say me that first chain is a [1] line of passphrase and second chain is a [2] line )
otherwise i will visit puzzle creator and dismantle "enter" button from his keyboard forever )(edited)
4
1
linuxcaptain04-Feb-19 02:29 PM
Decker04-Feb-19 02:36 PM
also may be we misunderstood "mirroring" ... for example:
618033
mirrored can be 330816 ... but may be also something like 10-n ... 770294 ...
need to look on screen once again ... how chains mirrored ...
finished to brute [0..9][0..9][0..9][0..9][0..9][0..9] + mirrored ... wrong ))
In geometry, a golden spiral is a logarithmic spiral whose growth factor is φ, the golden ratio. That is, a golden spiral gets wider (or further from its origin) by a factor of φ for every quarter turn it makes.
i try to combine it in a way of a golden spiral but i cant think a way now...
Decker04-Feb-19 03:41 PM
we also can count golden ratio for fibonacci numbers if we want )))))))(edited)
we can everything ))))))
linuxcaptain04-Feb-19 03:44 PM
yes.. thats a part of the theory of the fib series.. the ratio oscillates around the golden ratio..
Decker04-Feb-19 03:46 PM
Most important question - each block is a one digit or group of digits ...
ca33304-Feb-19 03:46 PM
@Decker i will be "free" (gonna make a little break) in ~1.5 - 2h - if you want lets team up (if anyone else wants to team up ping me).
have you tried using PHI as the connector?
1
which connects both sequences/block"rows"
Decker04-Feb-19 03:47 PM
i think template is φb1b2b3b4b5b6b7b7b6b5b4b3b2b1φ ...
ca33304-Feb-19 03:47 PM
also replacing PHI with its numerical constant?
just thinking out loud.
Decker04-Feb-19 03:47 PM
remains only one thing ... understand what is each Bn ...
probably i will leave PC for next 2-3 hours ... but when i return ... ))
2
ca33304-Feb-19 03:50 PM
we need to keep those puzzles for weekends @sφldat or no one s gonna work!
Fourth Hint: The title of one of Max Linder's films gives the number of digits included in each block.
The passphrase does not contain any letters except φ
Novo04-Feb-19 05:52 PM
is interest claimable on ledger with this new update?
cryptocat04-Feb-19 05:57 PM
Max Linder's films with numbers in the title:
- 1: One Can't Believe One's Eyes
- 2: Two Great Griefs
- 3: The Three Must-Get-Theres
- 7: Seven Years Bad Luck
- 10: Ten Wives for One Husband


Leaflet Plugin using PTV xServer JSON Services
General
Documentation
The documentation can be found
here
.
Demos
An
Leaflet
demo using the PTV xMap Client is available
here
.


Using allocators with Gecode
[Memory management]
Classes | |
| struct | Gecode::space_allocator< T > |
| Allocator that allocates memory from a space heap. More... | |
| struct | Gecode::region_allocator< T > |
| Allocator that allocates memory from a region. More... |
Detailed Description
Gecode provides two allocator classes that can be used with generic data structures such as those of the STL (e.g. std::set
). Memory can be allocated from the space heap (see Space) or from a region (see Region).
Using allocators with dynamic data structures
There are two possible scenarios for allocator usage. One is to let the dynamic data structure allocate memory from the space or region:
struct MySpace : public Space { typedef std::set<int, std::less<int>, Gecode::space_allocator<int> > S; S safe_set; MySpace(void) : safe_set(S::key_compare(), S::allocator_type(*this)) {} MySpace(bool share, MySpace& other) : Space(share, other), safe_set(other.safe_set.begin(), other.safe_set.end(), S::key_compare(), S::allocator_type(*this)) {} ... };
In this example, S is a set that allocates its nodes from the space heap. Note that we pass an instance of space_allocator bound to this space to the constructor of the set. A similar thing must be done in the copying constructor, where we must be sure to pass an allocator that allocates memory from the destination ("this") space, not "other". Note that the set itself is a member of MySpace, so it is destroyed within MySpace::~MySpace as usual. The set destructor destroys all contained items and deallocates all nodes in its destructors.
Preventing unnecessary destruction overhead
In the above example, we know that the value type in S is a builtin type and does not have a destructor. So what happens during safe_set destruction is that it just deallocates all nodes. However, we know that all nodes were allocated from the space heap, which is going to disappear with the space anyway. If we prevent calling safe_set destructor, we may save a significant amount of time during space destruction. A safe way of doing this is to allocate the set object itself on the space heap, and keep only a reference to it as a member of the space. We can use the convenience helpers Space::construct for the construction.
struct MySpace : public Space { typedef std::set<int, std::less<int>, Gecode::space_allocator<int> > S; S& fast_set; MySpace(void) : fast_set(construct<S>(S::key_compare(), S::allocator_type(*this))) {} MySpace(bool share, MySpace& other) : Space(share, other), fast_set(construct<S>(other.safe_set.begin(), other.safe_set.end(), S::key_compare(), S::allocator_type(*this))) {} ... };
Region example
The above examples were using a space_allocator. A region_allocator works similarly, one just should keep in mind that regions never really release any memory. Similar to Space, Region provides helper functions Region::construct to make non-stack allocation easy.
Space& home = ...; typedef std::set<int, std::less<int>, Gecode::region_allocator<int> > SR; // Create a set with the region allocator. Note that the set destructor is still quite costly... { Region r(home); SR r_safe_set(SR::key_compare(), (SR::allocator_type(r))); for(int i=0; i<10000; ++i) r_safe_set.insert(i*75321%10000); } // Create a set directly in the region (not on the stack). No destructors will be called. { Region r(*this); SR& r_fast_set=r.construct<SR>(SR::key_compare(), SR::allocator_type(r)); for(int i=0; i<10000; ++i) r_fast_set.insert(i*75321%10000); }


Pearson
Course Title
Grade
Grade Item Title
Letter Grade: A
Numeric Grade: 10/10
Comments:
Friendly Date
View All Course Grades


Make sure to include keywords in your bower.json as the search will make use of those.
Loading components...


Basic Usage¶
This section is about basic iocage usage and is meant as a “how-to” reference for new users.
Tip
Remember, command line help is always available by typing iocage --help or iocage [subcommand] --help.
iocage has a basic “flow” when first used. As a new user interacts with iocage for the first time, this flow guides them through initializing iocage, then interacting with newly created jails.
Tip
iocage has an experimental “color” mode enabled by setting the environment variable IOCAGE_COLOR to TRUE.
Setting Environment Variables¶
iocage currently has four environment variables:
Name |
Accepted Values |
Description |
IOCAGE_LOGFILE |
FILE |
File location to have iocage log into. |
IOCAGE_COLOR |
TRUE|FALSE |
Turns on a colored CLI output. |
IOCAGE_FORCE |
TRUE|FALSE |
Required for any automatic migrations |
IOCAGE_PLUGIN_IP |
IP_ADDR |
This environment variable is set in a plugin jail. Use it to quickly query it with another program/script |
The process for setting these variables depends on the shell being used. The defualt FreeBSD shell csh/tcsh and the bash/sh shell are different from one another and require a slightly different process for setting environment variables. For example:
In the FreeBSD shell csh/tcsh , setenv IOCAGE_COLOR TRUE
sets the environment variable IOCAGE_COLOR to true.
In the bash/sh shell, export IOCAGE_COLOR=TRUE
sets
the environment variable IOCAGE_COLOR to true.
Activate iocage¶
Before iocage is functional, it needs to activate. Essentially, iocage needs to link with a usable zpool. In most cases, activation is automatic to the primary system zpool, but more advanced users can use iocage activate to designate a different zpool for iocage usage.
Once iocage is ready with an active zpool, users are able to immediately begin downloading FreeBSD releases for jail creation.
Fetch a Release¶
iocage now needs to fetch a RELEASE, which is used to create jails. By default, typing iocage fetch opens a menu for the user to choose which release to download, as seen in this example:
# iocage fetch
[0] 9.3-RELEASE (EOL)
[1] 10.1-RELEASE (EOL)
[2] 10.2-RELEASE (EOL)
[3] 10.3-RELEASE
[4] 11.0-RELEASE
Type the number of the desired RELEASE
Press [Enter] to fetch the default selection: (11.0-RELEASE)
Type EXIT to quit: 4
Once the desired RELEASE is downloaded, the most recent patches are also applied to it.
iocage fetch also has a number of options and properties for users to fine-tune the functionality of the command.
To fetch the latest RELEASE,
iocage fetch -r LATEST
If a specific RELEASE is required, use the -r option:
iocage fetch -r [11.0-RELEASE]
If a specific download mirror is required, use the -s option:
iocage fetch -s [ftp.hostname.org]
fetch can also pull from a specific ftp directory, using the -d option:
iocage fetch -d [dir/]
Create a Jail¶
With a release downloaded, iocage is now able to create jails. There are two types of jails: normal and base. More details about these jail types can be found in the Jail Types section of this documentation.
Depending on the user’s requirements, the create subcommand can be adjusted to create either jail type. By default, iocage create creates a normal jail, but invoking the -b option changes the creation to the basejail type. iocage is able to create a jail with the latest release by adding LATEST to the create command.
Here is an example of creating a normal jail from the latest available release:
# iocage create -r LATEST -n [JAIL]
This creates a normal jail that is a clone of the latest release.
Here is an example of creating a normal jail from the 11.0-RELEASE:
# iocage create -r 11.0-RELEASE
This normal jail is a clone of the specified RELEASE.
To create multiple jails, use the -c option:
# iocage create -r 11.0-RELEASE -c 2
This example shows the numeric value after the -c flag is used to designate the number of jails to create. In the above example, two jails are created.
A simple basejail is created with the -b option:
iocage create -b -r [RELEASE]
After designating the type and number of jails to create with the option flags, specific jail properties can also be set. For example:
# iocage create -r 11.0-RELEASE --name myjail boot=on
Creates a FreeBSD 11.0-RELEASE jail with the custom name myjail and sets the jail to start at system boot time.
More information about jail properties is available in the iocage(8) FreeBSD manual page, accessible on a FreeBSD system by typing man iocage.
Listing Jails¶
To list all jails, use iocage list
To see all downloaded RELEASEs, use iocage list -r
View available templates with iocage list -t
Start, Stop, or Restart a Jail¶
Jails can be started, stopped, or restarted at any time. By default, new jails are in a down (stopped) state. To see the status of all jails, use iocage list and read the STATE column.
Use each jail’s UUID or custom NAME to start, stop, or restart it. Partial entries are acceptable, as long as the given characters are enough to identify the desired jail. Alternately, use ALL to apply the command to all created jails.
Tip
Partial entries can also be supplied for any other iocage operation or subcommand.
Start¶
Use iocage start to start jails.
Examples:
Start a jail with the custom name www01:
iocage start www01
.
If no custom NAME or UUID is provided by the user, iocage automatically assigns a complex UUID to a new jail. This UUID is always usable when doing iocage operations like starting a jail:
# iocage start 26e8e027-f00c-11e4-8f7f-3c970e80eb61
Partial entries are also acceptable:
# iocaget start www
# iocage start 26e8
Stop¶
iocage stop uses the same syntax as iocage start.
Examples:
# iocage stop www01
# iocage stop 26e8e027-f00c-11e4-8f7f-3c970e80eb61
# iocage stop 26e8
Restart¶
iocage restart also uses the same syntax as start and stop:
# iocage restart www01
# iocage restart 26e8e027-f00c-11e4-8f7f-3c970e80eb61
# iocage restart 26e8
Configure a Jail¶
Configuring the properties of an already created jail is best done with the set and get subcommands. Be sure to provide the NAME or UUID of the desired jail when using these subcommands.
Set Jail Property¶
iocage uses the set subcommand to configure jail properties.
To assign a custom note to a jail with the notes property:
# iocage set notes="This is a test jail." 26e8e027
The full list of jail properties is available in the iocage(8) manual page PROPERTIES section.
Get Jail Property¶
To view a specific jail property, use the get subcommand:
# iocage get notes 26e8e027
Destroy a Jail¶
Destroy a specific jail using the destroy subcommand:
# iocage destroy www02
Warning
This irreversibly destroys the jail!
Rename a Jail¶
iocage allows jails to be renamed after creation and/or migration. The iocage rename subcommand is used to alter an existing jail’s UUID or NAME. Type the command, then the UUID or name of the jail to be altered, then the desired name. This example shows using the rename subcommand:
# iocage rename jail1 TESTINGJAIL


Do you know that Colourworx can offer products such as customised wall paper? To find out more about this and similar products, please click here.
Do you know the difference between W type and P type metals? Would you like to know more about the wonderful metal substrates in stock at Colourworx? To find out more, click here.


ppmtouil(1) ppmtouil(1) NAME ppmtouil - convert a portable pixmap into a Motif UIL icon file SYNOPSIS ppmtouil [-name uilname] [ppmfile] DESCRIPTION Reads a portable pixmap as input. Produces a Motif UIL icon file as out‐ put. If the program was compiled with an rgb database specified, and a RGB value from the ppm input matches a RGB value from the database, then the corresponding color name mnemonic is printed in the UIL's colormap. If no rgb database was compiled in, or if the RGB values don't match, then the color will be printed with the #RGB, #RRGGBB, #RRRGGGBBB, or #RRRRGGGGBBBB hexadecimal format. OPTIONS -name Allows you to specify the prefix string which is printed in the resulting UIL output. If not specified, will default to the file‐ name (without extension) of the ppmfile argument. If -name is not specified and no ppmfile is specified (i.e. piped input), the pre‐ fix string will default to the string "noname". All flags can be abbreviated to their shortest unique prefix. SEE ALSO ppm(5) AUTHOR Converted by Jef Poskanzer from ppmtoxpm.c, which is Copyright (C) 1990 by Mark W. Snitily 31 August 1990 ppmtouil(1)


--- categories: [] date: 2012-03-28T07:27:59Z status: publish tags: [] title: Christine Blower - "teachers are being taxed" layout: post url: /2012/03/28/206/ ---
Teachers will have to contribute 50% more to their pensions over the next three years at a time when top earners can look forward to a cut in the 50p top rate of tax, said Blower.
http://www.guardian.co.uk/politics/2012/mar/28/education-system-privatised-2015-union?newsfeed=true


From here you can store and fetch positions from the browsers local storage. This storage persists between sessions.


To follow the trail means to continue to discover and explore what lies ahead.
Wherever I am, I love to hike and explore different areas on foot. This webite shows some of my most favorite spots that
are on and off the trail. Come follow the trail with me!


class: center, middle ### W4995 Applied Machine Learning # Clustering and Mixture Models 04/06/20 Andreas C. Müller ??? Today we're gonna talk about clustering and mixture models, mostly clustering algorithms. FIXME: 'real world' examples? Usecases, better motivation? FIXME: illustration of Kmeans++ FIXME: linkage explanation diagram FIXME: cluster sized in particularly good for dbscan (what did I mean?) debugging (what did I mean?!) --- class: center, middle # Clustering ??? --- .center[ ![:scale 70%](images/cluster_intro_1.png) ] ??? The ideas is that you start out with a bunch of data points, and the assumption is that they fall into groups or clusters, and the goal is to discover these underlying groups. --- .center[ ![:scale 70%](images/cluster_intro_2.png) ] ??? For example you want to find that these points belong to the same groups, and these, and these. --- .center[ ![:scale 70%](images/cluster_intro_3.png) ] ??? Usually the clusters are identified by a cluster label or cluster indicator, though these numbers are arbitrary. What you care about is which points belong to the same cluster. So I could relabel the clusters and this would still be considered the same clustering. What we're really interested in is the partitioning of the data, though the way it's implemented in the scikit-learn API is that you predict an integer for each data point, so the clusters are numbered 0.. n_clusters -1. So we'd label these points with 0, these with one, and so on. But you should keep in mind that the number themselves have no meaning, renumbering the clusters corresponds to the same clustering. We're really only interested in which points have the same labels and which points have different labels. --- class: spacious # Clustering - Partition data into groups (clusters) - Points within a cluster should be “similar”. - Points in different cluster should be “different”. ??? So you want to partition the data, so that each data point belongs to exactly one of the groups. And you want to define groups such that points in the same cluster are similar, and points in different clusters are different. And the different algorithms define how they measure similarity in different ways. - Number of clusters might be pre-specified. - Notations of “similar” and “different” depend on algorithm or user specified metrics. - Identify groups by assigning “cluster labels” to each data point. FIXME! --- .center[ ![:scale 70%](images/cluster_intro_3.png) ] ??? The cluster algorithms have many parameters, and one of the most common ones is the number of clusters. In this dataset I drew here, it's quite obvious that there are three groups, and if it's this obvious there is usually a way to figure out how many groups there are. But for many algorithms, you need to specify the number of groups in advance. --- .center[ ![:scale 70%](images/cluster_intro_4.png) ] ??? Group into 4 clusters If you misspecify the number of groups you'd get something like this. To pick the number of clusters, in general you either need to have some prior knowledge about the data, or you need to inspect the results manually to see if the parameters are good. Often, you don't know the number of clusters, or if there are even clusters in the data. Very rarely is the case as clear as in this example. Still there might be a reasonable grouping, so there is no "right" amount of clusters, but you might still get something out of the clustering. --- # Goals of Clustering - Data Exploration - Are there coherent groups ? - How many groups are there ? ??? So why would we want to use a clustering algorithm? The main usage that I've come across is exporation of the data and understanding the structure of the data. Are there similar groups within the data? What are these? How many are there? You can also use clustering to summarize or compress the data by representing each group by a single prototype, say the center. You can also use clustering if you want to divide your data, for example if you want to know different parts of the dataset behave fundamentally differently, so you could for example cluster a dataset, and then apply, say, a linear model, to each cluster. That would create a more powerfull model than just learning a linear model on the whole dataset. -- - Data Partitioning - Divide data by group before further processing -- - Unsupervised feature extraction - Derive features from clusters or cluster distances ??? Another use is unsupervised feature extraction. You can also use clustering to derive a different representation of the data. An often cited application of clustering is customer segmentation, though I'd say data exploration or feature extraction are more common. -- - Evaluation and parameter tuning - Quantitative measures of limited use - Usually qualitative measures used - Best: downstream tasks - What is your goal? ??? --- class: center, middle # Clustering Algorithms ??? So now let's start discussing some of the standard algorithms. --- class: center, middle # K-Means ??? One of the most basic and most well-known ones is kmeans. Here k stands for the number of clusters you're trying to find. --- # Objective function for K-Means
`$$\Large \min_{\mathbf{c}_j \in \mathbf{R}^p, j=1,..,k} \sum_i ||\mathbf{x}_i - \mathbf{c}_{x_i}||^2 $$` $\mathbf{c}_{x_i}$ is the cluster center $c_j$ closest to $x_i$ ??? - Finds a local minimum of minimizing squared distances (exact solution is NP hard): - New data points can be assigned cluster membership based on existing clusters. Here is what this algorithm optimizes, the objective function. It's the sum of the distances of the cluster centers to all the points in the clusters. So the clusters centers are c_j and we want to find cluster centers such that the sum of the distance of each point to its closest cluster center is minimized. This is an NP hard problem, so we can't really hope to solve it exactly, but we can run the k-means algorithm that we'll discussed, and it will provide us with some local minimum of this objective. --- # K-Means algorithm (Lloyd's) .wide-left-column[ .center[ ![:scale 100%](images/kmeans.png) ] ] .narrow-right-column[ .smaller[ - Pick number of clusters k. - Pick k random points as “cluster center” - While cluster centers change: 1. Assign each data point to it’s closest cluster center 2. Recompute cluster centers as the mean of the assigned points. ] ] ??? The algorithm proceeds like this: you pick the number of clusters k, then you randomly pick k data points from the data, and declare those as cluster centers. Then, you label each data point according to which cluster center it is closest to. Finally, you recompute the cluster centers as the means of the clusters, and you iterate. The algorithm always converges, which is when the assignment of the points to the clusters doesn't change any more. Often you might want to not wait until full convergence, but just stop if the cluster centers don't move much between iterations. So you can see the green cluster center moving towards the red here until it has captured all the points in this group. Questions? Who has seen this before? There's a couple of nice things about this algorithm; It's very easy to write down and understand. Each cluster is represented by a center, which makes things simple, and you can reassign any new point you observe to a cluster by just computing the distances to all the cluster centers. So in this case, if we build a model on some data that we collected, we can easily apply this clustering to new data points. That's not the case for all clustering algorithms. --- # K-Means API .narrow-right-column[ .center[ ![:scale 100%](images/kmeans_api.png) ] ] .wide-left-column[ .smaller[ ```python X, y = make_blobs(centers=4, random_state=1) km = KMeans(n_clusters=5, random_state=0) km.fit(X) print(km.cluster_centers_.shape) print(km.labels_.shape) ``` ``` (5, 2) (100,) ``` ```python # predict is the same as labels_ on training data # but can be applied to new data print(km.predict(X).shape) ``` ``` (100,) ``` ```python plt.scatter(X[:, 0], X[:, 1], c=km.labels_) ``` ] ] ??? In scikit-learn, I’ve made some random data points. I instantiated a KMeans object, passing the number of clusters I want and for reproducibility I set the random state to 0, I implemented fit, and then I inspected some of attributes. So the shape of cluster centers is 5 and 2. Meaning there’s 5 cluster centers in 2-dimensions. The labels are the cluster indices assigned to the data. So there's 100 data points and each of them is assigned an integer from zero to four. KMeans also has a predict method. The predict method computes the cluster labels according to this clustering. So this is a nice property of KMeans that you can assign cluster labels to new data points, via this predict methods. If you call predict method on the training dataset, you get the same thing back that is in labels, which is just a training data labels. But you can also pass in any new data that you observe, and it will assign one of the clusters based on which cluster centers are closest. Q: Why is the centers in two dimensions? Because the input spaces is in two dimensions in this toy dataset. Cluster centers live in the same space as the data. --- # Restriction of Cluster Shapes .left-column[ ![:scale 85%](images/cluster_shapes_1.png) ] .right-column[ ![:scale 100%](images/cluster_shapes_2.png) ] .reset-column[ Clusters are Voronoi-diagrams of centers ] ??? I want to talk about some of the properties and limitations of KMeans. So the cluster shapes, I restricted them in KMeans because they're Voronoi-diagram of the centers. Voronoi-diagrams basically just mean these cells… while the boundary between two neighboring clusters is just the center of the two centers. So given these centers completely define a clustering and so you compute this distance boundaries. The whole clustering is specified just by the cluster centers, but that really restricts the shape. So all of these cells will be convex sets, so you can't have like a banana shape or something like that. That's one of the limitations. - Clusters are always convex in space --- # Limitations of K-Means .center[ ![:scale 60%](images/kmeans_limitations_1.png) ] - Cluster boundaries equidistant to centers ??? You can also not really model the size of centers very well. So here, I have three clusters and this is the result of KMeans on this dataset that I created from three Gaussians. So the Gaussians I used to create this data set was one big blob in the center and one smaller ones in bottom left corner and top right corner. But KMeans wasn't really able to pick up on these three clusters because the boundary between the clusters is the middle between the cluster centers. --- # Limitations of K-Means .center[ ![:scale 60%](images/kmeans_limitations_2.png) ] - Can’t model covariances well ??? It's also not able to capture covariance. So here, for example, there's three groups in this dataset, and KMeans doesn't really pick up on these shapes. --- # Limitations of K-Means .center[ ![:scale 60%](images/kmeans_limitations_3.png) ] - Only simple cluster shapes ??? Since you have only simple cluster shapes, so if I use this two cluster dataset, this will be what KMeans gives me because basically it cannot do anything else but straight lines for two clusters. Even though it has these restrictions it’s still a very commonly used algorithm. And so we'll talk a little bit more about some of the other properties of this algorithm. --- class: spacious # Computational Properties - Naive implementation (Lloyd's): - n_cluster * n_samples distance calculations per iteration ??? The naïve implementation is what I basically talked about, in each iteration it requires you to compute the distance from all data points to all the cluster centers. So you have to do number of clusters times number of samples, many distance calculation per iteration. That's actually if you have many clusters or if you have many features or if you have many samples that can take like a whole bunch of time. -- - Fast "exact" algorithms: - Elkan's, Ying-Yang, ... ??? There's also fast exact algorithms. One of them is implemented in scikit-learn called Elkan’s. Another algorithm is Ying-Yang, which is maybe five years old. There are newer algorithms being developed that uses the triangle inequality to not re-compute all the distances. So basically, in these algorithms you compute the distances between the clusters and if one cluster is far enough from another cluster, the data point that was assigned to the first cluster will not be assigned to the second cluster since the distance between clusters is so big. And so you can use the triangle inequality to save lot of these distance calculations. -- - Approximate algorithms: - minibatch K-Means ???  It’s much much faster than KMeans, but it's an approximation. So here's, saying exact algorithm means exact in the sense, that they are exactly the same as what Lloyd wrote down in the 50s, but not exact as they don’t actually solve the problem. Solving the optimization problem exactly is impossible. So it's not really clear if it's very important how exactly this is as you always just have an approximation so it might be a good idea to give up on trying to do exactly the thing that Lloyd did and something like minibatch KMeans, which can be much, much faster. Q: Do we do feature engineering? Yes, since this is distance space, scaling is clearly important. But the problem is, you can't really evaluate well how good your clustering is. And so it's not very easy to prototype anything at all. So you can try to engineer features around the clustering again, but then you need to compare the old and the new clustering. And basically, you need to look into the data and see does the new clustering make more sense than the old one. --- # Initialization - Random centers fast. - K-means++ (default): Greedily add “furthest way” point - By default K-means in sklearn does 10 random restarts with different initializations. - K-means++ initialization may take much longer than clustering. ??? What I said before is basically compute random centers, that's very fast. But it's also not very great, there's a strategy that's the default in scikit-learn that is very commonly used is called K-means++. It picks a point randomly, and then adds the most furthest away point in the data to it. And then it adds the most further away point to both of these two points, and so on. So it always pick the further away point. I think there’s some randomization there. But the idea is for the initial cluster center to be far away as possible and that might give you better optima, and it might speed up the optimization. The problem with this is that if you do this, like greedily adding the furthest away point, you need to compute a lot of distances. And if you have many clusters and many data points it becomes very expensive. And in particular, if you're using Minibatch KMeans, I've seen that running this initialization scheme becomes actually much more expensive than running clustering. And that's kind of silly. So if you run KMeans on bigger data sets you should be aware of how much time does the initialization take and how much time does your clustering take and maybe do a super initialization if it takes too long. One thing you should be aware of is that by default, scikit-learn does 10 years random restarts for KMeans. So basically, it does this KMeans++ strategy 10 times, runs the full algorithm until convergence and then retains the results that is the best according to the criteria. So if you have a big data set, you might not want to do that. And you might just set init to one and just run it once. FIXME slide for kmeans++, computational cost of kmeans++ - Consider using random, in particular for MiniBatchKMeans --- # Feature Extraction using K-Means - Cluster membership → categorical feature - Cluster distanced → continuous feature - Examples: - Partitioning low-dimensional space (similar to using basis functions) - Extracting features from high-dimensional spaces, for image patches, see http://ai.stanford.edu/~acoates/papers/coatesleeng_aistats_2011.pdf ??? I think one of the most useful ways to use KMeans is to extract new nonlinear features. You can either add categorical features saying it belongs to this cluster or you can add continuous features saying the distance to this cluster is that. So if you call the transform method in scikit-learn, it will compute the distances to all the cluster centers. So you'll have a new feature space that has number of clusters many dimensions, and that's a very nonlinear transformation of original feature space. This can be helpful, sometimes. In particularly if you have very simple models. In this paper on the C4 dataset, they ran KMeans, used the cluster centers to extract features and then ran logistic regression and it was as good as the deep learning methods at that time. By now, deep learning is much, much better than this. But it was very interesting because it uses very simple approach to find basically prototypes in the data center, they used like hundreds or thousands of cluster centers and then use the distances to these cluster centers as the features. --- class: center, middle # Agglomerative Clustering ??? The next algorithm I want to talk about is similarly classical, it’s called agglomerative clustering. --- # Agglomerative Clustering - Start with all points in their own cluster. - Greedily merge the two most similar clusters. .center[ ![:scale 80%](images/agglomerative_clustering.png) ] ??? In agglomerative clustering, the idea is that you start out with a bunch of points again. You assign each point its own cluster label, and then you greedily merge clusters that are similar. So here, each of the points is its own cluster, then, in step one, I'm merge the two closest points. Step two, I merged the next closest one, and so on. I can keep merging and merging until one big group is left. Here, I merged until there's three clusters left. - Creates a hierarchical clustering from with cluster sizes from n_samples to single cluster. --- class: spacious # Dendograms .left-column[ ![:scale 100%](images/dendograms_1.png) ] .left-column[ ![:scale 80%](images/dendograms_2.png) ] ??? Dendogram is another visualization of agglomerative clustering. Here, given this procedure, you can visualize this as a tree. It is also called as hierarchical clustering, because it gives you a whole hierarchy of different clusters. On the lowest level of the hierarchy, each data point is its own cluster center. So here, I have 12 data points so I would have 12 clusters. And if I merged everything, I have one cluster. But in between, there's this whole hierarchy of different numbers of clusters. Here, you can see the one and four was merged first, then six and nine was merged, then two and eight was merged, then zero and eleven, then five and zero and eleven and so on. The length of these bars are basically the distance between the clusters that got merged. So you can see the distance between zero and eleven, and zero, eleven, and five are very small. So that basically means that all three of them have almost the same distance. Whereas here, you can see one and four are much closer together than one and four and three and two. By looking at this dendogram, it’s very helpful for picking the number of clusters. So if I look at this, I would probably say, three is the right number of clusters. So for agglomerative clustering, you can either pick the number of clusters or you can basically pick a threshold on the merging criteria. So basically, if the clusters are too far away, you stop merging. But you need to specify one of these two things, either number of clusters, or when should you stop merging. But for both, looking at Dendogram is quite useful. Agglomerative clustering is in scikit learn while Dendogram are not available. But Dendogram can be computed in scipy (code available in the GitHub repository) Dendograms are mostly helpful if you don't have many data points. If you have millions of data points, then this tree will not be very easy to look at. This is a bottom-up approach where you start merging things from the bottom. You can also start by splitting the data or compute in a top-down manner as well. Some of these are equivalent and it depends on how you do similarity. Some of the bottom up and top down approach lead to the same result. And it depends mostly on how you're define the similarities. Done with scipy! FIXME dendrogram code! --- # Linkage Criteria .center[ ![:scale 100%](images/merging_criteria.png) ] .narrow-left-column[ .smaller[ Cluster sizes: ``` single : [96 1 1 1 1] average : [82 9 7 1 1] complete : [50 24 14 11 1] ward : [31 30 20 10 9] ``` ]] .wide-right-column[ .smallest[ - Single Linkage - Smallest minimum distance - Average Linkage - Smallest average distance between all pairs in the clusters - Complete Linkage - Smallest maximum distance - Ward (default in sklearn) - Smallest increase in within-cluster variance - Leads to more equally sized clusters. ]] ??? Here's an example on some synthetic 2D data set. So here, I run three different clustering algorithms. You can see that here in average to data point being their own cluster where as in ward the cluster size are much more similar. In particular, average, complete and single linkage tend to cut off single points that are very far away. So if one point is far right from everything, every linkage criteria except ward will get their own cluster. There's four commonly used similarities. Complete linkage looks at the smallest maximum distance. So if you look between two clusters, you look at the maximum distance between points in these two clusters. Average linkage looks at the average distance of points between clusters. Single linkage looks at the minimum distance between clusters. Ward looks at smallest increase within cluster variance.  Single linkage is the same as computing a minimum spanning tree, and then cutting the longest edge. So that's actually equivalent to top down approach. Ward is the default in scikit-learn. It’s kind of nice because it makes relatively equally sized clusters. single linkage = cutting longest edge in minimum spanning tree. --- class: spacious # Pros and Cons - Can restrict to input “topology” graph. -- - Fast with sparse connectivity, otherwise O(log(n) n ** 2 ) -- - Some linkage criteria an lead to very imbalanced cluster sizes -- - Hierarchical clustering gives more holistic view than single clustering. ??? One thing that's nice about them is you can restrict them to some input topology of the input space. So you can look at only merge things that are neighboring. You can do neighboring the input space by using the KNearest neighbor graph or you can do input like in an image space. So for example, you could say looking at pixels in an image, I only want to merge pixels that are ease in the image. You have some idea of the structure of the data then this allows you to really speed up the algorithm because you only need to consider very few merges. If you have very high dimensional data, or a lot of data points, computing all possible distances will be very slow. But if you have a very restricted topology, this can become very fast. Some of the other people working on scikit-learn are really into this because they use that to cluster regions in the brain and they walk cells. So you have a priori topology, you know, like, which, which walks cells in the brain are next to each other and that means they can compute this very quickly. If you would use clustering algorithm that's not aware of this neighborhood structure then it would take a long time. If you have like a sparse connectivity structure, it's going to be fast otherwise might not be so fast. Most of linkage criteria except ward might lead to very imbalanced cluster sciences, that might be something you want or not, depending on your application. If your data set is reasonably small or something like that, you can look at the Dendogram which shows you all possible clusters, basically and this gives you a more holistic view of the structure of your data and help you pick the right number of clusters or tell you if there's the right number of clusters. Q: Can you use clustering for generalization? With KMeans, we could assign a new data point to one of the clusters. For agglomerative clustering, we can’t really do that. common graph: neighborhood in input space, neighborhood in image hierachy / dendrogram can help picking number of clusters. --- class: center, middle # DBSCAN ??? The last clustering algorithm I want to talk about is DBSCAN. This was developed in the 2000s. It's little bit more complicated, but it's actually quite useful in practice. --- # Algorithm .left-column[ ![:scale 100%](images/DBSCAN-Illustration.svg) ] .right-column[ - eps: neighborhood radius - min_samples: 4
- A: Core - B, C: not core - N: noise ] ??? It's also an iterative algorithm. This algorithm has two parameters, one is the neighborhood radius called epsilon and the other is the minimum number of samples in a cluster. So here in this example, the colored points are data points, and we've drawn the radius epsilon around it. That said the minimum number of samples is four. So this means each cluster is restricted to have a minimum of four samples to be a cluster. So given these parameters, we can define the notion of a core sample. Core sample in DBSCAN is a sample that has more than min_sample minus one other samples in its epsilon neighborhood. The way this algorithm works is, it picks a point at random. Let's say, we pick point A at random, then it looks whether this is a core point or not, by looking at the number of neighbors with an epsilon, you see three neighbors here with an epsilon and hence it's a core point and so that means I give it a new cluster label, in this case, it’s red. Then I add all of these neighbors to a queue and then I process them all in turn. So I go to this red point, check is it a core sample and not a core sample and again, it has four neighbors, so it's a core point. And I added all the neighbors to the queue. And so you keep doing that. Here, once you reach point B, every point that you're going to reach within an epsilon neighborhood of the cluster will get the same cluster label as A. So if you reach this point, you will see the epsilon neighborhood, this point B wasn't visited yet and you will assign that the same cluster label. But B itself is not a core point and so you stop iterating there. Same goes for C. So once your queue is empty, meaning you went through all of these points, all the core points that you could reach, then you pick the next point. If you pick a point like this N, this is not a core point. And so if you visit it, it has no enough samples in the neighborhood, you label it as noise. One kind of interesting thing about this, we label it as noise for now, basically, if at the very first point I pick B, I would have labeled B as noise in the beginning, since B is not a core point so it will not get its own cluster. So I would label B as noise. But then later on, when I label the red cluster, I see I can reach B from the red cluster, I’ll give it that cluster label. If there was an unexplored neighbor here, we would not visit it because only core points basically add points to the queue. So if there was two unexplored neighbors, it would be a core point, if there's only one, it's not a core point because it doesn't have enough neighbors. So basically, the cluster doesn't promote in that direction. One thing that’s nice about this is you identify noise points. The other clustering algorithm didn’t have a concept of noise points. In DBSCAN, all points are assigned to cluster or they’re labeled noise, depending on what you want to have on your clustering algorithm that might be good or bad. - Clusters are formed by “core samples” - Sample is “core sample” if more than min_samples is within epsilon - “dense region” - Start with a core sample - Recursively walk neighbors that are core-samples and add to cluster. - Also add samples within epsilon that are not core samples (but don’t recurse) - If can’t reach any more points, pick another core sample, start new cluster. - If newly picked point has not enough neighbors, label outlier - Outliers can later be relabeled to belong to a cluster. ] --- ![:scale 100%](images/dbscan_animation.gif) by David Sheehan
dashee87.github.io
??? This is from a blog post that shows you how DBSCAN works iteratively with two different settings. So basically, here in the left, epsilon is 1 and min points is 8 while on the right, epsilon is 0.6, and min points is 6. From the chart in the left, first we pick some in the blue thing and we cover all of the blue cluster, and then something in the green cluster and then the red and yellow. And the rest all are just labeled noise because they don't have eight neighbors. In the case on the right, some of them have six neighbors and so they’re labeled as their own clusters. You can see here, in between they're randomly picked. So once we picked these random points, they're labeled noise. So there's no easy way to pick a direct upper bound on a number of clusters, but you can run it for different volumes of epsilon, and pick the one that has the right number of clusters for you. So you can define that at priori. --- # Illustration of Parameters .center[ ![:scale 70%](images/dbscan_illustration.png) ] ??? In this illustration, all the big points are core points, all the small ones are not core points, and all the white ones are noise.  So here, in the first row, one cluster has four points, and the other cluster had three points. So if I do min samples equal to three, they're both clusters. So I do min samples to five, none of them are clusters, they're labeled noise. If you increase epsilon, you make more points neighbors. And so basically, you're merging more and more clusters together. Increasing epsilon creates fewer clusters, but they're bigger. So you can see from in the second row, with epsilon 1.5 you get three clusters, with epsilon equal two you get two clusters, with epsilon three, you get just one cluster. FIXME add epsilon circles to points? --- # Pros and Cons - Pro: Can learn arbitrary cluster shapes - Pro: Can detect outliers - Con: Needs two (non-obvious?) parameters to adjust - Improved version: HDBSCAN .center[ ![:scale 50%](images/dbscan_pro_con.png) ] ??? What's nice about this is that it can learn arbitrary cluster shapes. Even with agglomerative clustering, even if you don't add, like some neighborhood graph topology on it, agglomerative clustering would not be able to learn this. DBSCAN has no problem with learning this since it only works very locally. Also, DBSCAN can detect outliers, which is kind of nice. What's slightly less nice, but you need to adjust two parameters and parameters are not directly related to the number of clusters. So it's not entirely clear to me, whether it is harder to pick epsilon, or is it harder to pick number of clusters but sometimes if an application asks for 10 clusters, that's little bit harder so you need to rerun the algorithm with multiple values of epsilon to figure out what epsilon should it be to get you to 10 clusters. This algorithm is pretty fast, because it only uses local search. And it can find arbitrary cluster sizes. So that's pretty nice. Sometimes it can also give you very differently sized clusters, similar to the agglomerative metrics. Often, I find that I get like one big cluster and a couple of small clusters, which is not usually what you want. If you want various similar sized clusters, KMeans or ward is better. The last algorithm I want to talk about is actually not a clustering algorithm. But it's a probabilistic generative model. eps is related to number of clusters, so not much worse than kmeans or agglomerative --- class: center, middle # (Gaussian) Mixture Models ??? Gaussian mixture models are very similar to KMeans, but slightly more flexible. --- # Mixture Models - Generative model: find p(X). ` $$ p(\mathbf{x}) = \sum_{j=1}^k \pi_k p_k(\mathbf{x} | \theta) $$ ` ??? Mixture models are unsupervised models that try to fit per metric density to your data. So you want to model like for p(X), you want to model a distribution of your data. Mixture model does this as a mixture of some based distribution. My model for p(X) is the sum of Pk, each Pk is sum per metric distribution, and they’re weighted by πk, which is just a constant. - Assume form of data generating process - Mixture model assumption: - Data is mixture of small number of known distributions. - Each mixture component distribution can be learned "simply" - Each point comes from one particular component - We learn the component parameters and weights of components --- # Gaussian Mixture Models `$$ p(\mathbf{x}) = \sum_{j=1}^k \pi_k \mathcal{N}(\mathbf{x}, \mu_k, \Sigma_k) $$` `$$ k \sim \text{Mult}(\pi), x \sim \mathcal{N}(\mathbf{x}, \mu_k, \Sigma_k)$$` ??? So for Gaussian mixture models, each of these distribution would just be a Gaussian with a different mean and a different covariance function. So you say, my P(X), my data distribution I want to model as a mixture of K different Gaussian and I want to find these means and I want to find these covariance and I want to know how I should weight them. So this is one way to write down the model. Another way that I find often helpful when dealing with the generative model, so generative model is just a model that describes the data generation process. So basically, anything that gives you P(X) is called the generative model. Another way is writing down how you draw a new sample. And here, in this case of this mixture model, the way you would see sample from it is you sample from a multinomial with these weights, πk. So the πs, they all need to sum up to one, obviously so that the distribution is normalized. So the integrals of each of the normals is one. So if you want the integral over x to be one, the πks need to some to one. So you can draw from a multinomial, basically using these πks and then you say, I draw a cluster K, so now I'm going to draw a new data point from K and I'm using the Gaussian distribution associated with the mixture component K. And this is the way you would sample from this distribution.  The algorithm is basically the same as KMeans. So again, it's a non-convex optimization. So usually you initialize the means with KMeans, and possibly do random restarts. And the algorithm is called Expectation Maximization (EM) Basically what you do is in each iteration you assign each point a probability of being generated by each of the components. And then you can recompute mean and standard deviation or covariance matrix for each of the components based on the points that are assigned to it. So it's very similar to KMeans only you don't do a hard assignment, so you don't say this belongs to this component, you assign probabilities saying this point probably comes from this component, and is less likely to come from this component. And so, in addition to computing the means, you also compute the covariance matrices. These are the two big differences compared to KMeans. And obviously, in the end, you get an estimate of the parametric form of the density. - Each component is created by a Gaussian distribution. - There is a multinomial distribution over the components - non-convex, depends on initialization FIXME algorithm deserves a bit more explanation? -- - Non-convex optimization. - Initialized with K-means, random restarts. - Optimization (EM algorithm): - Soft-assign points to components. - Compute mean and variance of components. - Iterate --- `$$ p(\mathbf{x}) = \sum_{j=1}^k \pi_k \mathcal{N}(\mathbf{x}, \mu_k, \Sigma_k) $$` .center[ ![:scale 40%](images/gmm1.png) ] .center[ ![:scale 40%](images/gmm2.png) ] ??? This is just sort of trying to illustrate what a mixture model might look like. So here I drew three Gaussian and the bottom one is sort of the mixture of three Gaussian. It’s kind of hard to draw distributions in 2D so I did it in 1D. Usually you fix the number of components beforehand, KMeans and initialization and so on, and then you fit the means and the covariance FIXME make clear bottom is weighted sum of top plots --- class: spacious # Why Mixture Models?
- Clustering (components are clusters) - Parametric density model ??? One reason might be doing clustering as we did before but as a more powerful variant of KMeans. But you can also do much more with it. There’s a lot of things that makes having a parametric density model is a nice thing. You can say, if I see a new data point, how likely is it to observe this data point, given the model I fitted into the data, and you can use this, for example, to do outlier detection. If the point looks like it was not generated from this model that probably means it's an outlier. You can also use this like a base classifier where each class is more or less a mixture of Gaussians instead of just one Gaussian as we did with LDA. There's like many more different things where being able to compute the probability of a given data point, is often very helpful. So that's sort of when a parametric model might be helpful. - Create parametric density model. - Allows for testing how “likely” a new point is. - Clustering (each components is one cluster). - Feature Extraction --- # Examples .wide-left-column[ .smaller[ ```python from sklearn.mixture import GaussianMixture gmm = GaussianMixture(n_components=3) gmm.fit(X) print(gmm.means_) print(gmm.covariances_) ``` ``` [[-2.286 -4.674] [-0.377 6.947] [ 8.685 5.206]] [[[ 6.651 2.066] [ 2.066 13.759]] [[ 5.467 -3.341] [ -3.341 4.666]] [[ 1.481 -1.1 ] [ -1.1 4.191]]] ``` ] ] .narrow-right-column[ .center[ ![:scale 80%](images/mm_examples_1.png) ]] -- .narrow-right-column[ .center[ ![:scale 80%](images/mm_examples_2.png) ] ] ??? Here's how you do this with scikit-learn. So you only need to specify the number of components, usually, you fit it on data X and you get the means and the variances.  You can see KMeans since it can model covariance, it can learn something like is the blue cluster or the blue component, more spread out than the green component which KMeans couldn't. --- # Probability Estimates .left-column[ .smaller[ ```python gmm.predict_proba(X) ``` ``` array([[ 1. , 0. , 0. ], [ 0. , 0. , 1. ], ..., [ 1. , 0. , 0. ], [ 0.001, 0.999, 0. ]]) ``` .center[ ![:scale 60%](images/prob_est1.png) ] ] ] .right-column[ .smaller[ ```python # log probability under the model print(gmm.score(X)) print(gmm.score_samples(X).shape) ``` ``` -5.508 (500,) ``` .center[ ![:scale 60%](images/prob_est2.png) ] ] ] ??? So I can basically get two kinds of probability estimates from this model. I can get the probability of a point belonging to each of the components, I can get that with predict_proba. Predict_proba gives you basically for a given point, the posterior of which component it was probably generated from. The model is the same as the QDA classifier that we saw last time. So basically, it's just saying, given these three Gaussian, which Gaussian is it likely to come from. You could’ve also set the model to joint likelihood, and see how likely is it to observe X or do a core samples, which will give me a log likelihood of each individual sample stating which of the samples look strange. So the shape of the result is number of samples times number of components. So for each of the component, I say given the data that was generated by this mixture, how likely is it that it was generated by this particular component. For the blue components it would probably be one and near zero for the other two components. --- # Covariance restrictions ![:scale 100%](images/covariance_types.png) ??? So thing that's commonly done in higher dimensions is to restrict the shape of the covariance matrix and thereby the shape of the clusters. So basically, we're taking a step back and become a little bit closer to KMeans again. There’s four most common options to restrict the covariance matrix in scikit-learn. For each of these, I give the number of parameters of the covariance matrix that you're learning. So for spherical, all of the components are spherical but each has their own covariance. So I have one covariance number for each of the components. So it's like sigma i times the unit matrix. And then it looks like this, if I fit it to this dataset here. This is like very few numbers to learn so I need very little data. Also, this not very flexible. For diagonal, I learned a diagonal covariance matrix. So for each of the components, I have number of features many degrees of freedom. So that means I can learn ellipsoids that are access parallel. So along the x-axis I have a variance and variance along the y-axis. This doesn't grow quadratically with a number of features so that's sort of still reasonably behaved and that's something used quite commonly. Tied means that we assume that all the clusters have the same covariance matrix. So this is the same as what we did with like linear discriminate analysis. In linear discriminate analysis was basically the supervisor version of this, where we shared the covariance matrix between all the classes while here, we share the covariance matrix between all the components. So then we only need to learn one covariance matrix. But it's a symmetric matrix, but the number of parameters still grows as the number feature squared. This is probably something you only want to use, if you have some a priori knowledge that the clusters should sort of have a similar shape. The full is sort of the default that I talked about. In this, you have a full covariance matrix independently for each of the clusters. So this is the most flexible, but this is also the hardest to fit. So in a sense here, you can think of this as control overfitting. So you could actually overfit the density model. If you give the model too much flexibility, it could learn a two complicated model that doesn't really model the data well, in particular in very high dimensions. In high dimensions or with few samples, fitting the whole (n_features ** 2) covariance matrix can be unstable. We can restric it to be spherical, diagonal, tied or full. --- class:center # GMM vs KMeans ![:scale 47%](images/gmm_vs_kmeans_1.png)
![:scale 47%](images/gmm_vs_kmeans_2.png) ??? Here are two of the cases that KMeans failed, but the Gaussian mixture model can learn the covariance structure of these components and below, it can learn the variance. Obviously, I drew this data synthetically from Gaussians so the data is actually a mixture of three Gaussians and I specified fit three Gaussians to it so it's kind of obvious that it's going to work. In the real world, your data will not be generated by Gaussian and you won’t know how many components there might be. GMM can be more unstable, is more expensive to compute. --- class: some-space # Summary - KMeans
Classic, simple. Only convex cluster shapes, determined by cluster centers. -- - Agglomerative
Can take input topology into account, can produce hierarchy. -- - DBSCAN
Arbitrary cluster shapes, can detect outliers, often very different sized clusters. -- - Gaussian Mixture Models
Can model covariance, soft clustering, can be hard to fit. ??? The most classical clustering algorithm is KMeans. It's quite simple. It's nice, because they have cluster centers, and the cluster centers represent your clusters. But it's very restricted in terms of the shape of each cluster center. And it's sort of an approximate algorithm that depends on initialization. So if you initialize differently, you might get different results. Agglomerative is kind of nice, because it can take the input topology into account and it can produce the hierarchy. If you have not that many data points looking at the dendogram might be very helpful. DBSCAN is great because it can find arbitrarily shaped clusters and it can also detect outliers. The downside is that you need to specify two parameters that are sort of not so obvious to pick. And finally, there's Gaussian mixture models, which are sort of an upgrade of KMeans. They can model covariance. You can do soft clustering, in that you can say how likely does it comes from a particular component, so you don't hard assign each point to a particular component. It gives you a parametric density model, which is nice. But it can be hard to fit if you want to fit the full covariance matrix. If you only find the diagonal covariance matrix, it's not so bad. Gaussian mixture models require multiple initializations possibly, and they're like a local search procedure. KMeans requires initialization, as do GMMs. --- .center[ ![:scale 95%](images/bim_2.png) .smaller[ http://scikit-learn.org/dev/auto_examples/cluster/plot_cluster_comparison.html] ] ??? There's this example on the scikit-learn website which shows a range of different clustering algorithms. So there’s KMeans, affinity propagation, mean shift, spectral clustering, ward, agglomerative clustering, DBSCAN, Birach and Gaussian mixtures. So you can sort of see what kind of problems they work with or not work with. Though this is 2D and things behave very, very differently in 2D than they behave in higher dimensions. All of these algorithms have parameters and adjusting these parameters is really tricky. Another question that you should ask yourself is, while some of these can get like complex cluster shapes, like, DBSCAN and agglomerative were able to get these two circles and these two bananas, KMeans and the Gaussian mixtures can do that. But the question is, is your data set actually going to look like this or is it going to look like this? I think in in the real world data sets are much more likely to look something like this. --- class: middle # Questions ?


The Internship
Our 3 month internship in Papua New Guinea was an unbelievable time of learning and getting a feel for tribal ministry. We spent our days taking classes about cultural assimilation, as well as hands on training where we spent time in neighboring tribes. We formed relationships with native Papua New Guineans who eagerly took us under their wings to learn language and culture. The lessons we learned about the challenges and joys of tribal ministry are so valuable to us in our pursuit of becoming career missionaries. We have returned to the US with a much broader understanding of what it takes to reach a tribe with the Gospel. If you would like a more detailed, week to week account of our time in Papua New Guinea, please see the link to our blog below.
https://blog.ourjunglelife.com/Learn More: The Beginnings Where We're Headed Internship Ethnos360


The paper presents some general ideas and mechanisms for multiple model-based RL. Even though the task and model architecture may not be very relevant now, I find the general idea and the mechanisms to be quite useful. As such, I am focusing only on high-level ideas and not the implementation details themselves.
The main idea behind Multiple Model-based RL (MMRL) is to decompose complex tasks into multiple domains in space and time so that the environment dynamics within each domain is predictable.
MMRL proposes an RL architecture composes of multiple modules, each with its own state prediction model and RL controller.
The prediction error from each of the state prediction model defines the “responsibility signal” for each module.
This responsibility signal is used to:
Weigh the state prediction output ie the predicted state is the weighted sum of individual state predictions (weighted by the responsibility signal).
Weigh the parameter update of the environment models as well as the RL controllers.
Weighing the action output - ie predicted action is a weighted sum of individual actions.
The framework is amenable for incorporating prior knowledge about which module should be selected.
In the modular decomposition of a task, the modules should not change too frequently and some kind of spatial and temporal continuity is also desired.
Temporal continuity can be accounted for by using the previous responsibility signal as input during the current timestep.
Spatial continuity can b ensured by considering a spatial prior like the Gaussian spatial prior.
Though model-free methods could be used for learning the RL controllers, model-based methods could be more relevant given that the modules are learning state-prediction models as well.
Exploration can be ensured by using a stochastic version of greedy action selection.
One failure mode for such modular architectures is when a single module tries to perform well across all the tasks. The modules themselves should be relatively simplistic (eg linear models) which can learn quickly and generalize well.
Non-stationary hunting task in a grid world and non-linear, non-stationary control task of swinging up a pendulum provides the proof of concept for the proposed methods.


--- layout: docs_default title: Unit Neurons Documentation - Overview ---
Unit Neurons is a repository for development of a C++ neural network library where each neuron is expressed using object instances which we refer to as "Unit Neurons".
This documentation is written for Unit Neurons v1.0.
This documentation assumes that the reader has substantial knowledge about programming in C++, or basic operations (for loops, if statements, etc.), object oriented programming, and the usage of pointers.
It is also advisable to have a basic knowledge regarding the neural network model that you are going to implement beforehand in order to have an understanding of the overall structure of your code; however, we have provided some example implementations and code for readers to take a look at.
Please feel free to put a pull request in our repository if you have any questions, comments, criticisms, etc.


transverse annular rotor screen material housing device walls feed gap free seal longitudinal space disk shaft according region circumference disks wall claim radial CLAIM-TEXT:. claim-ref[claim outside machine support invention plates axial figref[FIG. order axially clearance cutting discharge metal width action-date: clamping comminution distance extends flow generating-office:: path paths Classification: attached direction entire frame located rotating air blade composed drive figref[FIGS. means opposite perforated radially sides stationary wearing arranged circumferential directly edge essentially extend face heat inside material, parts, present result scope shown spar strips EMI-D additional attachment closed concentric consequently document-id:: downstream forming gap. housing, ipc-version-indicator:: manner maximum parts reduced rotor, wall, walls. way wear [addressbook]: apparent area bars blades cm, cm. cover cpc-version-indicator:: detailed device, devices edges end ends example form frame. gap, gets given hand, interior invention, inventive leads length material. mm. mounted necessary opening parallel plate preferably processing proves purpose rectangular rotates rotor. section small supplied thermal tools


Describes the hour, minute and second values used to set the media clock.
@since SDL 1.0
- (nonnull instancetype)initWithCountryCode:
(nullable NSNumber<SDLInt> *)countryCode
fccFacilityId:(nullable NSNumber<SDLInt> *)id;
init(countryCode: (NSNumber & SDLInt)?, fccFacilityId id: (NSNumber & SDLInt)?)
Binary Representation of ITU Country Code. USA Code is 001
Binary representation of unique facility ID assigned by the FCC
An SDLStationIDNumber object
@abstract Binary Representation of ITU Country Code. USA Code is 001.
Optional, Integer, 0 - 999
@property (nonatomic, strong, nullable) NSNumber<SDLInt> *countryCode;
var countryCode: (NSNumber & SDLInt)? { get set }
@abstract Binary representation of unique facility ID assigned by the FCC FCC controlled for U.S. territory
Optional, Integer, 0 - 999
@property (nonatomic, strong, nullable) NSNumber<SDLInt> *fccFacilityId;
var fccFacilityId: (NSNumber & SDLInt)? { get set }


{{profile.followers}} followers {{profile.following}} following {{profile.public_repos}} public repos
{{repos.name}} - Created on: {{repos.created_at | date}}
View this project on github
{{repos.description}}


{#
{% endblock binder_header %}
{% block projects_form %}
{% include "projects_form.html" %}
{% endblock projects_form %}
{% block how_it_works %}
Turn a Git repo into a collection of interactive notebooks
#}
{% block persistency_explanation %}
{{ persistency_explanation|safe }}
{% endblock persistency_explanation %}
How it works
1
Build repositories like MyBinder.org
Enter your repository information in the Binder form. We build and launch your binder-ready repository so that you can interact with it just like on any other Binder deployment. Once a repository has been launched it will be added to the list of your projects.
Enter your repository information in the Binder form. We build and launch your binder-ready repository so that you can interact with it just like on any other Binder deployment. Once a repository has been launched it will be added to the list of your projects.
2
Persist /projects like a Jovyan
You are not just a visitor, but a true resident on Jupyter. Your projects have a persistent $HOME directory whose contents are mirrored at /projects. Use the buttons in the table to launch, stop or delete an existing project. The data science image can be your place to begin. To update a project-image use the Binder form and for files use git. You can launch one project at a time and have up to 5 projects in total.
You are not just a visitor, but a true resident on Jupyter. Your projects have a persistent $HOME directory whose contents are mirrored at /projects. Use the buttons in the table to launch, stop or delete an existing project. The data science image can be your place to begin. To update a project-image use the Binder form and for files use git. You can launch one project at a time and have up to 5 projects in total.


| ProjectTemplate-package | Automates the creation of new statistical analysis projects. |
| .add.extension | Associate a reader function with an extension. |
| .require.package | Require a package for use in the project |
| arff.reader | Read the Weka file format. |
| cache | Cache a data set for faster loading. |
| cache.name | Translate a variable name into a file name for caching. |
| cache.project | Cache a project's data sets in binary format. |
| clean.variable.name | Translate a file name into a valid R variable name. |
| create.project | Create a new project. |
| csv.reader | Read a comma separated values (.csv) file. |
| csv2.reader | Read a semicolon separated values (.csv2) file. |
| db.reader | Read a SQlite3 database with a (.db) file extension. |
| dbf.reader | Read an XBASE file with a .dbf file extension. |
| default.config | Default configuration |
| epiinfo.reader | Read an Epi Info file with a .rec file extension. |
| file.reader | Read an arbitrary file described in a .file file. |
| get.project | Show information about the current project. |
| load.project | Automatically load data and packages for a project. |
| migrate.project | Migrates a project from a previous version of ProjectTemplate |
| mp3.reader | Read an MP3 file with a .mp3 file extension. |
| mtp.reader | Read a Minitab Portable Worksheet with an .mtp3 file extension. |
| new.config | Configuration for new projects |
| octave.reader | Read an Octave file with a .m file extension. |
| package-ProjectTemplate | Automates the creation of new statistical analysis projects. |
| ppm.reader | Read a PPM file with a .ppm file extension. |
| preinstalled.readers | Maps file types to the reader functions used to autoload them. |
| ProjectTemplate | Automates the creation of new statistical analysis projects. |
| r.reader | Read an R source file with a .R file extension. |
| rdata.reader | Read an RData file with a .rdata or .rda file extension. |
| reload.project | Reload a project from scratch. |
| require.package | Require a package for use in the project |
| run.project | Run all of the analyses in the 'src' directory. |
| show.project | Show information about the current project. |
| spss.reader | Read an SPSS file with a .sav file extension. |
| sql.reader | Read a database described in a .sql file. |
| stata.reader | Read a Stata file with a .stata file extension. |
| stub.tests | Generate unit tests for your helper functions. |
| systat.reader | Read a Systat file with a .sys or .syd file extension. |
| test.project | Run all unit tests for this project. |
| translate.dcf | Read a DCF file into an R list. |
| tsv.reader | Read a tab separated values (.tsv or .tab) file. |
| url.reader | Read a remote file described in a .url file. |
| wsv.reader | Read a whitespace separated values (.wsv or .txt) file. |
| xls.reader | Read an Excel 2004 file with a .xls file extension. |
| xlsx.reader | Read an Excel 2007 file with a .xlsx file extension. |
| xport.reader | Read an XPort file with a .xport file extension. |


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Serves 4
Traditionally surf and turf is all about lobster and steak but I prefer something a little less extravagant. This humble salad combines one of my favourite fish - smoked mackerel - with some crisp, streaky bacon.
Preheat the grill to a medium high heat. Line a baking sheet with greaseproof paper.
Peel and finely slice the onion into rings. Put them into a small bowl with the white-wine vinegar and set aside for 10 minutes or more, tossing occasionally. This removes any harshness and will slightly soften the onion's flesh.
Boil the potatoes in deep, generously salted water for 15 minutes until they are tender. Lay the bacon out flat on the lined baking sheet and grill for 10 minutes until crisp.
Take the whole smoked mackerel and peel off the skin. Into a large bowl, flake the mackerel off the bone in large chunks.
While the potatoes are boiling and the bacon is grilling make the dressing. Spoon the mustard into another bowl. Briefly rinse the capers and add to the mustard. Pour in the white wine vinegar; add a little pepper and a few generous glugs of olive oil. Give it a stir.
Chop the dill and add half to the dressing and half to the bowl with the mackerel. Now take the softened onions out of the vinegar and add to the dressing.
When the potatoes are soft to a knifepoint, drain and slice them in half, leaving the skin on, and tip into the dressing to absorb. Mix together and then spoon over the flaked mackerel.
When the bacon is crisp, snip little 4cm/1½in squares over the salad and toss it altogether before serving.


Node Class
Item Index
Methods
getMatrix
()
CSSMatrix2d
Helper method to get the node's current 2d transfom matrix.
Returns:
inverseTransform
-
transitionConfig
-
callbackFunction
Transforms the node by the inverse of the nodes current 2d transform matrix.
Parameters:
-
transitionConfig
ObjectOptional. If defined, and if the transition module is available, a transition will be used to transform the node. This object is passed along to the transition method.
-
callbackFunction
FunctionOptional. Whether or not transition is used, the callback function, if defined, will get called when the transform is complete.
multiplyMatrix
-
matrix
-
transitionConfig
-
callbackFunction
Transforms the node by multiplying the nodes current 2d transform matrix with another matrix.
Parameters:
-
matrix
CSSMatrix2dThe matrix to multiply.
-
transitionConfig
ObjectOptional. If defined, and if the transition module is available, a transition will be used to transform the node. This object is passed along to the transition method.
-
callbackFunction
FunctionOptional. Whether or not transition is used, the callback function, if defined, will get called when the transform is complete.
rotate
-
angle
-
transitionConfig
-
callbackFunction
Rotates the node clockwise.
Parameters:
-
angle
NumberThe angle specified in degrees.
-
transitionConfig
ObjectOptional. If defined, and if the transition module is available, a transition will be used to transform the node. This object is passed along to the transition method.
-
callbackFunction
FunctionOptional. Whether or not transition is used, the callback function, if defined, will get called when the transform is complete.
rotateRad
-
angle
-
transitionConfig
-
callbackFunction
Rotates the node clockwise.
Parameters:
-
angle
NumberThe angle specified in radians.
-
transitionConfig
ObjectOptional. If defined, and if the transition module is available, a transition will be used to transform the node. This object is passed along to the transition method.
-
callbackFunction
FunctionOptional. Whether or not transition is used, the callback function, if defined, will get called when the transform is complete.
scale
-
scaleFactor
-
transitionConfig
-
callbackFunction
Scales the node horizontally and vertically.
Parameters:
-
scaleFactor
NumberThe horizontal and vertical scale factor.
-
transitionConfig
ObjectOptional. If defined, and if the transition module is available, a transition will be used to transform the node. This object is passed along to the transition method.
-
callbackFunction
FunctionOptional. Whether or not transition is used, the callback function, if defined, will get called when the transform is complete.
scaleXY
-
scaleFactorX
-
scaleFactorY
-
transitionConfig
-
callbackFunction
Scales the node horizontally and vertically.
Parameters:
-
scaleFactorX
NumberThe horizontal scale factor.
-
scaleFactorY
NumberThe vertical scale factor.
-
transitionConfig
ObjectOptional. If defined, and if the transition module is available, a transition will be used to transform the node. This object is passed along to the transition method.
-
callbackFunction
FunctionOptional. Whether or not transition is used, the callback function, if defined, will get called when the transform is complete.
skewX
-
angle
-
transitionConfig
-
callbackFunction
Skews the node horizontally.
Parameters:
-
angle
NumberThe horizontal skew angle specified in degrees.
-
transitionConfig
ObjectOptional. If defined, and if the transition module is available, a transition will be used to transform the node. This object is passed along to the transition method.
-
callbackFunction
FunctionOptional. Whether or not transition is used, the callback function, if defined, will get called when the transform is complete.
skewXRad
-
angle
-
transitionConfig
-
callbackFunction
Skews the node horizontally.
Parameters:
-
angle
NumberThe horizontal skew angle specified in radians.
-
transitionConfig
ObjectOptional. If defined, and if the transition module is available, a transition will be used to transform the node. This object is passed along to the transition method.
-
callbackFunction
FunctionOptional. Whether or not transition is used, the callback function, if defined, will get called when the transform is complete.
skewY
-
angle
-
transitionConfig
-
callbackFunction
Skews the node vertically.
Parameters:
-
angle
NumberThe vertical skew angle specified in degrees.
-
transitionConfig
ObjectOptional. If defined, and if the transition module is available, a transition will be used to transform the node. This object is passed along to the transition method.
-
callbackFunction
FunctionOptional. Whether or not transition is used, the callback function, if defined, will get called when the transform is complete.
skewYRad
-
angle
-
transitionConfig
-
callbackFunction
Skews the node vertically.
Parameters:
-
angle
NumberThe vertical skew angle specified in radians.
-
transitionConfig
ObjectOptional. If defined, and if the transition module is available, a transition will be used to transform the node. This object is passed along to the transition method.
-
callbackFunction
FunctionOptional. Whether or not transition is used, the callback function, if defined, will get called when the transform is complete.
transform
-
matrix
-
transitionConfig
-
callbackFunction
Transforms the node by the given matrix.
Parameters:
-
matrix
CSSMatrix2dThe 2d transform matrix.
-
transitionConfig
ObjectOptional. If defined, and if the transition module is available, a transition will be used to transform the node. This object is passed along to the transition method.
-
callbackFunction
FunctionOptional. Whether or not transition is used, the callback function, if defined, will get called when the transform is complete.
translate
-
x
-
y
-
transitionConfig
-
callbackFunction
Translates the node horizontally and vertically.
Parameters:
-
x
NumberThe amount to translate horizontally.
-
y
NumberThe amount to translate vertically.
-
transitionConfig
ObjectOptional. If defined, and if the transition module is available, a transition will be used to transform the node. This object is passed along to the transition method.
-
callbackFunction
FunctionOptional. Whether or not transition is used, the callback function, if defined, will get called when the transform is complete.


|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object cs.cscollections.utilities.SinglyLinkedList<T>
public class SinglyLinkedList<T>
The SinglyLinkedList class provides a utility class for implementing collections as a singly linked list. If collection is ordered, then the template parameter type T must implement the Comparable ADT in order to provide a ordering for elements.
| Nested Class Summary | |
|---|---|
class |
SinglyLinkedList.LinkedIterator<T>
|
protected class |
SinglyLinkedList.Node
|
| Constructor Summary | |
|---|---|
SinglyLinkedList()
Constructs an empty SinglyLinkedList. |
| Method Summary | |
|---|---|
T |
getDataFromHead()
getDataFromHead returns the data from the first node in the list. |
T |
getDataFromTail()
getDataFromTail returns the data from the last node in the list. |
T |
getIth(int i)
getIth returns the data from the ith node in the list. |
int |
getSize()
Reports the number of elements in the list. |
void |
insertAfter(T target,
T ele)
insertAfter inserts the specified element (ele) after the target element. |
void |
insertAtHead(T ele)
insertAtHead inserts the specified element at the head of the singly linked list. |
void |
insertAtTail(T ele)
insertAtTale inserts the specified element at the tail of a singly linked list. |
void |
insertIth(T ele,
int pos)
Inserts the specified element at the specified position in the list. |
boolean |
isEmpty()
Reports whether the singly linked list is empty or not. |
java.util.Iterator<T> |
iterator()
This method returns an iterator defined over the list. |
void |
orderedInsert(T ele)
orderedInsert inserts the specified inorder in the list. |
void |
remove(T target)
remove removes the node containing the object specified by target from the list. |
void |
removeFromHead()
removeFromHead removes the first element from the list. |
void |
removeFromTail()
removeFromTail removes the last element in the list. |
void |
removeIth(int pos)
removeIt removes the ith node from the list. |
java.lang.String |
toString()
toString returns a string version of the list. |
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
| Methods inherited from interface java.lang.Iterable |
|---|
forEach, spliterator |
| Constructor Detail |
|---|
public SinglyLinkedList()
Constructs an empty SinglyLinkedList.
| Method Detail |
|---|
public T getDataFromHead()
getDataFromHead returns the data from the first node in the list. Invoking this method on an empty list is an exception. The list should either be checked to verify it is not empty before calling this method, or the call should be nested in a try-catch block.
EmptyCollectionException
cs.cscollections.utilities.LinkedListADT#getDataFromHead()
public T getDataFromTail()
EmptyCollectionException
cs.cscollections.utilities.LinkedListADT#getDataFromTail()
public T getIth(int i)
getIth returns the data from the ith node in the list. Nodes in the list are numbered starting from 0. So, 0 <= i < size of the list. Invoking this method on an empty list is an exception. The list should either be checked to verify it is not empty before calling this method, or the call should be nested in a try-catch block.
i
- The position in the element in the list.
IndexOutOfBoundsException,
- EmptyCollectionExceptionpublic int getSize()
Reports the number of elements in the list.
cs.cscollections.utilities.LinkedListADT#getSize()
public void insertAfter(T target, T ele)
insertAfter inserts the specified element (ele) after the target element. If the target is not found in the list an IllegalInsertionException is thrown. Type T must implement the Comparable interface.
If it is not know whether the target element is in the list, calls to insertAfter should be nested in a try catch block as illustrated below:
T target = ... //reference to target element
T ele = ... //reference to element to insert
try {
insertAfter(target, ele);
}
catch IllegalInsertionException(e)
{
// Inset the element into the list using another insertion method or
// take corrective action.
}
target
- The element of the list to insert after.ele
- The element to insert into the list.
IllegalInsertionException
public void insertAtHead(T ele)
insertAtHead inserts the specified element at the head of the singly linked list.
ele
- The element to insertcs.cscollections.utilities.LinkedListADT#insertAtHead(T)
public void insertAtTail(T ele)
insertAtTale inserts the specified element at the tail of a singly linked list. Caution: this method's performance is linear in the lenght of the list, O(n).
cs.cscollections.utilities.LinkedListADT#insertAtTail(int)
public void insertIth(T ele, int pos)
Inserts the specified element at the specified position in the list. Note that the new element is in position pos in the list after the insert. pos must be in the range 0 .. size().
ele
- The element to insert.pos
- The position in the list in which to insert the new element.
IndexOutOfBoundsException
public boolean isEmpty()
Reports whether the singly linked list is empty or not.
cs.cscollections.utilities.LinkedListADT#isEmpty()
public java.util.Iterator<T> iterator()
iterator
in interface java.lang.Iterable<T>
public void orderedInsert(T ele)
orderedInsert inserts the specified inorder in the list. Type T must define an order on elements by implementing the Comparable interface.
ele
- The element to insert.public void remove(T target)
remove removes the node containing the object specified by target from the list. Invoking this method on an empty list is an exception. The list should either be checked to verify it is not empty before calling this method, or the call should be nested in a try-catch block.
target
- The target object to remove from the list.
EmptyCollectionException
public void removeFromHead()
removeFromHead removes the first element from the list. Note that removing from an empty list is not considered an error. Removing from an empty list leaves an empty list.
public void removeFromTail()
cs.cscollections.utilities.LinkedListADT#removeFromTail()
public void removeIth(int pos)
removeIt removes the ith node from the list. Nodes are enumerated starting at 0. Invoking this method on an empty list is an exception. The list should either be checked to verify it is not empty before calling this method, or the call should be nested in a try-catch block.
pos
- The position of the element in the list.
EmptyCollectionException,
- IndexOutOfBoundsExceptionpublic java.lang.String toString()
toString returns a string version of the list. It requires that the template type, T, implement toString.
toString
in class java.lang.Object
cs.cscollections.utilities.LinkedListADT#toString()
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


About: This sample uses Google Play Services Wearable Data APIs to communicate between applications on a phone and a paired wearable device. Users can create quiz questions on the phone, each of which has an associated DataItem. These DataItems are then received on the wearable, which displays them as notifications. Each notification contains the question as the first page, followed by answers as actions. When an answer is selected, the corresponding question's DataItem is updated, which allows the phone application to update the status of the question (i.e. did the user answer it correctly or not) and prompt the next question.
At the end of the quiz, the sample uses the Google Play Services Wearable Message APIs to create an end-of-quiz report notification on the wearable, with an option to reset the quiz (by sending a message back to the phone).
How to run: Install the Application APK on the companion, and the Wearable APK on the wearable. Start the sample by running the Quiz application on the companion.
Wearable APIs used: DataApi, MessageApi, NodeApi, WearableListenerService
Screenshots:


X-Force Recruits an Omega-Level Mutant to Avenge a Major Death
by Tim AdamsWARNING: The following contains spoilers for X-Force #2 by Benjamin Percy, Joshua Cassara, Dean White, VC's Joe Caramagna and Tom Muller, on sale Wednesday, Nov. 27.
X-Force is supposed to operate as the X-Men's version of the Central Intelligence Agency, but so far the team is failing at its job. With mutants getting a new lease on life and independence through the island nation of Krakoa, the odds have never been this stacked in their favor before. This is probably why their enemies are working like never before to bring the mutant society crashing to the ground.
While we have seen Orchis -- an offshoot of Hydra, A.I.M., S.H.I.E.L.D. and other organizations banded together -- in battle with the X-Men in House of X, there are plenty more threats rising from the shadows. One of those was a squad of soldiers that successfully infiltrated Krakoa to assassinate Charles Xavier. X-Force #1 shocked readers with Xavier's death, even though it has already been established that the X-Men have a way to cheat death with The Five (Hope Summers, Goldballs/Egg, Proteus, Tempus and Elixir) and the mutant resurrection protocols.
Click the button below to start this article in quick view.
Be that as it may, Xavier is still deceased as we head into a preview of X-Force #2. Of course, Wolverine is already on the case, following the assassins' tracks to an airport in South Korea. While Logan attempts to break into a computer system for answers, an unexpecting guard walks in on his break-in. Just as Wolverine is about to strike the guard down, he finds himself levitating in midair, thanks to the intervention of Quentin Quire, aka Kid Omega.
Quentin Quire is one of the 14 characters designated as an Omega-level mutant in a House of X #1 data page, with his Omega power listed as Telepathy. Kid Omega and Wolverine became somewhat close during Wolverine and the X-Men when Logan was running the Jean Grey School for Higher Learning. Always stubborn and narcissistic, Quentin was last seen as a member of Kate Bishop's West Coast Avengers.
The preview of X-Force #2 reveals Quentin is already ahead of Wolverine in his investigation of Xavier's murder case. "I'm here because the Professor finally realized what I've been preaching all along," Quentin tells Wolverine. "Mutants are @#$%& superior. Or at least I am." Quentin has already processed the assassins' false IDs and surveyed the surveillance footage. The duo now has a lead on getting payback against the individuals who dared to openly attack Krakoa.


--- layout: post title: "My Week in Review" date: 2017-09-10 09:55:00 +0000 tags: image: https://s3.amazonaws.com/audreywatters/2017-09-10-columbia.jpg imagecredits: https://www.flickr.com/photos/21022123@N04/15733524872 ---
Icon credits: The Noun Project