Saravanan666/pypi-org huggingface dataset:
Package: gpucompare
gpucompareCompare GPUsInstallationpipinstall-Ugpucompareor install withPoetrypoetryaddgpucompareThen you can rungpucompare--helpor withPoetry:poetryrungpucompare--helpWorking$gpucompare--helpUsage:gpucompare[OPTIONS]CompareGPUs╭─Options────────────────────────────────────────────────────────────────────────────────────────────────╮
│*--csv-dataTEXTCSVfilecontainingrow-wiseGPUdata[default:None][required]│
││
│Possiblecolumns:│
│gpu_name(str):nameofgpu[required]│
│architecture(str):GPUarchitecture│
│cuda_cores(int):numberofcudacores│
│fp32_perf(float):fp32performanceinTFLOPS│
│fp16_perf(float):fp16performanceinTFLOPS│
│int8_perf(float):int8performanceinTOPS│
│mem(float):gpumemoryinGiB│
│mem_bandwidth(float):memorybandwidthinGB/s│
│--version-vPrintstheversionofthegpucomparepackage.│
│--helpShowthismessageandexit.│
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────╯$gpucompare--csv-dataassets/gpu_data.csv# gpu_data.csv# gpu_name,architecture,int8_perf,mem_bandwidth# A2,ampere,36,200# A10,ampere,250,600# A30,ampere,330,933{'A10/A2':'3.0x','A30/A2':'4.67x'}ContributingThanks for considering contributing to this project. Please followContributing guidelines.🛡 LicenseThis project is licensed under the terms of theMITlicense. SeeLICENSEfor more details.📃 Citation@misc{gpucompare,author={kHarshit},title={Compare GPUs},year={2022},publisher={GitHub},journal={GitHub repository},howpublished={\url{https://github.com/kHarshit/gpucompare}}}CreditsThis project was generated withpython-package-template
Package: gpuctypes
gpuctypes (a low level GPU library for Python)Do you wish that there were simple wrappers for GPU libraries in Python? Like not pyopencl, pycuda, and (HIP library someday?) here, but just raw access to the APIs?That's whatgpuctypesdoes! While high level libraries have their place, the world needs more low level libraries. Like gpuctypes. Welcome home.Installation (usage)pipinstallgpuctypesUsageimportgpuctypes.hipashipimportgpuctypes.cudaascudaimportgpuctypes.openclasopenclHow it worksgpuctypes usesctypeslibto autogenerate Python files from the headers of the respective libraries.Installation (development)gitclonehttps://github.com/tinygrad/gpuctypes.gitcdgpuctypes
pipinstall-e.Current versionsROCm 6.0.0CUDA 11.5OpenCL (whatever is in Ubuntu 22.04)
Package: gpucv
# gpucvHave you used OpenCV on your CPU, and wanted to run it on GPU. Did you try installing OpenCV and get frustrated with its installation.
Fret not gpucv is here to save the day.
Simple installation and runs as good as OpenCV on GPU.You need to still install all the Nvidia drivers if you don’t have them.### Requirements
- Python 3.7
- CUDA### Installation1. Using pip` pip3 install gpucv `2. Building the project
Clone the project to your local repo and run setup.py.` git clone git@github.com:shrikumaran/gpucv.git python3 setup.py bdist_wheel `### Example`python import gpucv img =gpucv.readimg('index.jpeg')sobel = gpucv.sobel(img) `Colab noteobook:https://colab.research.google.com/drive/1o0LD56Qo88lZZtfVqshZL-rvCZUJ19ex?usp=sharing### TODO
- Basic IP stuff (grayscale,resize,threshold)
- Implement filters (mean,gaussian and sobel)
- Convolution kernels
Package: gpugpu
gpugpuDo you want to know which docker containers are currently using GPUs?gpugpushows current statistics of GPUs and memory usage by running containers.UsageTo run it:$dockerrun\--rm\--tty\--gpus=all\--pid=host\--envDOCKER_HOST=unix://tmp/docker.sock\--volume/var/run/docker.sock:/tmp/docker.sock:ro\ghcr.io/jonghwanhyeon/gpugpuAcknowledgmentsReporting formats are inspired bygpustat
Package: gpuheater
gpuheaterEnglish |中文In the harsh winter, with lackluster air conditioning and heating, it's time to use GPUs for heating.GPU, start!Installationpipinstallgit+https://github.com/sword4869/gpuheater.gitRunningSpecify which GPUs# use all gpus# gpuheater --device_index 0 1$gpuheater
device_index[0,1]Fanspeed|Temperature|GPUutilization|MemoryFree/MemoryTotal22%0%|60C59C|100%100%|1855MiB/11264MiB1423MiB/11264MiB# use the second gpu$gpuheater--device_index1device_index[1]Fanspeed|Temperature|GPUutilization|MemoryFree/MemoryTotal0%|57C|100%|1423MiB/11264MiBDecide to use a certain amount of free memory size (default of 10%)The size of free memory does not refer to the total memory size, but to the available free memory. So, it will not interfere with already running applications.# Only 1%$gpuheater--memory_free_percent1device_index[0,1]Fanspeed|Temperature|GPUutilization|MemoryFree/MemoryTotal25%20%|57C50C|37%34%|920.1MiB/11264MiB442.9MiB/11264MiBtype inq(and enter) or ctrl-c to exit
Package: gpuhub
CodeWithGPUis a community that focuses on the reproducible AI algorithms. It has close links withGithubby leveraging the managed code, and distributes corresponding docker images, models and logs for friendly reproduction.This repository provides a novel data loading solution that maps data between Python object and serialized bytes automatically. This solution encourages developers to build a hierarchical data loading pipeline, which decouples the reading, transforming and batching. Similar solution, such asNVIDIA DALI, is widely deployed in many HPC systems and ML benchmarks.Besides, it considers a modular and asynchronous design for the inference of AI models. Developers can easily serve their models on distributed devices by creating a many-to-many "Producer-Consumer" dataflow, and the flow control is dealt by the synchronous queues. By this way, model serving resembles training and can also get great benefit from the efficient data loader.Also, it develops the benchmarks of modern AI models on diverse accelerators, including the newest NVIDIA GPUs and Apple Silicon processors. It will help users to match their demand on picking the best suitable devices.“The more reasonable GPUs you buy, the more money you save.”InstallationInstall from PyPI:pipinstallcodewithgpuOr, clone this repository to local disk and install:cdcodewithgpu&&pipinstsall.You can also install from the remote repository:pipinstallgit+ssh://git@github.com/seetacloud/codewithgpu.gitQuick StartDeploy Image Inference ApplicationSeeExample: Image Inference.Use Record Dataset To Accelerate Data LoadingSeeExample: Record Dataset.Model BenchmarksSeeDoc: Model Benchmarks.LicenseApache License 2.0
Package: gpuhunt
Easy access to GPU pricing data for major cloud providers: AWS, Azure, GCP, and LambdaLabs.
The catalog includes details about prices, locations, CPUs, RAM, GPUs, and spots (interruptable instances).Usageimportgpuhuntitems=gpuhunt.query(min_memory=16,min_cpu=8,min_gpu_count=1,max_price=1.0,)print(*items,sep="\n")List of all available filters:provider: name of the provider to filter by. If not specified, all providers will be used. One or manymin_cpu: minimum number of CPUsmax_cpu: maximum number of CPUsmin_memory: minimum amount of RAM in GBmax_memory: maximum amount of RAM in GBmin_gpu_count: minimum number of GPUsmax_gpu_count: maximum number of GPUsgpu_name: name of the GPU to filter by. If not specified, all GPUs will be used. One or manymin_gpu_memory: minimum amount of GPU VRAM in GB for each GPUmax_gpu_memory: maximum amount of GPU VRAM in GB for each GPUmin_total_gpu_memory: minimum amount of GPU VRAM in GB for all GPUs combinedmax_total_gpu_memory: maximum amount of GPU VRAM in GB for all GPUs combinedmin_disk_size: minimum disk size in GB (not fully supported)max_disk_size: maximum disk size in GB (not fully supported)min_price: minimum price per hour in USDmax_price: maximum price per hour in USDmin_compute_capability: minimum compute capability of the GPUmax_compute_capability: maximum compute capability of the GPUspot: ifFalse, only ondemand offers will be returned. IfTrue, only spot offers will be returnedAdvanced usagefromgpuhuntimportCatalogcatalog=Catalog()catalog.load(version="20230831")items=catalog.query()print(*items,sep="\n")Supported providersAWSAzureDataCrunchGCPLambdaLabsNebiusTensorDockVast AISee alsodstack
Package: gpuinfo
# gpuinfoI implement some functions that can help users to obtain nvidia gpu information.To use gpuinfo, you need to be able to run 'ps' and 'nvidia-smi' in your terminal.# Install with pip```pip install gpuinfo```I only tested on linux system with python3.https://pypi.org/project/gpuinfo/# Usage```pythonfrom gpuinfo import GPUInfo```GPUInfo has the following functions:get_users(gpu_id)return a dict. show every user and memory on a certain gpucheck_empty()check_empty()return a list containing all GPU ids that no process is using currently.get_info()pid_list,percent,memory,gpu_used=get_info()return a dict and three lists. pid_list has pids as keys and gpu ids as values, showing which gpu the process is usingget_user(pid)get_user(pid)Input a pid number , return its creator by linux command psgpu_usage()gpu_usage()return two lists. The first list contains usage percent of every GPU. The second list contains the memory used of every GPU. The information is obtained by command 'nvidia-smi'# Example```pythonfrom gpuinfo import GPUInfoavailable_device=GPUInfo.check_empty()#available_device就是一个含有所有没有任务的gpu编号的列表percent,memory=GPUInfo.gpu_usage()#获得所有gpu的使用百分比和显存占用量min_percent=percent.index(min([percent[i] for i in available_device]))#未被使用的gpu里percent最小的min_memory=memory.index(min([memory[i] for i in available_device]))#未被使用的gpu里显存占用量最少的#如果你使用pytorchtorch.cuda.set_device(min_percent) 或者(min_memory)```
Package: gpulimit
GPU limit management机器学习领域的一些实验，由于参数较多，通常需要对不同参数跑多组实验。本项目维护使用GPU程序的任务队列，动态调度任务。避免手动跑实验带来的繁琐感受。install代码还在大改中，bug仍很多。。。源码安装gitclonehttps://github.com/lichunown/gpu-limit.gitcdgpu-limit
pythonsetup.pyinstallpip 安装pip3installgpulimitusage本程序使用linux socket进行交互，后台gpulimit_server动态调度，前台gpulimit发送命令，获取信息。启动后台服务gpulimit_server# 直接启动nohupgpulimit_server&# 后台运行前台命令$gpulimitchelpGPUTaskManage:usage:client.py-hshowhelpgpulimitadd[cmds]addtask[cmds]togpulimitqueue.othercommands:help[cmd]showhelpadd[cmds]lsGPUtaskqueuestatuslslsGPUtaskqueuestatusshow[id]showtask[id]details.rm[id]removetask[id]frommanage,iftaskisrunning,killit.kill[id]killtask[id]move[id][index(default=0)]move[id]to[index]set[name][value]setsomeproperty.start[iddefalut=None]Forcestarttask(s).log[id]show[id]output.statusshowSystemstatus.debug[id]iftask[id]is`CMD_ERROR`,usethisshowerrortraceback.添加任务gpulimitadd[cmds]# for example# gpulimit add python3 main.py --lambda=12 --alpha=1查看任务gpulimitls查看任务信息gpulimitls查看任务输出日志gpulimitlog[taskid]同样，也支持查看gpulimit_server的后台输出：gpulimitlogmainscheduling整个系统调度抽为以下4种：timer_call定时器：按照一定时间间隔运行callback_process_end：单个任务结束回调函数callback_add_process：用户添加任务时的回调函数user_start_scheduling：用户强制运行任务调用task信息：priority：default=5， 越小越优先status'CMD_ERROR'：命令本身有问题，python报错（仅在windows下）'complete'：任务完成'waiting'：等待调用'running'：正在运行'runtime_error'：任务在运行过程中出错，可能是显存爆了，也有可能是程序有问题'killed'：被用户kill的正在运行的进程，用户可以通过start命令重启'paused'：暂停的进程（暂停状态仍然占用GPU显存）run_times：任务出错V0.2.0重写status状态调整task调度简化调度算法TODO listchange raise type, and addtry exceptfor exception break.__doc__kill all, rangeadd commitsuse priority queue as task_manage.queueImprove scheduling aligorithmcatch memory error in cmds， when cmds ispython ...and usetforpytorch.
Package: gpulurker
gpu_lurker服务器 GPU 监控程序，当 GPU 属性满足预设条件 (如至少有 4 张卡且每张卡的显存多于 1000M) 时通过微信发送提示消息。服务器上输入监控命令：满足条件后发送消息到微信：安装从 PyPI 上安装:pipinstall--upgradegpulurker从 GitHub 上安装最新版本 (推荐):pipinstallgit+https://github.com/RenShuhuai-Andy/gpu_lurker.git#egg=gpulurker或克隆该仓库手动安装:gitclone--depth=1https://github.com/RenShuhuai-Andy/gpu_lurker.gitcdgpu_lurker
pipinstall.使用一、在WxPusher微信推送服务上注册并且创建应用进入https://wxpusher.zjiecode.com/admin/login，使用微信扫码关注「新消息服务」公众号并完善信息。创建新的应用，创建成功后请保存好显示的APP_TOKEN微信扫码关注应用进入「新消息服务」公众号，点击「我的」-「我的UID」获取UID二、在服务器上输入命令进行 GPU 监控# 每隔 30 分钟检查服务器状态，当有 8 张卡，每张卡的显存多余 1000M 时，向微信发送提示消息gpulurker-m1000-n8-f30m首次使用时需要输入自己的UID和APP_TOKEN。主要参数-m,--cuda-memory: 每张卡所需的显存 (默认为 5000 MB)-n,--device-num: 所需的 GPU 数 (默认为 1 块)-f,--check-freq: 检查服务器状态的间隔时间，如1d (1天)，1h (1小时)，1m (1分钟)，1s (1秒)，1h30m (1小时30分钟) 等。默认为 10 分钟-r,--reload: 重新输入用户信息 (包括 UID 和 APP_TOKEN，默认关闭)-c,--continuous: 满足条件时持续推送消息 (默认关闭)键入ctrl+c终止监控。键入gpulurker --help以获得更多信息:usage: gpulurker [-h] [-m CUDA_MEMORY] [-n DEVICE_NUM] [-f CHECK_FREQ] [-r]
                 [--log_file LOG_FILE]

