1. Taking our Pulse on FAUST Classifiers, 03/01/2014
Classifier (supervised analytic) constructs a model that distinguish classes. It is then used to predict the class of unclassified objects.
Models are constructed from a training set (table of objects with class labels).
Classification may need to be preceded by relevance analysis to eliminate attributes that do not seem to contribute much information as to class.
Summary of FAUST Classifiers: X=(X1..Xn,C)=TrainingSet (classified objects) Y=(Y1..Yn)=TestSet (unclassified objects) Classes: C1..CK
FAUST Centroid Classifier: Separate classes, Ci and Cj, with a CutPoint, ci,j, in the SPTS, XoDi,j, with D being the vector:
Di,jMeanCiMeanCj (or use VectorsOfMedians) ci,j=MdPt(D) (or use VarianceRatios) y isa Ck iff yoDk,j<ck,j k
SPTS primitives: Assume ClassMeans (VoMs) have been precomputed! Need only the (n2-n)/2 SPTSs, YoDk,j (concurrent)
Advantages: Very fast. Extendable to a fuzzy classifier: weightCi(y) = ji| ci,j - yoDi,j| ????
Disadvantages: For none of the above, need a separate step: yCk, check d2(y,Ck)=(y-Ck)o(y-Ck)? (very expensive!)
y isa Ck iff OneCount{Ck-y)o(Ck-y)  rk2} is the maximum over k=1..K
FAUST Spherical Classifier:
SPTS primitives: (Ck-y)o(Ck-y) SPTS is needed (y, k) pair, where yY and k=1..n
Advantages: Full 1-class w none of the above. Extendable to fuzzy classifier: wtCi(y) = OneCount{(Ci-y)o(Ci-y)ri2}
Disadvantages: Classifies one y at a time. Hard to decide on the values of (r1,...rn)? Slow!
FAUST Linear Classifier Construct hull, Hk, about Ck x isa Ck iff xHk.
(allows for a "none of the above" class when xHk,  k.)
Hks can be constructed in parallel:
For each in a series of vectors, D, let loD,kmnCkoD (or the 1st PCI); hiD,kmxCkoD (or the last PCD).
Classify yCk iff loD,k  Doy  hiD,k D.
SPTS primitives: Compute CkoD k=1..n,D 1 time. Min, Max of SPTSs. D,y need Doy (form Y into a PTS, DoY, D?)
Advantages: Full 1-class w none of the above. fast! Fuzzy extension: wt(y,k)=dis(y to Hk bddry)? Bulk classification
Disadvantages: Hard to decide on the value of l and h? Accuracy may suffer a bit.

