আমি এমন একটি ফাংশন সন্ধান করছি যা দুটি ইনপুট হিসাবে ইনপুট হিসাবে গ্রহণ করে এবং পিয়ারসন পারস্পরিক সম্পর্ক এবং পারস্পরিক সম্পর্কের তাৎপর্য প্রদান করে।
আমি এমন একটি ফাংশন সন্ধান করছি যা দুটি ইনপুট হিসাবে ইনপুট হিসাবে গ্রহণ করে এবং পিয়ারসন পারস্পরিক সম্পর্ক এবং পারস্পরিক সম্পর্কের তাৎপর্য প্রদান করে।
উত্তর:
আপনি একবার দেখতে পারেন scipy.stats:
from pydoc import help
from scipy.stats.stats import pearsonr
help(pearsonr)
>>>
Help on function pearsonr in module scipy.stats.stats:
pearsonr(x, y)
Calculates a Pearson correlation coefficient and the p-value for testing
non-correlation.
The Pearson correlation coefficient measures the linear relationship
between two datasets. Strictly speaking, Pearson's correlation requires
that each dataset be normally distributed. Like other correlation
coefficients, this one varies between -1 and +1 with 0 implying no
correlation. Correlations of -1 or +1 imply an exact linear
relationship. Positive correlations imply that as x increases, so does
y. Negative correlations imply that as x increases, y decreases.
The p-value roughly indicates the probability of an uncorrelated system
producing datasets that have a Pearson correlation at least as extreme
as the one computed from these datasets. The p-values are not entirely
reliable but are probably reasonable for datasets larger than 500 or so.
Parameters
----------
x : 1D array
y : 1D array the same length as x
Returns
-------
(Pearson's correlation coefficient,
2-tailed p-value)
References
----------
http://www.statsoft.com/textbook/glosp.html#Pearson%20Correlation
পিয়ারসন পারস্পরিক সম্পর্ককে নম্পিসের সাথে গণনা করা যায় corrcoef।
import numpy
numpy.corrcoef(list1, list2)[0, 1]
একটি বিকল্প লিনিগ্র্রেস থেকে নেটিভ স্কিপি ফাংশন হতে পারে যা গণনা করে:
opeাল: রিগ্রেশন লাইনের opeাল
বিরতি: রিগ্রেশন লাইনের বিরতি
r- মান: পারস্পরিক সম্পর্ক সহগ
পি-মান: দ্বি-পার্শ্বযুক্ত পি-মান একটি অনুমানের পরীক্ষার জন্য যার নাল অনুমানটি হ'ল zeroালটি শূন্য
stderr: অনুমানের স্ট্যান্ডার্ড ত্রুটি
এবং এখানে একটি উদাহরণ:
a = [15, 12, 8, 8, 7, 7, 7, 6, 5, 3]
b = [10, 25, 17, 11, 13, 17, 20, 13, 9, 15]
from scipy.stats import linregress
linregress(a, b)
আপনাকে ফিরিয়ে দেবে:
LinregressResult(slope=0.20833333333333337, intercept=13.375, rvalue=0.14499815458068521, pvalue=0.68940144811669501, stderr=0.50261704627083648)lineregress(two_row_df)
আপনি যদি স্কিপি ইনস্টল করার মতো মনে করেন না, আমি প্রোগ্রামিং কালেক্টিভ ইন্টেলিজেন্স থেকে কিছুটা পরিবর্তিত এই দ্রুত হ্যাকটি ব্যবহার করেছি :
(সংশোধন জন্য সম্পাদিত।)
from itertools import imap
def pearsonr(x, y):
# Assume len(x) == len(y)
n = len(x)
sum_x = float(sum(x))
sum_y = float(sum(y))
sum_x_sq = sum(map(lambda x: pow(x, 2), x))
sum_y_sq = sum(map(lambda x: pow(x, 2), y))
psum = sum(imap(lambda x, y: x * y, x, y))
num = psum - (sum_x * sum_y/n)
den = pow((sum_x_sq - pow(sum_x, 2) / n) * (sum_y_sq - pow(sum_y, 2) / n), 0.5)
if den == 0: return 0
return num / den
TypeError: unsupported operand type(s) for -: 'itertools.imap' and 'float'এnum = psum - (sum_x * sum_y/n)
নিম্নলিখিত কোডটি সংজ্ঞাটির সোজা-আপ ব্যাখ্যা :
import math
def average(x):
assert len(x) > 0
return float(sum(x)) / len(x)
def pearson_def(x, y):
assert len(x) == len(y)
n = len(x)
assert n > 0
avg_x = average(x)
avg_y = average(y)
diffprod = 0
xdiff2 = 0
ydiff2 = 0
for idx in range(n):
xdiff = x[idx] - avg_x
ydiff = y[idx] - avg_y
diffprod += xdiff * ydiff
xdiff2 += xdiff * xdiff
ydiff2 += ydiff * ydiff
return diffprod / math.sqrt(xdiff2 * ydiff2)
টেস্ট:
print pearson_def([1,2,3], [1,5,7])আয়
0.981980506062এটি এক্সেল, এই ক্যালকুলেটর , সায়পি (এছাড়াও নম্পপি ) এর সাথে একমত , যা যথাক্রমে 0.981980506 এবং 0.9819805060619657, এবং 0.98198050606196574 ফিরে আসে।
আর :
> cor( c(1,2,3), c(1,5,7))
[1] 0.9819805
সম্পাদনা : একজন মন্তব্যকারী দ্বারা নির্দেশিত একটি বাগ সংশোধন করা হয়েছে।
sum(x) / len(x)আপনি ints ভাগ, floats না। সুতরাং sum([1,5,7]) / len([1,5,7]) = 13 / 3 = 4, পূর্ণসংখ্যা বিভাগ অনুযায়ী (যেখানে আপনি চান 13. / 3. = 4.33...) এটি ঠিক করার জন্য এই লাইনটি পুনরায় লিখুন float(sum(x)) / float(len(x))(পাইথন এটি স্বয়ংক্রিয়ভাবে রূপান্তরিত হওয়ায় একটি ভাসা যথেষ্ট)।
আপনি এটি দিয়ে pandas.DataFrame.corrএটিও করতে পারেন :
import pandas as pd
a = [[1, 2, 3],
[5, 6, 9],
[5, 6, 11],
[5, 6, 13],
[5, 3, 13]]
df = pd.DataFrame(data=a)
df.corr()এই দেয়
0 1 2
0 1.000000 0.745601 0.916579
1 0.745601 1.000000 0.544248
2 0.916579 0.544248 1.000000ন্পি / স্কিপি উপর নির্ভর করার পরিবর্তে, আমি মনে করি যে আমার উত্তরটি পিয়ারসন সহকারী গুণাগুণ (পিসিসি) গণনা করার পদক্ষেপগুলি কোড করা এবং বোঝার পক্ষে সবচেয়ে সহজ হওয়া উচিত ।
import math
# calculates the mean
def mean(x):
sum = 0.0
for i in x:
sum += i
return sum / len(x)
# calculates the sample standard deviation
def sampleStandardDeviation(x):
sumv = 0.0
for i in x:
sumv += (i - mean(x))**2
return math.sqrt(sumv/(len(x)-1))
# calculates the PCC using both the 2 functions above
def pearson(x,y):
scorex = []
scorey = []
for i in x:
scorex.append((i - mean(x))/sampleStandardDeviation(x))
for j in y:
scorey.append((j - mean(y))/sampleStandardDeviation(y))
# multiplies both lists together into 1 list (hence zip) and sums the whole list
return (sum([i*j for i,j in zip(scorex,scorey)]))/(len(x)-1)তাত্পর্য পিসিসি আপনার দেখানোর জন্য কিভাবে মূলত দৃঢ়ভাবে সম্পর্কিত দুটি ভেরিয়েবল / করণীয় তালিকা আছে। এটি লক্ষণীয় যে পিসিসির মান -1 থেকে 1 এর মধ্যে রয়েছে । 0 থেকে 1 এর মধ্যে একটি মান একটি ধনাত্মক সম্পর্ককে বোঝায়। 0 = সর্বোচ্চ প্রকরণের মান (যাই হোক না কেন কোনও সম্পর্ক নেই)। -1 থেকে 0 এর মধ্যে একটি মান একটি নেতিবাচক সম্পর্ককে বোঝায়।
sumফাংশন রয়েছে।
পাইথনে পাইন্ডস ব্যবহার করে পাইয়ারসন সহগের গণনা: আমি এই পদ্ধতির চেষ্টা করার পরামর্শ দেব কারণ আপনার ডেটাতে তালিকা রয়েছে। আপনার ডেটার সাথে যোগাযোগ করা এবং এটি কনসোল থেকে ম্যানিপুলেট করা সহজ হবে যেহেতু আপনি নিজের ডেটা কাঠামোটি কল্পনা করতে এবং আপনার ইচ্ছামত আপডেট করতে পারবেন can আপনি ডেটা সেটটি রফতানি করতে পারেন এবং এটিকে সংরক্ষণ করতে পারেন এবং পরবর্তী বিশ্লেষণের জন্য পাইথন কনসোল থেকে নতুন ডেটা যুক্ত করতে পারেন। এই কোডটি সহজ এবং কোডের কম লাইন রয়েছে। আমি ধরে নিচ্ছি যে আরও বিশ্লেষণের জন্য আপনার ডেটা স্ক্রিন করতে আপনার কোডের কয়েকটি দ্রুত লাইন দরকার
উদাহরণ:
data = {'list 1':[2,4,6,8],'list 2':[4,16,36,64]}
import pandas as pd #To Convert your lists to pandas data frames convert your lists into pandas dataframes
df = pd.DataFrame(data, columns = ['list 1','list 2'])
from scipy import stats # For in-built method to get PCC
pearson_coef, p_value = stats.pearsonr(df["list 1"], df["list 2"]) #define the columns to perform calculations on
print("Pearson Correlation Coefficient: ", pearson_coef, "and a P-value of:", p_value) # Results তবে, বিশ্লেষণের আগে যে ডেটা সেট বা রূপান্তর প্রয়োজন হতে পারে তা আকারের জন্য আপনি আমার জন্য আপনার ডেটা পোস্ট করেননি।
হুঁ, এর মধ্যে বেশিরভাগ প্রতিক্রিয়াগুলির কোড পড়া দীর্ঘ এবং শক্ত রয়েছে ...
অ্যারে নিয়ে কাজ করার সময় আমি নিম্পটিকে এর নিফটি বৈশিষ্ট্যগুলি সহ ব্যবহার করার পরামর্শ দিই:
import numpy as np
def pcc(X, Y):
''' Compute Pearson Correlation Coefficient. '''
# Normalise X and Y
X -= X.mean(0)
Y -= Y.mean(0)
# Standardise X and Y
X /= X.std(0)
Y /= Y.std(0)
# Compute mean product
return np.mean(X*Y)
# Using it on a random example
from random import random
X = np.array([random() for x in xrange(100)])
Y = np.array([random() for x in xrange(100)])
pcc(X, Y)এটি নিম্পি ব্যবহার করে পিয়ারসন সহ সম্পর্ক ফাংশনের একটি বাস্তবায়ন:
def corr(data1, data2):
"data1 & data2 should be numpy arrays."
mean1 = data1.mean()
mean2 = data2.mean()
std1 = data1.std()
std2 = data2.std()
# corr = ((data1-mean1)*(data2-mean2)).mean()/(std1*std2)
corr = ((data1*data2).mean()-mean1*mean2)/(std1*std2)
return corr
এম, এম, এর উত্তরের একটি বৈকল্পিকতা এটির চেয়ে আরও দ্রুত গতিতে চলেছে এবং নাম্বার ব্যবহার করে scipy.stats.pearsonr।
import numba
@numba.jit
def corr(data1, data2):
M = data1.size
sum1 = 0.
sum2 = 0.
for i in range(M):
sum1 += data1[i]
sum2 += data2[i]
mean1 = sum1 / M
mean2 = sum2 / M
var_sum1 = 0.
var_sum2 = 0.
cross_sum = 0.
for i in range(M):
var_sum1 += (data1[i] - mean1) ** 2
var_sum2 += (data2[i] - mean2) ** 2
cross_sum += (data1[i] * data2[i])
std1 = (var_sum1 / M) ** .5
std2 = (var_sum2 / M) ** .5
cross_mean = cross_sum / M
return (cross_mean - mean1 * mean2) / (std1 * std2)স্পার্স ভেক্টরের উপর ভিত্তি করে পিয়ারসন পারস্পরিক সম্পর্কের জন্য একটি বাস্তবায়ন এখানে দেওয়া হয়েছে। এখানকার ভেক্টরগুলিকে (সূচক, মান) হিসাবে প্রকাশিত টিপলগুলির একটি তালিকা হিসাবে প্রকাশ করা হয়। দুটি স্পার ভেক্টর পৃথক দৈর্ঘ্যের হতে পারে তবে সমস্ত ভেক্টরের আকার একই হতে হবে। এটি পাঠ্য খনির অ্যাপ্লিকেশনগুলির জন্য দরকারী যেখানে বেশিরভাগ বৈশিষ্ট্য শব্দের ব্যাগ হওয়ার কারণে ভেক্টরের আকার অত্যন্ত বড় এবং সেইজন্য গণনাগুলি সাধারণত বিরল ভেক্টর ব্যবহার করে করা হয়।
def get_pearson_corelation(self, first_feature_vector=[], second_feature_vector=[], length_of_featureset=0):
indexed_feature_dict = {}
if first_feature_vector == [] or second_feature_vector == [] or length_of_featureset == 0:
raise ValueError("Empty feature vectors or zero length of featureset in get_pearson_corelation")
sum_a = sum(value for index, value in first_feature_vector)
sum_b = sum(value for index, value in second_feature_vector)
avg_a = float(sum_a) / length_of_featureset
avg_b = float(sum_b) / length_of_featureset
mean_sq_error_a = sqrt((sum((value - avg_a) ** 2 for index, value in first_feature_vector)) + ((
length_of_featureset - len(first_feature_vector)) * ((0 - avg_a) ** 2)))
mean_sq_error_b = sqrt((sum((value - avg_b) ** 2 for index, value in second_feature_vector)) + ((
length_of_featureset - len(second_feature_vector)) * ((0 - avg_b) ** 2)))
covariance_a_b = 0
#calculate covariance for the sparse vectors
for tuple in first_feature_vector:
if len(tuple) != 2:
raise ValueError("Invalid feature frequency tuple in featureVector: %s") % (tuple,)
indexed_feature_dict[tuple[0]] = tuple[1]
count_of_features = 0
for tuple in second_feature_vector:
count_of_features += 1
if len(tuple) != 2:
raise ValueError("Invalid feature frequency tuple in featureVector: %s") % (tuple,)
if tuple[0] in indexed_feature_dict:
covariance_a_b += ((indexed_feature_dict[tuple[0]] - avg_a) * (tuple[1] - avg_b))
del (indexed_feature_dict[tuple[0]])
else:
covariance_a_b += (0 - avg_a) * (tuple[1] - avg_b)
for index in indexed_feature_dict:
count_of_features += 1
covariance_a_b += (indexed_feature_dict[index] - avg_a) * (0 - avg_b)
#adjust covariance with rest of vector with 0 value
covariance_a_b += (length_of_featureset - count_of_features) * -avg_a * -avg_b
if mean_sq_error_a == 0 or mean_sq_error_b == 0:
return -1
else:
return float(covariance_a_b) / (mean_sq_error_a * mean_sq_error_b)ইউনিট পরীক্ষা:
def test_get_get_pearson_corelation(self):
vector_a = [(1, 1), (2, 2), (3, 3)]
vector_b = [(1, 1), (2, 5), (3, 7)]
self.assertAlmostEquals(self.sim_calculator.get_pearson_corelation(vector_a, vector_b, 3), 0.981980506062, 3, None, None)
vector_a = [(1, 1), (2, 2), (3, 3)]
vector_b = [(1, 1), (2, 5), (3, 7), (4, 14)]
self.assertAlmostEquals(self.sim_calculator.get_pearson_corelation(vector_a, vector_b, 5), -0.0137089240555, 3, None, None)এর জন্য আমার একটি খুব সহজ এবং সহজে বোঝার সমাধান রয়েছে। সমান দৈর্ঘ্যের দুটি অ্যারেগুলির জন্য, পিয়ারসন সহগকে নিম্নরূপে সহজেই গণনা করা যায়:
def manual_pearson(a,b):
"""
Accepts two arrays of equal length, and computes correlation coefficient.
Numerator is the sum of product of (a - a_avg) and (b - b_avg),
while denominator is the product of a_std and b_std multiplied by
length of array.
"""
a_avg, b_avg = np.average(a), np.average(b)
a_stdev, b_stdev = np.std(a), np.std(b)
n = len(a)
denominator = a_stdev * b_stdev * n
numerator = np.sum(np.multiply(a-a_avg, b-b_avg))
p_coef = numerator/denominator
return p_coefআপনি হয়ত ভাবতে পারেন যে কোনও নির্দিষ্ট দিক (নেতিবাচক বা ধনাত্মক সম্পর্ক) এর সাথে সম্পর্কিত হওয়ার সন্ধানের প্রসঙ্গে আপনার সম্ভাবনাটি কীভাবে ব্যাখ্যা করা যায় তা এখানে সহায়তা করার জন্য আমি একটি ফাংশন লিখেছি। এটা এমনকি সঠিক হতে পারে!
এটি http://www.vassarstats.net/rsig.html এবং http://en.wikedia.org/wiki/Student%27s_t_dist वितरण থেকে সংগ্রহ করা তথ্যের উপর ভিত্তি করে এখানে পোস্ট করা অন্যান্য উত্তরের জন্য ধন্যবাদ।
# Given (possibly random) variables, X and Y, and a correlation direction,
# returns:
# (r, p),
# where r is the Pearson correlation coefficient, and p is the probability
# that there is no correlation in the given direction.
#
# direction:
# if positive, p is the probability that there is no positive correlation in
# the population sampled by X and Y
# if negative, p is the probability that there is no negative correlation
# if 0, p is the probability that there is no correlation in either direction
def probabilityNotCorrelated(X, Y, direction=0):
x = len(X)
if x != len(Y):
raise ValueError("variables not same len: " + str(x) + ", and " + \
str(len(Y)))
if x < 6:
raise ValueError("must have at least 6 samples, but have " + str(x))
(corr, prb_2_tail) = stats.pearsonr(X, Y)
if not direction:
return (corr, prb_2_tail)
prb_1_tail = prb_2_tail / 2
if corr * direction > 0:
return (corr, prb_1_tail)
return (corr, 1 - prb_1_tail)আপনি এই নিবন্ধটি একবার দেখে নিতে পারেন। পান্ডাস লাইব্রেরি (পাইথনের জন্য) ব্যবহার করে একাধিক ফাইলের historicalতিহাসিক ফরেক্স মুদ্রা জোড়া ডেটার উপর ভিত্তি করে পারস্পরিক সম্পর্ক গণনা করার জন্য এটি সমুদ্রদৈর্ঘ্য গ্রন্থাগার ব্যবহার করে হিটম্যাপ প্লট তৈরির জন্য একটি ভাল-নথিযুক্ত উদাহরণ।
http://www.tradinggeeks.net/2015/08/calculating-correlation-in-python/
def pearson(x,y):
n=len(x)
vals=range(n)
sumx=sum([float(x[i]) for i in vals])
sumy=sum([float(y[i]) for i in vals])
sumxSq=sum([x[i]**2.0 for i in vals])
sumySq=sum([y[i]**2.0 for i in vals])
pSum=sum([x[i]*y[i] for i in vals])
# Calculating Pearson correlation
num=pSum-(sumx*sumy/n)
den=((sumxSq-pow(sumx,2)/n)*(sumySq-pow(sumy,2)/n))**.5
if den==0: return 0
r=num/den
return r