Saravanan666/pypi-org huggingface dataset:
Package: traildb
TrailTrail is a Python package that makes it easier to bring transparency to your machine learning (ML) experimentation process. It helps you keep track of your experiments, so you can better understand how your models are performing and communicate that information to your team and stakeholders.PrerequisitesBefore you can use Trail, you'll need to sign up for a user account on the Trail-ML homepage (see Project-Links). Once you've signed up, you can start using MLflow to track your experiments. You'll need your email and password to use Trail, as well as your project ID and parent values, which you can find in the Trail web app.InstallationInstall Trail from Pypi viapipinstalltraildbGet startedfromtraildbimporttrail_initlog experimentLogging experiments is as easy as including one line of code. You'll get the parameters email and password at signup and see the project_id and parent values in the web app.withmlflow.start_run()asrun:withtrail_init(email,password,project_id,parent):...yourtrainingcode...This will start a new MLflow run and initialize a Trail experiment for that run, using the provided email, password, project ID, and parent values. You can then use the MLflow tracking API to log metrics, parameters, and artifacts for that run, and Trail will automatically record this information as part of the experiment.By using Trail to track your ML experiments, you can gain greater transparency into your development process and better communicate your results to your team and stakeholders.
Package: trailhead-scraper
A simple package that enables retrieval of public data from Salesforce Trailhead user profiles.Installationtrailhead-scraper can be installed viapip:$pipinstalltrailhead-scraperQuickstartYou can now retrieve information about a Trailhead user based on a username:fromtrailhead_scraperimportfetch_profile_data,fetch_rank_data,fetch_awardsusername="trailhead-username"# get profile informationprofile=fetch_profile_data(username)# get rank informationrank_data=fetch_rank_data(username)# get list of awards (badges)awards=fetch_awards(username)Use the profile data to access basic information about the user:print(profile["profilePhotoUrl"])print(profile["profileUser"]["FirstName"])print(profile["profileUser"]["LastName"])print(profile["profileUser"]["CompanyName"])print(profile["profileUser"]["Title"])Use the rank data to get the user’s rank and related information:print(rank_data["RankLabel"])print(rank_data["RankImageUrl"])print(rank_data["EarnedPointTotal"])print(rank_data["EarnedBadgeTotal"])print(rank_data["CompletedTrailTotal"])print(rank_data["PointTotalForNextRank"])print(rank_data["BadgeTotalForNextRank"])The list of awards contains details about each award (badge/recognition) earned by the user:forawardinawards:print(award["AwardType"],award["Award"]["Label"])
Package: trailmet
Transmute AI Model Efficiency ToolkitIntroductionTrailmet is a model efficiency toolkit for compressing deep learning models using state of the art compression techniques.
Today deep learning models are not deployable because of their huge memory footprint, TRAILMET is an effort to make deep learning models more efficient in their size to performance ratio. It is developed using Pytorch 1.13.Major featuresState of the art compression algorithms implemented.Demo notebooks for training each algorithm.Modular Design: All alogithms are modular and can customized easily for any kind of model and dataset.InstallationBelow are quick steps for installation:gitclonehttps://github.com/transmuteAI/trailmet.gitcdtrailmet
condacreate-ntrailmet
condaactivatetrailmet
condainstallpytorch=1.13torchvision=0.14pytorch-cuda=11.7-cpytorch-cnvidia
pipinstalltrailmetAlgorithms ImplementedDemo notebooks for each algorithm is added inexperimentsfolderKnowledge DistillationResponse KDFactor TransferAttention TransferPruningChipnetNetwork slimmingGrowth RegularizationQuantizationBitSplitBRECQLAPQBinarizationBiRealNetReActNetBNN-BNAcknowledgementCitationIf you find this project useful in your research, please consider cite:@misc{,title={},author={},howpublished = {}},year={2023}}LicenseThis project is released under theMIT license.
Package: trailml
TrailTrail brings more transparency to your ML experiments.
Start by using MLflow to track experiments and follow the steps below.InstallationInstall Trail from PyPI viapip install trailmlGet startedimportmlflowfromtrailimportTrailwithmlflow.start_run()asrun:withTrail():...yourtrainingcode...User configurationPrimary path:trailconfig.ymlSecondary path:~/.config/trail.ymlusername:<YOUR_USERNAME>password:<YOUR_PASSWORD>projects:id:1234ABCparentExperimentId:ABCD123Required options:usernamepasswordProject-specific options are required if not overwritten at runtime.If the project is started with missing configuration file, you will be guided through configuration file creation process. If you want to change your configuration file after initial creation,scripts/create_configcan be run to edit the configuration file via command line.
Package: trailrunner
trailrunnerWalk paths and run thingstrailrunner is a simple library for walking paths on the filesystem, and executing
functions for each file found. trailrunner obeys project level.gitignorefiles,
and runs functions on a process pool for increased performance. trailrunner is designed
for use by linting, formatting, and other developer tools that need to find and operate
on all files in project in a predictable fashion with a minimal API:walk()takes a singlePath, and generates a list of significant files in that tree:>>>fromtrailrunnerimportwalk>>>sorted(walk(Path("trailrunner")))[PosixPath('trailrunner/__init__.py'),PosixPath('trailrunner/__version__.py'),PosixPath('trailrunner/core.py'),PosixPath('trailrunner/tests/__init__.py'),PosixPath('trailrunner/tests/__main__.py'),PosixPath('trailrunner/tests/core.py'),]run()takes a list ofPathobjects and a function, and runs that function once
for each path given. It runs these functions on a process pool, and returns a mapping
of paths to results:>>>fromtrailrunnerimportrun>>>paths=[Path('trailrunner/core.py'),Path('trailrunner/tests/core.py')]>>>run(paths,str){PosixPath('trailrunner/core.py'): 'trailrunner/core.py',PosixPath('trailrunner/tests/core.py'): 'trailrunner/tests/core.py',}walk_and_run()does exactly what you would expect:>>>fromtrailrunnerimportwalk_and_run>>>walk_and_run([Path('trailrunner/tests')],str){PosixPath('trailrunner/tests/__init__.py'): 'trailrunner/tests/__init__.py',PosixPath('trailrunner/tests/__main__.py'): 'trailrunner/tests/__main__.py',PosixPath('trailrunner/tests/core.py'): 'trailrunner/tests/core.py',}Installtrailrunner requires Python 3.6 or newer. You can install it from PyPI:$pipinstalltrailrunnerLicensetrailrunner is copyrightAmethyst Reese, and licensed under
the MIT license.  I am providing code in this repository to you under an open
source license.  This is my personal repository; the license you receive to
my code is from me and not from my employer. See theLICENSEfile for details.
Package: trails-rivasiker
TRAILSDefine demographic model and calculate transition and emission probabilities:fromtrails.optimizerimporttrans_emiss_calcfromtrails.cutpointsimportcutpoints_ABCimportpandasaspdn_int_AB=3n_int_ABC=3mu=2e-8N_AB=25000*2*muN_ABC=25000*2*mut_1=240000*mut_2=40000*mut_3=800000*mut_upper=t_3-cutpoints_ABC(n_int_ABC,1/N_ABC)[-2]t_out=t_1+t_2+t_3+2*N_ABCr=1e-8/mutransitions,emissions,starting,hidden_states,observed_states=trans_emiss_calc(t_1,t_1,t_1+t_2,t_2,t_upper,t_out,N_AB,N_ABC,r,n_int_AB,n_int_ABC)Print transition probability matrix:df_transitions=pd.DataFrame(transitions).melt(ignore_index=False).reset_index(level=0)df_transitions.columns=['from','to','value']df_transitions['from']=[hidden_states[i]foriindf_transitions['from']]df_transitions['to']=[hidden_states[i]foriindf_transitions['to']]df_transitions=df_transitions.sort_values(['from','to']).reset_index(drop=True)print(df_transitions)from         to         value
0    (0, 0, 0)  (0, 0, 0)  9.986414e-01
1    (0, 0, 0)  (0, 0, 1)  2.717854e-04
2    (0, 0, 0)  (0, 0, 2)  2.717854e-04
3    (0, 0, 0)  (0, 1, 0)  1.831404e-04
4    (0, 0, 0)  (0, 1, 1)  5.365867e-08
..         ...        ...           ...
724  (3, 2, 2)  (3, 0, 1)  5.593765e-08
725  (3, 2, 2)  (3, 0, 2)  2.437075e-04
726  (3, 2, 2)  (3, 1, 1)  2.767875e-08
727  (3, 2, 2)  (3, 1, 2)  2.706694e-04
728  (3, 2, 2)  (3, 2, 2)  9.974707e-01

