ম্যাট্রিক্স গুণন ব্যবহার করে বাইনারি ডেটার জন্য জ্যাকার্ড বা অন্যান্য সমিতি সহগের গণনা করা হচ্ছে

Question

আমি জানতে চাই যে ম্যাট্রিক্স গুণনের সাহায্যে জ্যাকার্ড সহগের গণনা করার কোনও সম্ভাব্য উপায় আছে কিনা।

আমি এই কোডটি ব্যবহার করেছি

    jaccard_sim <- function(x) {
    # initialize similarity matrix
    m <- matrix(NA, nrow=ncol(x),ncol=ncol(x),dimnames=list(colnames(x),colnames(x)))
    jaccard <- as.data.frame(m)

    for(i in 1:ncol(x)) {
     for(j in i:ncol(x)) {
        jaccard[i,j]= length(which(x[,i] & x[,j])) / length(which(x[,i] | x[,j]))
        jaccard[j,i]=jaccard[i,j]        
       }
     }

আর এটিকে বাস্তবায়ন করা বেশ ঠিক the কেউ সাহায্য করতে পারেন?

Comments

দেখে মনে হচ্ছে @ttnphns এর মধ্যে এটি রয়েছে, তবে আপনি যেহেতু আর ব্যবহার করছেন তাই আমি ভেবেছিলাম যে veganপ্যাকেজে ইতিমধ্যে বেশ কয়েকটি মিলের সূচকগুলি (জ্যাকার্ডস সহ) ইতিমধ্যে প্রয়োগ করা হয়েছে । আমি মনে করি তারাও গতির জন্য বেশ সুন্দর-অনুকূল হয়ে উঠেছে।

— ডেভিড জে হ্যারিস

Answer 1

আমরা জানি যে জ্যাকার্ড ( বাইনারি ডেটার যে কোনও দুটি কলামের মধ্যে গণনা করা)$\bf{X}$) হয় $\frac{a}{a+b+c}$, যখন রজার্স-তানিমোটো $\frac{a+d}{a+d+2(b+c)}$, কোথায়

• a - উভয় কলাম 1 যেখানে সারি সংখ্যা
• খ - সারিগুলির সংখ্যা যেখানে এটি এবং অন্যান্য কলামটি 1 নয়
• সি - সারিগুলির সংখ্যা যেখানে অন্যটি এবং এই কলামটি 1 নয়
• d - সারিগুলির সংখ্যা যেখানে উভয় কলাম 0 হয়

$a+b+c+d=n$, সারি সংখ্যা $\bf{X}$

তারপর আমাদের আছে:

$\bf X'X=A$ এর বর্গ প্রতিসম ম্যাট্রিক্স $a$ সমস্ত কলামের মধ্যে।

$\bf (not X)'(not X)=D$ এর বর্গ প্রতিসম ম্যাট্রিক্স $d$ সমস্ত কলামের মধ্যে ("এক্স নয়" এক্স-তে 1-> 0 এবং 0-> 1 রূপান্তর করছে)।

সুতরাং, $\frac{\bf A}{n-\bf D}$ সমস্ত কলামের মধ্যে জ্যাকার্ডের বর্গাকার প্রতিসম ম্যাট্রিক্স।

$\frac{\bf A+D}{\bf A+D+2(n-(A+D))}=\frac{\bf A+D}{2n-\bf A-D}$ সমস্ত কলামের মধ্যে রজার্স-তানিমোটোর বর্গ প্রতিসাম্য ম্যাট্রিক্স।

এই সূত্রগুলি যদি সঠিক ফলাফল দেয় তবে আমি সংখ্যায় পরীক্ষা করেছি। তারা করে.

---

Upd। আপনি ম্যাট্রিকও পেতে পারেন$\bf B$ এবং $\bf C$:

