Oral Exam - Community Grids Lab

Document Sample
Oral Exam - Community Grids Lab Powered By Docstoc
					    MapReduce, GPGPU and 
Iterative Data mining algorithms
        Oral exam Yang Ruan




                                   1
                   Outline
•   MapReduce Introduction
•   MapReduce Frameworks
•   General Purpose GPU computing
•   MapReduce on GPU
•   Iterative Data Mining Algorithms
•   LDA and MDS on distributed system
•   My own research

                                        2
               MapReduce
• What is MapReduce
  – Google MapReduce / Hadoop
  – MapReduce merge
• Different MapReduce Runtimes
  – Dryad
  – Twister
  – Haloop
  – Spark
  – Pregel

                                 3
                                             MapReduce
      • Introduced by Google MapReduce
      • Hadoop is an open source MapReduce framework
                                                               User
Mapper: read input data, emit                                Program                    Reducer: accept a key and all 
key/value pairs                                                                         the values belongs to that key, 
                                           fork            fork     fork                emits final output
                                                             Master
                        Map              assign                                  assign         Reduce
                                         map                                     reduce
 Input Data
                                Worker                                                                  write             Output
     Split 0                                      local                                 Worker                             File 0
     Split 1 read               Worker
                                                  write
     Split 2                                                                                                              Output
                                                                                        Worker                             File 1
                                Worker                                   remote read, sort


Dean, J. and S. Ghemawat (2008). "MapReduce: simplified data processing on large clusters." Commun. ACM 51(1): 107-113.       4
                                MapReduce-Merge
   •    Can handle heterogeneous inputs with a Merge step after MapReduce

                                   Driver                  coordinator



            split                 mapper
            split                                                reducer
                                  mapper
            split                                                reducer
                                  mapper
            split                                                                            merger                   output
                                                                                             merger                   output
            split                mapper                          reducer
            split
                                 mapper                          reducer
            split
            split                mapper


H. Yang, A. Dasdan, R. Hsiao, and D. S. Parker. Map-Reduce-Merge: Simplified Relational Data Processing on Large Clusters. 
                                                                                                                               5
                                                      SIGMOD, 2007.
                                                         Dryad
   • Use computational  as
         “vertices” and 
         communication as 
         “channels”
         to draw DAG.
   • Using DryadLINQ to 
         program
   • Always use one node 
         as the head node to 
         run graph manager (scheduler) for a DryadLINQ job (besides the head 
         node of the cluster)


 ISARD, M., BUDIU, M., YU, Y., BIRRELL, A., AND FETTERLY,D. Dryad: Distributed data-parallel programs from sequential 
               building blocks. In Proceedings of European Conference on Computer Systems (EuroSys), 2007.
Yu, Y., M. Isard, et al. (2008). DryadLINQ: A System for General-Purpose Distributed Data-Parallel Computing Using a High   6
                   -Level Language. Symposium on Operating System Design and Implementation (OSDI).
                                                    Twister
 • Iterative MapReduce by keeping long running mappers and reducers.
 • Use data streaming instead of
       file I/O
 • Use broadcast to send out 
       updated data to all mappers
 • Load static data into memory 
 • Use a pub/sub messaging 
       infrastructure
 • No file system, the data are 
       saved in local disk or NSF




 J.Ekanayake, H.Li, et al. (2010). Twister: A Runtime for iterative MapReduce. Proceedings of the First International 
                                                                                                                         7
Workshop on MapReduce and its Applications of ACM HPDC 2010 conference June 20-25, 2010. Chicago,  Illinois, ACM.
   Other iterative MapReduce runtimes
Haloop                       Spark                          Pregel
Extension based on Hadoop Iterative MapReduce by            Large scale iterative graphic 
                          keeping long running              processing framework
                          mappers and reducers
