Saravanan666/pypi-org huggingface dataset:
Package: hmi-kuberesourcereport
Helmion Plugin: Kube Resource Reporthmi_kuberesourcereport is a chart generator forHelmionthat deploys aKube Resource Reportservice in Kubernetes.Helmion is a python library to download and customizeHelmcharts, and can
also be used to generate custom charts.Website:https://github.com/RangelReale/hmi_kuberesourcereportRepository:https://github.com/RangelReale/hmi_kuberesourcereport.gitDocumentation:https://hmi_kuberesourcereport.readthedocs.org/PyPI:https://pypi.python.org/pypi/hmi_kuberesourcereportExamplefromkubragen2.outputimportOutputProject,OutputFile_ShellScript,OutputFile_Kubernetes,OD_FileTemplate,\OutputDriver_Printfromhmi_kuberesourcereportimportKubeResourceReportChartRequestout=OutputProject()shell_script=OutputFile_ShellScript('create_gke.sh')out.append(shell_script)shell_script.append('set -e')## OUTPUTFILE: app-namespace.yaml#file=OutputFile_Kubernetes('app-namespace.yaml')file.append([{'apiVersion':'v1','kind':'Namespace','metadata':{'name':'app-monitoring',},}])out.append(file)shell_script.append(OD_FileTemplate(f'kubectl apply -f ${{FILE_{file.fileid}}}'))shell_script.append(f'kubectl config set-context --current --namespace=app-monitoring')## SETUP: kube-resource-report#kms_req=KubeResourceReportChartRequest(namespace='app-monitoring',values={'resources':{'requests':{'cpu':'5m','memory':'50Mi'},'limits':{'cpu':'10m','memory':'100Mi'},},})kms_chart=kms_req.generate()## OUTPUTFILE: kuberesourcereport.yaml#file=OutputFile_Kubernetes('kuberesourcereport.yaml')out.append(file)file.append(kms_chart.data)shell_script.append(OD_FileTemplate(f'kubectl apply -f ${{FILE_{file.fileid}}}'))## Write files#out.output(OutputDriver_Print())# out.output(OutputDriver_Directory('/tmp/build-gke'))Output:****** BEGIN FILE: 001-app-namespace.yaml ********
apiVersion: v1
kind: Namespace
metadata:
  name: app-monitoring

****** END FILE: 001-app-namespace.yaml ********
****** BEGIN FILE: 002-kuberesourcereport.yaml ********
apiVersion: v1
kind: ServiceAccount
metadata:
  name: kuberesourcereport
  namespace: app-monitoring
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: kuberesourcereport
rules:
- apiGroups:
  - ''
  resources:
  - nodes
  - pods
  - namespaces
  - services
<...more...>

****** END FILE: 002-kuberesourcereport.yaml ********
****** BEGIN FILE: create_gke.sh ********
#!/bin/bash

set -e
kubectl apply -f 001-app-namespace.yaml
kubectl config set-context --current --namespace=app-monitoring
kubectl apply -f 002-kuberesourcereport.yaml

