Saravanan666/pypi-org huggingface dataset:
Package: cycIFAAP
# Cyclic ImmunoFluorescence Automatic Analysis PipelineThis pipeline takes as input a set of cyclic immunofluorescence (cycIF) images and performs the following operations:RegistrationNuclei segmentation (using CellPose or own trained Mask R-CNN model)Background subtractionCompute each marker exclusiveness to be used with RestoreUse Restore when possible for automatic gating (optionnal)Features extractionCell type computationAutomatic visualization using NapariQuality control (tissue loss and Restore based)For installation, more information/details and full examples with code and data, visit:https://www.thibault.biz/Research/cycIFAAP/cycIFAAP.html
Package: cyckei
Cyckei ReadmeA battery cycler written in Python 3AboutCyckei is a battery cycling application designed to interface with the Keithley 2602A/B SourceMeter.
The application uses a simple scripting format in order to write cycles that are carried out on cells.Cyckei is currently developed and maintained by Cyclikal, LLC.VayuCyckei Vayu is currently being developed as a more efficient and distributable version of Cyckei. It can be installed using a package manager, and executed as a normal python application assuming python executables are in the system path.pip install cyckei
cyckeiThis version is currently under development, and most documentation only applies to the main cyckei branch.How-ToBefore the first launch, be sure to create the config.json file as described in the HELP.md file. The file default.config.json can be renamed and edited so that further updates do not overwrite your configuration.
To start the application, double-click the cyckei.bat file or run the following command from the Cyckei installation folder.
The "-s" flag can be used to start the server independently, but this is not necessary as it will be called by the client automatically.python cyckei.pywFor more details on using the application, refer to the HELP.md file or go to Menu > Help from within the client.DependenciesCyckei is currently developed and tested on the latest version of Python 3, but should work on most installations including Anaconda. We use Windows 10 for both development and deployment.In addition various python packages, there may be additional drivers necessary depending on how you interface with the Keithley SourceMeter. We use the National Instruments GPIB-USB-HS adaptors which require NI's 488.2 driver and NI-VISA. There is a python based visa library included with py-visa, but this has not been tested with Cyckei.
Package: cycle
A Python software build management tool inspired by Maven.QuickstartAfter installing cycle via pip or rpm, just generate your first simple project calling:cycle prototype generate mynewproject [-p prototype]IntroCycle is small prototype of a build tool inspired by Apache Maven.
On the long term, it should provide some of the features Maven provides, such asa predefined, but flexible to customize lifecycle for projectsa flexible integration of additional commandsintegrations to pypi, github and other remote servicesand a bunch of prototypes (maven archetypes) with good common used conventionsWhy I started the project?I’m a sysadmin and developers for a while working with several languages and tools.
For some languages there a powerful tools and guidelines how to develop,
for other languages a developer has to review a bunch of projects to analyze the common practices.For almost all software projects a basic software lifecylce is identical as you can
review for yourself looking at the Maven documentation, eg.generate a project from a skeleton/templategenerate additional config files (special environments, test-tools config, …)registering/setup remote resource (pypi, scm repo, …)develop and test (best in the way of feature branches)write/generate documentationrelease (source, binary, distro formats)Sometimes this seems a bit far away fromDRY?Why not just using Maven?Good question! Maybe the best answer is: Maven is too powerful and a too huge step for many
developers. At least working/customizing the pom.xml files seems to be a too horrible thing
for many.So I try to develop this small Maven inspired tool as a lightweight tools for Python and other
languages. Let’s look what it becomes :-)Contributions are welcome.ReferencesApache Maven Website
Package: cycle-analysis
cycle-coalescence-algorithmHave you ever wondered how cycles in graphs form a vector space and encapsulate nesting information? Here is a tool ready to use, enabling you to calculate the cycle bases, mapping them onto a merging tree, and analyze this tree's asymmetry.IntroductionThis python module allows users to analyze weighted, undirected simple graphs for their nested cycle structure by performing two major functions: Calculating minimal cycle bases (Horton algorithm) and computing the merging tree (cycle coalescence algorithm). The algorithm is described in "Modes et al,'Extracting Hidden Hierarchies in 3D Distribution Networks', 2016" and basically follows the shown scheme below:All fundamentals minimal cyles (minimal number of edges) are listed in the weighted graph G and mapped onto the leaves of a new tree T.Then one identifies the lightest edge e in G and merges the two smallest cycles along this edge, creating a new vertex in the tree T for the merger cycleremove the original two cycles and proceed with the next lightest edge e until all cycles in G are mergedfinally calculate the tree asymmetry using the techniques of "Van-Pelt et al, 'Tree Asymmetry—A Sensitive and Practical Measure for Binary Topological Trees' ,1992"the asymmetry orderparameter will be be 1 for perfecly asymmetric trees and 0 for perfectly symmetric treesFigure taken from: Modes et al,'Extracting Hidden Hierarchies in 3D Distribution Networks', 2016Installationpip install cycle_analysisUsageCurrently this implementation only supports networkx graphs.
Call cycle_analysis.cycle_coalescence for graph analysis, while cycle_analysis.test provides you with pre-customized functions to put specific weight patterns onto the graph: random/gradient/nested_squareimportnetworkxasnximportcycle_analysis.cycle_coalescenceasccimportcycle_analysis.cycle_custom_patternasccp# generate a dummy graph for testing# put an edge weight distribution on the system, available are random/gradient/nested_squareG=nx.grid_graph((7,7,1))G=ccp.generate_pattern(G,'nested_square')# merge all shortest cycles and calc the merging tree's asymmetry for each branchasymmetry=cc.calc_cycle_asymmetry(G)print(asymmetry)./notebook contains examples to play with in the form of jupyter notebooksRequirementspython3.6+,networkx,numpyGalleryrandom weight distributionnested square weight distributiongradient weight distributionAcknowledgementcycle_analysiswritten by Felix KramerThis implementation is based on the cycle coalescence algorithm as described byModes et al, 2016. Please acknowledge if used for any further publication or projects.
Package: cyclehunter
# Cyclehunter## IntroductionThis package/repository is a organizational effort to manage a collection of Physics research projects associated
with the Center of Nonlinear Dynamics and Chaos at Georgia Tech and their collaborators. The sister Python package,
orbithunter, was mainly concerned with solving differential algebraic equations associated with finding spatiotemporal
solutions to partial differential equations.In this case, we are concerned with counting of prime cycles of discrete mappings such as Arnold’s cat map, phi-k scalar
field theory, etc. where the systems are simple enough to enable analytic counting formulae and well founded symbolic
alphabets. Because of this, the overhead to find individual cycles is greatly diminished; the main hurdle is instead to
enumerate the entire set of prime cycles for usage in cycle expansion equations / dynamical zeta functions. “Prime”
denotes the set of cycles which remain after quotienting all symmetries, i.e. the unique cycles.Therefore, the focus is much less on singular/individual cycles, rather, entire collections of prime cycles. Numerically
this is a different challenge and makes much more sense to solve the problemen massebecause cycles of a specified
length $n$ are easy to enumerate, can be solved for simultaneously and in parallel. The object oriented programming
which results from this is one in which the custom class objects will representallcycles at once.You can install the python environment by downloading a python distribution (go to python.org).I highly recommend you create a virtual environment as well; so do one of the following
in command line terminal` pip install-rrequirements.txt `or(note the periods; they are necessary)Make a folder, copy the requirements.txt file into it, then type these commands; this
assumes your python.exe is in your terminal path.` python-mvenv . cd Scripts ./activate cd .. pip install-rrequirements.txt `
Package: cyclepath-classifier
Cyclepath classifierA command-line tool for automatically calculating round complexity of LCL problems in cycles and paths based on their description in the node-edge-checkable formalism. It also reports the number of solvable/unsolvable instances of a problem when classifying it (see examples below).The tool is based on the techniques described inthis paper.RequirementsPython 3.8.3 or later versionGetting startedRun the tool specifying node and edge constraints of a problem in the node-edge-checkable formalism.The required parameters are-tor--type,-nor--node-constrand-eor--edge-constr.
There are also optional parameters specifying start and end constraints:--start-constrand--end-constr--typeaccepts 3 values:dir,undirandtreefor directed cyclepath, undirected cyclepath and a rooted tree respectively.Unless the type istree, the tool will assume that the problem is defined for apathif either--start-constror--end-constris specified. Otherwise,cyclesetting is assumed.Examples$ python3 -m cyclepath_classifier -t undir -n "{ 11, 22, 33 }" -e "{ 12, 21, 13, 31, 23, 32 }"