Task Scheduler keeps data    Build on Nexus, a cluster      Use  long living workers to 
locality for mappers and     manger keep long running       keep the updated vertices 
reducers                     executor on each node.         between Super Steps.
Input and output are         Static data are cached in      Vertices update their status 
cached on local disks to     memory between iterations.     during each Super Step.
reduce I/O cost between                                     Use aggregator for global 
iterations                                                  coordinates.

Fault tolerance same as      Use Resilient Distributed      Keep check point through 
Hadoop.                      Dataset to ensure the fault    each Super Step. If one 
Reconstruct cache to the     tolerance                      worker fail, all the other 
worker assigned with failed                                 work will need to reverse.
worker’s partition.

                                                                                          8
                         Different Runtimes
Name      Iterative     Fault       File   Scheduling     Higher Caching   Worker    Environment
                      Tolerance   System                   level            Unit
                                                        language
Google       No        Strong      GFS      Dynamic     Sawzall     --     Process      C++
Hadoop       No        Strong     HDFS      Dynamic       Pig       --     Process      Java
Dryad        No        Strong      DSC      Dynamic      Dryad-     --       --         .NET
                                                          LINQ
Twister     Yes        Weak         --       Static        --     Memory   Thread       Java
Haloop      Yes        Strong     HDFS      Dynamic        --      Disk    Process      Java
Spark       Yes        Weak       HDFS       Static      Scala    Memory   Thread       Java
Pregel      Yes        Weak        GFS       Static        --     Memory   Process      C++




                                                                                           9
 General Purpose GPU Computing
• Runtimes on GPU
  – CUDA
  – OpenCL
• Different MapReduce framework for 
  Heterogeneous data
  – Mars/Berkley’s MapReduce
  – DisMarc/Volume Rendering MapReduce
  – MITHRA

                                         10
                            CUDA architecture
•   Scalable parallel programming model on heterogeneous data
•   Based on NVIDIA’s TESLA architecture

                                                      Integrated CPU + GPU C 
               CUDA Optimized Libraries
                                                            Source Code

                                      NVIDIA C Compiler (NVCC)

                    NVIDIA Assembly for 
                                                            CPU Host Code
                     Computing (PTX)

             CUDA Driver                  Profiler        Standard C Compiler


                                GPU                              CPU


http://developer.nvidia.com/category/zone/cuda-zone                             11
                             GPU programming
•    CPU(host) and GPU(device) are separate devices with separate DRAMs
•    CUDA and openCL are two very similar libraries



Host                                         Device          GPU
                     CPU                                              MultiProcessor
                                               DRAM
                                                                   MultiProcessor
                                                  Local 
                                                 memory
                                                               MultiProcessor
                                                   Global         Register
    DRAM           Chipset                                     Shared Memory
                                                  Memory




     http://developer.nvidia.com/category/zone/cuda-zone                               12
          GPU MapReduce on single GPU
                                                    Scheduler                           Map Split
  •     Mars                                         on CPU
         – Static scheduling
         – Mapper: one thread per partition                                            M           M
         – Reducer: one thread per key
         – Hiding the GPU programming from                                                                GPU 
               the programmer                                                                          Processing
                                                                                           Sort

  •    GPU MapReduce (GPUMR)
         – Use hierarchical reduce                                                     Reduce Split



                                                                                       R           R



Bingsheng He, Wenbin Fang, Qiong Luo, Naga K. Govindaraju, and Tuyong Wang. Mars: A        Merge
              MapReduce Framework on Graphics Processors. PACT 2008.
 B. Catanzaro, N. Sundaram, and K. Keutzer. A map reduce framework for programming                          13
    graphics processors. In Workshop on Software Tools for MultiCore Systems, 2008.
        GPU MapReduce on multiple nodes
    •    Distributed MapReduce                                    •     Volume Rendering 
         framework on GPU cluster                                       MapReduce (VRMR)
         (DisMaRC)                                                •     Use data streaming for 
    •    Use MPI (Message Passing                                       cross node communication
         Interface) cross node 
         communication
                                             Inter keys & vals            sorted keys & vals


                                                     M                                     R
                                       G1                                          G1
                                                     M                                     R
                   Master             … …                        Master            … …          output
