def testFrankFrozen(self): # Load matlab data set stocks = np.loadtxt(dataDir + 'stocks.csv', delimiter=',') x = stocks[:, 0] y = stocks[:, 1] stockModel = PairCopula(x, y, family={ 'frank': 0, }) # Try to fit all copula stockModel.copulaTournament(verbosity=0) # Eval the frozen model frzU, frzV = stockModel.copulaModel.sample(40000) # Eval a model with specified params setU, setV = stockModel.copulaModel.sample(40000, *stockModel.copulaParams[1]) # Ensure both frozen model and specified param model produce same result frzModel = PairCopula(frzU, frzV) setModel = PairCopula(setU, setV) frzKtau, fp = frzModel.empKTau() setKtau, sp = setModel.empKTau() self.assertAlmostEqual(frzKtau, setKtau, places=2) self.assertAlmostEqual(fp, sp, places=2)
def testKtauFitGauss(self): # Load matlab data set stocks = np.loadtxt(dataDir + 'stocks.csv', delimiter=',') x = stocks[:, 0] y = stocks[:, 1] stockModel = PairCopula(x, y) # Try to fit all copula stockModel.copulaTournament() # Check gaussian copula parameters for correctness self.assertAlmostEqual(stockModel.copulaParams[1], 0.73874003, 4) # Obtain Ktau kTauFitted = stockModel.copulaModel.kTau() # Use fitted kTau to specify a new copula stockModelRefit = Copula("gauss") # Fit gauss copula param given kTau fittedParam = stockModelRefit.fitKtau(kTauFitted)[0] print("Fitted Ktau = %f" % kTauFitted) print("Expected Theta = %f" % 0.738740) print("Computed Theta = %f" % fittedParam) # check result self.assertAlmostEqual(0.73874003, fittedParam, delta=0.01)
def testBivariateBase(self): print( "--------------------- MULTI COPULA FIT TEST --------------------------" ) # Load matlab data set stocks = np.loadtxt(dataDir + 'stocks.csv', delimiter=',') x = stocks[:, 0] y = stocks[:, 1] stockModel = PairCopula(x, y) empTau = stockModel.empKTau() # kendall's tau corr coeff empSRho = stockModel.empSRho() # spearmans corr coeff empPRho = stockModel.empPRho() # pearson's corr coeff print("Emprical kTau, spearmanr, pearsonr: " + str(empTau[0]) + ", " + str(empSRho[0]) + ", " + str(empPRho[0])) # Try to fit all copula stockModel.copulaTournament() # Ensure that the gaussian copula was chosen as the best fit self.assertTrue(stockModel.copulaModel.name == "gauss") self.assertTrue(stockModel.copulaParams[0] == "gauss") # Check gaussian copula parameters for correctness self.assertAlmostEqual(stockModel.copulaParams[1], 0.73874003, 4)
def testClaytonRotate(self): expectedKtaus = { 0: 0.7777777, 1: -0.7777777, 2: 0.7777777, 3: -0.7777777 } shapeParam = 7.0 for rotation, expectedKtau in iteritems(expectedKtaus): clayton = Copula("clayton", rotation) u, v = clayton.sample(10000, *(shapeParam, )) g = sns.jointplot(u, v, stat_func=kendalltau) g.savefig("clayton_sample_pdf_" + str(rotation) + ".png") clayton.fittedParams = (shapeParam, ) c_kTau = clayton.kTau() # check kTau self.assertAlmostEqual(c_kTau, expectedKtau, delta=0.001) # compute rank corr coeff from resampled data clayton_model = PairCopula(u, v) clayton_model.copulaTournament() print(clayton_model.copulaParams) self.assertTrue("clayton" in clayton_model.copulaModel.name) # Ensure fitted shape parameter is same as original self.assertAlmostEqual(shapeParam, clayton_model.copulaParams[1][0], delta=0.2) self.assertEqual(rotation, clayton_model.copulaParams[3]) # Ensure kTau is nearly the same from resampled data self.assertAlmostEqual(c_kTau, clayton_model.copulaModel.kTau(), delta=0.02) # fit to resampled data u_model, v_model = clayton_model.copulaModel.sample(10000) clayton_refit = PairCopula(u_model, v_model) clayton_refit.copulaTournament() u_resample, v_resample = clayton_refit.copulaModel.sample(1000) self.assertAlmostEqual(c_kTau, clayton_refit.copulaModel.kTau(), delta=0.05) # plot resampled data g_resample = sns.jointplot(u_resample, v_resample, stat_func=kendalltau) g_resample.savefig("clayton_resample_pdf_" + str(rotation) + ".png")
def testFrankRotate(self): expectedKtaus = { 0: 0.602619667, 1: -0.602619667, 2: 0.602619667, 3: -0.602619667 } shapeParam = 8.0 for rotation, expectedKtau in iteritems(expectedKtaus): frank = Copula("frank", rotation) u, v = frank.sample(10000, *(shapeParam, )) g = sns.jointplot(u, v, stat_func=kendalltau) g.savefig("frank_sample_pdf_" + str(rotation) + ".png") frank.fittedParams = (shapeParam, ) c_kTau = frank.kTau() # check kTau self.assertAlmostEqual(c_kTau, expectedKtau, delta=0.001) # compute rank corr coeff from resampled data frank_model = PairCopula(u, v) frank_model.copulaTournament() print(frank_model.copulaParams) self.assertTrue("frank" in frank_model.copulaModel.name) # Ensure refitted shape parameter is same as original self.assertAlmostEqual(shapeParam, frank_model.copulaParams[1][0], delta=0.2) # Ensure kTau is nearly the same from resampled data self.assertAlmostEqual(c_kTau, frank_model.copulaModel.kTau(), delta=0.02) # fit to resampled data u_model, v_model = frank_model.copulaModel.sample(10000) frank_refit = PairCopula(u_model, v_model) frank_refit.copulaTournament() u_resample, v_resample = frank_refit.copulaModel.sample(1000) self.assertAlmostEqual(c_kTau, frank_refit.copulaModel.kTau(), delta=0.05) # plot resampled data g_resample = sns.jointplot(u_resample, v_resample, stat_func=kendalltau) g_resample.savefig("frank_resample_pdf_" + str(rotation) + ".png")
def testClaytonSample(self): # 0 deg clayton00 = Copula("clayton", 0) u00, v00 = clayton00.sample(10000, *(0.5, )) clayton00.fittedParams = (0.5, ) c00_kTau = clayton00.kTau() # check kTau self.assertAlmostEqual(c00_kTau, 0.2) # compute rank corr coeff from resampled data clayton00_model = PairCopula(u00, v00) clayton00_model.copulaTournament() # check that clayton copula won since # we seeded with samples from a clayton df self.assertTrue("clayton" in clayton00_model.copulaModel.name) # Ensure kTau is nearly the same from resampled data kTauDelta = c00_kTau - clayton00_model.copulaModel.kTau() self.assertTrue(abs(kTauDelta) < 0.01) # 90 deg clayton90 = Copula("clayton", 1) u90, v90 = clayton90.sample(10000, *(0.5, )) clayton90.fittedParams = (0.5, ) c90_kTau = clayton90.kTau() self.assertAlmostEqual(c90_kTau, -0.2) # compute rank corr coeff from resampled data clayton90_model = PairCopula(u90, v90, family={"clayton": 1}) clayton90_model.copulaTournament() # check that clayton copula won since # we seeded with samples from a clayton df self.assertTrue("clayton" in clayton90_model.copulaModel.name) self.assertTrue(1 == clayton90_model.copulaModel.rotation) # Ensure kTau is nearly the same from resampled data kTauDelta = c90_kTau - clayton90_model.copulaModel.kTau() self.assertTrue(abs(kTauDelta) < 0.01) # 180 deg clayton180 = Copula("clayton", 2) u180, v180 = clayton180.sample(1000, *(0.5, )) # 270 deg clayton270 = Copula("clayton", 3) u270, v270 = clayton270.sample(1000, *(0.5, ))
def testGumbelRotate(self): expectedKtaus = {0: 0.87499, 1: -0.87499, 2: 0.87499, 3: -0.87499} shapeParam = 8.0 for rotation, expectedKtau in iteritems(expectedKtaus): gumbel = Copula("gumbel", rotation) u, v = gumbel.sample(10000, *(shapeParam, )) g = sns.jointplot(u, v, stat_func=kendalltau) g.savefig("gumbel_sample_pdf_" + str(rotation) + ".png") gumbel.fittedParams = (shapeParam, ) c_kTau = gumbel.kTau() # check kTau self.assertAlmostEqual(c_kTau, expectedKtau, delta=0.001) # compute rank corr coeff from resampled data gumbel_model = PairCopula(u, v) gumbel_model.copulaTournament() print(gumbel_model.copulaParams) self.assertTrue("gumbel" in gumbel_model.copulaModel.name) # Ensure fitted shape parameter is same as original self.assertAlmostEqual(shapeParam, gumbel_model.copulaParams[1][0], delta=0.2) self.assertEqual(rotation, gumbel_model.copulaParams[3]) # Ensure kTau is nearly the same from resampled data self.assertAlmostEqual(c_kTau, gumbel_model.copulaModel.kTau(), delta=0.02) # fit to resampled data u_model, v_model = gumbel_model.copulaModel.sample(10000) gumbel_refit = PairCopula(u_model, v_model) gumbel_refit.copulaTournament() u_resample, v_resample = gumbel_refit.copulaModel.sample(1000) self.assertAlmostEqual(c_kTau, gumbel_refit.copulaModel.kTau(), delta=0.05) # plot resampled data g_resample = sns.jointplot(u_resample, v_resample, stat_func=kendalltau) g_resample.savefig("gumbel_resample_pdf_" + str(rotation) + ".png")
def testGaussRotate(self): shapes = {0: 0.7777777, 1: -0.7777777, 2: 0.7777777, 3: -0.7777777} for rotation, shapeParam in iteritems(shapes): gauss = Copula("gauss", 0) u, v = gauss.sample(10000, *(shapeParam, )) g = sns.jointplot(u, v, stat_func=kendalltau) g.savefig("gauss_sample_pdf_" + str(rotation) + ".png") gauss.fittedParams = (shapeParam, ) c_kTau = gauss.kTau() # compute rank corr coeff from resampled data gauss_model = PairCopula(u, v) gauss_model.copulaTournament() print(gauss_model.copulaParams) self.assertTrue("gauss" in gauss_model.copulaModel.name) # Ensure fitted shape parameter is same as original self.assertAlmostEqual(shapeParam, gauss_model.copulaParams[1][0], delta=0.2) # Ensure kTau is nearly the same from resampled data self.assertAlmostEqual(c_kTau, gauss_model.copulaModel.kTau(), delta=0.02) # fit to resampled data u_model, v_model = gauss_model.copulaModel.sample(10000) gauss_refit = PairCopula(u_model, v_model) gauss_refit.copulaTournament() u_resample, v_resample = gauss_refit.copulaModel.sample(1000) self.assertAlmostEqual(c_kTau, gauss_refit.copulaModel.kTau(), delta=0.05) self.assertAlmostEqual(shapeParam, gauss_refit.copulaParams[1][0], delta=0.2) # plot resampled data g_resample = sns.jointplot(u_resample, v_resample, stat_func=kendalltau) g_resample.savefig("gauss_resample_pdf_" + str(rotation) + ".png")
def testFrankSample(self): # 0 deg frank00 = Copula("frank", 0) u00, v00 = frank00.sample(30000, *(8.0, )) frank00.fittedParams = (8.0, ) c00_kTau = frank00.kTau() # check kTau print(c00_kTau) self.assertAlmostEqual(c00_kTau, 0.602619667, 6) # compute rank corr coeff from resampled data frank00_model = PairCopula(u00, v00, family={"frank": 0}) frank00_model.copulaTournament() print(frank00_model.copulaParams) # check that frank copula won since # we seeded with samples from a frank df self.assertTrue("frank" in frank00_model.copulaModel.name) # Ensure kTau is nearly the same from resampled data kTauDelta = c00_kTau - frank00_model.copulaModel.kTau() self.assertTrue(abs(kTauDelta) < 0.01) self.assertAlmostEqual(c00_kTau, frank00_model.copulaModel.kTau(), 2) # 90 deg frank90 = Copula("frank", 1) u90, v90 = frank90.sample(30000, *(8.0, )) frank90.fittedParams = (8.0, ) c90_kTau = frank90.kTau() self.assertAlmostEqual(c90_kTau, -0.602619667, 6) # compute rank corr coeff from resampled data frank90_model = PairCopula(u90, v90, family={"frank": 1}) frank90_model.copulaTournament() print(frank90_model.copulaParams) # check that frank copula won since # we seeded with samples from a frank df self.assertTrue("frank" in frank90_model.copulaModel.name) # Ensure kTau is nearly the same from resampled data kTauDelta = c90_kTau - frank90_model.copulaModel.kTau() self.assertTrue(abs(kTauDelta) < 0.01) self.assertAlmostEqual(c90_kTau, frank90_model.copulaModel.kTau(), 2)
def testGumbelSample(self): # TODO: TEST FAILS FOR SMALL GUMBEL PARAMETER VALUES # 0 deg gumbel00 = Copula("gumbel", 0) u00, v00 = gumbel00.sample(10000, *(8.0, )) gumbel00.fittedParams = (8.0, ) c00_kTau = gumbel00.kTau() # check kTau self.assertAlmostEqual(c00_kTau, 0.8749999999999, 6) # compute rank corr coeff from resampled data gumbel00_model = PairCopula(u00, v00, family={"gumbel": 0}) gumbel00_model.copulaTournament() print(gumbel00_model.copulaParams) # check that gumbel copula won since # we seeded with samples from a gumbel df self.assertTrue("gumbel" in gumbel00_model.copulaModel.name) # Ensure kTau is nearly the same from resampled data kTauDelta = c00_kTau - gumbel00_model.copulaModel.kTau() self.assertTrue(abs(kTauDelta) < 0.01) self.assertAlmostEqual(c00_kTau, gumbel00_model.copulaModel.kTau(), 2) # 90 deg gumbel90 = Copula("gumbel", 1) u90, v90 = gumbel90.sample(10000, *(8.0, )) gumbel90.fittedParams = (8.0, ) c90_kTau = gumbel90.kTau() self.assertAlmostEqual(c90_kTau, -0.87499999999, 6) # compute rank corr coeff from resampled data gumbel90_model = PairCopula(u90, v90, family={"gumbel": 1}) gumbel90_model.copulaTournament() print(gumbel90_model.copulaParams) # check that gumbel copula won since # we seeded with samples from a gumbel df self.assertTrue("gumbel" in gumbel90_model.copulaModel.name) # Ensure kTau is nearly the same from resampled data kTauDelta = c90_kTau - gumbel90_model.copulaModel.kTau() self.assertTrue(abs(kTauDelta) < 0.04)
def testGaussFrozen(self): # Load matlab data set stocks = np.loadtxt(dataDir + 'stocks.csv', delimiter=',') x = stocks[:, 0] y = stocks[:, 1] stockModel = PairCopula(x, y) # Try to fit all copula stockModel.copulaTournament(verbosity=0) # Ensure that the gaussian copula was chosen as the best fit self.assertTrue(stockModel.copulaModel.name == "gauss") self.assertTrue(stockModel.copulaParams[0] == "gauss") # Check gaussian copula parameters for correctness self.assertAlmostEqual(stockModel.copulaParams[1], 0.73874003, 4) # Eval the frozen model frzU, frzV = stockModel.copulaModel.sample(30000) # Eval a model with specified params setU, setV = stockModel.copulaModel.sample(30000, (0.73874003, )) # Ensure both frozen model and specified param model produce same result frzModel = PairCopula(frzU, frzV) setModel = PairCopula(setU, setV) frzKtau, fp = frzModel.empKTau() setKtau, sp = setModel.empKTau() self.assertAlmostEqual(frzKtau, setKtau, places=2) self.assertAlmostEqual(fp, sp, places=2) # Eval a model with different specified params setU2, setV2 = stockModel.copulaModel.sample(10000, (0.3, )) setModel2 = PairCopula(setU2, setV2) setKtau2, sp2 = setModel2.empKTau() self.assertTrue(setKtau2 != setKtau) self.assertTrue(abs(setKtau2 - setKtau) > 0.2)