def motivation_test():
cause = []
for i in range(0, 5):
cause.extend(up(0.0, 1.0, 10))
cause.extend(const(1.0, 20))
cause.extend(down(0.0, 1.0, 10))
cause.extend(const(0.0, 20))
noise1 = np.random.normal(0, 0.1, len(cause))
noise2 = np.random.normal(0, 0.1, len(cause))
effect = forward_shift_continue_data(cause, 8)
for i in range(0, len(cause)):
cause[i] += noise1[i]
effect[i] += noise2[i]
plt.plot(cause)
plt.plot(effect)
plt.show()
print cause
print effect
#cause2effect = calculate_difference3(cause, effect, 6)
#effect2cause = calculate_difference3(effect, cause, 6)
cause = change_to_zero_one(cause)
effect = change_to_zero_one(effect)
cause2effect = bernoulli(effect) - cbernoulli(effect, cause)
effect2cause = bernoulli(cause) - cbernoulli(cause, effect)
print 'cause' + ' -> ' + 'effect' + ':' + str(cause2effect)
print 'effect' + ' -> ' + 'cause' + ':' + str(effect2cause)
p = math.pow(2, -(cause2effect - effect2cause))
print p
def test_sin3(c, e):
cause = c
effect = e
cause = change_to_zero_one(cause)
effect = change_to_zero_one(effect)
cause2effect = bernoulli(effect) - cbernoulli(effect, cause)
effect2cause = bernoulli(cause) - cbernoulli(cause, effect)
print 'cause' + ' -> ' + 'effect' + ':' + str(cause2effect)
print 'effect' + ' -> ' + 'cause' + ':' + str(effect2cause)
p = math.pow(2, -(cause2effect - effect2cause))
print p
def test_sin():
input, output1, output2, output3 = read_sin_data()
#noise1 = np.random.normal(0, 0.1, 100)
#noise2 = np.random.normal(0, 0.1, 100)
#cause = input[0:113]
#cause.extend(noise1)
#cause.extend(input[113:-1])
#effect = output2[0:113]
#effect.extend(noise2)
#effect.extend(output2[113:-1])
#for i in range(0,len(effect)):
#effect[i] = effect[i]+np.random.normal(0, 0.3, 1)[0]
cause = input
effect = output1
noise = np.random.normal(0, 0.5, len(effect))
noise2 = np.random.normal(0, 0.5, len(effect))
for i in range(0, len(effect)):
cause[i] = cause[i] + noise[i]
effect[i] = effect[i] + noise2[i]
print cause
print effect
plt.plot(cause)
plt.plot(effect)
plt.show()
#cause = normalize(cause)
#cause = zero_change(cause)
#effect = normalize(effect)
#effect = zero_change(effect)
#cause2effect = calculate_difference3(cause, effect, 100)
#effect2cause = calculate_difference3(effect, cause, 100)
cause = change_to_zero_one(cause)
effect = change_to_zero_one(effect)
cause2effect = bernoulli(effect) - cbernoulli(effect, cause)
effect2cause = bernoulli(cause) - cbernoulli(cause, effect)
print 'cause' + ' -> ' + 'effect' + ':' + str(cause2effect)
print 'effect' + ' -> ' + 'cause' + ':' + str(effect2cause)
p = math.pow(2, -(cause2effect - effect2cause))
print p
def river_test2():
length = 6
date_time, fremersdorf, hanweiler, sanktarnual = collect_data2()
fremersdorf = map(float, fremersdorf)
hanweiler = map(float, hanweiler)
sanktarnual = map(float, sanktarnual)
fremersdorf = zero_change(fremersdorf)
hanweiler = zero_change(hanweiler)
sanktarnual = zero_change(sanktarnual)
cause = change_to_zero_one(fremersdorf)
effect = change_to_zero_one(hanweiler)
delta_fr_to_hw = bernoulli2(effect, length) - cbernoulli2(
effect, cause, length)
delta_hw_to_fr = bernoulli2(cause, length) - cbernoulli2(
cause, effect, length)
#delta_fr_to_hw = calculate_difference3(fremersdorf,hanweiler,10)
#delta_hw_to_fr = calculate_difference3(hanweiler,fremersdorf,10)
print "fr->hw =", delta_fr_to_hw, " hw->fr =", delta_hw_to_fr
cause = change_to_zero_one(sanktarnual)
effect = change_to_zero_one(hanweiler)
delta_sa_to_hw = bernoulli2(effect, length) - cbernoulli2(
effect, cause, length)
delta_hw_to_sa = bernoulli2(cause, length) - cbernoulli2(
cause, effect, length)
#delta_sa_to_hw =calculate_difference3(sanktarnual,hanweiler,10)
#delta_hw_to_sa = calculate_difference3(hanweiler,sanktarnual,10)
print "sa->hw =", delta_sa_to_hw, " hw->sa =", delta_hw_to_sa
cause = change_to_zero_one(fremersdorf)
effect = change_to_zero_one(sanktarnual)
delta_fr_to_sa = bernoulli2(effect, length) - cbernoulli2(
effect, cause, length)
delta_sa_to_fr = bernoulli2(cause, length) - cbernoulli2(
cause, effect, length)
#delta_fr_to_sa = calculate_difference3(fremersdorf,sanktarnual,10)
#delta_sa_to_fr = calculate_difference3(sanktarnual,fremersdorf,10)
print "fr->sa =", delta_fr_to_sa, " sa->fr =", delta_sa_to_fr
def test_data(length, array_length):
#txtName = "causal_continue_noise_0.4_normal_sample_1000_length_200.txt"
#f = file(txtName, "a+")
counter11 = 0
counter10 = 0
counter01 = 0
counter00 = 0
counter11_01 = 0
counter10_01 = 0
counter01_01 = 0
counter00_01 = 0
counter_undecided = 0
counter_true = 0
counter_false = 0
counter_undecided2 = 0
counter_true2 = 0
counter_false2 = 0
counter_error_1 = 0
counter_error_2 = 0
p_array_granger1 = []
p_array_granger2 = []
p_array_CUTE1 = []
p_array_CUTE2 = []
p_array_improve_CUTE1 = []
p_array_improve_CUTE2 = []
p_array1 = []
p_array2 = []
p_array_granger = []
for i in range(0, 1000):
write_str = ""
p = random.randint(1, 3)
#effect, test1 = generate_continue_data(200, p)
#cause, effect = generate_continue_data(150, p)
#cause_tmp = list(cause)
#effect_tmp = list(effect)
#cause = zero_change(cause)
#effect = zero_change(effect)
#cause,effect = generate_continue_data_with_change_lag(350,10)
cause = GMM(3, array_length)
effect = GMM(5, array_length)
cause_tmp = list(cause)
effect_tmp = list(effect)
#effect = forward_shift_continue_data(cause,p)
#noise = np.random.normal(0, 0.1, 200)
#for j in range(0, 200):
# effect[j] = effect[j] + noise[j]
#for i in range(0,len(cause)):
#cause[i]=math.tanh(cause[i])
#cause[i] = math.pow(math.e,cause[i])
#effect[i] = math.pow(math.e,effect[i])
#cause[i] = math.pow(cause[i],3)/10
#effect[i] = math.pow(effect[i],3)/10
#effect[i]=math.tanh(effect[i])
#effect[i] = math.pow(effect[i],3)
#effect = GMM(8,200)
#plt.plot(cause)
#plt.plot(effect)
#plt.show()
#cause = normalize(cause)
#effect = normalize(effect)
#cause = normalize_data(cause)
#effect = normalize_data(effect)
#cause = zero_change(cause)
#effect = zero_change(effect)
from scipy.special import expit
#for i in range(0,len(effect)):
#effect[i]=expit(effect[i])
#effect[i] = 1.0/effect[i]
for ii in range(0, len(cause)):
write_str = write_str + " " + str(cause[ii])
for jj in range(0, len(effect)):
write_str = write_str + " " + str(effect[jj])
#print "cause:" + str(cause)
#print "effect:" + str(effect)
# effect, test2 = ge_normal_data(p,200)
print "Continuous data, Granger causality test"
print "cause->effect"
p_value_cause_to_effect1 = []
flag1 = False
#ce1 = grangercausalitytests([[effect[i], cause[i]] for i in range(0, len(cause))], p)
ce_p = granger(cause, effect, -1)
#for key in ce1:
# p_value_cause_to_effect1.append(ce1[key][0]["params_ftest"][1])
# if ce1[key][0]["params_ftest"][1] < 0.05:
# flag1 = True
if ce_p < 0.05:
flag1 = True
print "effect->cause"
p_value_effect_to_cause2 = []
flag2 = False
#ce2 = grangercausalitytests([[cause[i], effect[i]] for i in range(0, len(cause))], p)
ce2_p = granger(effect, cause, -1)
#for key in ce2:
# p_value_effect_to_cause2.append(ce2[key][0]["params_ftest"][1])
# if ce2[key][0]["params_ftest"][1] < 0.05:
# flag2 = True
if ce2_p < 0.05:
flag2 = True
if ce_p < 0.05:
p_array_granger1.append(ce_p)
elif ce2_p < 0.05:
p_array_granger2.append(ce2_p)
if flag1 and flag2:
print "Continuous data，Granger two-way cause and effect"
write_str = write_str + " " + "连续数据，格兰杰双向因果"
counter11 += 1
elif flag1 and not flag2:
print "Continuous data，Granger correct cause and effect"
write_str = write_str + " " + "连续数据，格兰杰正确因果"
counter10 += 1
p_array_granger.append(ce_p)
elif not flag1 and flag2:
print "Continuous data，Granger wrong cause and effect"
write_str = write_str + " " + "连续数据，格兰杰错误因果"
counter01 += 1
elif not flag1 and not flag2:
print "Continuous data，Granger no cause and effect"
write_str = write_str + " " + "连续数据，格兰杰没有因果"
#break
counter00 += 1
#write_str = write_str + " " + str(min(p_value_cause_to_effect1)) + " " + str(min(p_value_effect_to_cause2))
cause2 = get_type_array(cause, length)
effect2 = get_type_array(effect, length)
print "01 data, Granger causality test"
print "cause->effect"
p_value_cause_to_effect3 = []
flag3 = False
#ce3 = grangercausalitytests([[effect2[i], cause2[i]] for i in range(0, len(cause2))], p)
ce3_p = granger(cause2, effect2, -1)
#for key in ce3:
# p_value_cause_to_effect3.append(ce3[key][0]["params_ftest"][1])
# if ce3[key][0]["params_ftest"][1] < 0.05:
# flag3 = True
if ce3_p < 0.05:
flag3 = True
print "effect->cause"
p_value_effect_to_cause4 = []
flag4 = False
#ce4 = grangercausalitytests([[cause2[i], effect2[i]] for i in range(0, len(cause2))], p)
ce4_p = granger(effect2, cause2, -1)
#for key in ce4:
# p_value_effect_to_cause4.append(ce4[key][0]["params_ftest"][1])
# if ce4[key][0]["params_ftest"][1] < 0.05:
# flag4 = True
if ce4_p < 0.05:
flag4 = True
if flag3 and flag4:
print "01 data，Granger two-way cause and effect"
write_str = write_str + " " + "离散数据，格兰杰双向因果"
counter11_01 += 1
elif flag3 and not flag4:
print "01 data，Granger correct cause and effect"
write_str = write_str + " " + "离散数据，格兰杰正确因果"
counter10_01 += 1
elif not flag3 and flag4:
print "01 data，Granger wrong cause and effect"
write_str = write_str + " " + "离散数据，格兰杰错误因果"
counter01_01 += 1
elif not flag3 and not flag4:
print "01 data，Granger no cause and effect"
write_str = write_str + " " + "离散数据，格兰杰没有因果"
counter00_01 += 1
#write_str = write_str + " " + str(min(p_value_cause_to_effect3)) + " " + str(min(p_value_effect_to_cause4))
print
delta_ce = calculate_difference3(cause, effect, length)
delta_ec = calculate_difference3(effect, cause, length)
print 'cause' + ' -> ' + 'effect' + ':' + str(delta_ce)
print 'effect' + ' -> ' + 'cause' + ':' + str(delta_ec)
if delta_ce > delta_ec and delta_ce - delta_ec >= -math.log(0.05, 2):
print "CUTE，correct cause and effect"
write_str = write_str + " " + "CUTE，正确因果"
counter_true += 1
elif delta_ec > delta_ce and delta_ec - delta_ce >= -math.log(0.05, 2):
print "CUTE，wrong cause and effect"
write_str = write_str + " " + "CUTE，错误因果"
counter_false += 1
else:
print "CUTE，undecided"
write_str = write_str + " " + "CUTE，未决定"
counter_undecided += 1
write_str = write_str + " " + str(pow(2, -abs(delta_ce - delta_ec)))
p = math.pow(2, -(delta_ce - delta_ec))
if p < 1:
p_array1.append(p)
else:
p_array2.append(math.pow(2, -(delta_ec - delta_ce)))
#f.write(write_str)
#f.write("\n")
cause = change_to_zero_one(cause_tmp)
effect = change_to_zero_one(effect_tmp)
cause2effect = bernoulli2(effect, length) - cbernoulli2(
effect, cause, length)
effect2cause = bernoulli2(cause, length) - cbernoulli2(
cause, effect, length)
# print 'cause' + ' -> ' + 'effect' + ':' + str(cause2effect)
# print 'effect' + ' -> ' + 'cause' + ':' + str(effect2cause)
p = math.pow(2, -(cause2effect - effect2cause))
if p < 1:
p_array_improve_CUTE1.append(p)
else:
p_array_improve_CUTE2.append(
math.pow(2, -(effect2cause - cause2effect)))
cause2effect = bernoulli(effect) - cbernoulli(effect, cause)
effect2cause = bernoulli(cause) - cbernoulli(cause, effect)
if p < 1:
p_array_CUTE1.append(p)
else:
p_array_CUTE2.append(math.pow(2, -(effect2cause - cause2effect)))
print
print "*****************************cut line*****************************"
print
#f.close()
print "连续数据，格兰杰因果关系检验："
print "双向因果:" + str(counter11)
print "正确因果:" + str(counter10)
print "错误因果:" + str(counter01)
print "没有因果" + str(counter00)
print "-----------------"
print "离散数据，格兰杰因果关系检验："
print "双向因果:" + str(counter11_01)
print "正确因果:" + str(counter10_01)
print "错误因果:" + str(counter01_01)
print "没有因果" + str(counter00_01)
print "-----------------"
print "discret data，snml causality test："
print "correct cause and effect:" + str(counter_true)
print "wrong cause and effect:" + str(counter_false)
print "no cause and effect:" + str(counter_undecided)
print "-----------------"
print "01 data，CUTE causality test："
granger_test = (bh_procedure(p_array_granger1, 0.05) +
bh_procedure(p_array_granger2, 0.05)) / 1000.0
ourmodel = (bh_procedure(p_array1, 0.05) +
bh_procedure(p_array2, 0.05)) / 1000.0
cute = (bh_procedure(p_array_CUTE1, 0.05) +
bh_procedure(p_array_CUTE2, 0.05)) / 1000.0
improve_cute = (bh_procedure(p_array_improve_CUTE1, 0.05) +
bh_procedure(p_array_improve_CUTE2, 0.05)) / 1000.0
print granger_test
print improve_cute
print ourmodel
return granger_test, ourmodel, cute, improve_cute
def river_test():
length = 6
date_time, speyer, mannheim, worms, mainz = collect_data()
counter = 0
speyer_low = []
mannheim_low = []
worms_low = []
mainz_low = []
while counter < 2880:
speyer_low.append(speyer[counter])
mannheim_low.append(mannheim[counter])
worms_low.append(worms[counter])
mainz_low.append(mainz[counter])
counter += 1
speyer = map(float, speyer_low)
mannheim = map(float, mannheim_low)
worms = map(float, worms_low)
mainz = map(float, mainz_low)
cause = speyer
effect = mannheim
cause = zero_change(cause)
effect = zero_change(effect)
cause = change_to_zero_one(cause)
effect = change_to_zero_one(effect)
sp2ma = bernoulli2(effect, length) - cbernoulli2(effect, cause, length)
ma2sp = bernoulli2(cause, length) - cbernoulli2(cause, effect, length)
#sp2ma = calculate_difference3(cause, effect, 10)
#ma2sp = calculate_difference3(effect, cause, 10)
print 'sp' + ' -> ' + 'ma' + ':' + str(sp2ma)
print 'ma' + ' -> ' + 'sp' + ':' + str(ma2sp)
print
cause = speyer
effect = worms
cause = zero_change(cause)
effect = zero_change(effect)
cause = change_to_zero_one(cause)
effect = change_to_zero_one(effect)
sp2wo = bernoulli2(effect, length) - cbernoulli2(effect, cause, length)
wo2sp = bernoulli2(cause, length) - cbernoulli2(cause, effect, length)
#sp2wo = calculate_difference3(cause, effect, 10)
#wo2sp = calculate_difference3(effect, cause, 10)
print 'sp' + ' -> ' + 'wo' + ':' + str(sp2wo)
print 'wo' + ' -> ' + 'sp' + ':' + str(wo2sp)
print
cause = speyer
effect = mainz
cause = zero_change(cause)
effect = zero_change(effect)
cause = change_to_zero_one(cause)
effect = change_to_zero_one(effect)
sp2mz = bernoulli2(effect, length) - cbernoulli2(effect, cause, length)
mz2sp = bernoulli2(cause, length) - cbernoulli2(cause, effect, length)
#sp2mz = calculate_difference3(cause, effect, 10)
#mz2sp = calculate_difference3(effect, cause, 10)
print 'sp' + ' -> ' + 'mz' + ':' + str(sp2mz)
print 'mz' + ' -> ' + 'sp' + ':' + str(mz2sp)
print
cause = mannheim
effect = worms
cause = zero_change(cause)
effect = zero_change(effect)
cause = change_to_zero_one(cause)
effect = change_to_zero_one(effect)
ma2wo = bernoulli2(effect, length) - cbernoulli2(effect, cause, length)
wo2ma = bernoulli2(cause, length) - cbernoulli2(cause, effect, length)
#ma2wo = calculate_difference3(cause, effect, 10)
#wo2ma = calculate_difference3(effect, cause, 10)
print 'ma' + ' -> ' + 'wo' + ':' + str(ma2wo)
print 'wo' + ' -> ' + 'ma' + ':' + str(wo2ma)
print
cause = mannheim
effect = mainz
cause = zero_change(cause)
effect = zero_change(effect)
cause = change_to_zero_one(cause)
effect = change_to_zero_one(effect)
ma2mz = bernoulli2(effect, length) - cbernoulli2(effect, cause, length)
mz2ma = bernoulli2(cause, length) - cbernoulli2(cause, effect, length)
#ma2mz= calculate_difference3(cause, effect, 10)
#mz2ma = calculate_difference3(effect, cause, 10)
print 'ma' + ' -> ' + 'mz' + ':' + str(ma2mz)
print 'mz' + ' -> ' + 'ma' + ':' + str(mz2ma)
print
cause = worms
effect = mainz
cause = zero_change(cause)
effect = zero_change(effect)
cause = change_to_zero_one(cause)
effect = change_to_zero_one(effect)
wo2mz = bernoulli2(effect, length) - cbernoulli2(effect, cause, length)
mz2wo = bernoulli2(cause, length) - cbernoulli2(cause, effect, length)
#wo2mz = calculate_difference3(cause, effect, 10)
#mz2wo = calculate_difference3(effect, cause, 10)
print 'wo' + ' -> ' + 'mz' + ':' + str(wo2mz)
print 'mz' + ' -> ' + 'wo' + ':' + str(mz2wo)
print