Input
                                                    … …                                   … …

                                       Gn            M                             Gn      R

  Jeff A. Stuart, Cheng-Kai Chen, Kwan-Liu Ma, John D. Owens, Multi-GPU Volume 
                             Rendering using MapReduce
Alok Mooley, Karthik Murthy, Harshdeep Singh. DisMaRC: A Distributed Map Reduce                     14
                                framework on CUDA
                                              MITHRA
•   Based on Hadoop for cross node communication, use Hadoop Streaming 
    as mapper 
•   Use CUDA to write the map function kernel
•   Intermediate key/value pairs will be grouped by just one key

                                               Node 1                          CUDA
                             M                  GPU


                             M                  GPU
    Hadoop                                                                         R        Hadoop

                                                 …
                              …

                             M                  GPU

                                             Node n
Reza Farivar, et al, MITHRA: Multiple data Independent Tasks on a Heterogeneous Resource 
                                                                                                     15
                                        Architecture
Different GPU MapReduce Framework
 Name     MultiNode     Fault Communi-     GPU     Scheduling   Largest
                      tolerance cation Programming               Test
 Mars        No         No        --       CUDA       Static    1 node/
                                                                 1 GPU
GPUMR        No         No        --       CUDA       Static    1 node/
                                                                 1 GPU
DisMaRC      Yes        No       MPI       CUDA       Static    2 node/
                                                                 4 GPU
 VRMR        Yes        No       Data      CUDA       Static    8 node/ 
                              Streaming                         32 GPU
MITHRA       Yes        Yes    Hadoop      CUDA      Dynamic    2 node/
                                                                 4 GPU




                                                                      16
        Data Mining Algorithms
• Latent Drichlet Allocation (LDA)
  – Gibbs sampling in LDA
  – Approximate Distributed LDA (AD-LDA)
  – Parallel LDA (pLDA)
• Multidimensional Scaling
  – Scaling by Majorizing a Complex Function 
    (SMACOF)
  – Parallel SMACOF
  – MDS Interpolation

                                                17
                  Latent Dirichlet Allocation
•                                                                                                   α



                                                                                                    θ



                                                                                                    z



                                                                                                    w        β
                                                                                                N
                                                                                            M



 Blei, D. M., A. Y. Ng, et al. (2003). "Latent Dirichlet allocation." Journal of Machine 
                                                                                                        18
                              Learning Research 3: 993-1022.
              Gibbs Sampling in LDA
•   Used for generating a sequence of sample from the joint probability 
    distribution of two or more random variables 
•   In LDA model, the sample refers to the topic assignment of word i in 
    document d; the joint probability distribution are from the topic 
    distribution over words and the document distribution over topics.
•   Given a corpus D ={w1,w2,…,wM}, a vocabulary {1,…,V} and a sequence of 
    words in Document w = (w1,w2,…,wn) and a topic collection T={0,1,2,…K}, 
    we can have 3 2D matrices to complete Gibbs sampling process:
     – nw: topic frequency over words(terms)
     – nd: document frequency over topics
     – z: topic assignment for a word in document




                                                                           19
                Approximate Distributed LDA
    •  




               Input                                           Processor


               …                                                 …                                Merge


               Input                                           Processor




Newman, D., A. Asuncion, et al. (2007). Distributed inference for latent Dirichlet allocation. 
                                                                                                          20
 NIPS' 07: Proc. of the 21st Conf. on Advances in Neural Information Processing Systems.
                                                              PLDA
    •     Use MPI and MapReduce to parallel LDA, applied on multi-nodes
    •     Apply global reduction after each iteration
    •     Test up to 256 nodes
                   MapReduce Model

                  nd and z                        nw                  1                             MPI Model

                                                                                                                    W
                       M                                          …