****** END FILE: create_gke.sh ********AuthorRangel Reale (rangelreale@gmail.com)
Package: hmile
8 MILEPython 3.x module to treat financial data for machine learning purpose. Many features including :download financial data from various sourcespreprocess dataexport data🔥 InstallationPre-requisites:python3pip3Install the talib library:wgethttp://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz
tar-xzfta-lib-0.4.0-src.tar.gzcdta-lib/&&./configure--prefix=/usr&&make&&makeinstallInstall the package with pip3pip3installhmile📚 DocumentationFind doc here🛠️ Build docYou can rebuild the doc with the following commands:makehtml
rm-rdocs
mv_build/htmldocs
rm-rf_build
Package: hmip
Hopfield-NLMIPSolver for large scale nonlinear mixed integer problems. Work published as "Dual Hopfield Methods for Large-Scale Mixed-Integer Programming", B. Travacca, S. J. Moura, 2018 IEEE Conference on Decision and Control (CDC)[link]Developed ateCAL, UC Berkeley.Work funded byTOTAL.InstallationpipinstallhmipRunningimporthmipFor examples of how to use the module, run thejupyter notebookand read theWiki.Contacts:Mathilde Badoual:mathilde.badoual@berkeley.eduBertand Travacca:bertrand.travacca@berkeley.edu
Package: hmi-rabbitmq
Helmion Plugin: RabbitMQhmi_rabbitmqchart generator forHelmionthat deploys
aRabbitMQserver in Kubernetes.Helmion is a python library to download and customizeHelmcharts, and can
also be used to generate custom charts.Website:https://github.com/RangelReale/hmi_rabbitmqRepository:https://github.com/RangelReale/hmi_rabbitmq.gitDocumentation:https://hmi_rabbitmq.readthedocs.org/PyPI:https://pypi.python.org/pypi/hmi_rabbitmqExamplefromkubragen2.outputimportOutputProject,OutputFile_ShellScript,OutputFile_Kubernetes,OD_FileTemplate,\OutputDriver_Printfromhmi_rabbitmqimportRabbitMQChartRequest,RabbitMQConfigFileout=OutputProject()shell_script=OutputFile_ShellScript('create_gke.sh')out.append(shell_script)shell_script.append('set -e')## OUTPUTFILE: app-namespace.yaml#file=OutputFile_Kubernetes('app-namespace.yaml')file.append([{'apiVersion':'v1','kind':'Namespace','metadata':{'name':'app-monitoring',},}])out.append(file)shell_script.append(OD_FileTemplate(f'kubectl apply -f ${{FILE_{file.fileid}}}'))shell_script.append(f'kubectl config set-context --current --namespace=app-monitoring')## SETUP: rabbitmq#rabbitmq_req=RabbitMQChartRequest(namespace='app-monitoring',releasename='myrabbitmq',values={'configuration':RabbitMQConfigFile(),'persistence':{# 'existingClaim': 'xx',},'metrics':{'enabled':True,'serviceMonitor':{'enabled':True,}}})rabbitmq_chart=rabbitmq_req.generate()## OUTPUTFILE: rabbitmq.yaml#file=OutputFile_Kubernetes('rabbitmq.yaml')out.append(file)file.append(rabbitmq_chart.data)shell_script.append(OD_FileTemplate(f'kubectl apply -f ${{FILE_{file.fileid}}}'))## Write files#out.output(OutputDriver_Print())# out.output(OutputDriver_Directory('/tmp/build-gke'))Output:****** BEGIN FILE: 001-app-namespace.yaml ********
apiVersion: v1
kind: Namespace
metadata:
  name: app-monitoring

****** END FILE: 001-app-namespace.yaml ********
****** BEGIN FILE: 002-rabbitmq.yaml ********
apiVersion: v1
kind: ServiceAccount
metadata:
  name: myrabbitmq
  namespace: app-monitoring
---
kind: Role
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: myrabbitmq
  namespace: app-monitoring
rules:
- apiGroups:
  - ''
  resources:
  - endpoints
  verbs:
  - get
- apiGroups:
  - ''
  resources:
  - events
  verbs:
  - create
---
kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: myrabbitmq
  namespace: app-monitoring
subjects:
- kind: ServiceAccount
  name: myrabbitmq
<...more...>

****** END FILE: 002-rabbitmq.yaml ********
****** BEGIN FILE: create_gke.sh ********
#!/bin/bash

set -e
kubectl apply -f 001-app-namespace.yaml
kubectl config set-context --current --namespace=app-monitoring
kubectl apply -f 002-rabbitmq.yaml