Round complexity of the problem is Θ(log* n)
There are infinitely many solvable instances
There are finitely many unsolvable instances$ python3 -m cyclepath_classifier -t undir -n "{ 12, 21 }" -e "{ 11, 22 }"

Round complexity of the problem is Θ(n)
There are infinitely many solvable instances
There are infinitely many unsolvable instances$ python3 -m cyclepath_classifier -t undir -n "{00, 1M}" -e "{01, 10, 11, MM}" --start-constr "{ 1 }" --end-constr "{ 1 }"

A problem cannot be of 'undirected' type if its constraints are asymmetric. Otherwise it is not well-defined.$ python3 -m cyclepath_classifier -t dir -n "{00, 1M}" -e "{01, 10, 11, MM}" --start-constr "{ 1 }" --end-constr "{ 1 }"

Round complexity of the problem is O(1)
There are finitely many solvable instances
There are infinitely many unsolvable instances$ python3 -m cyclepath_classifier -t tree -e "{ 11, 22 }"

Round complexity of the problem is O(1)
There are infinitely many solvable instances
There are finitely many unsolvable instancespython3 -m cyclepath_classifier -t tree -e "{ 12, 13, 23, 21, 31, 32 }"
Round complexity of the problem is Θ(log* n)
There are infinitely many solvable instances
There are finitely many unsolvable instancesTestsRun tests withpython -m unittest discover. See thetests/test.pyfile for details.
Package: cycle-prediction
Predicting Remaining Cycle Time from Ongoing CasePredicting the remaining cycle time of ongoing cases is one important use case of predictive process monitoring.
It is machine learning approach based on survival analysis that can learn from complete/ongoing traces.we train a neural network to predict the probability density function of the remaining cycle time of a running case.Documentation:https://fazaki.github.io/cycle_prediction/Getting started:A) pip installation1. Cd to home dircd ~2. Initialize a virtualenv that uses the Python 3.7 available at home directoryvirtualenv -p ~/python-3.7/bin/python3 PROJECTNAME3. Activate the virtualenvWindows:source ~/PROJECTNAME/Scripts/activateLinux:source ~/PROJECTNAME/bin/activate4. Install below packagespip install cycle-prediction5. Create a new kernel with the same project namepip install -U pip ipykernel
ipython kernel install --user --name=PROJECTNAME6. Use the example notebookB) Source code installation:1. Cd to home dircd ~2. Initialize a virtualenv that uses the Python 3.7 available at home directoryVirtualenv -p ~/python-3.7/bin/python3 PROJECTNAME3. Activate the virtualenvWindows:source ~/PROJECTNAME/Scripts/activateLinux:source ~/PROJECTNAME/bin/activate4. Install ipykernelpip install -U pip ipykernel5.  Clone the repogit clone https://github.com/fazaki/time-to-event/tree/master
cd time-to-event6.  Install required dependencies:pip install -e .7.  Use the example notebookTheoryPaper publication in progressReferenceshttps://arxiv.org/abs/1612.02130https://ragulpr.github.io/assets/draft_master_thesis_martinsson_egil_wtte_rnn_2016.pdfhttps://verenich.github.io/ProcessSequencePrediction/https://github.com/ragulpr/wtte-rnn
Package: cycless
cyclessA collection of algorithms to analyze a graph as a set of cycles.Some codes come fromhttps://github.com/vitroid/Polyhedandhttps://github.com/vitroid/countringsare integrated and improved.APIAPI manual ishere.cycles.pyA simple algorithm to enumerate all irreducible cycles of n-members and smaller in an undirected graph. [Matsumoto 2007]importcycless.cyclesascyimportnetworkxasnxg=nx.cubical_graph()forcycleincy.cycles_iter(g,maxsize=6):print(cycle)dicycles.pyAn algorithm to enumerate the directed cycles of a size in a dircted graph. [Matsumoto 2021]fromgenice2.geniceimportGenIcefromgenice2.pluginimportLattice,Format,Moleculeimportcycless.dicyclesasdc# Generate an ice I structure as a directed graphlattice=Lattice("1h")formatter=Format("raw",stage=(3,))raw=GenIce(lattice,signature="ice 1h",rep=[2,2,2]).generate_ice(formatter)forcycleindc.dicycles_iter(raw["digraph"],size=6):print(cycle)polyhed.pyAn algorithm to enumerate the quasi-polyhedral hull made of cycles in an undirected graph. A quasi-polyhedral hull (vitrite) obeys the following conditions: [Matsumoto 2007]The surface of the hull is made of irreducible cycles.Two or three cycles shares a vertex of the hull.Two cycles shares an edge of the hull.Its Euler index (F-E+V) is two.importcycless.cyclesascyimportcycless.polyhedasphimportnetworkxasnxg=nx.dodecahedral_graph()cycles=[cycleforcycleincy.cycles_iter(g,maxsize=6)]forpolyhedinph.polyhedra_iter(cycles):print(polyhed)simplex.pyEnumerate triangle, tetrahedral, and octahedral subgraphs found in the given graph.ReferencesM. Matsumoto, A. Baba, and I. Ohmine, Topological building blocks of hydrogen bond network in water, J. Chem. Phys. 127, 134504 (2007).http://doi.org/10.1063/1.2772627Matsumoto, M., Yagasaki, T. & Tanaka, H. On the anomalous homogeneity of hydrogen-disordered ice and its origin. J. Chem. Phys. 155, 164502 (2021).https://doi.org/10.1063/5.0065215
Package: cyclic
Handle cyclic relation compared by value.InstallInstall from Pypi:pipinstallcyclicUsagefromcyclicimportCycliccy=Cyclic()# Let's say A is a prent of Bcy.add(B,A)# B is a parent of Ccy.add(C,B)# C is a parent of A (cyclic)cy.add(A,C)# let's see if C is in any kind of cyclic relationprint(cy.is_cyclic(C))# True
Package: cyclical
CyclicalEncode item list into "cyclical"Installationpip install cyclical