worker                                                                                            C                 W ……
  0                                                                                                                 ……
                       R                          R                                                                 W

                 Updated                    Updated                   p
                 nd and z                     nw
    Wang, Y., H. Bai, et al. (2009). PLDA: Parallel Latent Dirichlet Allocation for Large-Scale Applications. In 
                                                                                                                           21
  Proceedings of the 5th international Conference on Algorithmic Aspects in information and Management.
        Multidimentional Scaling (MDS)
 •     A statistical technique to visualize dissimilarity data
 •     Input: dissimilarity matrix with diagonal part all 0 (N * N)
 •     Output: target dimension matrix X (N * L), usually 3D or 2D (l=3 | l =2).
 •     Target matrix Euclidean distance:



 •     Raw Stress Value:




 •     Many possible algorithms: Gradient Descent-Type algorithms, Newton-
       Type algorithms and Quasi-Newton algorithms

Bronstein, M. M., A. M. Bronstein, et al. (2000). "Multigrid Multidimensional Scaling." 
                                                                                           22
            NUMERICAL LINEAR ALGEBRA WITH APPLICATIONS 00(1-6).
                                                   SMACOF
                                                     •    Scaling by Majorizing a Complex Function, 
                                                          given by equation:
                                                                                         with weight

                                                     •    Where  B(X) is




                                                     •    And V is a matrix with weight information. 
                                                          Assume all wij = 1, then:



Borg, I., & Groenen, P. J. F. (1997). Modern multidimensional scaling: Theory                           23
                                      Parallel SMACOF
    •    The main computation part is the matrix multiplication: B(Z) * Z
    •    Achieved Multicore matrix multiplication parallelism by block 
         decomposition




    •    The computation block can be fit into cache line.
    •    Multi-node using Message Passing Interface and Twister. 
                                                                        Broadcast X


                   Input                               M                           M
                Dissimilarity         …                …            R        C     …            R        C
                   Matrix                              M                           M
                                                    B(Z)Z Calculation              Stress Calculation
Bae, S.-H. (2008). Parallel Multidimensional Scaling Performance on Multicore Systems. Proceedings of 
  the Advances in High-Performance E-Science Middleware and Applications workshop (AHEMA) of                 24
                     Fourth IEEE International Conference on eScience, Indianapolis
                                 MDS Interpolation
  •  




Seung-Hee Bae, J. Y. C., Judy Qiu, Geoffrey C. Fox (2010). Dimension Reduction and Visualization 
                                                                                                    25
       of Large High-dimensional Data via Interpolation. HPDC'10 Chicago, Illinois USA.
                  My Research
• Million Sequence Clustering
  – Hierarchical MDS Interpolation
  – Heuristic MDS Interpolation
• Reduced Communication Parallel LDA
  – Twister-LDA
  – MPJ-LDA
• Hybrid Model in DryadLINQ programming
  – Matrix Multiplication
     • Row Split Algorithm
     • Row Column Split Algorithm
     • Fox-Hey Algorithm

                                          26
                                    Hierarchical/Heuristic MDS 
                                           Interpolation
•                    The k-NN problem in MDS interpolation can be time costing




                                                                                                10k Sample in 100k Data
                 16000
                                                                                 0.14
                 14000
                                                                                 0.12
                 12000
                                                                                  0.1
                 10000                                                                                                    standard-10k
time (seconds)




                                                                  Stress value




                                                                                 0.08
                 8000                                                                                                     hmds-10k
                                                            10k                  0.06
                 6000                                       50k                                                           heuristic-10k
                                                                                 0.04
                 4000                                                                                                     sample data stress
                                                                                 0.02
                 2000
                                                                                   0
                    0
                                                                                        2   3         5    10     50
                         Standard   Hierachical    Hybrid

                                    Input Models                                                k value
                                                                                                                                               27
                    Twister/MPJ-LDA