$\bf B= [1]'X-A$যেখানে "[1]" আকারের ম্যাট্রিক্সকে বোঝায় $\bf X$। $\bf B$ বর্গক্ষেত্রের অসম মেট্রিক্স $b$সমস্ত কলামের মধ্যে; এর উপাদান ij হ'ল সারিগুলির সংখ্যা$\bf X$i কলামে 0 এবং 1 কলামে জে ।

অতএব, $\bf C=B'$।

জরায়ু $\bf D$ অবশ্যই এইভাবে গণনা করা যেতে পারে: $n \bf -A-B-C$।

ম্যাট্রিকেস জানা $\bf A, B, C, D$, আপনি বাইনারি ডেটার জন্য উদ্ভাবিত যেকোন জোড়াওয়ালা (ডিস) সমতা সহগের ম্যাট্রিক্স গণনা করতে সক্ষম।

Comments

ভগ্নাংশ মেট্রিক্সের যাত্রা না করে কোনও ধারণা রাখে না: বিপরীত দ্বারা ডানদিকে গুণ করা অন্যথায় বাম দিকে গুণনের চেয়ে আলাদা ফলাফল দেয়। তদুপরি, সাধারণত এটি হয় না যে দুটি প্রতিসাম্য ম্যাট্রিকের একটি পণ্য প্রতিসম হয়। আপনি সম্ভবত উপাদান-দ্বারা-উপাদান বিভাগ বলতে চান? আপনি যা চান তার সঠিক সূত্রটি প্রতিফলিত করার জন্য আপনি নিজের স্বরলিপিটি ঠিক করতে পারেন?

— whuber

@ তবে আমি স্কোয়ার প্রতিসম মেট্রিকগুলির বিপরীততা বা গুণ ব্যবহার করি না । এক্স হ'ল বাইনারি ডেটা ম্যাট্রিক্স এবং এক্স'এক্স এটির এসএসসিপি ম্যাট্রিক্স। not Xএক্স যেখানে 1-> 0, 0-> 1। এবং এখানে যে কোনও বিভাগ হ'ল মৌলিক বিভাগ। দয়া করে আমার স্বরলিপিটি সংশোধন করুন যদি আপনি এটি উপযুক্ত না দেখেন।

— ttnphns

আর-তে কীভাবে অভ্যন্তরীণ পণ্য (notX) ′ (notX) গণনা করবেন?

— ব্যবহারকারী4959

@ user4959, আমি আর জানি না এখানে এক্স প্রস্তাবিত; তবে ফলাফলটি বুলিয়ান সত্য / মিথ্যা, সংখ্যা 1/0 নয়। নোট করুন যে আমি আমার উত্তরটি আপডেট করেছি যেখানে আমি বলেছি যে ডি ম্যাট্রিক্সে আসার আরও একটি উপায় রয়েছে।

— ttnphns

Answer 2

এক্স বিরল হলে উপরের সমাধানটি খুব ভাল নয়। কারণ! এক্স গ্রহণ করা একটি ঘন ম্যাট্রিক্স তৈরি করবে, প্রচুর পরিমাণে স্মৃতি এবং গণনা গ্রহণ করবে।

আরও ভাল সমাধান হ'ল জ্যাকার্ড সূত্র ব্যবহার করা [i, j] = # কমোন / (# আই + # জে - # কমোন) । বিরল ম্যাট্রিক্সের সাহায্যে আপনি নিম্নলিখিত হিসাবে এটি করতে পারেন (নোটটি নন-স্পার্স ম্যাট্রিকগুলির জন্যও কাজ করে) নোট করুন:

library(Matrix)
jaccard <- function(m) {
    ## common values:
    A = tcrossprod(m)
    ## indexes for non-zero common values
    im = which(A > 0, arr.ind=TRUE)
    ## counts for each row
    b = rowSums(m)

    ## only non-zero values of common
    Aim = A[im]

    ## Jacard formula: #common / (#i + #j - #common)
    J = sparseMatrix(
          i = im[,1],
          j = im[,2],
          x = Aim / (b[im[,1]] + b[im[,2]] - Aim),
          dims = dim(A)
    )

    return( J )
}

