Saravanan666/pypi-org huggingface dataset:
Package: fast-explain
# FastExplain
> Fit Fast, Explain Fast## Installing` pip installfast-explain`## Clean Data, Fit ML Models and Explore Results all in one line.
FastExplain provides anout-of-the-boxtool for analysts toquickly explore data,train and interpret models, withflexibility to fine-tuneif needed.
-Automated cleaning and fittingof machine learning models with hyperparameter search
-Aesthetic displayof explanatory methods ready for reporting
-Connected interfacefor all data, models and related explanatory methods## Quickstart[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/felixzhu17/FastExplain/blob/main/demos/FastExplain%20Titanic%20Quickstart.ipynb)### Automated Cleaning and Fitting` python from FastExplain import * df = load_titanic_data() classification = model_data(df,dep_var="Survived",model="ebm")`### Aesthetic Display` python feature_correlation(classification.data.df) `<img alt=”Feature Correlation” src=”images/feature_correlation.png”>` python plot_one_way_analysis(classification.data.df, "Age", "Survived", filter = "Sex == 1") `<img alt=”One Way” src=”images/one_way.png”>` python plot_ebm_explain(classification.m, classification.data.df, "Age") `<img alt=”EBM” src=”images/ebm.png”>` python plot_ale(classification.m, classification.data.xs, "Age", filter = "Sex == 1", dep_name = "Survived") `<img alt=”ALE” src=”images/ALE.png”>` python classification_1 = model_data(df,dep_var="Survived",model="rf",hypertune=True,cont_names=['Age'],cat_names = [], hypertune=True) models = [classification.m, classification_1.m] data = [classification.data.xs, classification_1.data.xs] plot_ale(models, data, 'Age', dep_name = "Survived") `<img alt=”multi_ALE” src=”images/multi_ALE.png”>### Connected Interface` pythonclassification_1.plot_one_way_analysis("Age",filter = "Sex == 1")classification_1.plot_ale("Age",filter = "Sex == 1") `` pythonclassification_1.shap_dependence_plot("Age",filter = "Sex == 1") `<img alt=”SHAP” src=”images/shap.png”>` python classification_1.error # {'auc': {'model': {'train': 0.9934332941166654, # 'val': 0.8421607378129118, # 'overall':0.9665739941840028}},# 'cross_entropy': {'model': {'train': 0.19279692001978943, # 'val': 0.4600233891109683, # 'overall':0.24648214781700722}}}`## Models Supported
- Random Forest
- XGBoost
- Explainable Boosting Machine
- ANY Model Class withfitandpredictattributes` python pip install lightgbm `` python from lightgbm import LGBMClassifier custom_model = model_data(df, 'Survived', model=LGBMClassifier)custom_model.plot_ale("Age")custom_model.shap_dependence_plot("Age")`## Exploratory Methods Supported:
- One-way Analysis
- Two-way Analysis
- Feature Importance Plots
- ALE Plots
- Explainable Boosting Methods
- SHAP Values
- Partial Dependence Plots
- Sensitivity Analysis
Package: fastf1
FastF1FastF1 is a python package for accessing and analyzing Formula 1 results,
schedules, timing data and telemetry.Main FeaturesAccess to F1 timing data, telemetry, sessions results and moreFull support forErgastto access current and
historical F1 dataAll data is provided in the form of extended Pandas DataFrames to make
working with the data easy while having powerful tools availableAdds custom functions to the Pandas objects specifically to make working
with F1 data quick and simpleIntegration with Matplotlib to facilitate data visualizationImplements caching for all API requests to speed up your scriptsInstallationIt is recommended to install FastF1 usingpip:pip install fastf1Alternatively, a wheel or a source distribution can be downloaded from Pypi.You can also install usingconda:conda install -c conda-forge fastf1Third-party packagesR package that wraps FastF1:https://cran.r-project.org/package=f1dataRThird-party packages are not directly related to the FastF1 project. Questions
and suggestions regarding these packages need to be directed at their
respective maintainers.DocumentationThe official documentation can be found here:docs.fastf1.devSupporting the ProjectIf you want to support the continuous development of FastF1, you can sponsor me
on GitHub or buy me a coffee.https://github.com/sponsors/theOehrlyNoticeFastF1 and this website are unofficial and are not associated in any way with
the Formula 1 companies. F1, FORMULA ONE, FORMULA 1, FIA FORMULA ONE WORLD
CHAMPIONSHIP, GRAND PRIX and related marks are trade marks of Formula One
Licensing B.V.
Package: fastface
FastFace: Lightweight Face Detection FrameworkEasy-to-use face detection framework, developed usingpytorch-lightning.Checkoutdocumentationfor more.Key Features:fire:Use pretrained models for inference with just few lines of code:chart_with_upwards_trend:Evaluate models on different datasets:hammer_and_wrench:Train and prototype new models, using pre-defined architectures:rocket:Export trained models with ease, to use in productionContentsInstallationPretrained ModelsDemoBenchmarksTutorialsReferencesCitationsInstallationFrom PyPIpip install fastface -UFrom sourcegit clone https://github.com/borhanMorphy/fastface.git
cd fastface
pip install .Pretrained ModelsPretrained models can be accessable viafastface.FaceDetector.from_pretrained(<name>)NameArchitectureConfigurationParametersModel SizeLinklffd_originallffdoriginal2.3M9mbweightslffd_slimlffdslim1.5M6mbweightsDemoUsing packageimportfastfaceasffimportimageiofrompytorch_lightning.utilities.model_summaryimportModelSummary# load image as RGBimg=imageio.imread("<your_image_file_path>")[:,:,:3]# build model with pretrained weightsmodel=ff.FaceDetector.from_pretrained("lffd_original")# model: pl.LightningModule# get model summaryModelSummary(model,max_depth=1)# set model to eval modemodel.eval()# [optional] move model to gpumodel.to("cuda")# model inferencepreds,=model.predict(img,det_threshold=.8,iou_threshold=.4)# preds: {#    'boxes': [[xmin, ymin, xmax, ymax], ...],#    'scores':[<float>, ...]# }Usingdemo.pyscriptpython demo.py --model lffd_original --device cuda --input <your_image_file_path>sample output;BenchmarksFollowing results are obtained with this repositoryWIDER FACEvalidation set resultsNameEasyMediumHardlffd_original0.8930.8660.758lffd_slim0.8660.8540.742TutorialsWiderface BenchmarkBentoML DeploymentReferencesLFFD PaperOfficial LFFD ImplementationCitations@inproceedings{LFFD,title={LFFD: A Light and Fast Face Detector for Edge Devices},author={He, Yonghao and Xu, Dezhong and Wu, Lifang and Jian, Meng and Xiang, Shiming and Pan, Chunhong},booktitle={arXiv:1904.10633},year={2019}}
Package: fastfargate
Part1 (CDK Construct Library)Part2 (CDK App)Part3 (CDK Pipelines App)Part 1Steps1- Add Github SecretsTWINE_USERNAME
TWINE_PASSWORD
NPM_TOKEN
NUGET_API_KEY
MAVEN_USERNAME
MAVEN_PASSWORD
MAVEN_STAGING_PROFILE_ID
MAVEN_GPG_PRIVATE_KEY
MAVEN_GPG_PRIVATE_KEY_PASSPHRASE2- Create Project locally or launch usingGitpodmkdirprojen-cdk-tutorial-part-1cdprojen-cdk-tutorial-part-1
code.aliaspj="npx projen"pjnewawscdk-construct3- Configure ProjectAddyourcodeto.projenrc,Thisistheonlyfilethatwillbemodified.Duringprojenitwillscaffoldyourwholeprojectincludingwhatyouarereadingrightnow!:)4- Execute projenpj5- Commit & Pushgitadd.
gitcommit-m"Commit"gitpushLicenseTheApache-2.0licenseReferencesCDK Getting StartedCDK API ReferenceCDK WorkshopCDK PatternsCDK Construct HubAWS Solutions ConstructsProjenProjen API ReferenceProjen AWS CDK Construct LibraryProjen AWS CDK ApplicationsPublish CDK Constructsprojen-cdk-tutorial-part-1projen-cdk-tutorial-part-2projen-cdk-tutorial-part-3
Package: fastfeatureflag
FastFeatureFlag is a lightweight tool to generate and use feature flags. Build in python for python. The key components are:easy to add feature flag(s)easily activate/deactivate featuresnaming/grouping flagsdefine custom response for flagged featuresuse environment variables as your on/off switchmanage feature flags with a simple toml filedefine a shadow method which should be executed instead of your deactivated feature🛠 Installationpip install fastfeatureflagpoetry add fastfeatureflag🏳flagaway ...💡Take a look at the decoratorfeature_flag()- that is all you need.fromfastfeatureflag.feature_flagimportfeature_flag@feature_flag("off")defbroken_feature():return"I am broken"broken_feature()NotImplementedError:FeaturenotimplementedCopyright (c) 2012-2023 Sebastian Rieserflyingsepl@googlemail.comPermission 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.0.4.1 (2023-10-29)0.4.0 (2023-10-28)Featfeature_flag: enableselfwithin decorated functionsfeature_flag: pytest compatibility via.pytest()0.3.0 (2023-10-25)Featfeature_flag: useshadowto call a different function/methodall: feature flag configuration by fileFixfeature_flag_configuration: updating and synchronising featuresRefactorall/*: reduces complexity0.2.0 (2023-09-02)Featall: featuer flag configuration by fileflaggen: load configurationRefactorflaggen: simplified code0.1.0 (2023-08-14)Featfeature_flag: add named featureFixflaggen: improved the feuatre flag namingfeauter_flag: added stateful decoratorflaggen,-docs: added dynamic output to feature flagpyflag: simple featue flag implementation
Package: fastfft
Fast fourier transform algorithm implementationInstallationPython 3.8.15 required for OS X
Python 3.5 required for LinuxOS XSimply, runpipinstallfastfftLinuxInstall some additional packagessudoapt-getinstallbuild-essential
sudoaptinstallpython-devgcc
sudoapt-getinstallpython3-devAnd install the packagepipinstallfastfftUsageJust import and usefromfastfft.fftimportfft2,ifft2matrix=[[1.0,2.0],[3.0,4.0],]image=fft2(matrix)original=ifft2(image)
Package: fast-file-encryption
TheFast File Encryptionis an open, very simple and well-designed file encryption solution for medium and large files (up to terabytes). It uses asymmetric RSA keys to encrypt and decrypt the files, in order to store the public key for encryption on the server, with no worries.Quick Usage OverviewCreate a new key pair:>>>importfast_file_encryptionasffe>>>frompathlibimportPath>>>ffe.save_key_pair(public_key=Path('public.pem'),private_key=Path('private.pem'))Encrypt a file:>>>original_file=Path('original_file.txt')>>>original_file.write_text('Hello world!')>>>encryptor=ffe.Encryptor(ffe.read_public_key(Path('public.pem')))>>>encrypted_file=Path('encrypted_file.ffe')>>>encryptor.copy_encrypted(original_file,encrypted_file,meta={'my-meta':1},add_source_metadata=True)Decrypt a file and read its meta data:>>>decryptor=ffe.Decryptor(ffe.read_private_key(Path('private.pem')))>>>decryptor.load_decrypted(encrypted_file)b'Hello world!'>>>decryptor.read_metadata(encrypted_file){'my-meta': 1, 'file_path': '.../original_file.txt', ...}InstallationInstallFast File Encryptionusingpip:$pipinstallfast_file_encryptionDocumentationYou find all details about the library, it’s design and file format in thedocumentation.LicenseCopyright © 2021-2024 Tobias Erbslandhttps://erbsland.dev/and EducateIT GmbHhttps://educateit.ch/According to the copyright terms specified in the file “COPYRIGHT.md”.Licensed under the Apache License, Version 2.0 (the “License”); you may not use this file except in compliance with the License. You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
Package: fast-flow
fast-flow: A YAML-based processing configurationProvides a simple interface to describe a processing chain, where a user names
the stages and type of stage they want to run and then provides specific
parameters for each stage.Installingpip install --user fast-flowDocumentationWhile better documentation is on its way, you might want to look at the examples directory to see how this can be used.
In addition, thefast-carpenterpackage makes use of this, so it might be helpful to see how this is used there.
Package: fastflows
Run FastFlow serverFastFlows is a FastAPI server & command line tool to comunicate with Prefect 2.0 as a Workflow manager to deploy, run, track flows and more.To start work with FastFlows you should define at least 2 environment variables:#PrefectAPIServeraddressPREFECT_URI=http://localhost:4200#PathtofolderwithflowsFLOWS_HOME=flowsIf you want to define variables with env prefix, for example, like 'LOCAL_PREFECT_URI' or 'DEV_PREFECT_URI' you can use environment variable 'ENV_NAME'If Fastflow will see 'ENV_NAME' variable in environment - it will search for variables with prefix defined in this ENV_NAME, for example:if ENV_NAME = 'LOCAL'Fastflows will read variables like LOCAL_PREFECT_URI and LOCAL_FLOWS_HOME,if ENV_NAME = 'dev', then fastflow will expect variables like 'dev_PREFECT_URI' and 'dev_FLOWS_HOME'How to run FastFlows with Prefect clusterwith KubernetesKube instructionsKubernetes configurationwith Docker-ComposeDocker-Compose readmeDocker-compose YAMLRun clifastflows --helpFlows DeploymentAuto deploymentDeployment of Flows can be done by FastFlows automatically: if there is a new flow or changes in FLOWS_HOME directory - FastFlow create new deployment. To disable auto deployment set env variable to 0FASTFLOWS_AUTO_DEPLOYMENT = 0
Package: fastfm2
Welcome to fastfm v2NB: This is still in early development. Usev1unless you want to contribute to the next version of fastfmTo learn more about the library, read our introduction in thepaperpresenting it.Note that c++ dependencies are in a submodule, so to clone with all dependencies included, you should use:git clone --recurse-submodules https://github.com/palaimon/fastfm2InstallingWe infrequently push wheels to pypi that you can install withpip install fastfm2.Source InstallYou can build the latest version from source (requirescmake>=3.12) by first compiling the c++ library from the project root directory:makethen install fastfm2 python lib locally:User installpipinstall.Also you can buildpython wheels:macos:pipwheel.--no-deps-wwheelhouse
delocate-wheel-wfixed_macos_whlswheelhouse/fastfm*.whllinux:pipwheel.--no-deps-wwheelhouse
auditwheelrepairwheelhouse/fastfm-*.whl(auditwheelused insteaddelocate).Dev installFor development we use poetry as dependency managmer:poetryinstalland wheels:poetrybuildTestsTo run the tests launch:pytestFor the tests to run, you'll need to install the following optional dependency:pip install pytest
Package: fastfood
========Helps build cookbooks faster by pre-templating parts and exposingoptions in a command line and config friendly way.InstallationThe latest release of fastfood can be installed via pip:pip install fastfoodAn alternative install method would be manually installing it
leveragingsetup.py:git clone https://github.com/rackerlabs/fastfood
cd fastfood
python setup.py installCommand Line UsagelistShows a list of available stencils in your template pack.Example:$ fastfood list
Available Stencil Sets:
       varnish - Creates a recipe for installing Varnish
      ha-redis - Creates a highly available Redis and HAProxy recipe
          java - Installs Java JREshowShows more information about a stencil, including available options.$ fastfood show nginx
Stencil Set nginx:
  Stencils:
    nginx
  Options:
    name - Name of the recipe to create
    example - Various premade Nginx examplesbuildGenerates a new cookbook or updates an existing cookbook from a
fastfood.jsonfile.Example Template:{"name":"mycookbook","stencils":[{"stencil_set":"base"},{"stencil_set":"rabbitmq","openfor":"myapp"},{"stencil_set":"rails","stencil":"nginx","name":"myapp","tag":"myapp"}]}Ex:fastfood build fastfood.jsonTemplate NotesFastfood uses theJinja2templating
engine with2 modifications.qstring()There is a helper method added to jinja2 for fastfood called qstring,
ittakes in an argument and if that argument does not match a Chef nodeattributes (node[‘mysomething’] | node.chef_environment) it will
wrap that argumentin a string otherwise it just returns the argument.qstring("node['mysomething']")rendersasnode['mysomething']andqstring("mynonchefstr")

renders as

"mynonchefstr"jinja variableBecause the traditional jinja2 variable start and end strings can
conflictwith Ruby code fastfood uses ‘|{’ and ‘}|’ to represent a jinja2
variable.|{ options['name'] }|
Package: fast-forward-indexes
Fast-Forward IndexesThis is the reference implementation ofFast-Forward indexes.⚠Important: As this library is still in its early stages, the API is subject to change! ⚠InstallationInstall the package viapip:pipinstallfast-forward-indexesGetting StartedUsing a Fast-Forward index is as simple as providing a TREC run with sparse scores:frompathlibimportPathfromfast_forward.encoderimportTCTColBERTQueryEncoderfromfast_forward.indeximportInMemoryIndex,Modefromfast_forward.rankingimportRanking# choose a pre-trained query encoderencoder=TCTColBERTQueryEncoder("castorini/tct_colbert-msmarco")# load an index from disk into memoryindex=InMemoryIndex.from_disk(Path("/path/to/index"),encoder,Mode.MAXP)# load a sparse run (TREC format)sparse_ranking=Ranking.from_file(Path("/path/to/sparse/run.tsv"))# load all required queriesqueries={"q1":"query 1","q2":"query 2",# ..."qn":"query n"}# compute the corresponding dense scores and interpolatealpha=0.2result=index.get_scores(sparse_ranking,queries,alpha=alpha,cutoff=10,early_stopping=True)# create a new TREC runfile with the interpolated rankingresult[alpha].save(Path("/path/to/interpolated/run.tsv"))DocumentationA more detailed documentation is availablehere.ExamplesCreating a Fast-Forward index from a prebuilt Pyserini indexComputing dense scores for a sparse run and interpolating
Package: fastfuels
FastFuels-PythonPython client library for the FastFuels APIInstallYou can install FastFuels through the Python Package Index.pip install fastfuelsQuickstartConnecting to a.fioresourceA.fioresource is a directory-in-file object where important metadata and fuel arrays are stored. Start by importing the FastFuels module and open a.fioresource. If you have one locally, specify the path and file name.>>>importfastfuels>>>fio=fastfuels.open('./demo.fio',ftype='local')If you have the appropriate credentials, you can connect to the remote resource stored in AWS S3.>>>fio=fastfuels.open('./ca.fio',ftype='s3',username='username',password='password')Explore the metadataLet's take a look at some metadata. You can get the extent of the data in geographic coordinates (longitude and latitude) or in projected coordinates by changing themodeargument.>>>print(fio.get_extent(mode='geographic'))(-120.73665218037868,38.93933418427242,-120.6511979123941,38.90135366961076)>>>print(fio.get_extent(mode='projected'))(-2100315.0,2043015.0,-2094315.0,2037015.0)And the projection system is stored in theprojattribute.>>>print(fio.proj)You can also view metadata for resolution and units>>>print(fio.res)(1,1,1)>>>print(fio.units)'meters'Spatial queriesYou can perform spatial queries by specifying geographic coordinates in decimal degrees
and a radius in meters. The radius parameter defines the size of the bounding square in which
fuels are queried.# this command will return a square kilometer of fuels (radius=500 meters)roi=fio.query(-122.191,41.208,500)Viewing fuels in 3DFuel parameter arrays can be viewed interactively in 3D. To see the available parameters runprint(roi.get_properties())Then specify one of the properties in theview()method on theroiobject.roi.view('sav')Writing fire model input filesWith theroiobject, you can write input files for various fire models. Here,
you may also decrease the resolution to save computation.roi.write('./outputs',model='quicfire',res_xyz=[2,2,1])
Package: fastfuels-sdk
Python SDK for the FastFuels APIQuick-LinksDocumentation-PyPi Package-Project DescriptionWhat is FastFuels?FastFuels is an innovative solution that propels the use of advanced 3D fire
models into the future of fire and fuels management. It acts as a "3D fuels
superhighway," seamlessly merging existing data sources with cutting-edge
modeling to produce the detailed 3D fuel data required by these models. With
its unique ability to generate and manage comprehensive fuels data for large
areas, FastFuels enhances the precision and context of fire behavior insights
and management strategies. Moreover, it encourages the incorporation of new
data sources and techniques in the field, ensuring its relevance and
adaptability in the dynamic landscape of remote sensing and wildland fuels
science. Stay tuned as we continue to develop and refine FastFuels, paving the
way for next-generation fire models.Read more here:https://www.firelab.org/project/fastfuels-3d-fuels-next-generation-fire-modelsWhat is the FastFuels API?The FastFuels API is a RESTful web service that allows users to access
FastFuels data products and services.How do I use the FastFuels API?The API can be accessed using any HTTP client, such as curl, wget, or a
web browser at this address:https://fastfuels.silvx.ioWhat is the FastFuels Python SDK?The FastFuels Python SDK is a Python package that provides a convenient
interface to the FastFuels API. It allows users to access FastFuels data
products in a familiar Python environment.InstallationThe FastFuels Python SDK can be installed using pip:pipinstallfastfuels-sdkDocumentationDocumentation for the FastFuels Python SDK can be found here:https://silvxlabs.github.io/fastfuels-sdk-python/Additional examples can be found in the following repository:https://github.com/silvxlabs/demos
Package: fastfuzzy
FastFuzzyA Python module for fuzzy string matching and similarity measuring with constant lookup time
by building an in-memory index.This package relies onabydos,
providing a sheer endless amount ofdistance metrics.Installationpip install fuzzyfastUsageCreate Indexfrom fastfuzzy import QGramIndex

index = QGramIndex(tokens=["word1", "word2"], q=2)Or use the class methods to read the tokens from a file:with open("file.txt") as f:
    index = QGramIndex.from_file(f)Or:index = QGramIndex.from_path("file.txt")In both cases, the input file is expected to be a list of tokens line by line.Query for most similar tokenindex.max_sim("word1")
("word1", 1.0)If no token in the index as any overlap with the input token, it returns(None, 0.0).Merge two indicesindex1 = QGramIndex(tokens=["token1"])
index2 = QGramIndex(tokens=["token2"])
index3 = index1 + index2Alternative distance metricsBy default, the index uses the standardQGram distance metric.
Alternatively, all other metrics defined in theabydos distance packagecan be specified with thecmpargument:QGramIndex(tokens=[...], cmp=abydos.distance.PositionalQGramDice)TestingIn order to run the tests locally, install the test dependencies:pip install -e .
pip install -e .[test]And run the tests:pytest -v --cov=src tests/