•   The global matrix nw does not need to be transferred as a full matrix since 
    some of the documents might not having this term on it.




                                                                              28
                Hybrid Model in DryadLINQ
•   Applying different algorithms of matrix multiplication on Dryad, by porting 
    multicore technology, the performance improves significantly

                160

                140

                120

                100
      Speedup




                                                                                       Sequential
                 80
                                                                                       TPL
                 60                                                                    Thread
                                                                                       PLINQ
                 40

                 20

                  0
                      RowPartition           RowColumnPartition              Fox-Hey

                                     Different Matrix Multiplication Model




                                                                                                    29
             Conclusion and 
         Research Opportunities
• Iterative MapReduce
  – Fault tolerance
  – Dynamic scheduling
  – Scalability
• GPU MapReduce
  – Scalability
  – Hybrid Computing
• Application
  – Twister-LDA, Twister-MDS Scalability
  – Port LDA, MDS to GPU MapReduce system

                                            30
Thank you!




             31
APPENDIX




           32
                                               Hadoop
•     Concept are same as Google MapReduce
•     Input, Intermediate and output files are saved into HDFS
•     Using replicas for fault tolerance
•     Each file is saved into blocks, which makes load balance
•     Each worker is a process
•     Can use Hadoop Streaming to intergrade it into multiple languages




Apache. Hadoop. http://lucene.apache.org/hadoop/, 2006.                   33
                            Hadoop Streaming
•    Hadoop streaming is a utility that comes with the Hadoop distribution. 
     The utility allows you to create and run Map/Reduce jobs with any 
     executable or script as the mapper and/or the reducer. For example:
       – $HADOOP_HOME/bin/hadoop jar $HADOOP_HOME/hadoop-streaming.jar \ 
             -input myInputDirs \ 
             -output myOutputDir \ 
             -mapper /bin/cat \ 
             -reducer /bin/wc 




http://hadoop.apache.org/common/docs/current/streaming.htm
                             l                                                 34
                                                      Haloop
• Extend based on Hadoop 
       framework
• The Task Scheduler tries to
       keep data locality for mapper
       and reducer
• Caches the input and output
      on the physical node’s local
      disk to reduce I/O cost
• Reconstructing caching for 
      node failure or work node full
      load.


Bu, Y., B. Howe, et al. (2010). HaLoop: Efficient Iterative Data Processing on Large Clusters. The 36th 
                                                                                                           35
                   International Conference on Very Large Data Bases, Singapore.
                                                    Spark
•     Use resilient distributed dataset (RDD) to achieve fault tolerance and 
      memory cache.
• RDD can recover a lost partition                          Application
      by information on other RDDs, 
      using distributed nodes.                       Scala high level language

• Integrates into Scala
• Built on Nexus, using long-lived                        Spark runtime

      Nexus executor to keep re-usable
      dataset in the memory cache.                    Nexus cluster manager

• Data can be read from HDFS
                                                                     Node       Node    …   Node 
                                                                      1          2           n




Matei Zaharia, N. M. Mosharaf Chowdhury, Michael Franklin, Scott Shenker and Ion 
                                                                                                    36
                Stoica. Spark: Cluster Computing with Working Sets 
                                                    Pregel
                                                                                Inactive       active
• Support large scale graph 
      processing.
• Each iteration is defined as                                      3             6        2     1      Superstep 0
      SuperStep.
• Introduce inactive and active for 
                                                                    6             6        2     6      Superstep 1
      each vertices.
• Load balance is good since vertices
      number is much more than workers.
                                                                    6             6        6     6      Superstep 2
• Fault tolerance is achieved by using
      checkpoint. Developing confined 
      recovery                                                      6             6        6     6      Superstep 3


Grzegorz Malewicz, Matthew H. Austern, Aart J. C. Bik, James C. Dehnert, Ilan Horn,
Naty Leiser, Grzegorz Czajkowski, Pregel: A System for Large-Scale Graph Processing                         37
                                        OpenCL
