Saravanan666/pypi-org huggingface dataset:
Package: featureimpact
# featureimpact[![Actions](https://github.com/bloomen/featureimpact/actions/workflows/featureimpact-tests.yml/badge.svg?branch=master)](https://github.com/bloomen/featureimpact/actions/workflows/featureimpact-tests.yml?query=branch%3Amaster)featureimpact let’s you compute the statistical impact of features given
a trained estimator. The computation is based on the mean variation
of the difference between perturbed and original predictions. The estimator must
predict purely numerical values. All features must also consist of purely
numerical values.Example:`python from featureimpact import FeatureImpact fi = FeatureImpact() fi.make_quantiles(X_train) impact = fi.compute_impact(model, X_test) `Note: In order to run the examples you’ll need scikit-learn
installed in addition to this package and its regular dependencies.The algorithm is described here:https://bloomen.github.io/pub/featureimpact.pdf
Package: featurelayer
Dcontainer CLIInstallationpip install dcontainer[generate]Feature Generation:Usage: python -m dcontainer generate devcontainer-feature [OPTIONS]
                                                        FEATURE_DEFINITION
                                                        OUTPUT_DIR

Arguments:
  FEATURE_DEFINITION  [required]
  OUTPUT_DIR          [required]

Options:
  --help                          Show this message and exit.Input for feature generation is afeature-definition.jsonfile