Answer 3

আপনার প্রয়োজনগুলি নির্ভর করে এটি আপনার পক্ষে দরকারী বা নাও হতে পারে। ধরে নিচ্ছেন যে আপনি ক্লাস্টারিং কার্যের মধ্যে সাদৃশ্যটিতে আগ্রহী:

দুটি ক্লাস্টারিং অ্যাসাইনমেন্টের সাদৃশ্য গণনা করতে জ্যাকার্ড সাদৃশ্য সহগ বা জ্যাকার্ড সূচক ব্যবহার করা যেতে পারে।

লেবেলগুলি দেওয়া L1এবং L2, বেন-হুর, এলিসিফ এবং গায়ন (২০০২) দেখিয়েছে যে মধ্যবর্তী ম্যাট্রিক্সের ডট-পণ্য ব্যবহার করে জ্যাকার্ড সূচকটি গণনা করা যেতে পারে। নীচের কোডটি জ্যাকার্ড সূচকটি মেমরিতে ইন্টারমিডিয়েট ম্যাট্রিকগুলি সংরক্ষণ না করে দ্রুত গণনা করার জন্য এটিকে উপকৃত করে ।

কোডটি সি ++ তে লেখা, তবে sourceCppকমান্ডটি ব্যবহার করে আর-এ লোড করা যায় ।

/**
 * The Jaccard Similarity Coefficient or Jaccard Index is used to compare the
 * similarity/diversity of sample sets. It is defined as the size of the
 * intersection of the sets divided by the size of the union of the sets. Here,
 * it is used to determine how similar to clustering assignments are.
 *
 * INPUTS:
 *    L1: A list. Each element of the list is a number indicating the cluster
 *        assignment of that number.
 *    L2: The same as L1. Must be the same length as L1.
 *
 * RETURNS:
 *    The Jaccard Similarity Index
 *
 * SIDE-EFFECTS:
 *    None
 *
 * COMPLEXITY:
 *    Time:  O(K^2+n), where K = number of clusters
 *    Space: O(K^2)
 *
 * SOURCES:
 *    Asa Ben-Hur, Andre Elisseeff, and Isabelle Guyon (2001) A stability based
 *    method for discovering structure in clustered data. Biocomputing 2002: pp.
 *    6-17. 
 */
// [[Rcpp::export]]
NumericVector JaccardIndex(const NumericVector L1, const NumericVector L2){
  int n = L1.size();
  int K = max(L1);

  int overlaps[K][K];
  int cluster_sizes1[K], cluster_sizes2[K];

  for(int i = 0; i < K; i++){    // We can use NumericMatrix (default 0) 
    cluster_sizes1[i] = 0;
    cluster_sizes2[i] = 0;
    for(int j = 0; j < K; j++)
      overlaps[i][j] = 0;
  }

  //O(n) time. O(K^2) space. Determine the size of each cluster as well as the
  //size of the overlaps between the clusters.
  for(int i = 0; i < n; i++){
    cluster_sizes1[(int)L1[i] - 1]++; // -1's account for zero-based indexing
    cluster_sizes2[(int)L2[i] - 1]++;
    overlaps[(int)L1[i] - 1][(int)L2[i] - 1]++;
  }

  // O(K^2) time. O(1) space. Square the overlap values.
  int C1dotC2 = 0;
  for(int j = 0; j < K; j++){
    for(int k = 0; k < K; k++){
      C1dotC2 += pow(overlaps[j][k], 2);
    }
  }

  // O(K) time. O(1) space. Square the cluster sizes
  int C1dotC1 = 0, C2dotC2 = 0;
  for(int i = 0; i < K; i++){
    C1dotC1 += pow(cluster_sizes1[i], 2);
    C2dotC2 += pow(cluster_sizes2[i], 2);
  }

  return NumericVector::create((double)C1dotC2/(double)(C1dotC1+C2dotC2-C1dotC2));
}