[729 rows x 3 columns]Print emission probability matrix:df_emissions=pd.DataFrame(emissions).melt(ignore_index=False).reset_index(level=0)df_emissions.columns=['hidden','observed','value']df_emissions['hidden']=[hidden_states[i]foriindf_emissions['hidden']]df_emissions['observed']=[observed_states[i]foriindf_emissions['observed']]df_emissions=df_emissions.sort_values(['hidden','observed']).reset_index(drop=True)print(df_emissions)hidden observed     value
0     (0, 0, 0)     AAAA  0.236472
1     (0, 0, 0)     AAAC  0.003146
2     (0, 0, 0)     AAAG  0.003146
3     (0, 0, 0)     AAAT  0.003146
4     (0, 0, 0)     AACA  0.000459
...         ...      ...       ...
6907  (3, 2, 2)     TTGT  0.000905
6908  (3, 2, 2)     TTTA  0.002240
6909  (3, 2, 2)     TTTC  0.002240
6910  (3, 2, 2)     TTTG  0.002240
6911  (3, 2, 2)     TTTT  0.232358

[6912 rows x 3 columns]
Package: train
A library to build and train reinforcement learning agents in OpenAI Gym environments.Read full documentationhere.Getting StartedAn agent has to implement theact()method which takes the currentstateas input and returns an action:fromtrainimportAgentclassRandomAgent(Agent):defact(self,state):returnself.env.action_space.sample()Create an environment using OpenAIGym:importgymenv=gym.make('CartPole-v0')Initialize your agent using the environment:agent=RandomAgent(env=env)Now you can start training your agent (in this example, the agent acts randomly always and doesn’t learn anything):scores=agent.train(episodes=100)You can also visualize how the training progresses but it will slow down the process:scores=agent.train(episodes=100,render=True)Once you are done with the training, you can test it:scores=agent.test(episodes=10)Alternatively, visualize how it performs:scores=agent.test(episodes=10,render=True)To learn more about how to build an agent that learns seeAgentdocumentation.Seeexamplesdirectory to see implementations of some algorithms (DQN, A3C, PPO etc.) in TensorFlow.InstallationRequirements:Python >= 3.6Install from PyPI (recommended):pip install trainAlternatively, install from source:git clone https://github.com/marella/train.git
cd train
pip install -e .To run examples and tests, install from source.Other libraries such asGymandTensorFlowshould be installed separately.ExamplesTo run examples, installTensorFlowand install dependencies:pip install -e .[examples]and run an example inexamplesdirectory:cd examples
python PPO.pyTestingTo run tests, install dependencies:pip install -e .[tests]and run:pytest tests
Package: train_12306
## spider-12306[![Build Status](https://travis-ci.org/ecmadao/Spider-12306.svg?branch=master)](https://travis-ci.org/ecmadao/Spider-12306)最初的灵感来自于[PROTREAM](https://protream.github.io/)的博客[用Python写一个命令行火车票查看器](https://protream.github.io/post/build-a-command-line-train-tickets-query-tool-with-python/)，感谢他提供的车站名称转换链接，有了那个以后我就屁颠屁颠跑去写着玩了。### 开发环境python 3.5### 第三方依赖[prettytable](https://code.google.com/archive/p/prettytable/wikis/Tutorial.wiki)打个广告，[python教程及笔记](https://github.com/ecmadao/Coding-Guide/tree/master/Notes/Python)戳这边，prettytable使用方法可见[Python语言及其应用-3(数据处理)](https://github.com/ecmadao/Coding-Guide/blob/master/Notes/Python/Python%E8%AF%AD%E8%A8%80%E5%8F%8A%E5%85%B6%E5%BA%94%E7%94%A8-3%EF%BC%88%E6%95%B0%E6%8D%AE%E5%A4%84%E7%90%86%EF%BC%89.md)### USAGE在项目目录下，```bash$ train$ train --train-type=[g | d | t | k | z | None] # 查询不同类型的火车```example:```bash$ train$ train --train-type=g# output+------+------+----------+-------+--------+--------+--------+--------+------+------+------+------+------+| 车次 | 站点 | 起止时间 |  历时 | 商务座 | 特等座 | 一等座 | 二等座 | 软卧 | 硬卧 | 软座 | 硬座 | 无座 |+------+------+----------+-------+--------+--------+--------+--------+------+------+------+------+------+| K904 | 厦门 |  06:59   | 21:55 |   --   |   --   |   --   |   --   |  8   |  有  |  --  |  有  |  有  ||      | 太原 |  04:54   |       |        |        |        |        |      |      |      |      |      |+------+------+----------+-------+--------+--------+--------+--------+------+------+------+------+------+```
Package: trainable-initial-state-rnn
Treat the initial state(s) of TensorFlow Keras recurrent neural network (RNN)
layers as a parameter or parameters to be learned during training, as recommended in, e.g.,[1].Ordinary RNNs use an all-zero initial state by default. Why not let the neural
network learn a smarter initial state?Thetrainable-initial-state-rnnpackage provides a classTrainableInitialStateRNNthat can wrap anytf.kerasRNN (or
bidirectional RNN) and manage new initial state variables in addition to the
RNN’s weights.Typical usage looks as follows.importtensorflowastffromtrainable_initial_state_rnnimportTrainableInitialStateRNNbase_rnn=tf.keras.layers.LSTM(256)rnn=TrainableInitialStateRNN(base_rnn)# Treats initial state as a variable!model=tf.keras.Model(...)# Use rnn like any other tf.keras layer in your modelmodel.compile(...)history=model.fit(...)Documentation is available atRead the Docs.InstallationThetrainable_initial_state_rnnpackage can be installed using thepiputility directly from the package’sGitHub page:pipinstallgit+https://github.com/artemmavrin/trainable-initial-state-rnn.gitAlternatively, install a recent release from thePython Package Index (PyPI):pipinstalltrainable-initial-state-rnnNote.To install the project for development (e.g., to make changes to the
source code), clone the project repository from GitHub and runmake dev:gitclonehttps://github.com/artemmavrin/trainable-initial-state-rnn.gitcdtrainable-initial-state-rnn# Optional but recommended: create and activate a new Python virtual environmentmakedevThis will additionally install the requirements needed
to run tests, check code coverage, and produce documentation.References[1]Felix A. Gers, Nicol N. Schraudolph, Jürgen Schmidhuber. Learning Precise
Timing with LSTM Recurrent Networks. Journal of Machine Learning Research 3
(2002) 115-143. (Link)
Package: trainbench
TrainbenchTrainbench is a tool for quickly setup a (Deep Learning) cross-validation training session with configuration instantiation, learned weights, plots, etc, recording at each training epoch.Compatible with Keras.⚠️ This  package is currently under active development!Getting startedInstallpipinstalltrainbenchCreate a train session# train.py# namename='experiment_01'# parameters to cross validate againstparameters={'fc_size':[256,512,1024]# ...}deftrain(parameters):xyz=parameters['xyz']# ...Running from the command linetrainbench.Checkout your results<name>/crosses/
               /001 
                   ├─ meta.yml 
                   ├─ history.pkl 
                   └─ weights/
                          ├─ 001.h5
                          └─ 002.h5
                             ...In Jupyter Notebooks/Python scriptfromtrainbenchimportBenchparameters={}deftrain_fn(parameters):passbench=Bench()bench.train('experiment_xyz',train_fn,parameters)Author notesI'm wrote this tool for my own usage. Feel free to use it at your own will.