****** END FILE: create_gke.sh ********AuthorRangel Reale (rangelreale@gmail.com)
Package: hmirls
Harmonic Mean Iteratively Reweighted Least Squares for Low-Rank Matrix RecoveryThis repository contains python code to implement a basic variant of the Harmonic Mean Iteratively Reweighted Least Squares (HM-IRLS) algorithm for low-rank matrix recovery, in particular for the low-rank matrix completion problem, described in the paper:C. Kümmerle, J. Sigl.
"Harmonic Mean Iteratively Reweighted Least Squares for Low-Rank Matrix Recovery", Journal of Machine Learning Research (JMLR) volume 19, number 47, pages 1-49, 2018.
Available online:https://jmlr.org/papers/volume19/17-244/17-244.pdfVersion historyVersion 0.0.1, 10/25/2020AuthorKristof SchröderDocumentationhttps://hmirls.readthedocs.io/en/latest/
Package: hmkshub-kmeans
Requirements:sklearnnumpymatplotlib
Python:3.5
Inputs:X , a 2D numpy array of features.k , number of clusters to create.initial_centroids , initial centroid values generated by utility function(mentioned
in usage).maxiter , maximum number of iterations to process.heterogeneity , empty list that will be filled with hetrogeneity values if passed
to kmeans func.
Usage:define 'k' value, 'X' features array and 'hetrogeneity' empty listcreate initial_centroids,
initial_centroids = get_initial_centroids(
X,
k,
seed=0 # seed value for initial centroid generation,
# None for randomness(default=None)
)find centroids and clusters using kmeans function.
centroids, cluster_assignment = kmeans(
X,
k,
initial_centroids,
maxiter=400,
record_heterogeneity=heterogeneity,
verbose=True # whether to print logs in console or not.(default=False)
)Plot the loss function, hetrogeneity values for every iteration saved in
hetrogeneity list.
plot_heterogeneity(
heterogeneity,
k
)Transfers Dataframe into excel format it must have feature called
'Clust' with k means clustering numbers in it.
Package: hml_equation_parser
hml-equation-parserUsageIf you haveequation stringfromhmldocument, you can convert
it to latex string by usingeq2latexfunction.>>>importhml_equation_parserashp>>>hp.eq2latex("LEFT ⌊ a+b RIGHT ⌋")'\\left\\lfloor a+b\\right\\rfloor'Sample codeLet’s assume that you havetest.hmlfile for converting. There are
some sample code to show how to parse hml documents. You can refer to
this sample codes inhmlParser.py(parseHmlSample,convertEquationSample,extract2HtmlStrSample).importhml_equation_parserashpdoc=hp.parseHmlSample("test.hml")# parse hml document and make ElementTreedoc=hp.convertEquationSample(doc)# find equations from ElementTree and convert them to latex stringstring=hp.extract2HtmlStrSample(doc)# convert ElementTree to html document with MathJax.importcodecsf=codecs.open("test.html","w","utf8")f.write(string)f.close()hml-equation-parser 한글 문서사용법hml문서에서 수식string을 뽑아냈다면eq2latex함수를
이용하여latex수식으로 변환할 수 있습니다.>>>importhml_equation_parserashp>>>hp.eq2latex("LEFT ⌊ a+b RIGHT ⌋")'\\left\\lfloor a+b\\right\\rfloor'예제 코드hml문서를 파싱하여 전체 문서에서 수식을 바꾸고싶다면 다음 코드를
참조하면 됩니다. 예제에서는test.hml을 파싱하여 html문서로
바꿉니다. 파싱에 대한 더 자세한 내용은 library의hmlParser.py코드를
참조하세요(parseHmlSample,convertEquationSample,extract2HtmlStrSample).importhml_equation_parserashpdoc=hp.parseHmlSample("test.hml")# parse hml document and make ElementTreedoc=hp.convertEquationSample(doc)# find equations from ElementTree and convert them to latex stringstring=hp.extract2HtmlStrSample(doc)# convert ElementTree to html document with MathJax.importcodecsf=codecs.open("test.html","w","utf8")f.write(string)f.close()
Package: hmlr-frontend-jinja
HMLR Frontend Jinja MacrosThis repository provides a complete set ofJinjamacros that are kept up-to-date and 100% compliant with the originalHMLR FrontendNunjucks macros. Porting is intentionally manual rather than automated to make updates simpler than maintaining an automated conversion routine.CompatibilityThe following table shows the version of HMLR Frontend Jinja that you should use for your targeted version of HMLR Frontend:HMLR Frontend Jinja VersionTarget HMLR Frontend Version1.0.01.1.00.2.01.0.0-rc1Any other versions of HMLR Frontend not shown abovemaystill be compatible, but have not been specifically tested and verified.How to useAfter runningpip install hmlr-frontend-jinja, ensure that you tell Jinja where to load the templates from using thePackageLoaderas follows:fromflaskimportFlaskfromjinja2importChoiceLoader,PackageLoader,PrefixLoaderapp=Flask(__name__)app.jinja_loader=ChoiceLoader([PackageLoader("app"),PrefixLoader({"hmlr_frontend_jinja":PackageLoader("hmlr_frontend_jinja")}),])Calling a Macro in your templateTo use a component in your project templates you must import and call the component macro and pass the relevant options, for example:{%- from 'hmlr_frontend_jinja/components/header/macro.html' import hmlrHeader -%}

