Saravanan666/pypi-org huggingface dataset:
Package: robustgmm
A Robust EM Clustering Algorithm for Gaussian Mixture ModelsDescriptionPython implementation of Robust EM Clustering for Gaussian Mixture Models[1].
(Clickhereto view the paper for more detail.)robustgmm.robustgmmScikit-learn API style for Robust GMMrobustgmm.generatorGenerator for synthetic data from mixture of gaussian.For more detail to use, see the example below orpaper_example.pyReferenceMS Yang, A robust EM clustering algorithm for gaussian mixture models, Pattern Recognit., 45 (2012), pp. 3950-3961InstallInstall from PyPIpipinstallrobustgmmInstall from Githubpipinstallgit+https://github.com/HongJea-Park/robust_EM_for_gmm.gitExampleAll examples are conducted to compare with the experimental results of the paper.# For more detail, refer ./test/paper_example.pyimportnumpyasnpfromrobustgmmimportRobustGMMfromrobustgmmimportGenerator_Multivariate_Normal# Generate data from 2 multivariate normal distribution with fixed random seednp.random.seed(0)real_means=np.array([[.0,.0],[20,.0]])real_covs=np.array([[[1,.0],[.0,1]],[[9,.0],[.0,9]]])mix_prob=np.array([.5,.5])generator=Generator_Multivariate_Normal(means=real_means,covs=real_covs,mix_prob=mix_prob)X=generator.get_sample(800)# GMM using robust EM Algorithmrgmm=RobustGMM()rgmm.fit(X)Figures for each examples in paperExample 1Example 2Example 3Example 4Example 5Example 6Example 7Computational time cost
Package: robustgp
robustgpRobust Gaussian Process Regression Based on Iterative Trimming (ITGP)The Gaussian process (GP) regression can be severely biased when the data are contaminated by outliers. ITGP is a new robust GP regression algorithm that iteratively trims the most extreme data points. While the new algorithm retains the attractive properties of the standard GP as a nonparametric and flexible regression method, it can greatly improve the model accuracy for contaminated data even in the presence of extreme or abundant outliers. It is also easier to implement compared with previous robust GP variants that rely on approximate inference. Applied to a wide range of experiments with different contamination levels, the proposed method significantly outperforms the standard GP and the popular robust GP variant with the Student-t likelihood in most test cases. In addition, as a practical example in the astrophysical study, we show that this method can precisely determine the main-sequence ridge line in the color-magnitude diagram of star clusters.Installpip install robustgpDependency:GPyQuick startOne can start with examples inthis notebook.UsagefromrobustgpimportITGP# train ITGPres=ITGP(X,Y,alpha1=0.5,alpha2=0.975,nsh=2,ncc=2,nrw=1)gp,consistency=res.gp,res.consistency# make predictiony_avg,y_var=gp.predict(x_new)y_var*=consistencyHeregpis aGPy.core.GPobject, whose usage is further illustratedhere.See thedocstring of ITGPfor detailed usage and full API.See thisnotebookfor a complete example.ReferencesAlgorithm paper:Robust Gaussian Process Regression Based on Iterative Trimming,
Zhao-Zhou Li, Lu Li, & Zhengyi Shao, 2020First application:Modeling Unresolved Binaries of Open Clusters in the Color-Magnitude Diagram. I. Method and Application of NGC 3532,
Li et al., 2020LicenseThe MIT License
Package: robust-graphite-client
A simple graphite querying library with workarounds on some rare bugsUsageimport robgracli