2. FAUST Polygon classifier A very fast and very accurate model-based classifier
X=(X1..Xn,C)=TrainingSet of classified objects Y=(Y1..Yn)=TestSet of unclassified objects Classes: are C1..CK
Linear seems best, since Medoid is also really just a linear method with a more primitive cutpoint choice,
and Spherical is one at a time and slow (expensive!
The Linear (dot product) methods work (Medoid and Linear) and there is really only the slight difference in ctpt placement.
Pre-compute the following series of projection vectors, D:
all diagonal vectors, Di=ei, D1,2=e1+e2, D1,-2=e1-e2, D1,-2..-n=e1-..-en
all pairwise class Average (mean) vectors: DA,i,j=AiAj where Ak  Average_of_X_over_Ck, k=1..K
the pairwise class VectorOfMedians vectors: DM,i,j=MiMj where Mk  VOM_of_X_over_Ck, k=1..K
D we compute the midpoint of D or low and high of xoD over each class, then build a polygonal hull, tightly for Linear and loosely for Medoid. For a loose hull we have to examine for "none of the above" separately at great expense. If we always build a tight polygonal hull, we end up with just one method:
The FAUST Polygon classifier: Take the above series of D vectors
(Add additional Ds if you wish - the more the merrier - but watch out for the cost of computing {CkoD}k=1..K
e.g., add CAFFAs (Class Avg-FurthestFromAvg), CFFAFFF (Class FurthestFromAvg-FurthestFromFurthest)
D in the D_series, let lD,kmnCkoD (or 1st PCI) and let hD,kmxCkoD (or last PCD).
y isa Ck iff yHk where Hk = {zSpace | lD,k  Doz  hD,k D in the series}
If y is in the polygonal hull of more than one class, say, y Hi1..Hih, then y can be
fuzzy classified by weight(y,k)=OneCount{PCk & PHi1 ... & PHih} and, if we wish, we can
declare y isa Ck where weight(y,k) is a maximum weight.
Or we can let Sphere(y,r)={z | (y-z)o(y-z)<r2} vote (but, requires the construction of Sphere(y,r) )

3. FAUST Count Change Clusterer, FCCC
Taking our Pulse on FAUST Clusterers, 03/01/2014
A Clusterer (an unsupervised analytic) analyzes data objects without consulting a known class label (usually none are present).
Objects are clustered (grouped) by maximizing the intra-class similarity and minimizing the inter-class similarity.
Clustering facilitates taxonomy formation (organizing objects into a hierarchy that group similar events together (dendogram?).
FAUST Count Change Clusterer, FCCC
1.Choose a "next D" plan, e.g., always AM, AFFA, FFAFFF, cycle thru e1..en,e1e2.., AM, AFFA, FFAFFF ..
a DensityThreshold (DT), DensityUniformityThreshold(DUT), PrecipitousCountChangeThreshold(PCCT).
2. If DT or DUT are not exceeded at a dendogram node (a cluster), partition that node as follows:
2a. Apply UDR (from hi-to-lo bitslice pTrees) until a PCC appears.
Then build that (those) UDR branches all the way down to a PCC point or until the PCC disappears.
2b. Cut at each singleton PCC.
FAUST CC Clust Notes: As will be obvious from the next slide, deciding on and using PCCT is a challenge.
Expensive parts? Creating some of the SPTSs, e.g., XoD for D other than a diagonal. Finding PCC using UDR
Taking our Pulse on FAUST Anomaly Detectors
Anomaly Detector (outlier detection analytic) identifies objects that don't comply with behavior of data-model.
Mostly outliers are discarded as noise or exceptions.
In some apps, such as fraud detection, rare events are the more interesting.
Outliers may be detected with Statistics, Distance, Density and Deviation based outlier detectors.
Deviation based use a dissimilarity measure to reduce overall dissimilarity by removing "deviation outliers"
Statistical tests assume a distribution/probability model,
Outlier mining can mean:
1. Given a set of n objects and k, find the top k objects in terms of dissimilarity from the rest of the objects.
2. Given a Training Set, identify outlier objects within each class (correctly classified but noticeably dissimilar.
3. Determine "fuzzy" clusters, i.e., assign a weight for each object in each cluster (Does a dendogram do that?).
We believe that FAUST Count Change clusterer is the best Anomaly Detector we have at this time.

4. [0,32) 118 [32,64) 2 (Drop this branch)
FCCC on IRIS 1st 10 of each class= TestSet For a change to be Precipitous, it must be > 8 (which is 8/120=.067 of the TrainingSet)
Should the PCCT be reduced as you go down the tree?
I think so since as we enter a round cluster, the absolute change starts small and builds
Avg
Med
D=AM
[0,64) 120
[0,32) [32,64) 2 (Drop this branch)
1 =25 bit
[0,16) [16,32) [32,48) [48,64)
1 =24 bit
[0,8) [8,16) [16,24) [24,32) 6 (Drop branch) 1
1 =23 bit
[0,4)3 [4,8)12 [8,12)21 [12,16)32 [16,20)28 [20,24)16 1
1 =22 bit
[4,6)4 [6,8)8 [8,10)9 [10,12)12 [12,14)19 [14,16)13 [16,18)12 [18,20)16 [20,22)11 [22,24)5 1
=21 bit 1
1 =20 bit
So then at 20 level, we might use PCCT=4, so we would cut at 13.5 and Having checked, these cutpoints are not so good
F < 13.5: s=34, e=14, i= 4
13.5 < F < 17.5: s= 5, e=15, i= 7
17.5 < F s= 1, e=11, i=29
The reason may be Avg and Med are so close (which will be the case for most larger datasets). I will try ek and other diagonals.

5. FAUST OCS One Class Spherical on the Spaeth dataset as a "lazy" classifier
So yf is not in C since it is spherically gapped away from C by r=3 units.
How expensive is the algorithm? For each x
1. Compute SPTS, (C-x)o(C-x)
2. Compute mask pTree (C-x)o(C-x) < r2
3. Count 1-bits in that mask pTree.
Let the Class be {yb,yc.yd,ye}. OCS classify x=yf. Let r=3.
1 y1y y7
2 y3 y y8
3 y y y9 ya 5 6 7 yf yb
a yc
b yd ye
a b c d e f
C1 pTrees C2 pTrees
C C C (c-x)o(c-x) yb yc yd ye yf
Shortcut for 1.d,e,f by some comparison of hi bitslices of (C-x)o(C-x) with #9?
(I think Yue Cui has a shortcut ???)
C C yb yc yd ye
x=yf
C as a
PTS is:
and x=yf:
Shortcut for 1.a,b,c,d,e,f:
(C-x)o(C-x) = CoC -2Cox +|x|2 < r2
|x|2-r2 + CoC < 2Cox
# # #
1a Compute SPTS (C-x)o(C-x):
1.f Conclude that yfC
1.b Form cosntant SPTSs
1.e Count the 1 bits = 0
1.c Construct (C-x)o(C-x) by SPTS arithmetic:
(C-x)o(C-x)=(C1-#7)(C1-#7) + (C2-#8)(C2-#8)
1.d Construct the mask pTree (C-x)o(C-x)<#9
Precompute (1 time) SPTS CoC and PTS 2C (2C is just a re-labeling (shift left) of pTrees of C).
For each new unclassified sample, x,
add |x|2-r2 to CoC (adding one constant to one SPTS)
compute 2Cox (n multiplications of one SPTS, 2Ci, by one constant, xi' then add the n resulting SPTSs.
compare |x|2-r2 +CoC to 2Cox giving us a mask pTree. Count 1-bits in this mask pTree (shortcuts?, shortcuts?, shortcuts?)
CoC pTrees
CoC
2C1 pTrees C2 pTrees
2C C
a = |x|2-r2 = 104
CoC+a pTrees
CoC+a
2Cox pTrees
2Cox
CoC+a>2Cox
Ct=0 so x not in C
1class classify unclassified sample, x=(a,9). Let r=3.
CoC+a pTrees
CoC+a
2Cox pTrees
2Cox
CoC+a>2Cox 1
Ct=4 so x in C

6. FAUST OCL One Class Linear classifier applied to IRIS, SEEDS, WINE, CONCRETE datasets
For series of D's = diagonals e1, e2, ...en, e1+e2, e1-e2, e1+e3, e1-e3, ...,e1-e2-...-en
For IRIS with C=Vers, outliers=Virg, FAUST 1D: SLcutpts (49,70); SWcutpts(22,32); PLcutpts(33,49); PW Ctpts(10,16) 44 vers correct. 7 virg errors
Trim outliers: ; :50,
1D_2D model classifies 50 vers (no eliminated outliers) and 3 virg in the 1class
1D_2D_3D model classifies 50 vers (no eliminated outliers) and 3 virg in the 1class
1D_2D_3D_4D model classifies 50 vers (no eliminated outliers) and 3 virg in the 1class
The 3 persistent virg errors
virg
virg
virg
The 1D model classifies 50 class1 and 15 class2 incorrectly as class1.
The 1D model classifies 50 class1 and 30 class3 incorrectly as class1.
The 1D model classifies 50 class1 and 0 class3 incorrectly as class1.
For SEEDS with C=class1 and outliers=class2
The 1D_2D model classifies 50 class1 and 8 class2 incorrectly as class1.
The 1D_2D_3D model classifies 50 class1 and 8 class2 incorrectly as class1.
The 1D_2D_3D_4D model classifies 50 class1 and 8 class2 incorrectly as class1.
For SEEDS with C=class1 and outliers=class3
The 1D_2D model classifies 50 class1 and 27 class3 incorrectly as class1.
The 1D_2D_3D model classifies 50 class1 and 27 class3 incorrectly as class1.
The 1D_2D_3D_4D model classifies 50 class1 and 27 class3 incorrectly as class1.
For SEEDS with C=class2 and outliers=class3
The 1D_2D model classifies 50 class1 and 0 class3 incorrectly as class1.
The 1D_2D_3D model classifies 50 class1 and 0 class3 incorrectly as class1.
The 1D_2D_3D_4D model classifies 50 class1 and 0 class3 incorrectly as class1.
For WINE with C=class4 and outliers=class7 (Class 4 was enhanced with 3 class3's to fill out the 50)
The 1D model classifies 50 class1 and 48 class3 incorrectly as class1.
The 1D_2D model classifies 50 class1 and 43 class3 incorrectly as class1.
The 1D_2D_3D model classifies 50 class1 and 43 class3 incorrectly as class1.
The 1D_2D_3D_4D model classifies 50 class1 and 42 class3 incorrectly as class1.
For CONCRETE, concLH with C=class(8-40) and outliers=class(43-67)
The 1D model classifies 50 class1 and 43 class3 incorrectly as class1.
The 1D_2D model classifies 50 class1 and 35 class3 incorrectly as class1.
The 1D_2D_3D model classifies 50 class1 and 30 class3 incorrectly as class1.
The 1D_2D_3D_4D model classifies 50 class1 and 27 class3 incorrectly as class1.
For CONCRETE, concM (class is the middle range of strengths)
The 1D model classifies 50 class1 and 47 class3 incorrectly as class1.
The 1D_2D model classifies 50 class1 and 37 class3 incorrectly as class1.
The 1D_2D_3D_4D model classifies 50 class1 and 26 class3 incorrectly as class1.

7. FAUST MCL Class1=C1={y1,y2.y3,y4. Class2=C2={y7,y8.y9}.
C e e y y y y y y y yb yc yd ye
mn1 1
mx1 3
mn2 1 mx mn mx mn mx
mn1 14
mx1 15
mx2 3 mn mx mn mx
mn1 9 mx
mn2 9 mx mn mx mn mx
Class1=C1={y1,y2.y3,y4.
xCk iff lok,D  Dox  hik,D D.
Class2=C2={y7,y8.y9}.
Class3=C3={yb,yc.yd,ye}
1 y1y y7
2 y3 y y8 y
3 y y y9 ya 5 6 7 yf yb
a x yc
b yd ye
a b c d e f
Shortcuts for MCL? Pre-compute all diagonal minimums and maximums; e1, e2, e1+e2, e1-e2. Then in fact, there is no pTree processing left to do (just straight forward number comparisons).
xf On basis of e1 it is "none-or-the-above"
9,a It is in class3 (red) only
ya On the basis of e1 it is "none-or-the-above"
Versicolor 1D
min
max
n n n n4
x x x x4
y On the basis of e1 it is "none-or-the-above"
f, It is in class2 (green) only
1D MCL Hversicolor has 7 virginica!
Versicolor 2D
min
max
n12 n13 n14 n23 n24 n34 n1-2 n1-3 n1-4 n2-3 n2-4 n3-4
x12 x13 x14 x23 x24 x34 x1-2 x1-3 x1-4 x2-3 x2-4 x3-4
1D_2D MCL Hversicolor has 3 virginica!
1D_2D_3D MCL Hversicolor has 3 virginica!
Versicolor 3D
min
max
n n n n234 n n1-23 n n n1-24
x x x x234 x x1-23 x x x1-24
n n n1-34 n n n2-34 n2-3-4
x x x1-34 x x x2-34 x2-3-4
Versicolor 4D
min
max
n1234 n n n n n n n
x1234 x x x x x x x
1D_2D_3D_4D MCL Hversicolor has 3 virginica (24,27,28)
1D_2D_3D_4D MCL Hvirginica has 20 versicolor errors!! Look at removing outliers (gapped>=3) from Hullvirginica
23 Ct gp
'''
e1 Ct gp
...
79 1
e2 Ct gp
...
38 2
e3 Ct gp
...
69 1
e4 Ct gp
25 3
12 Ct gp
...
13 Ct gp
104
...
146
14 Ct gp
...
102 1
24 Ct gp
no outliers
34 Ct gp
...
92 1
Hvirginica
12 versic
Hvirginica
15 versic
Hvirginica
3 versic
1D MCL Hvirginica
only 16 versicolors!
One possibility would be to keep track of those that are outliers to their class but are not in any other class hull and put a sphere around them. Then any unclassified sample that doesn't fall in any class hull would be checked to see if it falls in any of the class outlier spheres???

8. FAUST Outlier Detector When the goal is to only to find outliers as quickly as possible.
FOD-1 recursively uses a vector, D=FurthestFromMedian-to-FurthestFromFurthestFromMedia. Mean=(8.53, 4,73) Median=(9, 3)
1 y1y y7
2 y3 y y8
3 y y y9 ya 5 6 7 yf yb
a yc
b yd ye
a b c d e f
d2(y1,x),
D=y1->y9 4 2 8 17 68
196
170
200
153
145
181
164 85
xoD =
xo(14,2) 16 44 32 48 74
132
212
200
216
190
158
174
148
176
114
d2(med,x) 68 40 50 36 17 26 37 53 64 29
xoD2
13.
14.
12.
11.
20.
17.
16. 14
3.9
2.6
0.9
4.2
xoD3
1.6
4.3
3.3 5
7.3 13
20.
19. 21
18.
16. 18
15. 12
FOD-1 won't work for big data. Finding outliers is local.
Big data has many localities to exhaustively search.
We may need to enclose each outlier in a gapped hulls.
Those gapped hulls will likely be filled in when projecting onto a randomly chosen line.
I.e., barrel gapping suffers from a chicken-egg problem:
First look for linear gaps and then radial gaps out from it.
Unless line runs thru outlier radial gap not likely to appear y1 y2 y3 y4 y5 y6 y7 y8 y9 ya yb yc yd ye yf
xoD Distribution down to 25:
[0,32) [32,64) [64,96) [96,128) [128,160) [160,192) [192,224)
Thinnings [0,32) and [64,128). So we check y1,y5,yf. y5 and yf check out as outliers, y1 does not. Note y6 does not either!
Let D2 be mean to median and go down to 22:
[0,4) [4,8) [8,12) [12,16) [16,20) [20,24) Thinnings [4,12), [20,24). yf checks out as outlier, y4 does not. Note y6 does not either!
Let D3 be (Median to FurthestFromMedian)/6 and go down to 22:
[0,4) [4,8) [8,12) [12,16) [16,20) [20,24) Thinnings [8,16) yf , y6 check out as outlier, yd does not.
This D3 isd best? FOD-1 doesn't work well for interior outlier identifiction (which is the case for all Spaeth outliers.
FOD-2 uses FAUST CC Clusterer (CC=Count Change) to find outliers.
CC removes big clusters so that as it moves down the dendogram clusters gets smaller and smaller.
Thus outliers are more likely to reveal themselves as singletons (and doubletons?) gapped away from their complements.
With each dendogram iteration we will attempt to identify outlier candidates and construct the SPTS of distances from each candidate
(If the minimum of those distance exceeds a threshold, declare that candidate an outlier.).
E;g;, look for outliers using projections onto the sequence of D's = e1,...,en , then diagonals, e1+e2, e1-e2, ...
We look for singleton (and doubleton?...) sets gapped away from the other points.
We start out looking for coordinate hulls (rectangles) that provide a gap around 1 (or2? or 3?) points only.
We can do this by intersecting "thinnings" in each DoX distribution.
ote, if all we're interested in anomalies, then we might ignore all PCCs that are not involved in thinnings. This would save lots of time!
(A "thinning" is a PCD to below threshold s.t. the next PCC is a PCI to above threshold. The threshold should be  PCC threshold.)
1 y1y y7
2 y3 y y8
3 y y y9 ya 5 6 7 yf yb
a yc
b yd ye
a b c d e f
DensityCount/r2 labeled dendogram for FAUST on Spaeth with D=AvgMedian DET=.3 A A
So intersect thinnings [1,1]1, [5,7]1 and
[13,14]1 with [4,10]2

9. Choosing a clustering from a Density and/or Density Uniformity labeled Dendogram
The algorithm for choosing the optimal clustering from a labeled dendogram is as follows:
Let DET=DEnsityThreshold=.4
and DUT=DensityUniformityThreshold=½
Since a full dendogram is far bigger than the original table, we set threshold(s),
We build a partial dendogram (ending a branch when threshold(s) are met)
Then a slider for density would work as follows:
The user set the threshold(s). We give the clustering.
The user increases threshold(s). We prune the dendogram and give clustering.
The user decreases threshold(s). We build each branches down further until the new threshold(s) are exceeded and give the new clustering.
We might want to also display the dendogram to the user and let him select a "node=cluster" for further analysis, etc.
DEL=.1
DUL=1/6
DEL=.2
DUL=1/8
DEL=.5
DUL=½
DEL=.3
DUL=½
DEL=.4
DUL=1
DEL=
DUL=
DEL=
DUL=
DEL=
DUL=
DEL=
DUL=
DEL=
DUL=
DEL=
DUL=
DEL=
DUL=
A B C D E F G

10. FAUST Clusterer Gap-based cut-points only. Spaeth Dataset
FAUST Clusterer Gap-based cut-points only. Spaeth Dataset. DensityCount/r2 labeled dendogram
We make cuts only in the middle of Gaps in the XoD SPTS, rather than at all Precipitous Count Changes (PCCs).
Since the Spaeth dataset is very small, we get by with gaps only. For large datasets, we would use PCC cuts.
DensityCount/r No DensityUniformity is used here We create a labeled dendogram using FAUST Cluster on Spaeth
a bc def
UDR gives the above distribution of xoD values
D is the Average-to-FurthestFromAverage (AFFA) vector
Gap cuts are made at 7 and 11
1 y1y y7
2 y3 y y8
3 y y y9 ya 5 6 7 yf yb
a yc
b yd ye c d e f
a b c d e f
D-line
DensityThreshold=.3
cut-lines
Y (Density=.15)
{y1,y2,y3,y4,y5}(.37)
{y6,yf}(.08)
{y7,y8,y9,ya,yb.yc.yd.ye} (Density=.07)
{y6}()
{yf}()
{y7,y8,y9,ya}(.39)
{yb,yc,yd,ye}(1.01)
On the next slide the Density Threshold is increased to In the User Interface this would presumably be done with a slider. The above DensityThreshold=.3 dendogram is the starting point. We build the 2 leaves that have a density <.5 down further until they do.
One final note: For large datasets we don't apply UDR all the way down to singleton points since the distribution object is then bigger than the dataset itself. We build it down until the PCCs reveal themselves roughly but then we may want to build those PCC branches all the way down so that we get a precise placement for our cut point. There should be approximately two PCCs per cluster, and therefore the number of branches built all the way down will usually not be high.

11. FAUST Clusterer Gap-based cut-points only; applied to the Spaeth Dataset. Increase DensityThreshold from .3 to ,5
1 y1y y7
2 y3 y y8
3 y y y9 ya 5 6 7 yf yb
a yc
b yd ye c d e f
a b c d e f
D=Average-to-FurthestFromAverage
Density Threshold=.3
Y(.15)
{y1,y2,y3,y4,y5}(.37)
{y6,yf}(.08)
{y7,y8,y9,ya,yb.yc.yd.ye}(.07)
Density Threshold=.5
{y1,y2,y3,y4}(.63)
{y5}()
{y6}()
{yf}()
{y7,y8,y9,ya}(.39)
{yb,yc,yd,ye}(1.01)
DensThresh=.5
{y7,y8,y9}(1.27)
{ya}()

12. FAUST Clusterer Gap-based cut-points only; applied to the Spaeth Dataset. Increase DensityThreshold from .5 to 1
1 y1y y7
2 y3 y y8
3 y y y9 ya 5 6 7 yf yb
a yc
b yd ye c d e f
a b c d e f
D=Average-to-FurthestFromAverage
DensityThreshold=.5
Y(.15)
{y1,y2,y3,y4,y5}(.37)
{y6,yf}(.08)
{y7,y8,y9,ya,yb.yc.yd.ye}(.07)
{y1,y2,y3,y4}(.63)
{y5}()
{y6}()
{yf}()
{y7,y8,y9,ya}(.39)
{yb,yc,yd,ye}(1.01)
DensityThreshold=1
{y7,y8,y9}(1.27)
{ya}()
{y1,y2,y3}(2.54)
{y4}()

13. FAUST Clusterer Gap-based cut-points only; applied to the Spaeth Dataset. DensityThreshold = .3
Comparing D=AverageToFuirthestFromAverage (AFFA) applied recursively to D=diagonals applied cyclically.
On this slide we see that we can use a different sequence of D-lines and get a different dendogram.
However notice that the leaf clusterings arrived at in the end are the same..
1 y1y y7
2 y3 y y8
3 y y y9 ya 5 6 7 yf yb
a yc
b yd ye
a b c d e f
Labeled dendogram for FAUST Cluster on Spaeth
with D=furthest-to-Avg, DensityThreshold=.3
1 y1y y7
2 y3 y y8
3 y y y9 ya 5 6 7 yf yb
a yc
b yd ye
a b c d e f
DCount/r2 labeled dendogram for FAUST Clusteron Spaeth with
D=cylces thru diagonals nnxx,nxxn,nnxx,nxxn..., DensThresh=.3
Y(.15)
{y1,y2,y3,y4,y5}(.37)
{y6,y7,y8,y9,ya,yb.yc.yd.ye,yf}(.09)
Y(.15)
{y6,y7,y8,y9,ya}(.17)
{yb,yc,yd,ye,yf}(.25)
y1,2,3,4,5(.37
{y6,yf}(.08)
{y7,y8,y9,ya,yb.yc.yd.ye}(.07)
{y7,y8,y9,ya}(.39)
{y6}()
{yf}()
{yb,yc,yd,ye}(1.01)
{y6}()
{yf}()
{y7,8,9,a}(.39)
{yb,yc,yd,ye}(1.01)

14. UDR Univariate Distribution Revealer (on Spaeth:)15
UDR Univariate Distribution Revealer (on Spaeth:)
applied to S, a column of numbers in bistlice format (an SpTS), will produce the DistributionTree of S DT(S)
depth=h=0
depth=h=1
Y y1 y2 y y y y y y y y y
ya 13 4
pb 10 9
yc 11 10
yd 9 11
ye 11 11
yf 7 8
yofM 11 27 23 34 53 80
118
114
125
110
121
109 83 p6 1 p5 1 p4 1 p3 1 p2 1 p1 1 p0 1
p6' 1
p5' 1
p4' 1
p3' 1
p2' 1
p1' 1
p0' 1
node2,3
[96.128) f=
depthDT(S)b≡BitWidth(S) h=depth of a node k=node offset
Nodeh,k has a ptr to pTree{xS | F(x)[k2b-h+1, (k+1)2b-h+1)} and its 1count
p6' 1
5/64 [0,64) p6
10/64 [64,128)
p5' 1
3/32[0,32)
2/32[64,96) p5
2/32[32,64)
¼[96,128)
p3' 1
0[0,8) p3
1[8,16)
1[16,24)
1[24,32)
1[32,40)
0[40,48)
1[48,56)
0[56,64)
2[80,88)
0[88,96)
0[96,104)
2[194,112)
3[112,120)
3[120,128)
p4' 1
1/16[0,16) p4
2/16[16,32)
1[32,48)
1[48,64)
0[64,80)
2[80,96)
2[96,112)
6[112,128)
Pre-compute and enter into the ToC, all DT(Yk) plus those for selected Linear Functionals (e.g., d=main diagonals, ModeVector .
Suggestion: In our pTree-base, every pTree (basic, mask,...) should be referenced in ToC( pTree, pTreeLocationPointer, pTreeOneCount ).and these
OneCts should be repeated everywhere (e.g., in every DT). The reason is that these OneCts help us in selecting the pertinent pTrees to access - and in fact are often all we need to know about the pTree to get the answers we are after.).

15. APPENDIX:
UDR: Can we create distributionX1+2 etc. using only X1 and X2 basic ptrees (concurrently with the creation of distributionsX1, distributionX2)?
An example: X1 3 1 2
P1,1 1
P1,0 1 X2 1 3
P2,1 1
P2,0 1
X1+2 4 1 3
P1+2,2 1
P1+2,1 1
P1+2,0 1
Let D=D1,2  e1+e2 Then DoX = 21P1,1+20P1, P2,1+20P2,0
= 21(P1,1+P2,1) (P1,0+P2,0) so we can make the 2 SPTS additions (the ones in parenthesis), shift the first left by 1 and add it to the second. But can we go directly to the UDR construction?
P1+2,1 = (P1,1 XOR P2,1) AND (NOT(P1,0&P2,0)) ...
Is there a more efficient way to get the X1+X2 distribution using this route? Md?
We don't need the SPTS for X1+X2 and it's expensive to create it just to get its distribution.
no carry from zero bit
P1+2,0 = P1,0 XOR P2,0
Md: This seems like it would give us a tremendous advantage over the "horizontal datamining boys and girls" because even though they could concurrently create all diagonal distributions, X1, X2, X1+2, X1-2, ... in one pass down the table, we would be able to do it with concurrent programs which make one pass across the SPTSs for X1 and X2.

16. Size P_4bit P_8bit P_12bit P_16bit Horizontal 1 465 930 1390 1790 2990
Mohammad's results 2014_02_15:
Experimental Result of Addition:
Data size:
1 billion, 2 billion, 3 billion, 4 billion.
Number of columns: 2
Bit width of the values:
4 bit, 8 bit, 12 bit and 16 bit .
Vertical axis is time measured in millisecond. Horizontal axis is number of bit positions.
Size
P_4bit
P_8bit
P_12bit
P_16bit
Horizontal 1
465
930
1390
1790
2990 2
950
1910
2860
3590
5970 3
1420
2850
4270
5360
8950 4
1800
3560
5370
7140
12420

17. APPLYING FAUST GAP Clusterer TO SPAETH
DensityCount/r2 labeled dendogram for FAUST GAP Cluster on Spaeth
with D=Avg-to-Furthest and DensityThreshold=.3
a bc def
Y(.15)
{y1,y2,y3,y4,y5}(.37)
{y6,yf}(.08)
{y7,y8,y9,ya,yb.yc.yd.ye}(.07)
D=Avg-to-Furthest cut at 7 and 11
1 y1y y7
2 y3 y y8
3 y y y9 ya 5 6 7 yf yb
a yc
b yd ye c d e f
a b c d e f
{y1,y2,y3,y4}(.63)
{y5}()
{y6}()
{yf}()
{y7,y8,y9,ya}(.39)
{yb,yc,yd,ye}(1.01)
{y7,y8,y9}(1.27)
{ya}()
{y1,y2,y3}(2.54)
{y4}()
D=Avg-to-Furth
DensityThresh=1
D=Avg-to-Furth
DensityThresh=.5
D-line
Labeled dendogram for FAUST Cluster on Spaeth
with D=furthest-to-Avg, DensityThreshold=.3
1 y1y y7
2 y3 y y8
3 y y y9 ya 5 6 7 yf yb
a yc
b yd ye
a b c d e f
DCount/r2 labeled dendogram for FAUST Gap Cluster on Spaeth w
D=cylces thru diagonals nnxx,nxxn,nnxx,nxxn..., DensThresh=.3
Y(.15)
{y1,y2,y3,y4,y5}(.37)
{y6,y7,y8,y9,ya,yb.yc.yd.ye,yf}(.09)
Y(.15)
{y6,y7,y8,y9,ya}(.17)
{yb,yc,yd,ye,yf}(.25)
y1,2,3,4,5(.37
{y6,yf}(.08)
{y7,y8,y9,ya,yb.yc.yd.ye}(.07)
{y7,y8,y9,ya}(.39)
{y6}()
{yf}()
{yb,yc,yd,ye}(1.01)
{y6}()
{yf}()
{y7,8,9,a}(.39)
{yb,yc,yd,ye}(1.01)

18. Classify x as class C iff there exists cC such that (c-x)o(c-x)  r2
FAUST Classifiers FAUST = Fast, Analytic, Unsupervised and Supervised Technology
C = class, X = unclassified samples,
r = a chosen minimum gap threshold.
Classify x as class C iff there exists cC such that (c-x)o(c-x)  r2
FAUST One-Class Spherical (OCS)
Classify x as class C iff the count of cCk s.t.(c-x)o(c-x)  r2 is max
FAUST Multi-Class Spherical (MCS)
FAUST One-Class Linear (OCL) Construct a hull, H, around C. x is class C iff xH. For a series of vectors, D, let loDmnCoD (or the 1st PCI); hiDmxCoD (or the last PCD). Classify xC iff loD  Dox  hiD D.
E.g., let the D-series be the diagonals e1, e2, ...en, e1+e2, e1-e2, e1+e3, e1-e3, ...,e1-e2-...-en? (add more Ds until diamH-diamC < ε?
FAUST Multi-Class Linear (MCL) Construct a hull, Hk, about Ck k as above. Then x isa Ck iff k, xHk.
(allows for a "none of the classes" when xHk,  k.)
The Hks can be constructed in parallel:
mnAoD12
mnCoD12
mxCoD12
Convex hull
Our hull, H
c c
c c c
c c c cc
c c
c c cc c
c c
c c c
c c c cc
c c
c c cc c
a a
a a a
a a a aa
a a
a a aa a
b b
b b b
b b b bb
b b
b b bb b
D12=e1-e2
line
mnC1
mxC1
mnA1
mxAoD12
mnB1
mxA1
mxB1 e1 e2 e3
mnBoD12
mxBoD12
D=e1+e2+e3
3D example of HULL1
D=e1+e3
D=e1-e3
e1 line
1-class classification Reference :