# or
git clone https://github.com/jojoee/cyclical
cd cyclical
python setup.py installUsagefromcyclicalimportcyclicaln_rows=1000n_hrs=24hrs=[item%n_hrsforiteminlist(range(0,n_rows,1))]encoded_hrs=cyclical.encode(hrs,n_hrs)print(encoded_hrs)"""([0.0, 0.25881904510252074, 0.49999999999999994, 0.7071067811865476, 0.8660254037844386,0.9659258262890682, 1.0, 0.9659258262890683, 0.8660254037844387, 0.7071067811865476,0.5000000000000003, 0.258819045102521, 1.2246467991473532e-16, -0.25881904510252035,-0.4999999999999997, ..."""Real use caseTLTR: normalize cyclical data (e.g. month number [0-11], hour number [0, 23]) by mapping them into sin and cos of 1-radius-circle2 years ago while I was doing the “ocean current prediction model”. From the background knowledge of its nature which the ocean current has a strong relation with wind speed and wind speed also based on the season. So, I try to give the model “month number” which starts with 0 and ends with 11.With the deep learning model, I have to normalize data into [0, 1] which 1 refers to the maximum magnitude. There have many ways to normalize data such as min/max, mean/std, and other normalization but it can’t apply to this “month number” data.“Month number” has a cyclical characteristic, so month-number-11 can’t be compared with month-number-0 as it showed, Thus I have to represent “month number” with other normalization method instead which is “cyclical” in this module.importpandasaspdfromcyclicalimportcyclicalimportmathimportmatplotlib.pyplotasplt%matplotlibinlinen_rows=1000n_hrs=24hrs=[item%n_hrsforiteminlist(range(0,n_rows,1))]encoded_hrs=cyclical.encode(hrs,n_hrs)# print(encoded_hrs)n_months=12months=[item%n_monthsforiteminlist(range(0,n_rows,1))]encoded_months=cyclical.encode(months,n_months)# datframedf=pd.DataFrame({# hr'hr_sin':encoded_hrs[0],'hr_cos':encoded_hrs[1],# month'month_sin':encoded_months[0],'month_cos':encoded_months[1],})display(df)# plotn_samples=math.floor(n_rows*0.1)df.sample(n_samples).plot.scatter('hr_sin','hr_cos').set_aspect('equal')plt.show()# plotdf.sample(n_samples).plot.scatter('month_sin','month_cos').set_aspect('equal')plt.show()ReferenceEncoding cyclical continuous features - 24-hour time
Package: cyclicbm
Cyclic Boosting MachinesThis is an efficient and Scikit-learn compatible implementation of the machine learning algorithmCyclic Boosting -- an explainable supervised machine learning algorithm, specifically for predicting count-data, such as sales and demand.FeaturesOptimized for categorical featuresContinuous features are discretized usingpandas.qcut.Date auto-expansion (weekday + month).Feature importance plots: categorical, continuous and interactions.Metrics to stop training: RMSE, L1, SMAPE.UsageThe CBM model predicts by multiplying the global mean with each weight estimate for each bin and feature. Thus the weights can be interpreted as % increase or decrease from the global mean. e.g. a weight of 1.2 for the binMondayof the featureDay-of-Weekcan be interpreted as a 20% increase of the target.withpipinstallcyclicbmimportcbmfromsklearn.metricsimportmean_squared_error# load data using https://www.kaggle.com/c/demand-forecasting-kernels-onlytrain=pd.read_csv('data/train.csv',parse_dates=['date'])test=pd.read_csv('data/test.csv',parse_dates=['date'])# feature engineeringmin_date=train['date'].min()deffeaturize(df):out=pd.DataFrame({# TODO: for prediction such features need separate modelling'seasonal':(df['date']-min_date).dt.days//60,'store':df['store'],'item':df['item'],'date':df['date'],# <name-1> _X_ <name-2> to mark interaction features'item_X_month':df['item'].astype(str)+'_'+df['date'].dt.month.astype(str)})returnoutx_train_df=featurize(train)x_test_df=featurize(test)y_train=train['sales']# model trainingmodel=cbm.CBM()model.fit(x_train_df,y_train)# test on train errory_pred_train=model.predict(x_train_df).flatten()print('RMSE',mean_squared_error(y_pred_train,y_train,squared=False))# plottingmodel.plot_importance(figsize=(20,20),continuous_features=['seasonal'])ContributingThis project welcomes contributions and suggestions.  Most contributions require you to agree to a
Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
the rights to use your contribution. For details, visithttps://cla.opensource.microsoft.com.When you submit a pull request, a CLA bot will automatically determine whether you need to provide
a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions
provided by the bot. You will only need to do this once across all repos using our CLA.This project has adopted theMicrosoft Open Source Code of Conduct.
For more information see theCode of Conduct FAQor
contactopencode@microsoft.comwith any additional questions or comments.TrademarksThis project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft
trademarks or logos is subject to and must followMicrosoft's Trademark & Brand Guidelines.
Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship.
Any use of third-party trademarks or logos are subject to those third-party's policies.
Package: cyclic-boosting
cyclic-boostingThis package contains the implementation of the machine learning algorithm Cyclic Boosting, which is described inCyclic Boosting - an explainable supervised machine learning algorithmandDemand Forecasting of Individual Probability Density Functions with Machine Learning.DocumentationThe documentation can be foundhere.Quickstartpip install cyclic-boostingfromcyclic_boosting.pipelinesimportpipeline_CBPoissonRegressorCB_est=pipeline_CBPoissonRegressor()CB_est.fit(X_train,y)yhat=CB_est.predict(X_test)UsageIt can be used in ascikit-learn-like fashion, combining a binning method (e.g.,BinNumberTransformer) with a Cyclic Boosting estimator (find all estimators in theinit). Usage examples can be found in theintegration tests.
Package: cyclicgan
IntroductionCyclicGANThis API is an implementation of theCyclicGANbeen presented in theoriginal paper.CylicGAN is a special type of GAN network which works with Unpaired Data to extract mapping between the
two domains (X and Y). We generally have two Generator networks to generate images and two Discriminator networks to criticize
the work of the Generators (declare the images are fake or real). Apart from theAdversarial loss, we also havecyclic consistency losswhich makes sure that any mapping of the image from the domainXto domainYhas
the same reverse mapping.This API aims to makes it easy for developers to train and infer from a CyclicGAN model.DependenciesBefore installing the package, install the dependencies specified inrequirements.txtfile.InstallationThis package is also available on Pypi and thus one can directly pip install it.$pipinstallcyclicganSteps to build the API:If you wanna contribute or build the package from repository, you can build the package as follows:Clone the repo.Runpython setup.py installAPI has been installed as a python package and now you can directly use its functionalities.TutorialYou can followthistutorial notebook to get an idea of the functionality of this API with a dataset.
Package: cyclicityanalysis
Cyclicity Analysis of Time-SeriesThis repository contains a working implementation of Cyclicity Analysis, which is a pattern recognition technique for analyzing the leader follower dynamics of multiple time-series.Full documentation and an example Jupyter notebook are available in theGitHub repository.RequirementsDownloadPython >=3.10Installationpip3installcyclicityanalysisUsagefromcyclicityanalysis.orientedareaimport*fromcyclicityanalysis.coomimport*df=pd.DataFrame([[0,1],[1,0],[0,0]],columns=['0','1'])oa=OrientedArea(df)# Returns the lead lag matrix of df as a dataframelead_lag_df=oa.compute_lead_lag_df()coom=COOM(lead_lag_df)# Returns leading eigenvector of the lead lag matrix as an array, the leading eigenvector component phases as an array,# and sequential order of the lead lag matrix according to COOM as a dictionaryleading_eigenvector,leading_eigenvector_component_phases,sequential_order_dict=coom.compute_sequential_order(0)lead_lag_df,leading_eigenvector,leading_eigenvector_component_phases,sequential_order_dictReferencesCyclicity in Multivariate Time-series and Applications to Functional MRI data :paperDissociating Tinnitus Patients from Healthy Controls using Resting-state Cyclicity Analysis and Clustering :paperSlow Cortical Waves through Cyclicity Analysis :paperComparing Cyclicity Analysis With Pre-established Functional Connectivity Methods to Identify Individuals and Subject Groups Using Resting State fMRI :paper