Python cPickle.load函数代码示例

    def testPickle(self):
      ffeat = ChemicalFeatures.FreeChemicalFeature("HBondDonor", "HBondDonor1", geom.Point3D(1.0, 2.0, 3.0),123)
      pkl = cPickle.dumps(ffeat)
      ffeat2 = cPickle.loads(pkl, encoding='bytes')
      self.assertTrue(ffeat2.GetId()==ffeat.GetId());      
      self.assertTrue(ffeat2.GetFamily()==ffeat.GetFamily())
      self.assertTrue(ffeat2.GetType()==ffeat.GetType())
      self.assertTrue(ptFeq(ffeat2.GetPos(),ffeat.GetPos()))

      # Check that the old pickled versions have not been broken        
      inF = open(os.path.join(RDConfig.RDBaseDir,
                              'Code/ChemicalFeatures/Wrap/testData/feat.pkl'),'rb')
      ffeat2=cPickle.load(inF, encoding='bytes')
      # this version (1.0) does not have an id in the byte stream 
      self.assertTrue(ffeat2.GetFamily()==ffeat.GetFamily())
      self.assertTrue(ffeat2.GetType()==ffeat.GetType())
      self.assertTrue(ptFeq(ffeat2.GetPos(),ffeat.GetPos()))
        
      # Test the new version also has the id and works as expected
      
      # uncomment the following to generate (overrwrite) new version of pickled
      # data file
      #cPickle.dump(ffeat,file(os.path.join(RDConfig.RDBaseDir, 'Code/ChemicalFeatures/Wrap/testData/featv2.pkl'),'wb+'))
      inF = open(os.path.join(RDConfig.RDBaseDir,
                              'Code/ChemicalFeatures/Wrap/testData/featv2.pkl'),'rb')
      ffeat2=cPickle.load(inF, encoding='bytes')
      self.assertTrue(ffeat2.GetId()==ffeat.GetId());
      self.assertTrue(ffeat2.GetFamily()==ffeat.GetFamily())
      self.assertTrue(ffeat2.GetType()==ffeat.GetType())
      self.assertTrue(ptFeq(ffeat2.GetPos(),ffeat.GetPos()))

  def test1_Issue163(self):
    name1 = os.path.join(self.baseDir, 'humanoral.1.pkl')
    try:
      with open(name1, 'rb') as pklF:
        c1 = pickle.load(pklF)
    except Exception:
      c1 = None
    self.assertTrue(c1)
    name2 = os.path.join(self.baseDir, 'humanoral.2.pkl')
    try:
      with open(name2, 'rb') as pklF:
        c2 = pickle.load(pklF)
    except Exception:
      c2 = None
    self.assertTrue(c2)

    try:
      res = sorted(AnalyzeComposite.ProcessIt([c1, c2], verbose=-1))
    except Exception:
      import traceback
      traceback.print_exc()
      ok = 0
    else:
      ok = 1
    self.assertTrue(ok)

    self.assertEqual(res[0][0],'BALABANJ')
    self.assertEqual(res[1][0],'BERTZCT')
    self.assertEqual(res[-1][0],'VSA_ESTATE9')
    for entry in res:
      self.assertEqual(len(entry),5)

 def testBuild(self):
   """ tests building and screening a packager """
   with open(os.path.join(self.dataDir,'Jan9_build3_calc.dsc'),'rb') as calcF:
     calc = cPickle.load(calcF)
   with open(os.path.join(self.dataDir,'Jan9_build3_model.pkl'),'rb') as modelF:
     model = cPickle.load(modelF)
   pkg = Packager.ModelPackage(descCalc=calc,model=model)
   self._verify(pkg,self.testD)

 def test6Bug29_2(self):
   """ a more extensive test of the cmp stuff using pickled trees"""
   import os
   with open(os.path.join(RDConfig.RDCodeDir,'ML','DecTree','test_data','CmpTree1.pkl'),'rb') as t1File:
     t1 = cPickle.load(t1File)
   with open(os.path.join(RDConfig.RDCodeDir,'ML','DecTree','test_data','CmpTree2.pkl'),'rb') as t2File:
     t2 = cPickle.load(t2File)
   assert cmp(t1,t2),'equality failed'

 def test6Bug29_2(self):
   """ a more extensive test of the cmp stuff using pickled trees"""
   import os
   with open(os.path.join(RDConfig.RDCodeDir,'ML','DecTree','test_data','CmpTree1.pkl'),'r') as t1TFile:
     buf = t1TFile.read().replace('\r\n', '\n').encode('utf-8')
     t1TFile.close()
   with io.BytesIO(buf) as t1File:
     t1 = cPickle.load(t1File)
   with open(os.path.join(RDConfig.RDCodeDir,'ML','DecTree','test_data','CmpTree2.pkl'),'r') as t2TFile:
     buf = t2TFile.read().replace('\r\n', '\n').encode('utf-8')
     t2TFile.close()
   with io.BytesIO(buf) as t2File:
     t2 = cPickle.load(t2File)
   assert cmp(t1,t2),'equality failed'

  def test3Pickle2(self):
    """

    """
    l=1<<21
    v1 = ds.IntSparseIntVect(l)
    self.assertRaises(IndexError,lambda:v1[l+1])
    v1[0]=1
    v1[2]=2
    v1[1<<12]=3
    self.assertTrue(v1==v1)

    v2=  cPickle.loads(cPickle.dumps(v1))
    self.assertTrue(v2==v1)
    
    v3=  ds.IntSparseIntVect(v2.ToBinary())
    self.assertTrue(v2==v3)
    self.assertTrue(v1==v3)

    #cPickle.dump(v1,file('isiv.pkl','wb+'))
    with open(
      os.path.join(RDConfig.RDBaseDir, 
                   'Code/DataStructs/Wrap/testData/isiv.pkl'),
      'r'
      ) as tf:
      buf = tf.read().replace('\r\n', '\n').encode('utf-8')
      tf.close()
    with io.BytesIO(buf) as f:
      v3 = cPickle.load(f)
      self.assertTrue(v3==v1)

    def testTreeGrow(self):
        " testing tree-based composite "
        with open(RDConfig.RDCodeDir + "/ML/Composite/test_data/composite_base.pkl", "r") as pklTF:
            buf = pklTF.read().replace("\r\n", "\n").encode("utf-8")
            pklTF.close()
        with io.BytesIO(buf) as pklF:
            self.refCompos = cPickle.load(pklF)

        composite = Composite.Composite()
        composite._varNames = self.varNames
        composite.SetQuantBounds(self.qBounds, self.nPoss)
        from rdkit.ML.DecTree import CrossValidate

        driver = CrossValidate.CrossValidationDriver
        pruner = None
        composite.Grow(self.examples, self.attrs, [], buildDriver=driver, pruner=pruner, nTries=100, silent=1)
        composite.AverageErrors()
        composite.SortModels()

        # with open(RDConfig.RDCodeDir+'/ML/Composite/test_data/composite_base.pkl','wb') as pklF:
        #  cPickle.dump(composite,pklF)

        self.treeComposite = composite
        self.assertEqual(len(composite), len(self.refCompos))
        for i in xrange(len(composite)):
            t1, c1, e1 = composite[i]
            t2, c2, e2 = self.refCompos[i]
            self.assertEqual(e1, e2)

 def testSaveState(self):
   fName = os.path.join(RDConfig.RDCodeDir,'ML/Descriptors/test_data','molcalc.dsc')
   with open(fName,'rb') as inF:
     calc = cPickle.load(inF)
   self.assertEqual(calc.GetDescriptorNames(),tuple(self.descs))
   self.assertEqual(calc.GetDescriptorVersions(),tuple(self.vers))
   self._testVals(calc,self.testD)

  def testPerm1(self):
    """ tests the descriptor remapping stuff in a packager """
    from rdkit.Chem import Descriptors
    with open(os.path.join(self.dataDir,'Jan9_build3_pkg.pkl'),'r') as pkgTF:
      buf = pkgTF.read().replace('\r\n', '\n').encode('utf-8')
      pkgTF.close()
    with io.BytesIO(buf) as pkgF:
      pkg = cPickle.load(pkgF)
    calc = pkg.GetCalculator()
    names = calc.GetDescriptorNames()
    ref = {}
    DataUtils.InitRandomNumbers((23,42))
    for smi,pred,conf in self.testD:
      for desc in names:
        fn = getattr(Descriptors,desc,lambda x:777)
        m = Chem.MolFromSmiles(smi)
        ref[desc] = fn(m)

      for i in range(5):
        perm = list(names)
        random.shuffle(perm,random=random.random)

        m = Chem.MolFromSmiles(smi)
        for desc in perm:
          fn = getattr(Descriptors,desc,lambda x:777)
          val = fn(m)
          assert feq(val,ref[desc],1e-4),'%s: %s(%s): %f!=%f'%(str(perm),
                                                               smi,
                                                               desc,
                                                               val,
                                                               ref[desc])

  def test1PPDataset(self):
    fileN = os.path.join(RDConfig.RDBaseDir, 'Code', 'GraphMol', 'PartialCharges', 'Wrap',
                         'test_data', 'PP_descrs_regress.2.csv')
    infil = open(fileN, 'r')
    lines = infil.readlines()
    infil.close()

    infile = os.path.join(RDConfig.RDBaseDir, 'Code', 'GraphMol', 'PartialCharges', 'Wrap',
                          'test_data', 'PP_combi_charges.pkl')
    with open(infile, 'r') as cchtFile:
      buf = cchtFile.read().replace('\r\n', '\n').encode('utf-8')
      cchtFile.close()
    with io.BytesIO(buf) as cchFile:
      combiCharges = pickle.load(cchFile)

    for lin in lines:
      if (lin[0] == '#'):
        continue
      tlst = lin.strip().split(',')
      smi = tlst[0]
      rdmol = Chem.MolFromSmiles(smi)
      rdPartialCharges.ComputeGasteigerCharges(rdmol)

      nat = rdmol.GetNumAtoms()
      failed = False
      for ai in range(nat):
        rdch = float(rdmol.GetAtomWithIdx(ai).GetProp('_GasteigerCharge'))
        if not feq(rdch, combiCharges[smi][ai], 1.e-2):
          failed = True
          print(smi, ai, rdch, combiCharges[smi][ai])
      if failed:
        rdmol.Debug()
      self.assertFalse(failed)

 def test6(self):
   """ multiple models """
   self.details.tableName = 'ferro_noquant'
   with open(os.path.join(self.baseDir,'ferromag_auto_10_3.pkl'),'r') as pklTF:
     buf = pklTF.read().replace('\r\n', '\n').encode('utf-8')
     pklTF.close()
   with io.BytesIO(buf) as pklF:
     compos = pickle.load(pklF)
   tgt = 10
   self.assertEqual(len(compos),tgt)
   composites = [compos,compos]
   tpl = ScreenComposite.ScreenFromDetails(composites,self.details)
   nGood,misCount,nSkipped,avgGood,avgBad,avgSkip,tbl = tpl
   self.assertEqual(nGood[0],95)
   self.assertEqual(misCount[0],8)
   self.assertEqual(nSkipped[0],0)
   self.assertAlmostEqual(avgGood[0],.9684,4)
   self.assertAlmostEqual(avgBad[0],.8375,4)
   self.assertEqual(nGood[1],0)
   self.assertEqual(misCount[1],0)
   self.assertEqual(nSkipped[1],0)
   self.assertEqual(avgGood[1],0)
   self.assertEqual(avgBad[1],0)
   self.assertEqual(tbl[0,0],50)
   self.assertEqual(tbl[1,1],45)
   self.assertEqual(tbl[0,1],5)
   self.assertEqual(tbl[1,0],3)

  def test11(self):
    """ filtering with segmentation """
    self.details.tableName = 'ferro_noquant'
    with open(os.path.join(self.baseDir,'ferromag_filt_10_3.pkl'),
              'r') as pklTF:
      buf = pklTF.read().replace('\r\n', '\n').encode('utf-8')
      pklTF.close()
    with io.BytesIO(buf) as pklF:
      compos = pickle.load(pklF)
    tgt = 10
    self.assertEqual(len(compos),tgt)
    self.details.doHoldout=1
    self.details.filterVal=1
    self.details.filterFrac=.33

    nGood,misCount,nSkipped,avgGood,avgBad,avgSkip,tbl = ScreenComposite.ScreenFromDetails(compos,self.details)

    self.assertEqual(nGood,37)
    self.assertEqual(misCount,6)
    self.assertEqual(nSkipped,0)
    self.assertAlmostEqual(avgGood,.95946,4)    
    self.assertAlmostEqual(avgBad,.85,4)
    self.assertEqual(tbl[0,0] , 14)
    self.assertEqual(tbl[1,1] , 23)
    self.assertEqual(tbl[0,1] , 1)
    self.assertEqual(tbl[1,0] , 5)

  def test3Pickle2(self):
    """

    """
    l=1<<21
    v1 = ds.IntSparseIntVect(l)
    self.assertRaises(IndexError,lambda:v1[l+1])
    v1[0]=1
    v1[2]=2
    v1[1<<12]=3
    self.assertTrue(v1==v1)

    v2=  cPickle.loads(cPickle.dumps(v1))
    self.assertTrue(v2==v1)
    
    v3=  ds.IntSparseIntVect(v2.ToBinary())
    self.assertTrue(v2==v3)
    self.assertTrue(v1==v3)

    #cPickle.dump(v1,file('isiv.pkl','wb+'))
    with open(
      os.path.join(RDConfig.RDBaseDir, 
                   'Code/DataStructs/Wrap/testData/isiv.pkl'),
      'rb'
      ) as f:
      v3 = cPickle.load(f)
      self.assertTrue(v3==v1)

  def test4(self):
    """ include thresholding """
    self.details.tableName = 'ferro_quant'
    self.details.threshold = 0.80
    self.details.doHoldout=0
    self.details.doTraining=0

    with open(os.path.join(self.baseDir,'ferromag_quant_10.pkl'),'r') as pklTF:
      buf = pklTF.read().replace('\r\n', '\n').encode('utf-8')
      pklTF.close()
    with io.BytesIO(buf) as pklF:
      compos = pickle.load(pklF)
    tgt = 5
    self.assertEqual(len(compos),tgt)

    nGood,misCount,nSkipped,avgGood,avgBad,avgSkip,tbl = ScreenComposite.ScreenFromDetails(compos,self.details)
    self.assertEqual(nGood,91)
    self.assertEqual(misCount,1)
    self.assertEqual(nSkipped,3)
    self.assertAlmostEqual(avgGood,0.9956,4)
    self.assertAlmostEqual(avgBad,1.000,4)
    self.assertAlmostEqual(avgSkip,0.6000,4)
    self.assertEqual(tbl[0,0] , 54)
    self.assertEqual(tbl[1,1] , 37)
    self.assertEqual(tbl[0,1] , 1)
    self.assertEqual(tbl[1,0] , 0)

 def test3CatFilePickle(self):
   with open(os.path.join(RDConfig.RDCodeDir,'Chem',
                          'test_data','simple_catalog.pkl'),
             'rb') as pklFile:
     cat = cPickle.load(pklFile, encoding='bytes')
   assert cat.GetNumEntries()==21
   assert cat.GetFPLength()==21
   self._testBits(cat)