•    A similar library to CUDA
•    Can run on heterogeneous devices, i.e. ATI cards and nVidia cards

    Host                         Compute Device

                                                                        Private 
                                                            Work-Item
                                                   Local                Memory
                                                  Memory                Private 
                                                            Work-Item
                                                                        Memory
        Host                       Global/
       memory                     Constant 
                                  Memory
                                                                        Private 
                                                            Work-Item
                                                   Local                Memory
                                                  Memory                Private 
                                                            Work-Item
                                                                        Memory

                                                                                   38
http://www.khronos.org/opencl/
        CUDA thread/block/memory
•   Threads are grouped into thread blocks
•   Grid is all blocks for a given launch
•   Registers, block shared memory on-chip, fast
•   Thread local memory is off-chip, uncached
•   Kernel to global memory will has I/O cost




                                                   39
                            Phoenix
•   Mapreduce on multicore CPU system.




                                         40
       Common GPU mapreduce
• MAP_COUNT counts result size of the map function
• MAP
• REDUCE_COUNT counts result size of the reduce function
• REDUCE
• EMIT_INTERMEDIATE_COUNT emit the key size and the 
  value size in MAP_COUNT
• EMIT_INTERMEDIATE emit an intermediate result in MAP
• EMIT_COUNT emit the key size and the value size in 
  REDUCE_COUNT
• EMIT emits a final result in REDUCE



                                                           41
          Volume Rendering MapReduce
•      Use data streaming for cross node communication



           Brick
            …                       M             Partition                  Sort   R
           Brick
             …                      …                   …                      …    …
           Brick
             …                     M              Partition                  Sort   R
           Brick


    Jeff A. Stuart, Cheng-Kai Chen, Kwan-Liu Ma, John D. Owens, Multi-GPU Volume 
                                                                                        42
                               Rendering using MapReduce
                                                       CellMR
   • Tested on Cell-based clusters
   • Use data streaming across nodes
   • Keep streaming chunks until all task
         finish




 M. M. Rafique, B. Rose, A. R. Butt, and D. S. Nikolopoulos. CellMR: A framework for supporting MapReduce on asymmetric 
                                                                                                                              43
Cell-based clusters. In Proceedings of the 23rd IEEE International Parallel and Distributed Processing Symposium, May 2009.
                        Topic models
•   From unigram, mixture of unigrams and PLSI to LDA




                                                        44
                            Text Mining
Name                  Topic number          Feature                Drawback
Unigram               1
Mixture of Unigram    1 per document
Probalistic Latent    K per document        d is fixed as a        Over fitting
Semantic Indexing                           multinomial 
                                            random variable
Latent Drichlet       K per document        Predict un-sampled 
Allocation                                  words/terms

 The pLSI model does not make any assumptions about how the mixture weights 
 θ are generated, making it difficult to test the generalizability of the model to 
 new documents. 




                                                                                      45
                 Latent Dirichlet Allocation
•    Common defined terms:
       – A word is the basic unit of discrete data, vocabulary
            indexed by {1,…,V}
       – A document is a sequence of N words donated by
           w = (w1,w2,…,wn)
       – A corpus is a collection of M documents denoted
            by D ={w1,w2,…,wM}
•    Different algorithms:
       – Variational Bayes (shown below)
       – Expectation propagation
       – Gibbs sampling
•    Variational inference



Blei, D. M., A. Y. Ng, et al. (2003). "Latent Dirichlet allocation." Journal of Machine 
                                                                                           46
                             Learning Research 3: 993-1022.
             Different algorithms for LDA
•    Gibbs sampling can converge faster than the Variational Bayes algorithm 
     proposed in the original paper and Expectation propagation                             .




From Griffiths, T. and M. Steyvers (2004). Finding scientific topics. Proceedings of the 
                                                                                                47
                    National Academy of Sciences. 101: 5228-5235.