This is anextendedversion of thedevcontainer-feature.jsonfile withadditional fields:{...regular devcontainer-json fields  like id,name,description etc...# dependencies are list of features and options  (those will be installed as prerequisites to your feature)"dependencies":[{"feature":"ghcr.io/devcontainers-contrib/features/asdf-package:latest","options":{"plugin":"act","version":"latest"}}],# This command will be executed after the dependency feature list has been installed"install_command":"echo'Done'",# this example test scenario checks the default options (empty options dict), each test_command should exit wth code `0` if your feature is installed correctly."test_scenarios":[{"name":"test_defaults","image":"mcr.microsoft.com/devcontainers/base:debian","test_commands":["act--version"],"options":{}}]}redirect input{..."options":{"version":{"type":"string","default":"latest","description":"Selecttheversionofacttoinstall2."}},# you can also redirect one of your actual devcontainer-feature.json options values into a dependency input, note the `$options.version` pointer to the asdf-package version option"dependencies":[{"feature":"ghcr.io/devcontainers-contrib/features/asdf-package:latest","options":{"plugin":"act","version":"$options.version"}}],...}Usage examplethis will generate the Elixir feature
It assumes you have the dcontainer cli already installedgitclonehttps://github.com/devcontainers-contrib/cli--depth1cdcli


dcontainergeneratedevcontainer-feature"./test/resources/test_feature_definitions/elixir-asdf/feature-definition.json""./output_dir"
Package: featurelayers
FeatureLayersInstallationpipinstallfeaturelayersUsageLBC Layersimportnumpyasnpfromkeras.modelsimportSequentialfromkeras.layersimportDense,Flattenfromfeaturelayers.layers.LBCimportLBC# Create a simple Keras modelmodel=Sequential()# Add the LBC layer as the first layer in the modelmodel.add(LBC(filters=32,kernel_size=3,stride=1,padding='same',activation='relu',sparsity=0.9,name='lbc_layer'))# Add a Flatten layer to convert the output to 1Dmodel.add(Flatten())# Add a Dense layer for classificationmodel.add(Dense(units=10,activation='softmax'))# Compile the modelmodel.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'])# Generate some dummy datax_train=np.random.rand(100,28,28,1)y_train=np.random.randint(0,10,size=(100,))# Convert the labels to one-hot encodingy_train=keras.utils.to_categorical(y_train,num_classes=10)# Train the modelmodel.fit(x_train,y_train,epochs=10,batch_size=32)version= ""1.5.6""
Package: featuremap-learn
This software package contains an implementation of feature-preserving data visualization tool FeatureMAP, which improves the UMAP algorithm to enable the feature projection and generalizes densMAP algorithm to preseve anisotropic density.InstallationFeatureMAP shares the same dependencies as UMAP, including:numpyscipyscikit-learnnumba==0.57.1Install OptionsPyPI installation of FeatureMAP is performed as:pip install featuremap-learnFor a manual install, first download this package:wget https://github.com/YYT1002/FeatureMAP/archive/main.zip
unzip FeatureMAP-main.zip
rm FeatureMAP-main.zip
cd FeatureMAP-mainInstall the requirements:sudo pip install -r requirements.txtorconda install scikit-learn numbaFinally, install the package:python setup.py installUsageLike UMAP, the densMAP package inherits from sklearn classes, and thus drops in neatly next to other sklearn transformers with an identical calling API.import featuremap:
from sklearn.datasets 
import fetch_openml
from sklearn.utils import resample

digits = fetch_openml(name='mnist_784')
subsample, subsample_labels = resample(digits.data, digits.target, n_samples=7000, stratify=digits.target, random_state=1)

x_emb, v_emb,_,_ = featuremap.featureMAP().fit_transform(subsample)Input argumentsThere are a number of parameters that can be set for the densMAP class; the major ones inherited from UMAP are:n_neighbors: This determines the number of neighboring points used in local approximations of manifold structure. Larger values will result in more global structure being preserved at the loss of detailed local structure. In general this parameter should often be in the range 5 to 50; we set a default of 30.min_dist: This controls how tightly the embedding is allowed compress points together. Larger values ensure embedded points are more evenly distributed, while smaller values allow the algorithm to optimise more accurately with regard to local structure. Sensible values are in the range 0.001 to 0.5. For expression embedding, we set min_dist as 0.3; for variation embedding, we set it as 0.5.metric: This determines the choice of metric used to measure distance in the input space. The default is 'euclidean'.Output argumentsOutput includes the expression embedding, variation embeding, gauge embedding of 1st principal component, and gauge embedding of 2nd principal component, e.g.,x_emb, v_emb, gauge_1_emb, gauge_2_emb = featuremap.featureMAP().fit_transform(subsample)
Package: feature-merge
feature_mergeMerge features in GFF filesInstallation:pip install feature-mergeor:conda install feature_mergeor:git clone https://github.com/brinkmanlab/feature_merge.git
cd feature_merge
./setup.py installUsage:feature_merge [-i] [-e] [-x] [-s] [-v] [-m merge|append|error|skip|replace] [-f type[,type..]].. <input1> [<input_n>..]
Accepts GFF or GTF format.
-v Print version and exit
-f Comma seperated types of features to merge. Must be terms or accessions from the SOFA sequence ontology, \"ALL\", or \"NONE\". (Can be provided more than once to specify multiple merge groups)
-i Ignore strand, merge feature regardless of strand
-s Ignore sequence id, merge feature regardless of sequence id
-x Only merge features with identical coordinates
-t Threshold distance between features to merge
-e Exclude component features from output
-m Merge strategy used to deal with id collisions between input files.
    merge: attributes of all features with the same primary key will be merged
    append: entry will have a unique, autoincremented primary key assigned to it (default)
    error: exception will be raised. This means you will have to edit the file yourself to fix the duplicated IDs
    skip: ignore duplicates, emitting a warning
    replace: keep last duplicateSeeCONTRIBUTING.rstfor information on contributing to this repo.
Package: feature-mining
GFLM: mine implicit features using a generative feature language modelDescriptionThis package implements a Generative Feature Language Models for Mining Implicit Features.Given the following input:a text dataseta set of predefined featuresCompute the following:mapping of explicit and implicit features on the datausing both gflm_word and gflm_section algorithmsInstallpip install feature_miningSample UsageUsage:
    from feature_mining import FeatureMining
    fm = FeatureMining()
    fm.load_ipod(full_set=False)
    fm.fit()
    fm.predict()

Results:
    - prediction using 'section': fm.gflm.gflm_section
    - prediction using 'word': fm.gflm.gflm_word

Display result:
    fm.section_features()
    print(fm.gflm_section_result.sort_values(by=['gflm_section'], ascending=False)[['feature', 'section_text']].head(20))Package created based on the following paperS. Karmaker Santu, P. Sondhi and C. Zhai, "Generative Feature Language Models for Mining Implicit Features from Customer Reviews", Proceedings of the 25th ACM International on Conference on Information and Knowledge Management - CIKM '16, 2016.Pydocs (Code Documentation)Accessible via this link:http://htmlpreview.github.io/?https://github.com/nfreundlich/CS410_CourseProject/blob/dev/docs/feature_mining.html(Apologies for the color scheme - it was the default)TutorialSee Jupyter notebook tutorialhttps://github.com/nfreundlich/CS410_CourseProject/blob/dev/tutorial.ipynbVideo presentation and tutorialLink to YouTube:https://www.youtube.com/watch?v=mjJHkyrkxHMPackage on PyPihttps://pypi.org/project/feature-mining/Slideshttps://github.com/nfreundlich/CS410_CourseProject/blob/dev/docs/CS_410_GFLM_Slides.pdfKnown IssuesExplicit feature mentions not removed from GFLM word/sentence:https://github.com/nfreundlich/CS410_CourseProject/issues/28
Package: featuremonkey
compose python programs out of features by using monkeypatching.Installationclone this reporunpython setup.py installorpython setup.py developor use piprun the tests:test_featuremonkeyThe documentation is incomplete right now (work in progress):https://featuremonkey.readthedocs.org/For more details, have a look atfeaturemonkey/test/composer.py.License: MIT (see LICENSE)
Package: featuremonkey3
compose python programs out of features by using monkeypatching.Installationclone this reporunpython setup.py installorpython setup.py developor use piprun the tests:test_featuremonkeyThe documentation is incomplete right now (work in progress):https://featuremonkey.readthedocs.org/For more details, have a look atfeaturemonkey/test/composer.py.License: MIT (see LICENSE)
Package: featuren
<H1 align='center'> Featuren </H1><p align="center"><a href="https://travis-ci.org/jairojair/featuren"><img src="https://travis-ci.org/jairojair/featuren.svg?branch=master" alt="Build Status"></a><a href='https://coveralls.io/github/jairojair/featuren?branch=master'><img src='https://coveralls.io/repos/github/jairojair/featuren/badge.svg?branch=master&service=github' alt='Coverage Status' /></a></p><p align="center"><em>A simple application for managing your features in production.</em></p>### IntroductionFeature flags give a software organization the power to reduce risk, iterate quicker, and gain more control. Feature flags allow you to decouple feature rollout from code deployment. This separation allows you unprecedented control of who sees what when, independent of release. And the “you” can be anyone in your organization – from developers, ops, designers, product managers, or marketers. Allowing control over a release unlocks the true power of your software.More details about: http://featureflags.ioThe main goal for this project is to create a simple and open source application for managing your features in production.### Getting Started*Requirement*- [Docker](https://www.docker.com/products/docker-desktop)##### Project setupdocker-compose builddocker-compose run app make migrate##### Run standalonedocker-compose upAccess: http://0.0.0.0:8000### Development tips- REST API Framework we're use [APIStar](https://github.com/encode/apistar)- Database management we're use [Orator ORM](https://orator-orm.com)- Test we're use [Pytest](https://docs.pytest.org/en/latest/)---Firstly, run the command below to go inside the container.docker-compose run --service-ports app /bin/sh##### Run in migrationsmake migrate##### Run testsmake tests##### Python code lintermake lint##### Python format code.make fmt##### Run applicationmake##### Install new Python dependencyThis way you can install a new Python dependency without rebuild docker image.make deps##### Project cleanmake clean
Package: featureng
FeaturEngcreated by Austin Poorfeatureng(pronouncedfeatur-ing) is a library for feature engineering.I wanted to create a library to store tools to help in the feature engineering
process – by extracting information from existing data or by simplifying the
process of adding in external data.GitHub:https://github.com/a-poor/featurengPyPi:https://pypi.org/project/featurengRead the Docs:https://featureng.readthedocs.io
Package: featureprobe-server-sdk-python
FeatureProbeis an open source feature management service. This SDK is used to control features in Python programs.
This SDK is designed primarily for use in multi-user systems such as web servers and applications.Basic TermsReading the shortIntroductionwill help to understand the code blow more easily.中文How to User This SDKSeeSDK Docfor detail.中文ContributingWe are working on continue evolving FeatureProbe core, making it flexible and easier to use.
Development of FeatureProbe happens in the open on GitHub, and we are grateful to the
community for contributing bugfixes and improvements.Please readCONTRIBUTINGfor details on our code of conduct, and the process for taking part in improving FeatureProbe.LicenseThis project is licensed under the Apache 2.0 License - see theLICENSEfile for details.
Package: feature_ramp
Feature Ramp allows developers to “ramp” their user base up on a particular functionality. It is essentially Martin Folwer’s Feature Toggle (http://martinfowler.com/bliki/FeatureToggle.html) but with even more control.Details:
- Toggle a feature completely on or off for the entire application
- Whitelist and blacklist specific users given an identifier of some sort (e.g. user id).
- Toggle a feature for a subset of users by percentage given an identifier of some sort (e.g. user id).
Package: features-anal
Feature Analysis: Simple Feature Analysis in PythonIt performs feature analysis for data preprocessing or usage of data in Machine Learning.MethodsThere are four methods used to identify features to remove:Finding Missing Values (find_missing(missing_threshold))%% Find the features with a fraction of missing values abovemissing_thresholdSingle Unique Values (find_unique())%% Find the features having a single unique value. NaNs do not count as a unique value.Collinear Features (find_collinear(correlation_threshold,one_hot=False))%% Finds collinear features based on thecorrelation coefficientbetween features.Low Importance Features (find_low_impt(cumulative_impt,label))%% Finds the lowest importance features not needed to account forcumulative_importancefraction
of the total feature importance from the gradient boosting machine.
label corresponding to regession or classificationUsageRefer to thetesting.pyfor how to use the different methods in module.VisualizationsTheFeatureAnalysismethods also includes a number of visualization in each methods mentioned above to inspect
characteristics of a dataset.Histogram for missing valuesHistogram for unique valuesCorrelation Heat mapImportant FeaturesCumulative Feature ImportanceRequirements:Install dependencies just mentioned in requirements.txt by typing command in shell.pip install -r requirements.txtContactAny questions can be directed todipanshugolan96@gmail.com.ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.
Package: featureselect
Feature Selectis a simple yet effective solution to select features from a numeric dataset, which yields the best results, given a Machine Learning algorithm.GitHub repo:https://github.com/himanshu-dutta/featureselect/Free software: MIT licenseFeaturesMultiple optimization algorithms to work with.Works with most class based Machine Learning models over a range of libraries.Compatible with all platforms.QuickstartInstall the latest Feature Select withpip install featureselectUsagefromfeatureselectimportDEOptimizer,SAOptimizer,GAOptimizer,PSOptimizerfromsklearn.treeimportDecisionTreeClassifierimportpandasaspd# loading a datasetdataset=pd.read_csv("dataset.csv",header=None)dataset[34]=dataset[34].apply(lambdax:1ifx=="g"else0)dataset=dataset.dropna()X,y=dataset.iloc[:,:-1].to_numpy(),dataset.iloc[:,-1].to_numpy()# best_accuracy, index_of_best_features = GAOptimizer((X, y), DecisionTreeClassifier, epochs = 10, threshold=0.6, verbose=1, max_depth=3)# best_accuracy, index_of_best_features = SAOptimizer((X, y), DecisionTreeClassifier, epochs = 10, threshold=0.6, verbose=True, max_depth=3)# best_accuracy, index_of_best_features = PSOptimizer((X, y), DecisionTreeClassifier, epochs = 10, verbose=1, max_depth=3)best_accuracy,index_of_best_features=DEOptimizer((X,y),DecisionTreeClassifier,epochs=10,threshold=0.6,verbose=1,max_depth=3)##############   Output#############InitialAccuracy:0.887.----------------------------------*Epoch:1|Accuracy:0.958.----------------------------------*Epoch:2|Accuracy:0.958.----------------------------------*Epoch:3|Accuracy:0.958.----------------------------------*Epoch:4|Accuracy:0.958.----------------------------------*Epoch:5|Accuracy:0.972.----------------------------------*Epoch:6|Accuracy:0.972.----------------------------------*Epoch:7|Accuracy:0.972.----------------------------------*Epoch:8|Accuracy:0.972.----------------------------------*Epoch:9|Accuracy:0.986.----------------------------------*Epoch:10|Accuracy:0.986.----------------------------------(0.9859154929577465,array([2,4,5,6,9,11,12,13,14,17,19,20,21,24,26,29,32]))NoteThe project is still in developement phase and will be expanded and made better over time. Any contribution to it is welcomed. Stable release would be made available soon.
Package: feature-selection-ga
FeatureSelectionGAFeature Selection using Genetic Algorithm (DEAP Framework)Data scientists find it really difficult to choose the right features to get maximum accuracy especially if you are dealing with a lot of features. There are currenlty lots of ways to select the right features. But we will have to struggle if the feature space is really big. Genetic algorithm is one solution which searches for one of the best feature set from other features in order to attain a high accuracy.Installation:$pipinstallfeature-selection-gaUsage:fromsklearn.datasetsimportmake_classificationfromsklearnimportlinear_modelfromfeature_selection_gaimportFeatureSelectionGA,FitnessFunctionX,y=make_classification(n_samples=100,n_features=15,n_classes=3,n_informative=4,n_redundant=1,n_repeated=2,random_state=1)model=linear_model.LogisticRegression(solver='lbfgs',multi_class='auto')fsga=FeatureSelectionGA(model,X,y,ff_obj=FitnessFunction())pop=fsga.generate(100)#print(pop)Usage (Advanced):By default, the FeatureSelectionGA has its own fitness function class. We can also define our own
FitnessFunction class.classFitnessFunction:def__init__(self,n_splits=5,*args,**kwargs):"""Parameters-----------n_splits :int,Number of splits for cvverbose: 0 or 1"""self.n_splits=n_splitsdefcalculate_fitness(self,model,x,y):passWith this, we can design our own fitness function by defining our calculate fitness!
Consider the following example fromVieira, Mendoca, Sousa, et al. (2013)$f(X) = \alpha(1-P) + (1-\alpha) \left(1 - \dfrac{N_f}{N_t}\right)$Define the constructorinitwith needed parameters: alpha and N_t.classFitnessFunction:def__init__(self,n_total_features,n_splits=5,alpha=0.01,*args,**kwargs):"""Parameters-----------n_total_features :intTotal number of features N_t.n_splits :int, default = 5Number of splits for cvalpha :float, default = 0.01Tradeoff between the classifier performance P and size offeature subset N_f with respect to the total number of featuresN_t.verbose: 0 or 1"""self.n_splits=n_splitsself.alpha=alphaself.n_total_features=n_total_featuresNext, we define the fitness function, the name has to be
calculate_fitness:defcalculate_fitness(self,model,x,y):alpha=self.alphatotal_features=self.n_total_featurescv_set=np.repeat(-1.,x.shape[0])skf=StratifiedKFold(n_splits=self.n_splits)fortrain_index,test_indexinskf.split(x,y):x_train,x_test=x[train_index],x[test_index]y_train,y_test=y[train_index],y[test_index]ifx_train.shape[0]!=y_train.shape[0]:raiseException()model.fit(x_train,y_train)predicted_y=model.predict(x_test)cv_set[test_index]=predicted_yP=accuracy_score(y,cv_set)fitness=(alpha*(1.0-P)+(1.0-alpha)*(1.0-(x.shape[1])/total_features))returnfitnessExample:
You may also seeexample2.pyX,y=make_classification(n_samples=100,n_features=15,n_classes=3,n_informative=4,n_redundant=1,n_repeated=2,random_state=1)# Define the modelmodel=linear_model.LogisticRegression(solver='lbfgs',multi_class='auto')# Define the fitness function objectff=FitnessFunction(n_total_features=X.shape[1],n_splits=3,alpha=0.05)fsga=FeatureSelectionGA(model,X,y,ff_obj=ff)pop=fsga.generate(100)Example adopted frompyswarms
Package: feature-selection-michaelSkaro
Feature selection for ML workflowsThis python package will automate feature selection in ML projects.In the coming weeks I will add a plethora of information describing the use of the package and the algorithms that are working under the hood.For now we will settle for a simple Read me to get us started on 0.0.1.As a general description this package is intended for the use of novice users looking for general feature seleciton in an automated fashion. This will not replace your own featue analysis but can help users make a good first step eliminating redundant features and begin looking for strong signals in their feature columns.TODO[X] python3 -m pip install --upgrade build[] python3 -m build[] python3 -m pip install --upgrade twine[] python3 -m twine upload --repository feature_selection dist/*You will be prompted for a username and password. For the username, usetoken.For the password, use the token value, including the pypi- prefix.
Package: feature-selectionpy
Title of the python projectCitationIntroductionFeaturesInstallationContributionFuture ImprovementsIntroductionwhat it does. why it was made. what is future vision.AuthorsChandravesh chaudhari, Doctoral candidate atCHRIST (Deemed to be University), Bangalore, Indiaunder supervision ofDr. Geetanjali purswani.Featuresfirstsecondand so onsignificancefirstsecond and so onInstallationThis project is available atPyPI. For help in installation checkinstructionspython3-mpipinstallprojectnameDependenciesRequiredproject-name- Description of project.Optionalproject-name- Description of project.Important links[Documentation](documentation link)[Quick tour](tutorial file link)Project maintainer (feel free to contact)Future ImprovementsLicenseContributionall kinds of contributions are appreciated.[Improving readability of documentation](documentation link)Feature RequestReporting bugsContribute codeAsking questions in discussionsFuture ImprovementsWork titlework part onework part two
Package: feature-selector
Feature Selector: Simple Feature Selection in PythonFeature selector is a tool for dimensionality reduction of machine learning datasets.Installpip install feature_selectorMethodsThere are five methods used to identify features to remove:Missing ValuesSingle Unique ValuesCollinear FeaturesZero Importance FeaturesLow Importance FeaturesUsageRefer to theFeature Selector Usage notebookfor how to useVisualizationsTheFeatureSelectoralso includes a number of visualization methods to inspect
characteristics of a dataset.Correlation HeatmapMost Important FeaturesRequires:python==3.6+
lightgbm==2.1.1
matplotlib==2.1.2
seaborn==0.8.1
numpy==1.14.5
pandas==0.23.1
scikit-learn==0.19.1ContactAny questions can be directed towjk68@case.edu!