{{ hmlrHeader({
  'serviceName': "Service name",
  'serviceUrl': "#"
}) }}The options available to each component macro can be found in the originalHMLR Design System Componentsdocumentation. Since this project is a like-for-like port, the only difference between the Nunjucks examples and their Jinja equivalents is having to quote key names, e.g.'text'instead oftext.VersioningWe useSemVerfor versioning. For the versions available, see thetags on this repository.How to contributeWe welcome contribution from the community. If you want to contribute to this project, please review thecode of conductandcontribution guidelines.ContributorsMatt Shaw(Author and primary maintainer)
Package: hmm4ds
HMM provides python3 code that implements the following algorithms
for hidden Markov models:Forward: Recursive estimation of state probabilities at each time t,given observation likelihoods for times 1 to tBackward: Combined with Forward, provides estimates of stateprobabilities at each time given _all_ of the observation
likelihoodsTrain: Implements Baum Welch algorithm which finds a local maximum oflikelihood of model parametersDecode: Implements Viterbi algorithm for finding the most probablestate sequenceImplementations of the above algrithms are independent of the
observation model.  HMM enables users to implement any observation
model by writing code for a class that provides methods for
calculating the likelihood of an observation given a state and for
reestimating model parameters given observations and state
likelihoods.HMM includes implementations of the following observation models:IntegerObservation: Integers in a finite rangeGauss: Floats with state dependent mean and varianceGaussMAP: Like Gauss but uses maximum a posteriori probability
estimationMultivariateGaussian: Like GaussMAP but observations are vectors of
floatsAutoRegressive: Like GaussMAP but with linear autoregressive forecast
and Gaussian residualObservation_with_bundles: Observations that can include classification dataI (Andy Fraser) restarted this project on 2021-01-22.  I will rewrite
the code for my book “Hidden Markov Models and Dynamical Systems”.
This project contains general HMM code that is not specific to the
book.You can redistribute and/or modify hmm under the terms of the GNU
General Public License as published by the Free Software Foundation,
either version 3 of the License, or (at your option) any later
version.  See the file “License” in the root directory of the
hmm distribution.
Package: hmmCNV
HMM copy number variation callingThis is a Python package for Copy Number Variation
detection using an HMM as implemented inichorCNA.All citations should reference tooriginal paper.InstallIf you dont already have numpy and scipy installed, it is best to downloadAnaconda, a python distribution that has them included.https://continuum.io/downloadsDependencies can be installed by:pip install -r requirements.txtPyPI install, presuming you have all its requirements installed:pip install hmmCNVUsagefromhmmCNVimporthmmCNV# Call CNVs for bin dataloglik,hmm_results=hmmCNV.hmmCNV(tumour_copy,verbose=True)
Package: hmmkay
Hmmkay🤔👌Discrete Hidden Markov Models with NumbaHmmkay is a basic library for discrete Hidden Markov Models that relies on
numba's just-in-time compilation. It supports decoding, likelihood scoring,
fitting (parameter estimation), and sampling.Hmmkay accepts sequences of arbitrary length, e.g. 2d numpy arrays or lists
of iterables. Hmmkay internally converts lists of iterables into Numba typed
lists of numpy arrays.Installationpip install hmmkayRequires Python 3.6 or higher.ExamplesScoring and decoding:fromhmmkay.utilsimportmake_observation_sequencessequences=make_observation_sequences(n_seq=100,n_observable_states=4,random_state=0)hmm.fit(sequences)fromhmmkay.utilsimportmake_proba_matricesfromhmmkayimportHMMinit_probas,transition_probas,emission_probas=make_proba_matrices(n_hidden_states=2,n_observable_states=4,random_state=0)hmm=HMM(init_probas,transition_probas,emission_probas)sequences=[[0,1,2,3],[0,2]]hmm.log_likelihood(sequences)-8.336hmm.decode(sequences)# most likely sequences of hidden states[array([1,0,0,1],dtype=int32),array([1,0],dtype=int32)]Fitting:fromhmmkay.utilsimportmake_observation_sequencessequences=make_observation_sequences(n_seq=100,n_observable_states=4,random_state=0)hmm.fit(sequences)Sampling:hmm.sample(n_obs=2,n_seq=3)# return sequences of hidden and observable states(array([[0,1],[1,1],[0,0]]),array([[0,2],[2,3],[0,0]]))DocumentationDocs are online athttps://hmmkay.readthedocs.io/en/latest/BenchmarkIt should be faster thanhmmlearn. Here's the result of thebenchmark.pyscript on my laptop:StatusHighly experimental, API subjet to change without deprecation.DevelopmentThe following packages are required for testing:pip install pytest hmmlearn scipyFor benchmarks:pip install matplotlib hmmlearnFor docs:pip install sphinx sphinx_rtd_themeFor development, usepre-commit
hooksfor black and flake8.
Package: hmm-kit
hmm_kitSimple Hidden Markov Models library.Supports discrete/continuous emissions of one/multiple dimensions.Installpython setup.py installUsageSee examples in tests/hmm_test.pyStandalone scriptTo run it as a standalone script call simple_hmm.pyTraining modelsimple_hmm.py train_model train_data.csv --kernel gaussian --states 3 --model_name my_modelDecode -simple_hmm.py decode train_data.csv my_model decode.csvPosterior -simple_hmm.py posterior train_data.csv my_model posterior.csv
Package: hmmlearn
hmmlearnhmmlearn is a set of algorithms forunsupervisedlearning and inference
of Hidden Markov Models. For supervised learning learning of HMMs and similar
models seeseqlearn.Note: This package is under limited-maintenance mode.Important linksOfficial source code repo:https://github.com/hmmlearn/hmmlearnHTML documentation (stable release):https://hmmlearn.readthedocs.org/en/stableHTML documentation (development version):https://hmmlearn.readthedocs.org/en/latestDependenciesThe required dependencies to use hmmlearn arePython >= 3.6NumPy >= 1.10scikit-learn >= 0.16You also need Matplotlib >= 1.1.1 to run the examples and pytest >= 2.6.0 to run
the tests.InstallationRequires a C compiler and Python headers.To install from PyPI:pip install --upgrade --user hmmlearnTo install from the repo:pip install --user git+https://github.com/hmmlearn/hmmlearn
Package: hmm-py
HMMpyThe HMMpy documentation is athttps://hmmpy.readthedocs.io/en/latest/.InstallationGetting startedHMMpy is a Python-embedded modeling language for hidden markov models. It currently supports training of 2-state models using either maximum-likelihood or jump estimation, and uses and API that is very similar to scikit-learn.HMMpy began as a University project at Copenhagen Business School, where it was used for financial times series forecasting in an asset allocation project.InstallationHMMpy is available on PyPI, and can be installed with (only for windows)pip install hmm-pyHMMpy has the following dependencies:Python >= 3.8Cython >= 0.29NumPy >= 1.20.1Pandas >= 1.2.0SciPy >= 1.5.4tqdmGetting startedThe following code samples some data, and then trains a hidden markov model using the JumpHMM class:fromhmmpy.jumpimportJumpHMMfromhmmpy.samplerimportSampleHMM# Instantiate the HMM modelhmm=JumpHMM(random_state=42)# Instantiate the sampler with user defined HMM model parametershmm_params={'mu':[0.1,-0.05],'std':[0.1,0.2],'tpm':[[1-0.0021,0.0021],[0.0120,1-0.0120]]}sampler=SampleHMM(hmm_params=hmm_params,random_state=42)# Simulate dataobservations,state_sequence=sampler.sample(n_samples=2000,n_sequences=1)# Outputs 2000 observations and the underlying states# Fit the modelhmm.fit(observations)# Inspect model parametersprint(hmm.mu)print(hmm.std)print(hmm.tpm)
Package: hmms
UPDATE 2023/Feb/27Direct Pypi installation is now fixed.IntroHMMs is theHidden Markov Models libraryforPython.
It is easy to usegeneral purposelibrary implementing all the important
submethods needed for the training, examining and experimenting with
the data models.The computationally expensive parts are powered byCythonto ensure high speed.The library supports the building of two models:Discrete-time Hidden Markov ModelUsually simply referred to as the Hidden Markov Model.Continuous-time Hidden Markov ModelThe variant of the Hidden Markov Model where the state transition as well as observations occurs in the continuous time.Before starting work, you may check outthe tutorial with examples.the ipython notebook, covering most of the common use-cases.Forthe deeper understandingof the topic refer to the correspondingdiploma thesis.
Or read some of the main referenced articles:Dt-HMM,Ct-HMM.Sources of the project:Pypi,Github,Requirementspython 3.5libraries: Cython, ipython, matplotlib, notebook, numpy, pandas, scipy,libraries for testing environment: pytestDownload & InstallThe Numpy and Cython must be installed before installing the library package from pypi.(env)$ python -m pip install numpy cython
(env)$ python -m pip install hmms
Package: hmm-tool
A fast Python implementation of HMMInstallationTo install:$pipinstallhmm-toolQuickstartfromhmmtoolimportHMMimportnumpyasnp### 3 states, 6 observations:### states values:0/1/2, observations values:0/1/2/3/4/5hmm=HMM(3,6)#trains1=np.random.randint(6,size=60)s2=np.random.randint(6,size=40)hmm.add_data([s1,s2])hmm.train(maxStep=50,delta=0.001)#get paramsprint(hmm.pi)print(hmm.A)print(hmm.B)#predict#random datas3=np.random.randint(6,size=10)s4=np.random.randint(6,size=10)#multi inputs:[[o1,o2,o3,...,ot1],[o1,o2,o3,...,ot2]]#output: [prob1, prob2]print(hmm.estimate_prob([s3,s4]))#output: [(prob1, [s1,s2,s3,...,st1]), (prob2, [s1,s2,s3,...,st2])]print(hmm.decode([s3,s4]))
Package: hmmviz
hmmvizA package for visualizing state transition graphs from hidden Markov models or other models.This package is meant to serve as an out-of-the-box means of plotting small graphs (less than 10 nodes) in a customizable way.InstallationDeveloped with Python 3.6pip install hmmvizUsageEach graph object takes a pandas DataFrame with states indices and columns and transition probabilities (from index to column). However, these can be instantiated using different data structures such as numpy arrays, networkx graphs, etc. (help needed) via the appropriate class methods.
as values.Plotting a Transition Matrix from a Markov ProcessfromhmmvizimportTransGraphimportpandasaspdimportmatplotlib.pyplotaspltsequence=['sunny','sunny','rainy','rainy','sunny','sunny','sunny','rainy']T=pd.crosstab(pd.Series(sequence[:-1],name='Today'),pd.Series(sequence[1:],name='Tomorrow'),normalize=0)# Tomorrow  rainy  sunny# Today# rainy       0.5    0.5# sunny       0.4    0.6graph=TransGraph(T)# looks best on square figures/axesfig=plt.figure(figsize=(6,6))graph.draw()plt.show()This will make an all black graph with labels on the nodes but none on the edges.If we want to make the graph more colorful and informative we can pass some parameters into the graph's draw method.# same T as beforegraph=TransGraph(T)fig=plt.figure(figsize=(6,6))nodelabels={'sunny':'☁☀','rainy':'😊☂'}colors={'sunny':'orange','rainy':'blue'}graph.draw(nodelabels=nodelabels,nodecolors=colors,edgecolors=colors,edgelabels=True,nodefontsize=16,)plt.show()hmmviz really shines for graphs with 4 or 5 nodes. For larger graphs consider using a package like nxviz.importnumpyasnparr=np.ones((4,4))*0.25labels=['s0','s1','s2','s3']graph=TransGraph.from_array(arr,labels)colors={f's{i}':f'C{i}'foriinrange(4)}plt.figure(figsize=(6,6))graph.draw(edgecolors=colors,nodecolors=colors,nodelabels=False,edgewidths=2)plt.show()
Package: hmm-write
Hidden Markov Machine (HMM)This module provides the functionwrite(prompt, length, bias, training)which addslengthwords to the end of the prompt. If the bias is set to 0 (the minimum), there will be no bias, and the closer it gets to 1 (the maximum) nouns in the prompt are more likely to be chosen. If a bias is not provided, the default is 0. The training variable is optional, it defaults to a file of writing I've done in the past, but can be set to a different file. If you choose to change the training, change it to a txt file hosted online, e.g."https://raw.githubusercontent.com/TobyCK/markov-chain/master/Training/dataset2.txt". Below is an example of how to use the module:fromhmm_writeimporthmmhmm.write("The quick brown fox jumps over the",50,0.3)