Saravanan666/pypi-org huggingface dataset:
Package: recommender-utils
Recommender UtilitiesThis package (reco_utils) contains functions to simplify common tasks used when developing and evaluating recommender systems. A short description of the sub-modules is provided below. For more details about what functions are available and how to use them, please review the doc-strings provided with the code.See theonline documentation.AzureMLThe AzureML submodule contains utilities to train, tune and operationalize recommendation systems at scale using AzureML.CommonThis submodule contains high-level utilities for defining constants used in most algorithms as well as helper functions for managing aspects of different frameworks: gpu, spark, jupyter notebook.DatasetDataset includes helper functions for interacting with Azure Cosmos databases, pulling different datasets and formatting them appropriately as well as utilities for splitting data for training / testing.Data LoadingThere are dataloaders for several datasets. For example, the movielens module will allow you to load a dataframe in pandas or spark formats from the MovieLens dataset, with sizes of 100k, 1M, 10M, or 20M to test algorithms and evaluate performance benchmarks.df=movielens.load_pandas_df(size="100k")Splitting TechniquesCurrently three methods are available for splitting datasets. All of them support splitting by user or item and filtering out minimal samples (for instance users that have not rated enough item, or items that have not been rated by enough users).Random: this is the basic approach where entries are randomly assigned to each group based on the ratio desiredChronological: this uses provided timestamps to order the data and selects a cut-off time that will split the desired ratio of data to train before that time and test after that timeStratified: this is similar to random sampling, but the splits are stratified, for example if the datasets are split by user, the splitting approach will attempt to maintain the same set of items used in both training and test splits. The converse is true if splitting by item.EvaluationThe evaluation submodule includes functionality for performing hyperparameter sweeps as well as calculating common recommender metrics directly in python or in a Spark environment using pyspark.Currently available metrics include:Root Mean Squared ErrorMean Absolute ErrorR2Explained VariancePrecision at KRecall at KNormalized Discounted Cumulative Gain at KMean Average Precision at KArea Under CurveLogistic LossRecommenderThe recommender submodule contains implementations of various algorithms that can be used in addition to external packages to evaluate and develop new recommender system approaches. A description of all the algorithms can be found onthis table. Next a list of the algorithm utilities:CornacDeepRec (includes xDeepFM and DKN)FastAILightGBMNCFNewsRec (includes LSTUR, NAML NPA and NRMS)RBMRLRMCSARSurpriseVowpal Wabbit (VW)Wide&DeepTuningThis submodule contains utilities for performing hyperparameter tuning.
Package: recommender-xblock
This XBlock shows students a list of recommended resources for a given
problem. The resources are recommended, edited, and voted by students.
For each resource, we show its title, link, short summary, preview
screenshot, and votes:This is an module where students can share useful resources/hints and rate
them. This crowdsourcing mechanism allows a scalable solution to fulfill
students with varying learning needs.Staff Interface: manage problematic resourse easier, add comments, endorse,
de-endorse resourceDiscussion around each resourceBetter interface for adding varying types of resource (e.g., specific timestamps
in the video or specific elements in a learning sequence)Better user help/documentationTag/categorize resources around specific misconceptionsIn a randomized control trial in a computer science course, this XBlock led to
similar learning outcomes in about 10% less time than without it (so efficiency of
learning was about 10% better than without the XBlock – students learned the same
in less time). Qualitative analysis as well as quantitative analysis of usage data
showed it was helpful in contexts where there were complex, multiconcept problems.
It was not helpful or used in contexts where there were simple, single-step problems.In an analysis comparing to other remediation systems within edX, it was more
effective for deeper, more complex misconceptions, and less effective for simple
errors.
Package: recommendr
===============================Recommendr===============================.. image:: https://badge.fury.io/py/recommendr.png:target: http://badge.fury.io/py/recommendr.. image:: https://travis-ci.org/chrislawlor/recommendr.png?branch=master:target: https://travis-ci.org/chrislawlor/recommendr.. image:: https://pypip.in/d/recommendr/badge.png:target: https://crate.io/packages/recommendr?version=latestMovie recommendation engine.* Free software: BSD license* Documentation: http://recommendr.rtfd.org.Features--------* A Redis backend for storing movie and rating data.* A simple user-based recommendations algorithm with swappable distancefunctions.* Item-based recommendation algorithm in work.* A demo command-line client.Try it Out----------* Clone the repo::git clone git@github.com:chrislawlor/recommendr.git* Create a python virtual environment with virtualenvwrapper::mkvirtualenv recommendr* Install requirements::pip install -r requirements.txt* Install recommendr::python setup.py install* First, import some MovieLens data into Redis::python data/import_data.py* Run the demo program::python demo.pyThe demo program will ask you for ratings until you have rated 5 movies, thenit will give some recommendations. Recommendations should improve the moretimes you run the demo program.*NOTE*: If your Redis instance is somewhere other than ``locahost:6379``, setthe ``REDIS_HOST`` and ``REDIS_PORT`` environment variables. If you wish to usea Redis DB other than 1, set ``REDIS_DB``.Key Code Points---------------``recommendr.db``: Implements a Redis DB backend suitable for storing movieand rating information::recommendr.get_user_based_recommendations(reviewer_id, num=20, similarity=sim_distance)returns the top recommendations for a given user. It defaults to usingEuclidean distance for the similiarity function, optionally pass``recommendr.similarity.sim_pearson`` to use the Pearson Coefficient.Test Suite----------I haz one:::python setup.py testHistory-------0.0.1a (2013-08-27)++++++++++++++++++* First release on PyPI.
Package: recompose
RecomposeRecomposeis a Python package for recomposing data by following instructional schemas.Full documentation is online atcariad.github.io/recompose.ExampleFor example, the code below describes a dataset with groups of people with specific careers, and a schema that reduces the list of firefighters down to a single object.fromrecomposeimporttransform,CursorSchemadata={"2023-06-04":{"groups":{"chefs":[{"name":"Alice"},{"name":"Bob"}],"firefighters":[{"name":"Daniel"},{"name":"Esther"}],"zookeepers":[{"name":"Gregory"},{"name":"Harold"}]}},"2023-06-05":{"groups":{"chefs":[{"name":"Jet"},{"name":"Karen"}],"firefighters":[{"name":"Mater"},{"name":"Nigel"}],"zookeepers":[{"name":"Peter"},{"name":"Quentin"}]}}}schema:CursorSchema={"version":1,"on":"each-value","perform":{"path":"groups","cursor":{"perform":{"path":"firefighters","cursor":{"perform":"list-to-object",}}}}}transformed=transform(schema,data)print(transformed){"2023-06-04":{"groups":{"chefs":[{"name":"Alice"},{"name":"Bob"}],"firefighters":{"name":"Daniel"},"zookeepers":[{"name":"Gregory"},{"name":"Harold"}]}},"2023-06-05":{"groups":{"chefs":[{"name":"Jet"},{"name":"Karen"}],"firefighters":{"name":"Mater"},"zookeepers":[{"name":"Peter"},{"name":"Quentin"}]}}}AuthorHello! 👋 I'mCariad Eccleston, and I'm a freelance Amazon Web Services architect, DevOps evangelist, and infrastructure and backend engineer by the beach in the United Kingdom.You can find me atcariad.earth,github.com/cariadandlinkedin.com/in/cariad.
Package: recompy
RecompyRecompy is a library for recommender systems. It provides an easy framework to train models, calculate similarities, showing recommendations.Recompy shows the train end test errors in each epoch. After a new user is created by defining item id and rating, recommendation can simply obtained. Recompy uses FunkSVD algorithm to train recommender system model. Multiple similarity metrics can be used to calculate user similarity for any given new user.Functionsset_hyperparameters(initialization_method, max_epoch, n_latent,learning_rate, regularization, early_stopping, init_meaninitsd):A function to set hyperparameters. Available initialization techniques are: Random initializer, Normal initializer and He initializer. init_mean and init_sd parameters are used in Normal Initializer as mean and standard deviation.train_test_split(rated_count, movie_ratio_to_be_splitted, test_split):A function to perform train test split.fit():Trains FunkSVD model.get_recommendation_for_existing_user(user_id, howMany):Gets howMany recommendations for given user_id.get_recommendation_for_new_user(user_ratings, similarity_measure,howManyUsers, howManyItems):Gets recommendations for new user by a given similarity measure. Similarity measures can be Cosine Similarity, Pearson Correlation, Adjusted Cosine Similarity, Weighted Cosine Similarity, Constrained Pearson Correlation, Mean Squared Difference.get_similar_products(item_id, howMany):Gets howMany similar items to a given item.novelty(recommendation_list):Returns novelty of a given recommendation list.precision_recall_at_k(threshold, k):Returns precision and recall values of recommended items at k.
Package: reconchess
IntroductionReconnaissance Chess is a chess variant (more precisely, a family of chess variants) invented as an R&D project at Johns Hopkins Applied Physics Laboratory (JHU/APL). Reconnaissance Chess adds the following elements to standard (classical) chess: sensing; incomplete information; decision making under uncertainty; coupled management of â€˜battle forcesâ€™ and â€˜sensor resourcesâ€™; and adjudication of multiple, simultaneous, and competing objectives. Reconnaissance chess is a paradigm and test bed for understanding and experimenting with autonomous decision making under uncertainty and in particular managing a network of sensors to maintain situational awareness informing tactical and strategic decision making.The game implemented in this python package is a relatively basic version using only one kind of sensor that provides perfect information in a small region of the chess board. In the future, extended versions may include noisy sensors of different types; multiple sensing actions per turn; the need to divide attention and resources among multiple, concurrent games; and other complicating factors.This package includes a “game arbiter” which controls the game flow, maintains the ground truth game board, and notifies players of information collected by sense and move actions.  The package also contains a client API for interacting with the arbiter, which can be used by bot players or other game interfaces.Installationpip install reconchessDocumentationDocumentation is hosted byRead the Docs.LicenseDistributed under BSD 3-Clause License, for details see LICENSE file.
Package: reconchess-tools
reconchess-tools: utilities to aid bot development for reconchessGetting started developing bots in python for theReconnaissance Blind Chesscompetition from JHU APL is already simple thanks to thereconchesspackage. The code in this repository builds on that foundation to make it equally easy to move beyond beginner bot development. It provides utilities for multi-hypothesis-tracking (MHT), MHT game replays, sense and move simulation, and dominated action detection.See the example bot (reconchess_tools/example_bot/bot.py) for an overview of the capabilities included in this repository. You can run a local game and view the replay using the cli:reconchess-tools bot-match reconchess.bots.trout_bot reconchess_tools.example_bot.bot.
Package: reconcile
ReconcilepyReconcile is a library providing a reconciliation loop system for enabling declarative configuration of arbitrary systems.You bring the systems, the state representations, and the actions to modify them, and this brings the glue to put it all together.InstallaionUsageSee two-lists.py for an example of a built around mutating one list into another.ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.LicenseMozilla Public License, v2.0
Package: reconciler
reconcilerreconcileris a python package to reconcile tabular data with various reconciliation services, such asWikidata, working similarly to whatOpenRefinedoes, but entirely within Python, using Pandas.QuickstartYou can install the latest version of reconciler from PyPI with:pipinstallreconcilerThen to use it:fromreconcilerimportreconcileimportpandasaspd# A DataFrame with a column you want to reconcile.test_df=pd.DataFrame({"City":["Rio de Janeiro","São Paulo","São Paulo","Natal"],"Country":["Q155","Q155","Q155","Q155"]})# Reconcile against type city (Q515), getting the best match for each item.reconciled=reconcile(test_df["City"],type_id="Q515")The resulting dataframe would look like this:idmatchnamescoretypetype_idinput_valueQ8678TrueRio de Janeiro100cityQ515Rio de JaneiroQ174TrueSão Paulo100cityQ515São PauloQ131620TrueNatal100municipality of BrazilQ3184121NatalIn case you want to ensure the results are cities from Brazil, you can specify the property_mapping argument with
a specific property-value pair:# Reconcile against type city (Q515) and items have the country (P17) property equals to Brazil (Q155)reconciled=reconcile(test_df["City"],type_id="Q515",property_mapping={"P17":test_df["Country"]})OptionsThereconcile()function accepts several options.type_id- The type of items to reconcile against per theAPI specification.top_res- Either the number of results to return per entry or the string 'all' to return all results.property_mapping- A list of properties to filter results on per theAPI specification.reconciliation_endpoint- The reconciliation service to connect to.  Defaults tohttps://wikidata.reconci.link/en/api.Other very useful packagesAlthough my opinion may be biased, I thinkreconcileris a pretty nice package.
But the thing is, it probably won't fulfill all your Wikidata-related needs.
Here are other packages that could help with that:WikidataIntegratorhas a lot of very nice, low-level, functions
for dealing with various wikidata-related activities, such as item acquisition and programmatic editing.wikidata2dfis a very simple utility package for quickly and easily
turning wikidata SPARQL queries into Pandas DataFrames.
Package: reconDNS
reconDNSreconDNS is a Python module port of a script that was written by Dark OperatorThis script provides the ability to perform:Check all NS Records for Zone Transfers.Enumerate General DNS Records for a given Domain (MX, SOA, NS, A, AAAA, SPF and TXT).Perform common SRV Record Enumeration.Top Level Domain (TLD) Expansion.Check for Wildcard Resolution.Brute Force subdomain and host A and AAAA records given a domain and a wordlist.Perform a PTR Record lookup for a given IP Range or CIDR.Check a DNS Server Cached records for A, AAAA and CNAME Records provided a list of host records in a text file to check.Python VersionDNSRecon requires python3.6+
Package: reconfigurator
reconfiguratorThis package provides tools for reconfiguring files, markdown for sampling and generating configuration files.Please see ourDocumentation,Github source code,
and install fromPyPICitationIf you are using this in your work, please cite as@misc{beard2022reconfigurator,
    author = {Beard, Jared J.},
    title = {reconfigurator: A tool for configuration files},
    year = {2022},
    publisher = {GitHub},
    journal = {GitHub repository},
    howpublished = {\url{https://github.com/jaredjbeard/reconfigurator}},
}
Package: reconframe
reconframe v0.1.0A Reconnaissance Framework for Penetration TestingInstallation$pipinstallreconframeUsageCreating a projectreconframeinit[projectname]Creates an blank project within current directory or given optional project name. Equivalent togit clone --depth=1 https://github.com/0xcrypto/reconframe-projectInstalling dependenciesreconframeinstallInstalls required dependencies using pip. Equivalent topip install -r requirements.txtParsing external commandsreconframerun<externalcommand>Runs an external command and parses output from STDOUT thereof. Must run from within project's directory as the information captured will be parsed and stored within the project.Running StrategiesreconframestartImplements the strategies and gains the information.Prepare reportsreconframeprepare[reportname]Prepares a detailed report of gained information.
Package: reconnecting-ftp
reonnecting_ftpreconnecting_ftp provides a FTP client which wraps ftplib.FTP. It reconnects automatically to the server if it was
disconnected, and remembers the last recorded working directory.We found reconnection to be particularly important in scripts which run for a long time, and need to repeatedly iterate
over the files on the FTP server.Since results need to be atomic, we have to convert the result fromftplib.FTP.mlsd(an iterable of directory entries) to an explicit list of directory entries. While this gives you
atomicity (whatever you iterate over will be done in a single connection), all the directory entries need to be stored
in memory.Additionally, we provide an implementation ofmlstFTP command which is missing in the originalftplib.FTPclient.Usageimportreconnecting_ftpwithreconnecting_ftp.Client(hostname="some-host.com",port=21,user="some-user",password="some-password")asftp:# change working directoryftp.cwd(dirname='/some-dir/some-subdir')# you can execute here all the commands as provided in ftplib.FTP. If the connection failed, the command will# be retried while it succeeds or the maximum number of retries haven been exhausted..# MLST the filepth,entry=ftp.mlst(filename='some-file.txt')# iterate over a directory entries atomicallyforname,entry_dictinftp.mlsd(path=parent_path):# do somethingpassInstallationCreate a virtual environment:python3-mvenvvenv3Activate it:sourcevenv3/bin/activateInstall reconnecting_ftp with pip:pip3installreconnecting_ftpDevelopmentCheck out the repository.In the repository root, create the virtual environment:python3-mvenvvenv3Activate the virtual environment:sourcevenv3/bin/activateInstall the development dependencies:pip3install-e.[dev]We provide a set of pre-commit checks that lint and check code for formatting and runs unit tests. Run them locally
from an activated virtual environment with development dependencies:./precommit.pyThe pre-commit script can also automatically format the code:./precommit.py--overwriteVersioningWe followSemantic Versioning. The version X.Y.Z indicates:X is the major version (backward-incompatible),Y is the minor version (backward-compatible), andZ is the patch version (backward-compatible bug fix).
Package: reconner
Recon NER, Debug and correct annotated Named Entity Recognition (NER) data for inconsitencies and get insights on improving the quality of your data.Documentation:https://kabirkhan.github.io/reconSource Code:https://github.com/kabirkhan/reconRecon is a library to help you fix your annotated NER data and identify examples that are hardest for your model to predict so you can strategically prioritize the examples you annotate.The key features are:Data Validation and Cleanup: Easily Validate the format of your NER data. Filter overlapping Entity Annotations, fix missing properties.Statistics: Get statistics on your data. From how many annotations you have for each label, to more complicated metrics like quality scores for the balance of your dataset.Model Insights: Analyze how well your model does on your Dataset. Identify the top errors your model is making so you can prioritize data collection and correction strategically.Dataset Management: Recon providesDatasetandCorpuscontainers to manage the train/dev/test split of your data and apply the same functions across all splits in your data + a concatenation of all examples. Operate inplace to consistently transform your data with reliable tracking and the ability to version and rollback changes.Serializable Dataset: Serialize and Deserialize your data to and from JSON to the Recon type system.Type Hints: Comprehensive Typing system based on Python 3.7+ Type HintsRequirementsPython 3.7 +spaCyPydantic (Type system and JSON Serialization)Typer (CLI).Installation$pipinstallreconner---> 100%Successfully installed reconnerLicenseThis project is licensed under the terms of the MIT license.
Package: reconstruct
ReConstruct is a continuation of the excellent ‘Construct’ library by
Tomer Filiba <tomerfiliba [at] gmail dot com>.
The original description is reproduced below. This version is maintained by
Symbols <simplesymbols [at] gmail dot com>.Original DescriptionConstruct is a library for parsing and building of data structures (binary or
textual).The original description is
It is based on the concept of defining data structures in a declarative manner,
rather than procedural code: more complex constructs are composed of a hierarchy
of simpler ones. It’s the first library that makes parsing fun, instead of the
usual headache it is today.Construct features bit and byte granularity, symmetrical operation (parsing
and building), component-oriented design (declarative), easy debugging and
testing, easy to extend (subclass constructs), and lots of primitive constructs
to make your work easier (fields, structs, unions, repeaters, meta constructs,
switches, on-demand parsing, pointers, etc.)
Package: reconstructor
ReconstructorInstallation:Install Reconstructor python packageThis can be done via pip in the command linepip install reconstructor*You must be running >= Python 3.8Test suite:Use the following command to run the test suiteRun the following test to ensure reconstruction was installed correctly and is functional. This series of tests should take about an hour to run, dependent on computer/processor speed. These are runtimes for reconstructor on a 2020 MacBook Pro with a 1.4 GHz Quad-Core Intel Core i5 processor.Use the command below to test reconstructor to ensure correct installation.python -m reconstructor --test yes*YOU MUST RUN THE TEST SUITE BEFORE PROCEEDING TO USE RECONSTRUCTORUsage:Use reconstructor via command lineNow that reconstructor and all dependency databases are installed, you can proceed to use reconstructor via command line. An example would be:python -m reconstructor --input <input fasta file> --type <1,2,3> --gram <negative, positive> --other arguments <args>Type 1: Build GENRE from annotated amino acid fasta filespython -m reconstructor --input Osplanchnicus.aa.fasta --type 1 --gram negative --other_args <args>Type 2: Build GENRE from BLASTp hitspython -m reconstructor --input Osplanchnicus.hits.out --type 2 --gram negative --other_args <args>Type 3: Additional gap-filling (if necessary)python -m reconstructor --input Osplanchnicus.sbml --type 3 --other_args <args>Required and optional arguments--input <input file, Required>--type <input file type, .fasta = 1, diamond blastp output = 2, .sbml = 3, Required, Default = 1>--gram <Type of Gram classificiation (positive or negative), default = positive>--media <List of metabolites composing the media condition. Not required.>--tasks <List of metabolic tasks. Not required>--org <KEGG organism code. Not required>--min_frac <Minimum objective fraction required during gapfilling, default = 0.01>--max_frac <Maximum objective fraction allowed during gapfilling, default = 0.5>--out <Name of output GENRE file, default = default>--name <ID of output GENRE, default = default>--cpu <Number of processors to use, default = 1>--test <run installation tests, default = no>Additional InformationThank you for your interest in reconstructor. If you have any additional questions please emailtfz5vy@virginia.edu.If you encounter any problems, please file anissuealong with a detailed description.Distributed under the terms of theMIT license, "reconstructor" is free and open source software