From D.Blei, A.Ng, M.Jordan, Latent Drichlet Allocation   48
                             Gibbs Sampling in LDA
                                                                               Initial set nw, nd 
   •     3 2D matrices                                                          and z; count=0
                                                                                                                       count:=count+1

           – nw: topic frequency over words(terms)
           – nd: document frequency over topics                                        k=z[d][i]
                                                                                                                         For word i in  
           – z: topic assignment for a word in document                               nw[v][k]--;
                                                                                                                         document d
                                                                                      nd[d][k]--;
   •     Each word wi is estimate by the 
         probability of it assigned to each topic 
         conditioned on all other word tokens.                                    Calculate posterior                     z[d][i]:=k’
                                                                                  probability of z and                   nw[v][k’]++;
         Written as                                                                 update k to k’                       nd[d][k’]++;




                                                                                                           end of all               No
                                                                                                          documents?

   •     So the final probability distribution can                                                              Yes
         be calculate by:
                                                                                                            count >                 No
           – Probability of word w under topic k                                                          threshold?
           – Probability of topic k has under document d                                                        Yes
                                                                                                              end
Griffiths, T. and M. Steyvers (2004). Finding scientific topics. Proceedings of the National 
                                                                                                                                           49
                          Academy of Sciences. 101: 5228-5235.
                                  Gibbs Sampling
                                                             7.  End for topic k;
 1. For each iteration (2000 times):
                                                              8.  End for author x;
    2. For each document d:                                  
    3. For each word wd in document d:                       9.  
                                                              
    4. nw[word][topic]-=1; nd[document][topic]-=1; 
                                                            10. Random select u~Multi(1/(Ad*K));
        nwsum[topic]-=1;                                      11. For each x in Ad:
     5. For each author x in document d:                      12. For each topic k:
     6. For each topic k:
                                                              13. If                               >=u then
        topicdocumentprob = (nd[m][k] +                      
        alpha)/(ndsum[m] + M*alpha);                         14. Break;
        wordtopicprob = (nw[wd][k] + beta) / (nwsum[k] +       15. End
        V*beta);                                               16. Assign word=current x; topic=current k; 
                                                               17. All parameters for word, topic, document should 
        prob[x,k] = wordtopicprob * topicdocumentprob;      be added 1. Recover the    original situation for last 
                                                            instance.
                                                               18. End
                                                               19. End  




                                                                                                              50
                             KL-diverse
•   In probability theory and information theory, the Kullback–Leibler 
    divergence (also information divergence, information gain, relative 
    entropy, or KLIC) is a non-symmetric measure of the difference between 
    two probability distributions P and Q.




•   In words, it is the average of the logarithmic difference between the 
    probabilities P and Q, where the average is taken using the probabilities P. 
    The K-L divergence is only defined if P and Q both sum to 1 and if Q(i) > 0 
    for any i such that P(i) > 0. If the quantity 0log0 appears in the formula, it 
    is interpreted as zero.



                                                                                 51
                                      MDS algorithms
 Newton-type algorithms                                             Quasi-Newton algorithms
 Second-order algorithms for stress                                 Extend on Newton-type algorithms
 minimization
 Use a Hessian which is a fourth-order                              Construct an approximate inverse 
 tensor which can be very time costing.                             Hessian at each iteration, using 
                                                                    gradients from a few previous iterations



  • SMACOF can be faster than these two algorithms from the computational 
    complexity angle
  • SMACOF can converge faster than these two algorithms to achieve a lower stress 
    value




Bronstein, M. M., A. M. Bronstein, et al. (2000). "Multigrid Multidimensional Scaling." 
                                                                                                               52
            NUMERICAL LINEAR ALGEBRA WITH APPLICATIONS 00(1-6).
SMACOF




         53
MDS Interpolation




                    54

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:3
posted:8/5/2014
language:Latin
pages:54