প্রত্যাশা ম্যাক্সিমাইজেশন (ইএম) ডেটা শ্রেণিবদ্ধ করার জন্য এক ধরণের সম্ভাব্য পদ্ধতি। শ্রেণিবদ্ধ না হলে আমি ভুল হলে দয়া করে আমাকে সংশোধন করুন।
এই ইএম কৌশলটির একটি স্বজ্ঞাত ব্যাখ্যা কী? কি expectation
এখানে এবং কি হলো বা হচ্ছে maximized
?
প্রত্যাশা ম্যাক্সিমাইজেশন (ইএম) ডেটা শ্রেণিবদ্ধ করার জন্য এক ধরণের সম্ভাব্য পদ্ধতি। শ্রেণিবদ্ধ না হলে আমি ভুল হলে দয়া করে আমাকে সংশোধন করুন।
এই ইএম কৌশলটির একটি স্বজ্ঞাত ব্যাখ্যা কী? কি expectation
এখানে এবং কি হলো বা হচ্ছে maximized
?
উত্তর:
দ্রষ্টব্য: এই উত্তরের পিছনে কোডটি এখানে পাওয়া যাবে ।
ধরা যাক, লাল এবং নীল দুটি পৃথক গোষ্ঠী থেকে আমাদের কিছু ডেটা নমুনা পেয়েছে:
এখানে, আমরা দেখতে পাচ্ছি যে কোন পয়েন্টটি লাল বা নীল দলের সাথে সম্পর্কিত। এটি প্রতিটি গ্রুপকে চিহ্নিত করে এমন প্যারামিটারগুলি সন্ধান করা সহজ করে তোলে। উদাহরণস্বরূপ, লাল গোষ্ঠীর গড় প্রায় 3 টি, নীল দলের গড় প্রায় 7 টি (এবং আমরা চাইলে সঠিক উপায়টি খুঁজে পেতে পারি))
এটি, সাধারণত বলা হয়, সর্বাধিক সম্ভাবনার অনুমান হিসাবে পরিচিত । কিছু ডেটা দেওয়া, আমরা একটি পরামিতি (বা পরামিতি) এর মান গণনা করি যা সেই ডেটাটিকে সর্বোত্তমভাবে ব্যাখ্যা করে।
এখন কল্পনা করুন যে কোন গ্রুপ থেকে কোন মান নমুনা পেয়েছিল তা আমরা দেখতে পাচ্ছি না । আমাদের কাছে সবকিছু বেগুনি দেখাচ্ছে:
এখানে আমাদের জ্ঞান রয়েছে যে মানগুলির দুটি গ্রুপ রয়েছে তবে আমরা জানি না কোন নির্দিষ্ট মান কোন গ্রুপের অন্তর্ভুক্ত।
আমরা কি এখনও লাল গ্রুপ এবং নীল গোষ্ঠীর জন্য যে উপাত্তগুলিতে এই ডেটা সবচেয়ে ভাল ফিট করে তার উপায়গুলি অনুমান করতে পারি?
হ্যাঁ, প্রায়শই আমরা পারি! প্রত্যাশা ম্যাক্সিমাইজেশন আমাদের এটি করার একটি উপায় দেয়। অ্যালগরিদমের পিছনে সাধারণ ধারণাটি হ'ল:
এই পদক্ষেপগুলির আরও কিছু ব্যাখ্যা প্রয়োজন, সুতরাং আমি উপরে বর্ণিত সমস্যার মধ্য দিয়ে চলব।
আমি এই উদাহরণে পাইথন ব্যবহার করব, তবে কোডটি বোঝার জন্য আপনি যদি এই ভাষার সাথে পরিচিত না হন তবে মোটামুটি সহজ হওয়া উচিত।
ধরুন উপরের চিত্রের মতো মূল্যবোধগুলি সহ আমাদের দুটি গ্রুপ, লাল এবং নীল রয়েছে। বিশেষত, প্রতিটি গ্রুপের মধ্যে নিম্নলিখিত প্যারামিটারগুলির সাথে একটি সাধারণ বিতরণ থেকে আঁকা একটি মান থাকে :
import numpy as np
from scipy import stats
np.random.seed(110) # for reproducible results
# set parameters
red_mean = 3
red_std = 0.8
blue_mean = 7
blue_std = 2
# draw 20 samples from normal distributions with red/blue parameters
red = np.random.normal(red_mean, red_std, size=20)
blue = np.random.normal(blue_mean, blue_std, size=20)
both_colours = np.sort(np.concatenate((red, blue))) # for later use...
এই লাল এবং নীল গ্রুপগুলির আবার একটি চিত্র এখানে এসেছে (আপনাকে স্ক্রোল আপ থেকে বাঁচাতে):
আমরা যখন প্রতিটি পয়েন্টের রঙ দেখতে পাই (যেমন এটি কোন গ্রুপের অন্তর্ভুক্ত) তখন প্রতিটি দলের জন্য গড় এবং মানক বিচ্যুতি অনুমান করা খুব সহজ। আমরা কেবলমাত্র নিমপায় অন্তর্নির্মিত ফাংশনগুলিতে লাল এবং নীল মানগুলি দিয়েছি। উদাহরণ স্বরূপ:
>>> np.mean(red)
2.802
>>> np.std(red)
0.871
>>> np.mean(blue)
6.932
>>> np.std(blue)
2.195
কিন্তু যদি আমরা পয়েন্টগুলির রঙগুলি দেখতে না পারি ? তা হল, লাল বা নীল পরিবর্তে প্রতিটি পয়েন্ট বেগুনি রঙের হয়েছে।
লাল এবং নীল গ্রুপগুলির গড় এবং মানক বিচ্যুতি পরামিতিগুলি চেষ্টা ও পুনরুদ্ধার করতে আমরা প্রত্যাশা ম্যাক্সিমাইজেশন ব্যবহার করতে পারি।
আমাদের প্রথম পদক্ষেপ ( উপরে 1 ধাপ ) প্রতিটি গ্রুপের গড় এবং মানক বিচ্যুতির জন্য প্যারামিটার মানগুলি অনুমান করা। আমাদের বুদ্ধিমানভাবে অনুমান করার দরকার নেই; আমরা আমাদের পছন্দ মতো কোনও সংখ্যা বাছাই করতে পারি:
# estimates for the mean
red_mean_guess = 1.1
blue_mean_guess = 9
# estimates for the standard deviation
red_std_guess = 2
blue_std_guess = 1.7
এই পরামিতিগুলির অনুমানগুলি বেল বক্ররেখা উত্পন্ন করে যা দেখতে দেখতে এটি:
এগুলি খারাপ অনুমান। উভয় অর্থ (উল্লম্ব বিন্দুযুক্ত রেখাগুলি) উদাহরণস্বরূপ, পয়েন্টের বুদ্ধিমান গোষ্ঠীগুলির জন্য যে কোনও ধরণের "মাঝারি" দেখায় না। আমরা এই অনুমানগুলি উন্নত করতে চাই।
পরবর্তী পদক্ষেপ ( পদক্ষেপ 2 ) হ'ল বর্তমান প্যারামিটার অনুমানের অধীনে উপস্থিত প্রতিটি ডাটা পয়েন্টের সম্ভাবনা গণনা করা:
likelihood_of_red = stats.norm(red_mean_guess, red_std_guess).pdf(both_colours)
likelihood_of_blue = stats.norm(blue_mean_guess, blue_std_guess).pdf(both_colours)
এখানে, আমরা কেবলমাত্র লাল এবং নীল জন্য গড় এবং মানক বিচ্যুতিতে আমাদের বর্তমান অনুমানগুলি ব্যবহার করে একটি সাধারণ বিতরণের জন্য সম্ভাব্যতা ঘনত্ব ফাংশনটিতে প্রতিটি ডেটা পয়েন্ট রেখেছি। এটি আমাদের বলে, উদাহরণস্বরূপ, যে আমাদের বর্তমান অনুমান সঙ্গে 1,761 এ ডেটা বিন্দু অনেক আরো লাল হবে (0.189) নীল চেয়ে (0.00003) সম্ভবত।
প্রতিটি ডেটা পয়েন্টের জন্য, আমরা এই দুটি সম্ভাব্য মানকে ওজনে ( পদক্ষেপ 3 ) রূপান্তর করতে পারি যাতে সেগুলি নীচে হিসাবে 1 এর সমষ্টি হয়:
likelihood_total = likelihood_of_red + likelihood_of_blue
red_weight = likelihood_of_red / likelihood_total
blue_weight = likelihood_of_blue / likelihood_total
আমাদের বর্তমান অনুমান এবং আমাদের নতুন-গণনা করা ওজন সহ, আমরা এখন লাল এবং নীল দলগুলির গড় এবং মানক বিচ্যুতির জন্য নতুন অনুমানটি গণনা করতে পারি ( পদক্ষেপ 4 )।
সমস্ত ডেটা পয়েন্ট ব্যবহার করে আমরা দুটি বার গড় এবং মানিক বিচ্যুতি গণনা করি তবে বিভিন্ন ওজন সহ: একবার লাল ওজনের জন্য এবং একবার নীল ওজনের জন্য।
অন্তর্নিহিতের মূল বিটটি হ'ল কোনও ডেটার পয়েন্টে কোনও রঙের ওজন যত বেশি হয়, ততটাই ডেটা পয়েন্ট সেই রঙের প্যারামিটারগুলির জন্য পরবর্তী অনুমানগুলিকে প্রভাবিত করে। এটি সঠিক দিকের পরামিতিগুলিকে "টান" এর প্রভাব ফেলে।
def estimate_mean(data, weight):
"""
For each data point, multiply the point by the probability it
was drawn from the colour's distribution (its "weight").
Divide by the total weight: essentially, we're finding where
the weight is centred among our data points.
"""
return np.sum(data * weight) / np.sum(weight)
def estimate_std(data, weight, mean):
"""
For each data point, multiply the point's squared difference
from a mean value by the probability it was drawn from
that distribution (its "weight").
Divide by the total weight: essentially, we're finding where
the weight is centred among the values for the difference of
each data point from the mean.
This is the estimate of the variance, take the positive square
root to find the standard deviation.
"""
variance = np.sum(weight * (data - mean)**2) / np.sum(weight)
return np.sqrt(variance)
# new estimates for standard deviation
blue_std_guess = estimate_std(both_colours, blue_weight, blue_mean_guess)
red_std_guess = estimate_std(both_colours, red_weight, red_mean_guess)
# new estimates for mean
red_mean_guess = estimate_mean(both_colours, red_weight)
blue_mean_guess = estimate_mean(both_colours, blue_weight)
পরামিতিগুলির জন্য আমাদের কাছে নতুন অনুমান রয়েছে। এগুলিকে আবার উন্নত করতে আমরা দ্বিতীয় ধাপে ফিরে এসে প্রক্রিয়াটি পুনরাবৃত্তি করতে পারি। অনুমান একত্রিত না হওয়া পর্যন্ত বা কিছু সংখ্যক পুনরাবৃত্তি সম্পন্ন হওয়ার পরে আমরা এটি করি ( পদক্ষেপ 5 )।
আমাদের তথ্যের জন্য, এই প্রক্রিয়াটির প্রথম পাঁচটি পুনরাবৃত্তিগুলি দেখতে দেখতে (সাম্প্রতিক পুনরাবৃত্তির দৃ stronger়তর উপস্থিতি রয়েছে):
আমরা দেখতে পাই যে মাধ্যমগুলি ইতিমধ্যে কিছু মানগুলিতে রূপান্তরিত হচ্ছে এবং বক্ররেখার আকারগুলি (মানক বিচ্যুতি দ্বারা পরিচালিত) এছাড়াও আরও স্থিতিশীল হয়ে উঠছে।
যদি আমরা 20 টি পুনরাবৃত্তির জন্য চালিয়ে যান তবে আমরা নিম্নলিখিতটি দিয়ে শেষ করি:
EM প্রক্রিয়াটি নিম্নলিখিত মানগুলিতে রূপান্তরিত হয়েছে, যা প্রকৃত মানগুলির খুব কাছাকাছি চলে আসে (যেখানে আমরা রঙগুলি দেখতে পারি - কোনও গোপন ভেরিয়েবল নেই):
| EM guess | Actual | Delta
----------+----------+--------+-------
Red mean | 2.910 | 2.802 | 0.108
Red std | 0.854 | 0.871 | -0.017
Blue mean | 6.838 | 6.932 | -0.094
Blue std | 2.227 | 2.195 | 0.032
উপরের কোডটিতে আপনি লক্ষ্য করেছেন যে স্ট্যান্ডার্ড বিচ্যুতির জন্য নতুন অনুমানটি পূর্ববর্তী পুনরাবৃত্তির প্রাক্কলনটি গড় হিসাবে ব্যবহার করে গণনা করা হয়েছিল। পরিশেষে এটির জন্য কিছু আসে যায় না যদি আমরা প্রথমে গড়ের জন্য একটি নতুন মান গণনা করি কারণ আমরা কেবলমাত্র কিছু কেন্দ্রীয় বিন্দুর আশেপাশের মানগুলির (ভারিত) বৈচিত্র খুঁজে পাই। আমরা এখনও পরামিতি রূপান্তর জন্য অনুমান দেখতে পাবেন।
যখন আপনার মডেলের কিছু ভেরিয়েবলগুলি অবিচ্ছিন্ন থাকে (যেমন আপনার যখন সুপ্ত ভেরিয়েবল থাকে) তখন সম্ভাবনা ফাংশন সর্বাধিক করার জন্য ইএম একটি অ্যালগরিদম।
আপনি মোটামুটি জিজ্ঞাসা করতে পারেন, আমরা যদি কেবল কোনও ফাংশনকে সর্বাধিক করার চেষ্টা করি তবে কেন আমরা কেবলমাত্র একটি ফাংশন সর্বাধিককরণের জন্য বিদ্যমান যন্ত্রপাতিটি ব্যবহার করি না। ঠিক আছে, আপনি যদি ডেরিভেটিভগুলি গ্রহণ করে এবং এগুলি শূন্যে স্থাপন করে এটি সর্বাধিক করার চেষ্টা করেন তবে আপনি দেখতে পান যে বেশিরভাগ ক্ষেত্রে প্রথম-ক্রমের শর্তগুলির কোনও সমাধান হয় না। আপনার মডেল প্যারামিটারগুলির সমাধান করার জন্য একটি মুরগি এবং ডিমের সমস্যা রয়েছে আপনার অবরুদ্ধ ডেটা বন্টন জানতে হবে; তবে আপনার অরক্ষিত ডেটা বিতরণ করা আপনার মডেল পরামিতিগুলির ফাংশন।
EM পুনরুদ্ধারকৃত অরক্ষিত ডেটাগুলির জন্য একটি বিতরণ অনুমান করে এরপরে ঘুরে দেখার চেষ্টা করে, তারপরে মডেল প্যারামিটারগুলি প্রকৃত সম্ভাবনা ফাংশনটির নীচে আবদ্ধ হওয়া সর্বাধিক করে এবং অভিব্যক্তি না হওয়া পর্যন্ত পুনরাবৃত্তি করে:
ইএম অ্যালগরিদম
আপনার মডেল পরামিতিগুলির মানগুলির অনুমানের সাথে শুরু করুন
ই-পদক্ষেপ: প্রতিটি ডেটাপয়েন্টের জন্য যেগুলি অনুপস্থিত মান রয়েছে তার জন্য মডেল প্যারামিটারগুলির বর্তমান অনুমান এবং পর্যবেক্ষণ করা ডেটা দেওয়া অনুপস্থিত তথ্য বিতরণের জন্য সমাধান করার জন্য আপনার মডেল সমীকরণটি ব্যবহার করুন (নোট করুন যে আপনি প্রতিটি নিখোঁজের জন্য বিতরণের জন্য সমাধান করছেন) মান, প্রত্যাশিত মানের জন্য নয়)। এখন যেহেতু প্রতিটি অনুপস্থিত মানের জন্য আমাদের কাছে বিতরণ রয়েছে, আমরা অরক্ষিত ভেরিয়েবলের ক্ষেত্রে সম্ভাবনা কার্যকারিতাটির প্রত্যাশা গণনা করতে পারি । যদি মডেল প্যারামিটারের জন্য আমাদের অনুমান সঠিক থাকে তবে এই প্রত্যাশিত সম্ভাবনাটি আমাদের পর্যবেক্ষণের ডেটার প্রকৃত সম্ভাবনা হবে; যদি প্যারামিটারগুলি সঠিক না হয় তবে এটি কেবল নিম্ন সীমাবদ্ধ হবে।
এম-পদক্ষেপ: এখন আমরা এতে কোনও অনাবৃত ভেরিয়েবলগুলি নিয়ে একটি প্রত্যাশিত সম্ভাবনা ফাংশন পেয়েছি, আপনার মডেল প্যারামিটারগুলির একটি নতুন অনুমান পেতে আপনি পুরোপুরি পর্যবেক্ষণের ক্ষেত্রে যেমনটি করেন তেমনি ফাংশনটি সর্বাধিক করুন।
একত্রিত হওয়া অবধি পুনরাবৃত্তি করুন।
প্রত্যাশা সর্বাধিকতা অ্যালগরিদম বোঝার জন্য এখানে একটি সোজা-ফরোয়ার্ড রেসিপি দেওয়া হয়েছে:
1- এটি পড়ুন দো এবং ব্যাটজোগ্লো দ্বারা ইএম টিউটোরিয়াল কাগজটি ।
২- আপনার মাথায় প্রশ্ন চিহ্ন থাকতে পারে, এই গণিতের স্ট্যাক এক্সচেঞ্জের ব্যাখ্যাটি দেখুন পৃষ্ঠার ।
3- পাইথনে আমি লিখেছি এমন কোডটি দেখুন যা আইটেম 1 এর ইএম টিউটোরিয়াল পেপারে উদাহরণটি ব্যাখ্যা করেছে:
সতর্কতা: কোডটি অগোছালো / সাবপটিমাল হতে পারে, যেহেতু আমি পাইথন বিকাশকারী নই। কিন্তু এটা কাজ করে।
import numpy as np
import math
#### E-M Coin Toss Example as given in the EM tutorial paper by Do and Batzoglou* ####
def get_mn_log_likelihood(obs,probs):
""" Return the (log)likelihood of obs, given the probs"""
# Multinomial Distribution Log PMF
# ln (pdf) = multinomial coeff * product of probabilities
# ln[f(x|n, p)] = [ln(n!) - (ln(x1!)+ln(x2!)+...+ln(xk!))] + [x1*ln(p1)+x2*ln(p2)+...+xk*ln(pk)]
multinomial_coeff_denom= 0
prod_probs = 0
for x in range(0,len(obs)): # loop through state counts in each observation
multinomial_coeff_denom = multinomial_coeff_denom + math.log(math.factorial(obs[x]))
prod_probs = prod_probs + obs[x]*math.log(probs[x])
multinomial_coeff = math.log(math.factorial(sum(obs))) - multinomial_coeff_denom
likelihood = multinomial_coeff + prod_probs
return likelihood
# 1st: Coin B, {HTTTHHTHTH}, 5H,5T
# 2nd: Coin A, {HHHHTHHHHH}, 9H,1T
# 3rd: Coin A, {HTHHHHHTHH}, 8H,2T
# 4th: Coin B, {HTHTTTHHTT}, 4H,6T
# 5th: Coin A, {THHHTHHHTH}, 7H,3T
# so, from MLE: pA(heads) = 0.80 and pB(heads)=0.45
# represent the experiments
head_counts = np.array([5,9,8,4,7])
tail_counts = 10-head_counts
experiments = zip(head_counts,tail_counts)
# initialise the pA(heads) and pB(heads)
pA_heads = np.zeros(100); pA_heads[0] = 0.60
pB_heads = np.zeros(100); pB_heads[0] = 0.50
# E-M begins!
delta = 0.001
j = 0 # iteration counter
improvement = float('inf')
while (improvement>delta):
expectation_A = np.zeros((5,2), dtype=float)
expectation_B = np.zeros((5,2), dtype=float)
for i in range(0,len(experiments)):
e = experiments[i] # i'th experiment
ll_A = get_mn_log_likelihood(e,np.array([pA_heads[j],1-pA_heads[j]])) # loglikelihood of e given coin A
ll_B = get_mn_log_likelihood(e,np.array([pB_heads[j],1-pB_heads[j]])) # loglikelihood of e given coin B
weightA = math.exp(ll_A) / ( math.exp(ll_A) + math.exp(ll_B) ) # corresponding weight of A proportional to likelihood of A
weightB = math.exp(ll_B) / ( math.exp(ll_A) + math.exp(ll_B) ) # corresponding weight of B proportional to likelihood of B
expectation_A[i] = np.dot(weightA, e)
expectation_B[i] = np.dot(weightB, e)
pA_heads[j+1] = sum(expectation_A)[0] / sum(sum(expectation_A));
pB_heads[j+1] = sum(expectation_B)[0] / sum(sum(expectation_B));
improvement = max( abs(np.array([pA_heads[j+1],pB_heads[j+1]]) - np.array([pA_heads[j],pB_heads[j]]) ))
j = j+1
প্রযুক্তিগতভাবে "EM" শব্দটি কিছুটা অপ্রকাশিত, তবে আমি ধরে নিই যে আপনি গাউসিয়ান মিশ্রণ মডেলিং ক্লাস্টার বিশ্লেষণ কৌশলটি উল্লেখ করেছেন, এটি একটি উদাহরণ এটি সাধারণ EM নীতির ।
আসলে, ইএম ক্লাস্টার বিশ্লেষণ কোনও শ্রেণিবদ্ধ নয় । আমি জানি যে কিছু লোক ক্লাস্টারিংকে "নিস্ক্রিয় শ্রেণীবদ্ধকরণ" হিসাবে বিবেচনা করে তবে বাস্তবে ক্লাস্টার বিশ্লেষণটি একেবারেই আলাদা।
মূল পার্থক্য এবং লোকেদের ক্লাস্টার বিশ্লেষণের সাথে সর্বদা বড় ভুল বোঝাবুঝির শ্রেণিবিন্যাস হ'ল: ক্লাস্টার অ্যানালাইসিসে, কোনও "সঠিক সমাধান" নেই । এটি একটি জ্ঞান আবিষ্কারের পদ্ধতি, এটি আসলে নতুন কিছু আবিষ্কার করার জন্য বোঝানো হয়েছিল ! এটি মূল্যায়নকে খুব জটিল করে তোলে। এটি প্রায়শই রেফারেন্স হিসাবে পরিচিত শ্রেণিবিন্যাস ব্যবহার করে মূল্যায়ন করা হয় তবে এটি সর্বদা উপযুক্ত নয়: আপনার যে শ্রেণিবিন্যাস রয়েছে তা ডেটাতে যা রয়েছে তা প্রতিফলিত করতে পারে বা নাও পারে।
আমি আপনাকে একটি উদাহরণ দেই: আপনার কাছে লিঙ্গ ডেটা সহ গ্রাহকদের একটি বড় ডেটা সেট রয়েছে। এমন একটি পদ্ধতি যা এই তথ্যটিকে "পুরুষ" এবং "মহিলা" তে বিভক্ত করে সেগুলি সর্বোত্তম হয় যখন আপনি এটি বিদ্যমান ক্লাসগুলির সাথে তুলনা করেন। একটি "পূর্বাভাস" ভাবার পদ্ধতিতে এটি ভাল, নতুন ব্যবহারকারী হিসাবে আপনি এখন তাদের লিঙ্গ সম্পর্কে ভবিষ্যদ্বাণী করতে পারেন। একটি "জ্ঞান আবিষ্কার" ভাবার পদ্ধতিতে এটি আসলে খারাপ, কারণ আপনি ডেটাতে কিছু নতুন কাঠামো আবিষ্কার করতে চেয়েছিলেন । একটি পদ্ধতি যা উদাহরণস্বরূপ বয়স্ক ব্যক্তি এবং বাচ্চাদের মধ্যে ডেটা বিভক্ত করবে তবে পুরুষ / মহিলা শ্রেণীর সাথে সম্মানের সাথে এটি যত খারাপ হবে স্কোর করবে । তবে এটি দুর্দান্ত ক্লাস্টারিংয়ের ফলাফল হবে (যদি বয়স না দেওয়া হয়) was
এখন EM এ ফিরে আসুন। মূলত এটি ধরে নেওয়া হয় যে আপনার ডেটা একাধিক মাল্টিভারিয়েট স্বাভাবিক বিতরণ নিয়ে গঠিত (নোট করুন এটি একটি খুব দৃ ass় ধারণা, বিশেষত যখন আপনি ক্লাস্টারের সংখ্যা ঠিক করেন!)। এটি পর্যায়ক্রমে মডেলটি এবং মডেলটির সাথে অবজেক্ট অ্যাসাইনমেন্টটি উন্নত করে এর জন্য স্থানীয় সর্বোত্তম মডেল সন্ধান করার চেষ্টা করে ।
শ্রেণিবিন্যাসের প্রসঙ্গে সেরা ফলাফলের জন্য , ক্লাসের সংখ্যার চেয়ে বৃহত ক্লাস্টারের সংখ্যা চয়ন করুন বা এমনকি একক শ্রেণিতে ক্লাস্টারিং প্রয়োগ করুন (শ্রেণীর মধ্যে কিছু কাঠামো রয়েছে কিনা তা জানতে!)।
বলুন যে আপনি "গাড়ি", "বাইক" এবং "ট্রাক" আলাদা করার জন্য কোনও শ্রেণিবদ্ধকে প্রশিক্ষণ দিতে চান। ঠিক 3 টি সাধারণ বিতরণ নিয়ে ডেটা ধরে নেওয়ার ক্ষেত্রে খুব কম ব্যবহার হয়। তবে, আপনি ধরে নিতে পারেন যে এক ধরণের বেশি গাড়ি (এবং ট্রাক এবং বাইক) রয়েছে। সুতরাং এই তিনটি ক্লাসের জন্য কোনও শ্রেণিবদ্ধকারীকে প্রশিক্ষণের পরিবর্তে, আপনি গাড়ি, ট্রাক এবং বাইকগুলি 10 টি ক্লাস্টারে প্রতিটি (বা হতে পারে 10 গাড়ি, 3 ট্রাক এবং 3 টি বাইক, যাই হোক না কেন) ক্লাস্টার করুন, তারপরে কোনও শ্রেণিবদ্ধকে এই 30 টি ক্লাস আলাদা করে বলতে প্রশিক্ষণ দিন এবং তারপরে ক্লাসের ফলাফলটিকে মূল ক্লাসে ফিরিয়ে দিন। আপনি এটি আবিষ্কার করতে পারেন যে এখানে একটি ক্লাস্টার রয়েছে যা বিশেষত শ্রেণিবদ্ধ করা শক্ত, উদাহরণস্বরূপ ট্রাইক। তারা কিছুটা গাড়ি, আবার কিছুটা বাইক। বা বিতরণ ট্রাকগুলি, যা ট্রাকের চেয়ে বড় আকারের গাড়ির মতো।
অন্যান্য উত্তরগুলি ভাল হচ্ছে, আমি অন্য দৃষ্টিভঙ্গি সরবরাহ করার চেষ্টা করব এবং প্রশ্নের স্বজ্ঞাত অংশটি সামলানোর চেষ্টা করব।
EM (প্রত্যাশা-ম্যাক্সিমাইজেশন) অ্যালগরিদম দ্বৈততা ব্যবহার করে পুনর্গঠনকারী অ্যালগরিদমের একটি শ্রেণির একটি বৈকল্পিক
অংশ (জোর আমার):
গণিতে, একটি দ্বৈততা, যা সাধারণত বলা হয়, ধারণাগুলি, উপপাদাগুলি বা গাণিতিক কাঠামোকে এক-এক-এক ফ্যাশনে অন্যান্য ধারণা, উপপাদ্য বা কাঠামোয় অনুবাদ করে, প্রায়শই (তবে সর্বদা নয়) একটি আক্রমণ চালানের মাধ্যমে: যদি দ্বৈত দ্বৈত A হল B, তারপরে B এর দ্বৈত A হ'ল এ জাতীয় জড়ানের মাঝে মাঝে নির্দিষ্ট পয়েন্ট থাকে , যাতে A এর দ্বৈত নিজেই হয়
সাধারণত ক কোনও বস্তুর A এর দ্বৈত বি A এর সাথে কিছু উপায়ে সম্পর্কিত যা কিছু প্রতিসাম্যতা বা সামঞ্জস্যতা সংরক্ষণ করে । উদাহরণস্বরূপ এবি = কনস্ট্যান্ট
পুনরাবৃত্ত অ্যালগরিদমের উদাহরণ, নিয়োগ দ্বৈততা (পূর্ববর্তী অর্থে) হ'ল:
অনুরূপ ফ্যাশনে, ইএম অ্যালগরিদমকে দুটি দ্বৈত সর্বাধিকীকরণ পদক্ষেপ হিসাবে দেখা যেতে পারে :
.. [ইএম] প্যারামিটারগুলির একটি যৌথ ফাংশন এবং অরক্ষিত ভেরিয়েবলের উপর বিতরণের সর্বাধিকীকরণ হিসাবে দেখা যায় .. ই-স্টেপটি অননक्षित সংরক্ষিত ভেরিয়েবলগুলির উপর বিতরণের ক্ষেত্রে এই ফাংশনটিকে সর্বাধিক করে তোলে; পরামিতিগুলির সম্মানের সাথে এম-পদক্ষেপ ..
দ্বৈততা ব্যবহার করে পুনরাবৃত্ত অ্যালগরিদমে একটি ভারসাম্য (বা স্থির) রূপান্তর বিন্দুর স্পষ্ট (বা অন্তর্নিহিত) অনুমান রয়েছে (EM এর জন্য এটি জেনসেনের অসমতা ব্যবহার করে প্রমাণিত)
সুতরাং এই জাতীয় অ্যালগরিদমের রূপরেখাটি হ'ল:
নোট করুন যে যখন এই জাতীয় অ্যালগরিদম একটি (গ্লোবাল) সর্বোত্তম রূপান্তরিত করে, তখন এটি এমন একটি কনফিগারেশন পেয়েছে যা উভয় অর্থেই সেরা (যেমন উভয় এক্স ডোমেন / প্যারামিটার এবং y ডোমেন / পরামিতিগুলিতে)। তবে অ্যালগরিদম গ্লোবাল নয় কেবল একটি স্থানীয় সর্বোত্তম খুঁজে পেতে পারে সর্বোত্তম নয়।
আমি বলব এটি হল অ্যালগরিদমের রূপরেখার স্বজ্ঞাত বর্ণনা
পরিসংখ্যান যুক্তি এবং অ্যাপ্লিকেশনগুলির জন্য, অন্যান্য উত্তরগুলি ভাল ব্যাখ্যা দিয়েছে (এই উত্তরে রেফারেন্সগুলিও দেখুন)
গৃহীত উত্তরটি চুওং ইএম পেপারের উল্লেখ করে , যা ইএম ব্যাখ্যা করার একটি শালীন কাজ করে। একটি ইউটিউব ভিডিও রয়েছে যা আরও বিস্তারিতভাবে কাগজটি ব্যাখ্যা করে।
পুনরুদ্ধার করার জন্য, এখানে চিত্রটি দেওয়া হল:
1st: {H,T,T,T,H,H,T,H,T,H} 5 Heads, 5 Tails; Did coin A or B generate me?
2nd: {H,H,H,H,T,H,H,H,H,H} 9 Heads, 1 Tails
3rd: {H,T,H,H,H,H,H,T,H,H} 8 Heads, 2 Tails
4th: {H,T,H,T,T,T,H,H,T,T} 4 Heads, 6 Tails
5th: {T,H,H,H,T,H,H,H,T,H} 7 Heads, 3 Tails
Two possible coins, A & B are used to generate these distributions.
A & B have an unknown parameter: their bias towards heads.
We don't know the biases, but we can simply start with a guess: A=60% heads, B=50% heads.
প্রথম বিচারের প্রশ্নের ক্ষেত্রে, স্বজ্ঞাতভাবে আমরা মনে করব যে বি এটির সৃষ্টি করেছিল যেহেতু মাথাগুলির অনুপাত বিয়ের পক্ষপাতিত্বের সাথে খুব ভাল মেলে ... তবে সেই মানটি একটি অনুমান মাত্র, সুতরাং আমরা নিশ্চিত হতে পারি না।
এই বিষয়টি মাথায় রেখে আমি ইএম সমাধানটি এর মতো করে ভাবতে চাই:
এটি একটি ওভারসিম্প্লিফিকেশন হতে পারে (বা কিছু স্তরে এমনকি মৌলিকভাবে ভুল), তবে আমি আশা করি এটি একটি স্বজ্ঞাত স্তরে সহায়তা করবে!
ই এমটি সুপ্ত ভেরিয়েবল জেড সহ একটি মডেল কিউয়ের সম্ভাবনা সর্বাধিক করে তোলার জন্য ব্যবহৃত হয় E
এটি একটি পুনরাবৃত্তিমূলক অপ্টিমাইজেশন।
theta <- initial guess for hidden parameters
while not converged:
#e-step
Q(theta'|theta) = E[log L(theta|Z)]
#m-step
theta <- argmax_theta' Q(theta'|theta)
ই-পদক্ষেপ: প্রদত্ত জেড এর বর্তমান অনুমানটি প্রত্যাশিত লগলিফিকিলিটি ফাংশন গণনা করে
মি-স্টেপ: এই কিউটি সর্বাধিকীকরণকারী থিতাকে সন্ধান করুন
জিএমএম উদাহরণ:
ই-পদক্ষেপ: বর্তমান জিএমএম-প্যারামিটার অনুমানের ভিত্তিতে প্রতিটি ডেটাপয়েন্টের জন্য লেবেল অ্যাসাইনমেন্টগুলি অনুমান করুন
মি-স্টেপ: নতুন লেবেল অ্যাসিগমেন্টগুলি দিয়ে একটি নতুন থিটা সর্বাধিক করুন
কে-মানেগুলিও একটি ইএম অ্যালগরিদম এবং কে-মানেতে প্রচুর ব্যাখ্যা অ্যানিমেশন রয়েছে।
ঝুবার্বের উত্তরে উদ্ধৃত দো এবং ব্যাটজোগলোর একই নিবন্ধটি ব্যবহার করে, আমি জাভাতে এই সমস্যার জন্য ইএম প্রয়োগ করেছি । তার উত্তরের মন্তব্যগুলি দেখায় যে অ্যালগরিদম একটি স্থানীয় সর্বোত্তমে আটকে যায়, যা আমার বাস্তবায়নের সাথে ঘটে যদি থিটিএ এবং থিটা পরামিতিগুলির পরামিতি একই থাকে।
নীচে আমার কোডের স্ট্যান্ডার্ড আউটপুট রয়েছে, পরামিতিগুলির একত্রিতকরণ দেখাচ্ছে।
thetaA = 0.71301, thetaB = 0.58134
thetaA = 0.74529, thetaB = 0.56926
thetaA = 0.76810, thetaB = 0.54954
thetaA = 0.78316, thetaB = 0.53462
thetaA = 0.79106, thetaB = 0.52628
thetaA = 0.79453, thetaB = 0.52239
thetaA = 0.79593, thetaB = 0.52073
thetaA = 0.79647, thetaB = 0.52005
thetaA = 0.79667, thetaB = 0.51977
thetaA = 0.79674, thetaB = 0.51966
thetaA = 0.79677, thetaB = 0.51961
thetaA = 0.79678, thetaB = 0.51960
thetaA = 0.79679, thetaB = 0.51959
Final result:
thetaA = 0.79678, thetaB = 0.51960
নীচে আমার সমস্যাটি সমাধানের জন্য ইমের জাভা প্রয়োগ (ডু এবং ব্যাটজোগলু, ২০০৮) রয়েছে। বাস্তবায়নের মূল অংশটি প্যারামিটারগুলি একত্রিত না হওয়া পর্যন্ত EM চালানোর লুপ।
private Parameters _parameters;
public Parameters run()
{
while (true)
{
expectation();
Parameters estimatedParameters = maximization();
if (_parameters.converged(estimatedParameters)) {
break;
}
_parameters = estimatedParameters;
}
return _parameters;
}
নীচে পুরো কোডটি দেওয়া আছে।
import java.util.*;
/*****************************************************************************
This class encapsulates the parameters of the problem. For this problem posed
in the article by (Do and Batzoglou, 2008), the parameters are thetaA and
thetaB, the probability of a coin coming up heads for the two coins A and B,
respectively.
*****************************************************************************/
class Parameters
{
double _thetaA = 0.0; // Probability of heads for coin A.
double _thetaB = 0.0; // Probability of heads for coin B.
double _delta = 0.00001;
public Parameters(double thetaA, double thetaB)
{
_thetaA = thetaA;
_thetaB = thetaB;
}
/*************************************************************************
Returns true if this parameter is close enough to another parameter
(typically the estimated parameter coming from the maximization step).
*************************************************************************/
public boolean converged(Parameters other)
{
if (Math.abs(_thetaA - other._thetaA) < _delta &&
Math.abs(_thetaB - other._thetaB) < _delta)
{
return true;
}
return false;
}
public double getThetaA()
{
return _thetaA;
}
public double getThetaB()
{
return _thetaB;
}
public String toString()
{
return String.format("thetaA = %.5f, thetaB = %.5f", _thetaA, _thetaB);
}
}
/*****************************************************************************
This class encapsulates an observation, that is the number of heads
and tails in a trial. The observation can be either (1) one of the
experimental observations, or (2) an estimated observation resulting from
the expectation step.
*****************************************************************************/
class Observation
{
double _numHeads = 0;
double _numTails = 0;
public Observation(String s)
{
for (int i = 0; i < s.length(); i++)
{
char c = s.charAt(i);
if (c == 'H')
{
_numHeads++;
}
else if (c == 'T')
{
_numTails++;
}
else
{
throw new RuntimeException("Unknown character: " + c);
}
}
}
public Observation(double numHeads, double numTails)
{
_numHeads = numHeads;
_numTails = numTails;
}
public double getNumHeads()
{
return _numHeads;
}
public double getNumTails()
{
return _numTails;
}
public String toString()
{
return String.format("heads: %.1f, tails: %.1f", _numHeads, _numTails);
}
}
/*****************************************************************************
This class runs expectation-maximization for the problem posed by the article
from (Do and Batzoglou, 2008).
*****************************************************************************/
public class EM
{
// Current estimated parameters.
private Parameters _parameters;
// Observations from the trials. These observations are set once.
private final List<Observation> _observations;
// Estimated observations per coin. These observations are the output
// of the expectation step.
private List<Observation> _expectedObservationsForCoinA;
private List<Observation> _expectedObservationsForCoinB;
private static java.io.PrintStream o = System.out;
/*************************************************************************
Principal constructor.
@param observations The observations from the trial.
@param parameters The initial guessed parameters.
*************************************************************************/
public EM(List<Observation> observations, Parameters parameters)
{
_observations = observations;
_parameters = parameters;
}
/*************************************************************************
Run EM until parameters converge.
*************************************************************************/
public Parameters run()
{
while (true)
{
expectation();
Parameters estimatedParameters = maximization();
o.printf("%s\n", estimatedParameters);
if (_parameters.converged(estimatedParameters)) {
break;
}
_parameters = estimatedParameters;
}
return _parameters;
}
/*************************************************************************
Given the observations and current estimated parameters, compute new
estimated completions (distribution over the classes) and observations.
*************************************************************************/
private void expectation()
{
_expectedObservationsForCoinA = new ArrayList<Observation>();
_expectedObservationsForCoinB = new ArrayList<Observation>();
for (Observation observation : _observations)
{
int numHeads = (int)observation.getNumHeads();
int numTails = (int)observation.getNumTails();
double probabilityOfObservationForCoinA=
binomialProbability(10, numHeads, _parameters.getThetaA());
double probabilityOfObservationForCoinB=
binomialProbability(10, numHeads, _parameters.getThetaB());
double normalizer = probabilityOfObservationForCoinA +
probabilityOfObservationForCoinB;
// Compute the completions for coin A and B (i.e. the probability
// distribution of the two classes, summed to 1.0).
double completionCoinA = probabilityOfObservationForCoinA /
normalizer;
double completionCoinB = probabilityOfObservationForCoinB /
normalizer;
// Compute new expected observations for the two coins.
Observation expectedObservationForCoinA =
new Observation(numHeads * completionCoinA,
numTails * completionCoinA);
Observation expectedObservationForCoinB =
new Observation(numHeads * completionCoinB,
numTails * completionCoinB);
_expectedObservationsForCoinA.add(expectedObservationForCoinA);
_expectedObservationsForCoinB.add(expectedObservationForCoinB);
}
}
/*************************************************************************
Given new estimated observations, compute new estimated parameters.
*************************************************************************/
private Parameters maximization()
{
double sumCoinAHeads = 0.0;
double sumCoinATails = 0.0;
double sumCoinBHeads = 0.0;
double sumCoinBTails = 0.0;
for (Observation observation : _expectedObservationsForCoinA)
{
sumCoinAHeads += observation.getNumHeads();
sumCoinATails += observation.getNumTails();
}
for (Observation observation : _expectedObservationsForCoinB)
{
sumCoinBHeads += observation.getNumHeads();
sumCoinBTails += observation.getNumTails();
}
return new Parameters(sumCoinAHeads / (sumCoinAHeads + sumCoinATails),
sumCoinBHeads / (sumCoinBHeads + sumCoinBTails));
//o.printf("parameters: %s\n", _parameters);
}
/*************************************************************************
Since the coin-toss experiment posed in this article is a Bernoulli trial,
use a binomial probability Pr(X=k; n,p) = (n choose k) * p^k * (1-p)^(n-k).
*************************************************************************/
private static double binomialProbability(int n, int k, double p)
{
double q = 1.0 - p;
return nChooseK(n, k) * Math.pow(p, k) * Math.pow(q, n-k);
}
private static long nChooseK(int n, int k)
{
long numerator = 1;
for (int i = 0; i < k; i++)
{
numerator = numerator * n;
n--;
}
long denominator = factorial(k);
return (long)(numerator / denominator);
}
private static long factorial(int n)
{
long result = 1;
for (; n >0; n--)
{
result = result * n;
}
return result;
}
/*************************************************************************
Entry point into the program.
*************************************************************************/
public static void main(String argv[])
{
// Create the observations and initial parameter guess
// from the (Do and Batzoglou, 2008) article.
List<Observation> observations = new ArrayList<Observation>();
observations.add(new Observation("HTTTHHTHTH"));
observations.add(new Observation("HHHHTHHHHH"));
observations.add(new Observation("HTHHHHHTHH"));
observations.add(new Observation("HTHTTTHHTT"));
observations.add(new Observation("THHHTHHHTH"));
Parameters initialParameters = new Parameters(0.6, 0.5);
EM em = new EM(observations, initialParameters);
Parameters finalParameters = em.run();
o.printf("Final result:\n%s\n", finalParameters);
}
}