client = robgracli.GraphiteClient('http://my-graphite-server.com')
result = client.aggregate('my.awesome.metric')
print result['my.awesome.metric']For details consult thedocumentation.History1.1.0AddGraphiteClient.find_metrics().1.0.0Rewrote the client API to properly support queries returning multiple metrics.GraphiteClientnow has two methods,query()to get raw data from
graphite andaggregate()to retrieve single values (e.g. the average of the
metrics over a period).Both methods return ordered mappings, indexed by target.0.1.0Addallow_multipleargument toGraphiteClient.get_metric_value().0.0.1 to 0.0.4First public releases, fixing bugs.
Package: robustica
robusticaFully customizable robust Independent Component Analysis (ICA).DescriptionThis package contains 3 modules:RobustICADefines the most important class that allows to perform and customize robust independent component analysis.InferComponentsRetrieves the number of components that explain a user-defined percentage of variance.examplesContains handy functions to quickly create or access example datasets.A more user-friendly documentation can be found athttps://crg-cnag.github.io/robustica/.RequirementsIn brackets, versions of packages used to reveloprobustica.numpy(1.19.2)pandas(1.1.2)scipy(1.6.2)scikit-learn(0.23.2)scikit-learn-extra(0.2.0)joblib(1.0.1)tqdm(4.59.0)Installationpippipinstallrobusticalocal (latest version)gitclonehttps://github.com/CRG-CNAG/robusticacdrobustica
pipinstall-e.UsagefromrobusticaimportRobustICAfromrobustica.examplesimportmake_sampledataX=make_sampledata(ncol=300,nrow=2000,seed=123)rica=RobustICA(n_components=10)# note that by default, we use DBSCAN algorithm and the number of components can be smaller# than the number of components defined.S,A=rica.fit_transform(X)# source matrix (nrow x n_components)print(S.shape)print(S)(2000,3)[[0.009757140.006191380.00502649][-0.0021527-0.03768570.0117938][0.000463020.017125610.00518039]...[0.00128344-0.007670990.0047334][0.00644422-0.004983270.01325542][0.0017873-0.01739889-0.00445954]]# mixing matrix (ncol x n_components)print(A.shape)print(A)(300,3)[[-1.79503194e-02-1.05611924e+005.36688700e-01][1.03342514e-017.43471382e-024.90472157e-01][4.89753256e-01-1.11300905e+00-7.55809647e-01]...[4.30468472e-01-4.87992838e-01-7.77965512e-01][3.44078031e-024.09029805e-01-7.29076312e-01][2.15557427e-022.89301273e-01-2.96690459e-01]]TutorialsBasic pipeline for exploratory analysisUsing a custom clustering classInferring the number of componentsContactThis project has been fully developed at theCentre for Genomic Regulationwithin the group ofDesign of Biological SystemsPlease, report any issues that you experience through this repository's"Issues"or email:Miquel Anglada-GirottoSarah A. HeadLuis SerranoLicenserobusticais distributed under a BSD 3-Clause License (seeLICENSE).CitationAnglada-Girotto, M., Miravet-Verde, S., Serrano, L., Head, S. A.. "robustica: customizable robust independent component analysis". BMC Bioinformatics 23, 519 (2022). DOI:https://doi.org/10.1186/s12859-022-05043-9ReferencesHimberg, J., & Hyvarinen, A."Icasso: software for investigating the reliability of ICA estimates by clustering and visualization". IEEE XIII Workshop on Neural Networks for Signal Processing (2003). DOI:https://doi.org/10.1109/NNSP.2003.1318025Sastry, Anand V., et al."The Escherichia coli transcriptome mostly consists of independently regulated modules." Nature communications 10.1 (2019): 1-14. DOI:https://doi.org/10.1038/s41467-019-13483-wKairov, U., Cantini, L., Greco, A. et al.Determining the optimal number of independent components for reproducible transcriptomic data analysis. BMC Genomics 18, 712 (2017). DOI:https://doi.org/10.1186/s12864-017-4112-9
Package: robustify
MIT LicenseCopyright (c) 2022 Danyal Zia KhanPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: robustml
Interfaces for defining Robust ML models and precisely specifying the threat
models under which they claim to be secure. Also includes interfaces for
specifying attacks and evaluating attacks against models.The motivation behind this project is to make it easy to make specific,
testable claims about the robustness about machine learning models. Read more
in theFAQ.InstallationYou can install from PyPI:pip install robustml.UsageSeethis repositoryfor a complete
example of implenenting a model, implementing an attack, and evaluating the
attack against the model.If you’re implementing adefense, you should implementrobustml.model.Model. Seeherefor an
example.If you’re implementing anattackagainst a specific defense, you should
implementrobustml.attack.Attack. Seeherefor an example.Toevaluatea specific attack against a specific defense, userobustml.evaluate.evaluate(). Seeherefor an example.ContributingDo you have ideas on how to improve the robustml package? Have a feature
request (such as a specification of a new threat model) or bug report? Great!
Please open anissueor
submit apull request.Before contributing a major change, it’s recommended that you open a pull
request first and get feedback on the idea before investing time in the
implementation.PackagingUpdate version information.Build the package usingpython setup.py sdist bdist_wheel.Sign and upload the package usingtwine upload-sdist/*.Create a signed tag in the git repo with the version number that was
uploaded to PyPI.
Package: robust-password-generator
A simple password generator.
To generate password it uses all combinations like like Uppercase, lowercase letters, numbers and special characters.InstallationFast install:pip install robust-password-generatorFor a manual install get this package:wget https://github.com/ravitejasravi/robust-password-generator/archive/refs/heads/master.zip
unzip master.zip
rm master.zip
cd mygmap-masterInstall the package:python setup.py installExamplefrompassword_generatorimportrobust# generate password, by default length will be 8print(robust.password_generator())# now length will be 10print(robust.password_generator(10))
Package: robust-selection
Robust SelectionPython Package byC Tran, P Cisneros-Velarde, A Petersen and S-Y OhThis repository provides a Python package for Robust Selection algorithm
for estimation of the graphical lasso regularization parameter.P Cisneros-Velarde, A Petersen and S-Y Oh (2020). Distributionally Robust Formulation and Model Selection for the Graphical Lasso. Proceedings of the Twenty Third International Conference on Artificial Intelligence and Statistics. [PMLR][Papers with Code]DependenciesThe code contained in this repository was tested on the following configuration of Python:python=3.7.4robust-selection=0.0.7numpy=1.17.4scipy=1.3.1scikit-learn=0.22.1networkx=2.4pandas=0.25.3Installationpipinstallrobust-selection
Package: robustsp
robustspThis package contains the functions that are currently available in the RobustSP toolbox: a Matlab toolbox for robust signal processing[1]in Python. The toolbox can be freely used for non-commercial use only. Please make appropriate references to the book:Zoubir, A. M., Koivunen, V., Ollila, E., and Muma, M. Robust Statistics for Signal Processing Cambridge University Press, 2018.[1]https://github.com/RobustSP/toolboxDependenciesPython 3numpymatplotlibscipystatsmodelsInstallationThere are two ways to install this packageInstallation version 1Just run the following line in the command line:pip install robustspInstallation version 2If you would like to have the source files of the package easily accessible.Download the files.Unzip the files where you want them (if you downloaded the repo as a zip file)Open a command window in the freshly unzipped folder (should be called robustsp-master or something like that and contain setup.py)Run in in the command window:pip install -e .(Don't forget the dot)ExamplesPortfolio with examples for each chapter on google colab
Package: robust-statistics-simulator
Robust Statistics SimulatorAn interactive Python package for demonstrating the basic concepts of robust statistics.
This package relies on Streamlit for interactivity.From the root of the cloned repository, please run:cd robust_statistics_simulator
streamlit run robust_statistics_simulator/simulation.pyThis repository is in its early stages.Comparing estimators in terms of standard errorClickhereto access the hosted Streamlit appClickhereto access the hosted Streamlit appComparing estimators in terms of type-I error
Package: robust-stats
robust-statsProvides highly efficient implementations of various algorithm in robust statistics in Rust, with direct bindings to Python. The current focus is on robust mean estimation for known adversarial corruption for Gaussian distributions, but may later extend to robust covariance estimation or other useful robust statistical methods based on recent research efforts.As far as this package is concerned, beingrobustmeans being able to compute the mean of a dataset where at most an $\epsilon$-fraction of the data is corrupted by an arbitrary adversary (can replace any set of the original sample with arbitrary other points, so long as it only affects an $\epsilon$-fraction of the input dataset).Robust Mean EstimationTherobust_stats.robust_meanfunction computes the mean of an $n$-datapoint sample of a $d$-dimensionalGaussiandataset with identity covariance by default.UsageTherobust_statspackage can be installed viapipas follows:pipinstallrobust_statsTo compute the robust mean of a 2-dimensional numpy array with some $\epsilon$ sample corruption, then you can use the package as follows:fromrobust_statsimportrobust_meanx=get_data()# Returns some numpy array with dimension (n, d)x_bar=robust_mean(x,0.1,method='heuristic')The arguments torobust_meanare as follows:x: np.ndarray- the $(n \times d)$ input array to compute the mean of.epsilon: float- the percent of the data that is thought to be corrupted, in $[0, 1]$.method: str = 'heuristic'- which robust mean estimation method to use. Must be one of the methods defined below. Defaults toheuristic.It returns a $d$-dimensional outputnp.ndarraycontaining the computed mean value.MethodsWe provide efficient implementations of several means of robust mean estimation, based on relevant recent work in robust statistics. These methods(heuristic)Rust Source:src/robust/mean/robust_mean_heuristic.rs(filter)Rust Source:src/robust/mean/robust_mean_filter.rsProjected Gradient Descent (pgd)Rust Source:src/robust/mean/robust_mean_pgd.rsAcknowledgementsThis project was our final project for Brown's CSCI2952Q (Robust Algorithms in Machine Learning) taught by Professor Yu Cheng.MaintainersRobert Scheidegger (robert_scheidegger@brown.edu)Hammad Izhar (hammad_izhar@brown.edu)
Package: robust-vision-benchmark
Robust Vision BenchmarkThis Python package provides utility functions to create submissions for theRobust Vision Benchmarkand scripts to automatically test and upload them. You might also want to have a look atFoolbox, our python toolbox to benchmark the robustness of machine learning models using a large set of adversarial attacks.InstallationWe test using Python 2.7, 3.5 and 3.6. Other Python versions might work as well, but we recommend using Python 3.5 or newer.pipinstallrobust-vision-benchmarkSubmitting a modelA model submission consists of a Dockerfile, a script (e.g. Python) and data (e.g. network weights).Python scriptCreate a Python script that turns your model into a Foolbox model using one of our wrappers for TensorFlow, PyTorch, Theano, Keras, Lasagne, MXNet and starts themodel_server.fromrobust_vision_benchmarkimportmodel_server# create your model# ...# turn it into a Foolbox modelmodel=foolbox.models.SomeModel(...)# start the servermnist_model_server(model)cifar_model_server(model,channel_order='RGB or BGR')imagenet_model_server(model,channel_order='RGB or BGR',image_size=224)# For CIFAR and Imagenet, the channel_order must be set to either 'RGB' or 'BGR'.# For ImageNet, the image_size must be set to an integer (usually 224 vor VGG-like networks and 299 for inception-like networks).DockerfileCreate a Dockerfile that installs all dependencies and starts the script.FROMnvidia/cuda:8.0-cudnn5-devel-ubuntu16.04RUNapt-getupdate...&&install...RUNpip3install--no-cache-dirrobust-vision-benchmark...COPYmain.pymain.pyCMD["python3","./main.py"]For compatibility with our backend, please use a derivative of thenvidia/cuda:8.0image (e.g.nvidia/cuda8.0-cudnn5-devel-ubuntu16.04) as the base image or contact us if you have special requirements.Test the submissionPut the Dockerfile, script, data and other required files into a folder, e.g.modeland run the following in your shell:rvb-test-modelmodel/You can find an example inexamples/model/.Upload the submissionOnce your model is ready for submission, upload it:rvb-uploadmodel/SubmittingGo tohttps://robust.vision/benchmark/participateand put the URL returned by the upload script into theSubmission URL.Submitting an attackAn attack submission consists of a Dockerfile and a script (e.g. Python).Python scriptCreate a Python script that implements your attack and starts theattack_server.fromrobust_vision_benchmarkimportattack_server# implement your attackdefattack(a):# ...# start the serverattack_server(attack)DockerfileCreate a Dockerfile that installs all dependencies and starts the script.FROMpython:3.6RUNpip3install--no-cache-dirrobust-vision-benchmark...COPYmain.pymain.pyCMD["python3","./main.py"]Test the submissionPut the Dockerfile, script and other required files into a folder, e.g.attackand run the following in your shell:rvb-test-attackattack/You can find an example inexamples/attack/.Upload the submissionOnce your attack is ready for submission, upload it:rvb-uploadattack/SubmittingGo tohttps://robust.vision/benchmark/participateand put the URL returned by the upload script into theSubmission URL.AuthorsJonas RauberWieland Brendel
Package: robyn-data-validation
robyn-data-validationData validation module accompanying the MMM open source package Robyn (https://github.com/facebookexperimental/Robyn)installpip install robyn-data-validationuse the packageExample of running the package from project root with the sample data filefrompathlibimportPathfromrobyn_data_validationimportDataReviewerPROJECT_ROOT=Path(__file__).resolve().parentSAMPLE_WEEKLY_DATA_PATH=str(PROJECT_ROOT/"sample_data"/"simulated_data_weekly.csv")SAMPLE_DAILY_DATA_PATH=str(PROJECT_ROOT/"sample_data"/"simulated_data_daily.csv")media_vars=['tv_S','radio_S','paid_search_S']extra_vars=['competitor_sales']dependent_var='revenue'dr_weekly=DataReviewer(paid_media_vars=media_vars,paid_media_spends=media_vars,extra_vars=extra_vars,dep_var=dependent_var,file_path=SAMPLE_WEEKLY_DATA_PATH,date_frequency="weekly")dr_weekly.run_review()dr_daily=DataReviewer(paid_media_vars=media_vars,paid_media_spends=media_vars,extra_vars=extra_vars,dep_var=dependent_var,file_path=SAMPLE_DAILY_DATA_PATH,date_frequency="daily")dr_daily.run_review()
Package: robyn-rate-limits
Robyn Rate LimitsThis is an extension forRobynthat allows rate limiting your API.InstallationYou can getrobyn-rate-limitsfrom PyPI, whichm means you can install it with pip easily:python-mpipinstallrobyn-rate-limitsIf you would like to useRedisas a store, enable the redis feature:python-mpipinstallrobyn-rate-limits[redis]UsageDefine your API normally as you would with Robyn, and add a limiter middleware:fromrobynimportRobynfromrobyn_rate_limitsimportInMemoryStorefromrobyn_rate_limitsimportRateLimiterapp=Robyn(__file__)limiter=RateLimiter(store=InMemoryStore,calls_limit=3,limit_ttl=100)@app.before_request()defmiddleware(request:Request):returnlimiter.handle_request(app,request)@app.get("/")defh():return"Hello, World!"app.start(port=8080)In the above example the store for the limits is in memory, to useRedis, replace the limiter with:fromrobyn_rate_limitsimportRedisStoreimportredisconn=redis.Redis(host='localhost',port=6379,db=0)limiter=RateLimiter(store=RedisStore,calls_limit=2,limit_ttl=100,redis=conn)StoresCurrently, both in-memory store andRedisstore are using a sliding window algorithm to store the calls.The extension is designed in a way that you can implement your own store if you would like to use a different store or algorithm.IdentityThe identity of the client that the rate is limited by is automatically detected:For endpoints that require authentication, the rate is enforced by token.For endpoints that are open, the rate is enforced by IP.How to contributeIf you add more stores or algorithms and would like them to be part of the official package you are more than welcomed to!Please read thecontributing guidefor the guidelines.Feel free to open issues if you have any question or suggestion.Local developmentInstall the development dependencies:poetry install --with devInstall the pre-commit git hooks:pre-commit installRunpoetry run test_server. This will run a server containing several examples of routes we use for testing purposes. You can see them attests/base_routes.py. You can modify or add some to your likings.You can then request the server you ran from an other terminal. Here is aGETrequest done usingcurlfor example:curlhttp://localhost:8080/darwin/11/test# 200curlhttp://localhost:8080/darwin/11/test# 200curlhttp://localhost:8080/darwin/11/test# 200curlhttp://localhost:8080/darwin/11/test# 429
Package: roc
ROC - Remote Object CallROC is RPC enhancment allowing to manipulate remote objects like they
are localWhy ROC?ROC development was started to support acceptance testing of distributed
systems withFitNesse,waferslimandvagrantSystem infrastucture may be described
as follows:Host machine running FitNesse server and SLIM server;Set of guests, that are provisioned by vagrant with ROC servers;When hosts’ fixture is invoked by SLIM server, it can access guests’ roc
servers.UsageTo start serving your modules on remote machine with ROC:python -m "roc" -m <your-module-path> -p <port>To connect to your instance from host:from roc.client import server_proxy, remote_module
proxy = server_proxy(host='127.0.0.1', port=1234)
RModule = remote_module(proxy)To instantiate object on remote machine:remote_instance = RModule.RemoteClass(1, 2, 3)From now every method called on remote_instance will be executed on
remote.When you finished, callproxy.shutdown()to, well, shut down remote
ROC server.
Package: roc-2.1.1
ÔËÐÐ°ì·¨£º»·¾³£ºpython2    
ÔËÐÐÇ°ÏÈ°²×°ROC,transformºÍconRoc,°²×°°ì·¨£º
pip install roc-2.1.1


roc:
    ÊäÈë£ºÎÄ¼þ¼Ðtruth£¨±ê×¢½á¹ûÎÄ¼þ¼Ð£©,test£¨Ä£ÐÍÊä³öµÄ½á¹ûÎÄ¼þ¼Ð£©,result(Òª±£´æµÄtxtÎÄ±¾ÎÄµµÂ·¾¶£©£¬roc(Òª±£´æµÄÍ¼Æ¬Â·¾¶£©
    python 
            from ROC import roc
            roc.roc("truth","test","result","roc")
    Êä³ö£ºrocºÍ·ÖÊýÕÛÏßÍ¼,½á¹ûµÄÎÄ±¾ÎÄµµ
    PS:result ºÍroc²»´ø¸ñÊ½£¨Àý£º'D:\\python_work\\result')


conRoc:
    ÊäÈë£ºÎÄ¼þ¼Ðpre_file(ÐèÒª»æÍ¼µÄtxtËùÔÚµÄÎÄ¼þ¼Ð£©,image(Òª±£´æµÄÍ¼Æ¬Â·¾¶£©
    python 
            from ROC import conRoc
            conRoc.conRoc("pre_file","image")
    Êä³ö£ºrocÕÛÏßÍ¼
    PS:image²»´ø¸ñÊ½£¨Àý£º'D:\\python_work\\image') 
 

txt2xml:
    ÊäÈë£ºtxt_file(txt¸ñÊ½±ê×¢ÐÅÏ¢Ëù´æ·ÅÎÄ¼þ¼Ð£©
    python
            from transform import txt2xml
            txt2xml.txt2xml("txt_file","xml_file")
    Êä³ö£ºxml_file(xml¸ñÊ½±ê×¢ÐÅÏ¢Ëù´æ·ÅÎÄ¼þ¼Ð£©ÎÄ¼þ¼ÐËµÃ÷£ºtransformÎÄ¼þ¼Ð£ºtxt2xml £º½«txt¸ñÊ½ÎÄ±¾×ª»»ÎªxmlÎÄ¼þ£¨Ã¿¸ötxtÎÄ¼þ×ª»»ÎªÒ»¸öxmlÎÄ¼þ£©
ÐèÒª×ª»»µÄËùÓÐtxtÎÄ¼þ·ÅÔÚtxt_fileÖÐ£¬×ª»»ºóµÄxmlÎÄ¼þ´æ·ÅÔÚxml_fileÖÐROCÎÄ¼þ¼Ð£ºroc: »æÖÆrocÇúÏßºÍ·ÖÊýÇúÏß²¢¼ÆËãacu¡£Êý¾ÝÀ´Ô´ÓÚdbÁÐ±íIOU: ¼ÆËãÁ½¾ØÐÎIOU,´«ÈëÊý¾ÝÎªÃ¿¸ö¾ØÐÎÁ½Ìõ¶Ô½ÇÏßµÄºá×Ý×ø±êReframe=[X1,Y1,X2,Y2],GTframe=[X1,Y1,X2,Y2]¡£read:¶ÁÈ¡xmlÎÄ¼þµÄËùÓÐ±ê×¢µÄ±êÇ©Êý¾Ý(xmin,ymin,xmax,ymax)¡£´«ÈëÊý¾ÝÎª´ý²âÊÔxmlÎÄµµµÄÔªËØ¶ÔÏó¡£Analyze_xml£º½âÎöxmlÎÄ¼þ²¢µÃ³öIOU±È¶ÔÖÐ±È¶Ô´íÎó(ÖØµþ±ÈÂÊÐ¡ÓÚ0.5£©ºÍ±È¶ÔÕýÈ·µÄ¸öÊý¡£
ÊäÈë£ºtruthÎª±ê×¼xmlÎÄ¼þËùÔÚµÄÎÄ¼þ¼Ð£¬testÎª´ý±È¶ÔµÄxmlÎÄ¼þËùÔÚµÄÎÄ¼þ¼Ð¡£conROCÎÄ¼þ¼Ð:conRoc:¸ù¾ÝÎÄ¼þ¼ÐÖÐµÄËùÓÐtxtÎÄ¼þÄÚÈÝ»æÖÆÇúÏßÍ¼£¨Ã¿¸öÎÄ¼þ¶ÔÓ¦Á½ÌõÍ¬É«µÄÕÛÏß£©