check if gpu is available and notify on your WeChat

optional arguments:
  -h, --help            show this help message and exit
  -m CUDA_MEMORY, --cuda-memory CUDA_MEMORY
                        Required CUDA memory per device
  -n DEVICE_NUM, --device-num DEVICE_NUM
                        Required number of devices
  -f CHECK_FREQ, --check-freq CHECK_FREQ
                        Frequency of inspection, eg. 10m (10 minutes)
  -r, --reload          Reload and update your appToken and uid
  -c, --continuous      Continue to push message when the conditions are met
  --log_file LOG_FILE   define the threshold of avaliable (in MB)致谢本项目参考了以下仓库的代码：check_gpu_usage_and_forward_wechatnvitop微信消息实时推送服务由WxPusher提供。许可证GNU General Public License, version 3 (GPLv3)
Package: gpumonitor
gpumonitorgpumonitorgives youstats about GPUusage during execution of your scripts and trainings,
asTensorFloworPytorch Lightningcallbacks.InstallationInstallation can be done directly from this repository:pip install gpumonitorGetting startedOption 1: In your scriptsmonitor=gpumonitor.GPUStatMonitor(delay=1)# Your instructions here# [...]monitor.stop()monitor.display_average_stats_per_gpu()It keeps track of the average of GPU statistics. To reset the average and start from fresh, you can also reset the monitor:monitor=gpumonitor.GPUStatMonitor(delay=1)# Your instructions here# [...]monitor.display_average_stats_per_gpu()monitor.reset()# Some other instructions# [...]monitor.display_average_stats_per_gpu()Option 2: CallbacksAdd the following callback to your training loop:ForTensorFlow,fromgpumonitor.callbacks.tfimportTFGpuMonitorCallbackmodel.fit(x,y,callbacks=[TFGpuMonitorCallback(delay=0.5)])ForPyTorch Lightning,fromgpumonitor.callbacks.lightningimportPyTorchGpuMonitorCallbacktrainer=pl.Trainer(callbacks=[PyTorchGpuMonitorCallback(delay=0.5)])trainer.fit(model)Display FormatYou can customize the display format according to thegpustatoptions. For example, display of watts consumption,
fan speed are available. To know which options you can change, refer to:TensorFlow callback examplegpustat print_to()docstringSourcesBuilt on top ofGPUStatSeparate thread loop coming fromgputil
Package: gpu-monitor-isi
GPUDashboardA simple dashboard for NVIDIA GPUDemoExampleRequirementPython 2.7 or 3.6NVIDIA-simA Firebase realtime databaseLinux-like OSSetupCreate aFirebaseRealtimedatabaseSet the rules to{"rules":{".read":true,".write":true}}Go to Project overview clickAdd Firebase to your web appand copy following part.varconfig={apiKey:"XXXXXXXXXXXXXXXXXXXXXXXXXXXX",authDomain:"XXXXX.firebaseapp.com",databaseURL:"https://XXXXXX.firebaseio.com",projectId:"XXXXXXX",storageBucket:"XXXXXXX.appspot.com",messagingSenderId:"XXXXXXXXXXX"};On the serversthat have NVIDIA GPU(s) installed.pipinstallGPUDashboard
GPUDashboard-nyour_server_name-i20-uyour_databaseURL>GPUDashboard.log# your_server_name is the name you want to give your server e.g. MyFirstServer# -i is the interval of GPU information updating# your_databaseURL is the databaseURL obtained froom Firebase as shown aboveNow, the server GPU information is post to the firebase. *If you have many servers, all of them can make use of the same database you created in Firebase. You only need to specify different names for "your_server_name" when you start the GPUDashboard in the command line on the different servers.DownloadViewStatus.htmland open with text editor then replace the "config".<html><header><script>varconfig={apiKey:"XXXXXXXXXXXXXXXXXXXXXXXXXXXX",authDomain:"XXXXX.firebaseapp.com",databaseURL:"https://XXXXXX.firebaseio.com",projectId:"XXXXXXX",storageBucket:"XXXXXXX.appspot.com",messagingSenderId:"XXXXXXXXXXX"};</script><linkrel="stylesheet"href="https://fonts.googleapis.com/icon?family=Material+Icons"/>Open the "modifiedViewStatus.html" with browser.
Package: gpu-overseer
Command-line utility for notifying changes in GPU memory utilization via Telegram botWhy would you need thisto be notified when your GPU-intensive processes die or go upto be notified when GPUs become available on a serverSetupSet up your bot following instructionshere, get your api token for it.Start a dialog with your bot on an account that you would like to get notifications to.IMPORTANT: you need to send any message to your bot (this is due to the Telegram bot API limitations)Installoverseer:pip install gpu-overseerStart monitoring your GPUs:TELEGRAM_API_TOKEN=<your API token> TELEGRAM_API_URL=<relevant bot API URL> overseer monitorYou should instantly get a notification with a current GPU utilization status.TroubleshootingIf you do not get any notifications, tryoverseer notify <any_message>- this will send your message to all chat ids known to bot. In case you do not get this message either, try messaging your bot once again just like duringsetup.In case you move your notifier to a new machine or in any other way change its location, the notifier may forget all chat ids, and you will have to message it once again.
Package: gpuparallel
GPUParallelJoblib-like interface for parallel GPU computations (e.g. data preprocessing).importtorchfromgpuparallelimportGPUParallel,delayeddefperform(idx,device_id,**kwargs):tensor=torch.Tensor([idx]).to(device_id)return(tensor*tensor).item()result=GPUParallel(n_gpu=2)(delayed(perform)(idx)foridxinrange(5))print(list(result))# result: [0.0, 1.0, 4.0, 9.0, 16.0], ordered in accordance with input parametersFeatures:Initialize networks once on worker initReuse initialized workersPreserve sample order:preserve_orderflag, turned on by defaultResult is a generatorAuto batchingSimple logging from workersMain process inference mode for tasks debug (usedebug = True)Progressbar withtqdm:progressbarflagOptional ignoring task errors:ignore_errorsflagInstallpython3-mpipinstallgpuparallel# orpython3-mpipinstallgit+git://github.com/vlivashkin/gpuparallel.gitExamplesInitialize networks once on worker initFunctioninit_fnis called on init of every worker. All common resources (e.g. networks) can be initialized here.fromgpuparallelimportGPUParallel,delayeddefinit(device_id=None,**kwargs):globalmodelmodel=load_model().to(device_id)defperform(img,device_id=None,**kwargs):globalmodelreturnmodel(img.to(device_id))gp=GPUParallel(n_gpu=16,n_workers_per_gpu=2,init_fn=init)results=gp(delayed(perform)(img)forimginfnames)Reuse initialized workersOnce workers are initialized, they keep live untilGPUParallelobject exist.
You can perform several queues of tasks without reinitializing worker resources:gp=GPUParallel(n_gpu=16,n_workers_per_gpu=2,init_fn=init)overall_results=[]forfolder_imagesinfolders:folder_results=gp(delayed(perform)(img)forimginfolder_images)overall_results.extend(folder_results)delgp# this will close process pool to free memoryResult is a generatorGPUParallel call returns a generator to use results during caclulations (e.g. for sequential saving ordered results)importh5pygp=GPUParallel(n_gpu=16,n_workers_per_gpu=2,preserve_order=True)result=gp(delayed(perform)(img)forimginimages)withh5py.File('output.h5')asf:result_dataset=f.create_dataset('result',shape=(300,224,224,3))foridx,resultinenumerate(result):result_dataset[idx]=resultAuto batchingUse classBatchGPUParallelfor auto spliting tensor to workers.flat_resultflag de-batches results (works only if single array/tensor returned)arr=np.zeros((102,103))bgpup=BatchGPUParallel(task_fn=task,batch_size=3,flat_result=True,n_gpu=2)flat_results=np.array(list(bgpup(arr)))Simple logging from workersprint()inside a worker won't be seen in the main process, but you still can use logging to stderr of the main process.
Uselog_to_stderr()call to init logging, andlog.info(message)to log info from workersfromgpuparallelimportGPUParallel,delayed,log_to_stderr,loglog_to_stderr('INFO')defperform(idx,worker_id=None,device_id=None):hi=f'Hello world #{idx}from worker #{worker_id}with{device_id}!'log.info(hi)GPUParallel(n_gpu=2)(delayed(perform)(idx)foridxinrange(2))It will return:[INFO/Worker-1(cuda:1)]:Hello world #1 from worker #1 with cuda:1!
[INFO/Worker-0(cuda:0)]:Hello world #0 from worker #0 with cuda:0!
Package: gpuprog-log
PurposeThis log module can be used in microservices on JS and Python to write common (combined, or single) log file and also to notify administrator about errors.
The module provides similar format for different microservices and single configuration point (environment variables) that can be useful on server with SaaS b ased on different microservices.How to useConfiguration in codeIn code it's recommended to set module name with a call:log.set_module_name(name).Session identificator (sid)Sid is any (optional) string that can identify the session.Log formatAny message has common format like:[module][datetime] level [sid] messageWhere:module- configurable namedatetime- date and time of log call by format YYYY-MM-DD hh:mm:ss.mslevel- level of message,INFO,WARN,ERROR(and internal*CRITICAL*for logger internal errors)sid- Session identificator (can be undefined/None)Logging (by levels)To log any message use following functions by appropriate levels (sid is optional argument):log.info(message, sid)log.warn(message, sid)log.error(message, sid)Levels "info" and "warn" logged into stdout and log file only but level "error" also generates e-mail and Telegram message.External configurationThe logger configured with environment variables. Additionally to always enabled stdout/stderr you can enable up to three channels for logging by following variables:Log all levels of messages to file (can be used from different processes in parallel)LOG_FILENAME=<Filename for .log in HOME folder>Send e-mail per each error level message (with call stack)SENDER_GMAIL=<Your Gmail proxy account to send e-mails>SENDER_GMAIL_PASSWORD=<Your Gmail proxy account app password>- seehow to configure Gmail app passwordADMIN_EMAIL=<Admin e-mail to get critical error messages>Send Telegram notification per each error-level message (with call stack) - seehow to get Telegram the Bot Token and the Chat IDTELEGRAM_BOT_TOKEN=<Your Telegram bot token>TELEGRAM_CHAT_ID=<The chat ID to send messages>IntegrationRecommended way for integration is to use it as git submodule - to update it for your requirements.Python:PyPi package- usepip install gpuprog-logimport logJS:NPM package- usenpm i @gpuprog/logconst log = require('@gpuprog/log/log')Developmentcd logPython:Creating and publishing scoped public packagesnpm publish --access publicJS:Packaging Python Projectspython -m buildpython -m twine upload --repository pypi dist/*
Package: gpu-queuer
GPU 自动选择、排队gpu_queue(config: Union[DictConfig, dict] = {})：设置处理器支持自动选择和手动选择、排队和不排队

Args:
    config (dict, optional): Defaults to {}.
        queuing: 是否排队，依赖 Redis，默认为 True
        visible_devices: 可见的 GPU 序号，用逗号分隔，默认为 -1, 表示全部可见
        memo: 备注
Returns:
    Union[DictConfig, dict]: config