If you would like to see any additional features / report existing issues please submit a pull request and/or open an issue.
Package: traincv
🌟 TrainCV 🌟No-code Labeling and Training Toolkit for Computer VisionWithImproved Labelmefor Image LabelingTODOThis project isunder development. Please consider everything here unstable. There are a lot of features need to be added in the future.You can request new features throughthis contact form.Labeling:Integrate labelmeLabeling:UI for textbox labeling (OCR, labels + positions)Labeling:Group objects (can be used in key-value matching problems)Labeling:Auto-labeling with YOLOv5Labeling:Tracking for video labelingTraining:Project + Experiment managementTraining:Object detectionTraining:Image classificationTraining:Image segmentationTraining:Instance segmentationTraining:Add docker support for trainingDeployment:Export to ONNXDeployment:Export to TFLiteDeployment:Export to TensorRTCI/CD for Pypi package publishmentUnit testsDocumentationI. Install and runRequirements: Python >= 3.8Recommended: Miniconda/Anacondahttps://docs.conda.io/en/latest/miniconda.htmlCreate environment:conda create -n traincv python=3.8
conda activate traincv(For macOS only)Install PyQt5 using Conda:conda install -c conda-forge pyqt==5.15.7Install traincv:pip install traincvRun app:traincv_appOrpython -m traincv.appII. DevelopmentGenerate resources:pyrcc5 -o traincv/resources/resources.py traincv/resources/resources.qrcRun app:python traincv/app.pyIII. Referenceslabelmegpu_utilIcons: Flat Icons
Package: traindiagnostics
A Python library for unevenly-spaced time series analysis in train diagnostics.
Build on top of the magnificenttictslibrary.InstallationpipinstalltraindiagnosticsWant to try it out first without installing? Withbinderyou can test out the code in an online jupyter notebook.Usageimporttraindiagnosticsastdts=td.TimeSeries({'2019-01-01 09:00:00':0,'2019-01-01 09:00:05':1,'2019-01-01 09:01:02':0,'2019-01-01 09:05:09':1,'2019-01-01 09:05:16':0,'2019-01-01 09:11:01':1,'2019-01-01 09:12:59':0,})not_in_index='2019-01-01 00:05:00'assertts[not_in_index]==1# step function, previous valuets['2019-01-01 00:04:00']=10assertts[not_in_index]==10assertts+ts==2*tsts_evenly_spaced=ts.sample(freq='1Min')# From ticts to pandas, and the other way aroundassertts.equals(ts.to_dataframe().to_ticts(),)ContributingMissing some features? create an issue or pull request!
Package: trainer4win
👟 TrainerAn opinionated general purpose model trainer on PyTorch with a simple code base.InstallationFrom Github:git clone https://github.com/coqui-ai/Trainercd Trainermake installFrom PyPI:pip install trainerPrefer installing from Github as it is more stable.Implementing a modelSubclass and overload the functions in theTrainerModel()Training a modelSee the test scriptheretraining a basic MNIST model.Training with DDP$python-mtrainer.distribute--scriptpath/to/your/train.py--gpus"0,1"We don't use.spawn()to initiate multi-gpu training since it causes certain limitations.Everything must the pickable..spawn()trains the model in subprocesses and the model in the main process is not updated.DataLoader with N processes gets really slow when the N is large.Supported Experiment LoggersTensorboard- actively maintainedClearML- actively maintainedMLFlowAimWandDBTo add a new logger, you must subclassBaseDashboardLoggerand overload its functions.
Package: trainerlog
trainlogNice colorful logging module, which also includes an extra level TRAIN for model train etc.fromtrainerlogimportget_loggerlogger=get_logger(name="ebun",level="DEBUG")logger.train("Training step complete")logger.debug("this is just a debug message")logger.info("This is supposed to be more important")logger.warning("Somethings maybe not right")logger.error("Something went wrong")logger.critical("Something went very wrong")
Package: trainer-py
Trainer ⏱Lightweight benchmarking package with zero dependenciesInstallationpipinstalltrainer-pyUsagefromtrainerimportTrainert=Trainer().round(2)witht('metric1'):time.sleep(0.5)witht('metric2'):time.sleep(0.3)m=t.add_total('total').metricsprint(m)output:{
    'metric1': {'start': 1656844808.09, 'end': 1656844808.59, 'interval': 0.5},
    'metric2': {'start': 1656844808.59, 'end': 1656844808.89, 'interval': 0.3},
    'total': {'start': 1656844808.09, 'end': 1656844808.89, 'interval': 0.8}
}for more, seeexamplesFeaturesContextsusing Pythoncontexts,
you can indent specific parts of the code you want to benchmarkeach measured code part produces a 'metric' dictionary with name (key),
start (epoch), end (epoch), interval (epoch)all metrics can be retrieved at any point by callingtrainer.metricsTotal Execution Timeyou can add the total execution time by executingtrainer.add_total()at the endby default, the total time considers the first metric's start time as its
start, but it is possible to prematurely start measurement by callingtrainer.start_measuring()insteadRoundingall epoch timestamps can be rounded to any number of decimals usingtrainer.round(<int>)all epoch timestamps can be rounded to full seconds (making them
integers instead of floats) by executingtrainer.round()ortrainer.round(0)Turning off Trainerto turn off trainer, the DummyTrainer class is provided. This class can be
switched on, for example, based on a value of an environment variabletrainer=Trainer()ifENV_VARelseDummyTrainer()calling.metricsat the end will always return in an empty dictionary which
is falsy in Python. Your following code that uses themetricsdictionary can
first do a check for this falsy valuego to examples
Package: trainer-xy
trainer-xy : 训练仪表盘训练过程可视化。动态绘制训练的 loss 等信息，并且可以发送消息来暂停/继续训练进程。
由于训练进程和可视化的进程是独立的，所以关闭可视化进程不会影响训练进程，且重新打开可视化进程时，
仍然能正常显示。特点设：1各项目下有n次训练，1个训练会向m个消息队列发送消息。
设1个消息队列相当于sql中的一个表，则1次训练相当于一个数据库。
因此，消息队列中的各个队列需要知道他们所属的是哪个训练库。
由于消息队列中的数据会转存到sql中，所以，
在 sql 中，使用训练的名字作为库名，每个队列对应一个表。系统各进程独立，进程间使用消息队列通信。可视化(app)进程不会阻塞训练进程。
由于各部分是分开的，所以即便关闭前后端的可视化进程，也不会影响训练。并且重新打开可视化进程时，
也不会有任何影响。绘图是动态的，不断训练，不断绘图可以在前端页面上暂停/继续训练进程在同一个项目下，可能会对数据进行多次尝试性的训练，每个训练都会有记录（每个训练都属于这个项目名），
可以切换查看训练结果。在 msmg 中，可以一次性删除某个训练的所有队列信息。因为一个训练会有m个信息队列。在 sql 中，使用训练的名字作为库名，每个队列对应一个表。对项目整体结构有较强的要求，需要有标准的 model,config,dataset,train函数等整体依赖性较强，但修改起来也比较方便。比如：要增加一项数据，只需要增加响应的前后端程序即可环境配置rabbitmq使用 3.8.0 版本的rabbitmq，对应的 erlang 版本是 22.1。换用其他版本时，需要注意版本之间的配合。mysql后端数据存储使用 mysql，mysql 版本是 5.6.41. 当然，由于存储时直接使用的 pandas ，所以可以使用 pandas 支持的任何数据库，
而不仅仅是 mysql 。pandas 以及 ORM 框架使得切换数据库很方便。vuevue cli 版本是 4.0.5。(不做开发不需要配置)nodenode 版本是 11.14.0。(不做开发不需要配置)pythonpython 需要是 3.5/3.6 ，版本太高可能会有一定的问题。依赖说明后端依赖numpy==1.14.5pandas==0.23.4pika==1.1.0ujson==1.35sanic==19.3.1dill==0.3.1.1Sanic_Cors==0.9.8PyMySql>=0.9.2SQLAlchemy>=1.2.13trainer 依赖nvidia_ml_py3==7.352.0psutil==5.4.7dataset_xy==1.0.0tf (自选)keras (自选)pytorch (自选)安装pippip install trainer-xy
Package: traingame
traingametraingameis a 2D train racing game made for demonstrating AI applications.
The game is based on Laurens Koppenol'Train-a-TrainRepository,
With some additional tweaks to make it suitable for training Neural Networks.
This code includes some examples using NEAT: Neuro Evolution of Augmenting Topologies.Feel free to contact me for questions or your high score!This project was initially used for a workshop at ProRail, the Dutch rail infrastructure company. This explains the train ;)WarningThis project is still Work in Progress. You could run into bugs when trying it out!DocumentationLaurens documented his repository nicely.
I didn't, but you can still use his documentation to gain a fair bit of knowledge about the traingame library.
Package: train-generated-data-ml
Add-on forGitHub - hansalemaos/generate_training_data_ml$pythontrain_generated_data_ml.pyYOURCONFIGFILE#Config file explanation here: https://github.com/hansalemaos/generate_training_data_ml#If you don't want to use the command line, you can import the modulefromtrain_generated_data_mlimportrun_yolov5_trainingrun_yolov5_training(YOURCONFIGFILE)
Package: trainingbar
trainingbarMake Training Models look a little nicer. The next evolution from TPUBarDon't download this..yet# from pypipipinstall--upgradetrainingbar# from srcpipinstall--upgradegit+https://github.com/trisongz/trainingbar.gitexportGOOGLE_APPLICATION_CREDENTIALS=/path/to/adc.json
tbarmonitorstart# with optionstbarmonitorstart10[refreshtime]my-gcp-project[gcpproject]tpu-name[tpuname]
Package: training-dashboard
Training DashboardA no bullshit, dead simple training visualizer for tf-keras.UsageTrainingDashboard is meant to be used as a callback passed to the fit() function.fromtraining_dashboardimportTrainingDashboardcallback=TrainingDashboard(validation=True,min_loss=0,metrics=["accuracy","auc"],batch_step=10,min_metric_dict={"accuracy":0,"auc":0},max_metric_dict={"accuracy":1,"auc":1})model.fit(x_train,y_train,batch_size=512,epochs=25,verbose=1,validation_split=0.2,callbacks=[callback])Example Output