Saravanan666/pypi-org huggingface dataset:
Package: tabtools
Tabtools - SQL & streaming processing in command lineInstallpython3 -m pip install --user tabtoolsTestsmake testExamplesDemo file consists of HSBC daily stock data.>headtabtools/tests/files/hsbc-stock.tsv

DateOpenHighLowCloseVolume2014-02-2184.3584.4583.983.4517275.02014-02-2483.8584.483.7584.3510549.02014-02-2581.6582.381.683.931186.02014-02-2681.1581.6581.081.6518937.02014-02-2781.8582.481.081.1519688.02014-02-2882.2582.4581.881.910806.02014-03-0581.481.781.1581.56101.02014-03-0681.581.7581.0581.48642.02014-03-0781.381.4581.0581.4515464.0Convert daily data to weekly:>headtabtools/tests/files/hsbc-stock.tsv\|ttreduce-g'week=strftime("%U", DateEpoch(Date))'\-s"Date=FIRST(Date); Open=FIRST(Open); High=MAX(High)"\-s"Low=MIN(Low); Close=LAST(Close); Volume=SUM(Volume)"\|ttpretty


week|Date|Open|High|Low|Close|Volume
-----|------------|-------|-------|-------|-------|--------07|2014-02-21|84.35|84.45|83.9|83.45|17275.008|2014-02-24|83.85|84.4|81.0|81.9|9116609|2014-03-05|81.4|81.75|81.05|81.45|30207Sort original file, compute 3 different EMAs (exponential moving
averages), MACD and simple moving average indicators, select last 10
lines and prettify output:>cattabtools/tests/files/hsbc-stock.tsv\|ttsort-kDate\|ttmap-s"*"\-s"fast_macd = EMA(Close, 12) - EMA(Close, 26); slow_macd = EMA(fast_macd, 9)"\-s"macd_histogram = fast_macd - slow_macd; ma50 = AVG(Close, 50)"\|tttail\|ttpretty

Date|Open|High|Low|Close|Volume|fast_macd|slow_macd|macd_histogram|ma50
-----------|-------|-------|-------|-------|---------|-----------|-----------|----------------|--------2015-07-02|69.55|69.75|69.3|70.15|17180.0|-0.577588|-0.302581|-0.275007|73.74042015-07-03|69.55|70.25|69.45|69.55|13640.0|-0.74297|-0.390658|-0.352311|73.72242015-07-06|67.6|68.85|67.0|69.55|34244.0|-0.864075|-0.485342|-0.378734|73.69642015-07-07|68.7|69.0|68.35|67.9|15676.0|-1.08074|-0.604421|-0.476315|73.64542015-07-08|66.2|67.6|66.0|68.45|31911.0|-1.19429|-0.722395|-0.471898|73.59842015-07-09|67.05|67.5|65.35|65.75|29040.0|-1.48504|-0.874924|-0.610114|73.43742015-07-10|68.1|68.45|67.0|67.75|31350.0|-1.53636|-1.00721|-0.529149|73.26342015-07-13|69.0|69.05|67.0|68.1|16601.0|-1.53114|-1.112|-0.419145|73.09742015-07-14|68.25|69.0|68.0|69.05|15219.0|-1.43382|-1.17636|-0.257459|72.92942015-07-15|69.0|69.45|68.7|68.55|9676.0|-1.38112|-1.21731|-0.163806|72.7614License
Package: tabtosql
_        _     _                  _
| |_ __ _| |__ | |_ ___  ___  __ _| |
| __/ _` | '_ \| __/ _ \/ __|/ _` | |
| || (_| | |_) | || (_) \__ \ (_| | |
 \__\__,_|_.__/ \__\___/|___/\__, |_|
                                |_|Tableau Workbook SQL Extract ToolOVERVIEWtabtosql is a command line tool for parsing sql queries & related
information out of tableau workbooks (.twb & .twbx files). It works by
taking a tableau workbook, parsing the xml, and formatting information
about worksheets, connections to those worksheets, their connection(db)
details, and the corresponding custom sql (assuming it exists) in a
valid sql & human readable format.USAGE$tabtosqlinput.twb(x)>output.sqlINSTALL$python-mpipinstalltabtosql
Package: tabugen
TabugenTabugen是一个配置导出和代码生成工具，主要用于游戏项目中简化业务开发数据抽象过程。Tabugen导入Excel表格生成编程语言的结构体定义，导出CSV数据文件，并生成对应的CSV文件加载代码。Tabugen解决的几个痛点写一段代码来从excel表格导出csv和生成对应的业务代码并不难，但是要解决好日常使用中的几个痛点解决痛点1 基本功能从excel表格里导出结构体定义，并且把excel转为csv，这个是基本需求一个excel表格需要遵从下面的配置格式配置人英雄ID英雄名字初始价格#IDNamePricestringintstringintTom1001Sven2000Jack1002Viper2500第一行为注释说明文字；第二行为字段名称，此名称会原样生成到结构体里；第三行为字段类型，可以使用bool, int8, int16, int32, int64, float, string等基础类型；以#开头的字段名在导出为csv的时候会被忽略，可以用于配置一些说明信息；每个表格还可以在名称为@meta的sheet里配置一些选项参数；解决痛点2 字段类型支持简单的数组和字典格式章节需要完成的任务可以获得的奖励ChapterTasksRewardintint[]<int,int>1101 | 102 | 1033506=10 | 3602=20int[]表示数组类型，默认使用竖线|分隔元素，格式如：value1|value2|value3<int,int>表示字典类型，默认使用竖线|分隔元素，用=分隔键值，格式如:key1=value1|key2=value2解决痛点3 支持字段嵌套宝箱ID概率1物品1数量1概率2物品2数量2IDWeight[0]ItemID[0]ItemNum[0]Weight[1]ItemID[1]ItemNum[1]intintintintintintint如上表的配置格式，期望是配一个宝箱的掉落每个掉落有对应的概率和物品，这个表格期望生成的代码格式是：struct TreasureBoxItem
{
    int Weight;
    int ItemId;
    int ItemNum;
}

struct TreasureBox
{
    int ID;
    TreasureBoxItem[] BoxItems;
}Tabugen是支持这种配置格式的，字段名后面带数组索引的ItemID[0], ItemID[1]，就认为是要做字段嵌套，只需要在@meta表里，配置上InnerTypeClass=TreasureBoxItem表示嵌套的子类的class名称，和InnerFieldName=BoxItems表示对应字段名
生成的时候不需要加任何选项，就可以生成类似上面的代码。解决痛点4 全局变量表的纵向解析格式字段名字段类型值说明IDNamePrice# DescstringstringintstringKey1float3.14浮点数值Key2stringSUCEE显示文字Key3bool0功能开关Key4int[]1 | 2 | 3等级列表会生成下面格式结构体struct Global
{
    float Key1;
    string Key2;
    bool Key3;
    int[] Key4;
}解决痛点5，不同项目类型的区分导出这是一个常见的需求，比如，有一个excel表格，某些字段只有客户端需要，某些字段只有服务器需要
Tabugen的做法是通过前缀来实现字段名服务器字段客户端字段IDS_FieldC_Fieldstringstringint如果是仅服务器使用的字段，字段名的前缀加上S_，导出的时候指定选项--project_kind=server如果是仅客户端使用的字段，字段名的前缀加上C_，导出的时候指定选项--project_kind=client技术实现上来讲，只是匹配--project_kind参数的首字母是否与字段的X_Field中的X匹配如何使用Tabugen(How to Use)从pip导入pip install tabugentabugen --asset_path=example.xlsx --cpp_out=MyConfig --package=config  --with_csv_parse --with_conv --source_file_encoding=utf_8_sig这是推荐的方式，pip可以和项目的CI/CD更好的集成使用PyInstaller从源码打包git clone https://github.com/qki7chen/tabugen.gitcd tabugen && python -m PyInstaller --name "tabugen" -F tabugen/__main__.py几种主流强类型语言的示例请查看[examples]目录下的示例工程：C++的示例 [examples/Cpp] 演示如何配合C++使用;C#的示例 [examples/CSharp] 演示如何配合C#(Unity)使用;Golang的示例 [examples/Go] 演示如何配合Golang使用;Java的示例 [examples/Java] 演示如何配合Java使用;对于Python, JavaScript等动态语言，将Excel导出为json即可，指定选项--out_data_format=json== TO-DO增加结构体对齐优化选项；其它细节优化；
Package: tabula-py
tabula-pytabula-pyis a simple Python wrapper oftabula-java, which can read tables in a PDF.
You can read tables from a PDF and convert them into a pandas DataFrame. tabula-py also enables you to convert a PDF file into a CSV, a TSV or a JSON file.You can seethe example notebookand try it on Google Colab, or we highly recommend readingour documentation, especially the FAQ section.RequirementsJava 8+Python 3.8+OSI confirmed working on macOS and Ubuntu. But some people confirm it works on Windows 10. See alsothe documentation for the detailed installation for Windows 10.UsageDocumentationFAQwould be helpful if you have an issueExample notebook on Google ColaboratoryInstallEnsure you have a Java runtime and set the PATH for it.pipinstalltabula-pyIf you want to leverage faster execution with jpype, install withjpypeextra.pipinstalltabula-py[jpype]Exampletabula-py enables you to extract tables from a PDF into a DataFrame, or a JSON. It can also extract tables from a PDF and save the file as a CSV, a TSV, or a JSON.importtabula# Read pdf into list of DataFramedfs=tabula.read_pdf("test.pdf",pages='all')# Read remote pdf into list of DataFramedfs2=tabula.read_pdf("https://github.com/tabulapdf/tabula-java/raw/master/src/test/resources/technology/tabula/arabic.pdf")# convert PDF into CSV filetabula.convert_into("test.pdf","output.csv",output_format="csv",pages='all')# convert all PDFs in a directorytabula.convert_into_by_batch("input_directory",output_format='csv',pages='all')Seean example notebookfor more details. I also recommend readingthe tutorial articlewritten by@aegis4048, andanother tutorialwritten by@tdpetrou.ContributingInterested in helping out? I'd love to have your help!You can help by:Reporting a bug.Adding or editing documentation.Contributing code via a Pull Request. See alsofor the contributionWrite a blog post or spread the word abouttabula-pyto people who might be able to benefit from using it.Contributors@lahoffm@jakekara@lcd1232@kirkholloway@CurtLH@nikhilgk@krassowski@alexandreio@rmnevesLH@red-bin@Gallaecio@red-bin@alexandreio@bpben@Bueddl@cjotade@codeboy5@manohar-voggu@deveshSingh06@grfeller@djbrown@swar@mvoggu@tdpetrouAnother supportYou can also support our continued work ontabula-pywith a donation on GitHub Sponsors orPatreon.
Package: tabular
Tabular data can be easily represented in Python using the language’s native objects – e.g. by lists of tuples representing the records of the data set.    Though easy to create, these kind of representations typically do not enable important tabular data manipulations, like efficient column selection, matrix mathematics, or spreadsheet-style operations.Tabularis a package of Python modules for working with tabular data.     Its main object is thetabarrayclass, a data structure for holding and manipulating tabular data.  By putting data into atabarrayobject, you’ll get a representation of the data that is more flexible and powerful than a native Python representation.   More specifically,tabarrayprovides:ultra-fast filtering, selection, and numerical analysis methods, using convenient Matlab-style matrix operation syntaxspreadsheet-style operations, including row & column operations, ‘sort’, ‘replace’,  ‘aggregate’, ‘pivot’, and ‘join’flexible load and save methods for a variety of file formats, including delimited text (CSV), binary, and HTMLsophisticated inference algorithms for determining formatting parameters and data types of input filesNote to NumPy Users:Thetabarrayobject is based on thendarrayobject from the Numerical Python package (NumPy), and the Tabular package is built to interface well with NumPy in general.  In particular, users of NumPy can get many of the benefits of Tabular, e.g. the spreadsheet-style operations, without having replace their usual NumPy objects with tabarrays, since most of the useful functional pieces of Tabular are written to work directly on NumPy ndarrays and record arrays (seerelationship to NumPy).DownloadDownload the latest release of tabular from the Python Package Index (PyPi):http://pypi.python.org/pypi/tabular/.Tabular requires Python 2.6 or higher, but will not work with Python 3k (since NumPy itself is not ported to Py3k).  TabularrequiresNumPy v1.6 or higher.  Any earlier version WILL NOT WORK.Once these dependencies are installed, you can simply go to the Tabular source directory in your terminal and run the command “python setup.py install” (seeInstalling Python Modules).You can also clone our github repository:https://github.com/yamins81/tabular.   You can report bugs, make suggestions, submit pull requests, and follow an RSS from our github site.Documentationhttp://web.mit.edu/yamins/www/tabular/
Package: tabular-augmentation
Descriptiontabular_augmentationcontains some classical and novel methods used for data augmentation, making tabular data
augmentation easier, especially for few-shot learning case.UsageSMOTE-based methodsfromtabular_augmentationimportsmote_augmentationmethod='SVMSMOTE'x_synthesis,y_synthesis=smote_augmentation(x_few_train,y_few_train,method,seed=seed,oversample_num=100,positive_ratio=None,knn_neighbors=3)tabular_model_test(x_synthesis,y_synthesis,x_test,y_test,model_name='xgb')Mixup-base methodsfromtabular_augmentationimportmixup_augmentation_with_weightmethod='vanilla'x_synthesis,y_synthesis,sample_weight=mixup_augmentation_with_weight(x_few_train,y_few_train,oversample_num=200,alpha=1,beta=1,mixup_type=method,seed=seed,rebalanced_ita=1)tabular_model_test(x_synthesis,y_synthesis,x_test,y_test,model_name='xgb',sample_weight=sample_weight)CTGAN/TVAE-based methodsMethods(CTGAN/TVAE/DeltaTVAE/DiffTVAE) usesdv_synthesisfunction to generate synthetic data, and ConditionalTVAE usesdv_synthesis_cvaefunctionfromtabular_augmentationimportsdv_synthesis,sdv_synthesis_cvaemethod='CTGAN'x_synthesis,y_synthesis=sdv_synthesis(x_few_train,y_few_train,method,oversample_num=5000,seed=seed,init_synthesizer=True,positive_ratio=0.5,)tabular_model_test(x_synthesis,y_synthesis,x_test,y_test,model_name='xgb')TabDDPM-based methodsfromtabular_augmentationimportddpm_synthesismethod="DDPM"x_synthesis,y_synthesis=ddpm_synthesis(x_few_train,y_few_train,method,oversample_num=5000,seed=seed,init_synthesizer=True,positive_ratio=None,train_steps=10000)tabular_model_test(x_synthesis,y_synthesis,x_test,y_test,model_name='xgb')ExampleFor details, please refer toexample.ipynbCiteSMOTEimbalanced-learnMIXUP[ICLR' 18]mixup: BEYOND EMPIRICAL RISK MINIMIZATIONMixup[ICLR' 22]Noisy Feature MixupNoisyMixup[ECCV' 20]Remix: Rebalanced MixupCTGAN/TVAE[NIPS' 19]Modeling Tabular data using Conditional GANCTGANTabDDPM[ICML' 23] TabDDPM: Modelling Tabular Data with Diffusion ModelsTabDDPM
Package: tabular-classification-package
Tabular Classification PackageModelosEste conjunto de plugins está diseñado específicamente para facilitar la integración de modelos de Machine Learning en aplicaciones con enfoque en clasificación tabular. Los modelos incluidos son:Logistic Regression:Un modelo efectivo para abordar problemas de clasificación binaria en el contexto tabular, destacando por su simplicidad y rendimiento.SVC (Support Vector Classifier):Este clasificador basado en vectores de soporte se adapta bien a conjuntos de datos tabulares complejos, ofreciendo soluciones robustas tanto para clasificación como para regresión.KNN:Random Forest:
Package: tabular-data
tabular-dataThe sensible way to work with tabular dataRead CSV files with easeGo from this 😡importcsvwithopen('names.csv',newline='')ascsvfile:reader=csv.DictReader(csvfile)rows=[]forrowinreader:rows.append(row)to this 😎fromtabular_dataimportcsv_filerows=csv_file('names.csv').read()Write CSV files with no effortGo from this 🤮importcsvwithopen('names.csv','w',newline='')ascsvfile:fieldnames=['first_name','last_name']writer=csv.DictWriter(csvfile,fieldnames=fieldnames)writer.writeheader()writer.writerow({'first_name':'Baked','last_name':'Beans'})writer.writerow({'first_name':'Lovely','last_name':'Spam'})writer.writerow({'first_name':'Wonderful','last_name':'Spam'})to this 🤩fromtabular_dataimportcsv_filecsv_file('names.csv').write([{'first_name':'Baked','last_name':'Beans'},{'first_name':'Lovely','last_name':'Spam'},{'first_name':'Wonderful','last_name':'Spam'}])
Package: tabular-data-explorer
Tabular Data ExplorerVisualize dataframes via plotly in a streamlit dashboardInstallationComing soonExamplesVisualize the iris dataset:importplotly.expressaspxfromtabular_data_explorerimportTabularDataExploreriris_dataset=px.data.iris()iris_dataset.to_csv("iris_dataset.csv",index=False)board=TabularDataExplorer()board.open("iris_dataset.csv")Or create your own test data and visualize it:importpandasaspdfromtabular_data_explorerimportTabularDataExplorer# create so test dataset for this exampledf_array=[[0.5,6,50,0.6],[0.9,7,40,0.7],[0.2,9,70,0.8]]columns=["x1","x2","x3","score"]search_data=pd.DataFrame(df_array,columns=columns)# save the dataframe to filesearch_data.to_csv("./search_data.csv")data_explorer=TabularDataExplorer()# the dashboard must read the dataframe from a filedata_explorer.open("./search_data.csv")The search data that is loaded from file must follow the pattern below. The columns can have any name and some plots can handle data other than numerical.first column nameanother column namebla bla bla...0.7560.10.2...0.8230.30.1...........................
Package: tabular-data-synthesizer
TabularDataSynthesizerThe tabular data synthezier project has as a primary goal to support the general synthesis of tabular data, whatever its shape or form. Currently, the synthesizer supports the following data types:NominalOrdinalContinuousDates (approached as continous data)TODO:DatetimeFree textThe tabular data synthetization process consists of several steps:Tokenizing the data for the relevant columns. The 'relevant' columns in this case are determined by the columns with dtypes category and object. These values are tokenized using the pd.factorize class, which maps each value to an integer. We save this and the inverse mapping. This tokenization step allows us to input everyday data, that has textual columns as well.The second step consists of a numerical representation to a representation that can be used by a neural network. In short, this means getting all values in the range [-1, 1]. There are several implementations of this. For continues values, there is three ways at the moment.Gaussian Mixture Models.A combination of several gaussians are fit to the data of a single column and can represent the data when it does not follow a typical gaussian shape, which is the assumption of more neural networks.Bayesian Gaussian Mixture Models.The BGMM is an adaptation of the Gaussian Mixture Models, that, in short, allows for a varying number of components to be learned. This method takes quite a bit longer to fix, but should typically give a bit better results.Scaler. Futhermore, we can use normalizations and standardization to get the data in the required ranges. However, this often has caveats for the neural network, since the resulting distributions are not typically Gaussians.
Package: tabular-log
tabular_logDescriptionCreates and manage a tabular log.Requiredpython3pipDirectories structure.githubISSUE_TEMPLATEbug_report.mdfeature-request.mdworkflowspypi-on-push.ymlpypi-on-release.ymlpython-test.ymltabular_log__init__.pytest-tabular_log.pydocsLICENSEREADME.mdlogtrace.logrequirementsrequirements.txt.gitignoresetup.pyExecution examplespython3 __init__.pypython3 test_tabular_log.pyChangelogVersion_02.06_2021-03-22Version_02.05_2021-03-17Version_02.04_2021-03-17Version_02.03_2021-03-09Version_02.02_2021-03-03Version_02.01_2021-03-03Version_01.01_2021-2-21Version_02.06_2021-03-22OptimizedVersion_02.05_2021-03-17Removed python requirementsVersion_02.04_2021-03-17Now avariable for python >= 3.5Version_02.03_2021-03-09Fixed a bug when is on "send to db error"Version_02.02_2021-03-03Fixed a bugVersion_02.01_2021-03-03Optimized log funtionAdded some "standard" parameterAdded the possibility to send log to the serverNow faster, using threadsAdded verbose optionVersion_01.01_2021-2-21Initial versionMade by Castellani Davide
If you have any problem please contact me:help@castellanidavide.itIssue
Package: tabular-ml
[![Pre-Commit Status](https://github.com/xaviernogueira/Tabular_ML/actions/workflows/pre-commit.yml/badge.svg)](https://github.com/xaviernogueira/Tabular_ML/actions/workflows/pre-commit.yml)
[![Tests Status](https://github.com/xaviernogueira/Tabular_ML/actions/workflows/tests.yml/badge.svg)](https://github.com/xaviernogueira/Tabular_ML/actions/workflows/tests.yml)
[![Coverage](https://codecov.io/gh/xaviernogueira/Tabular_ML/graph/badge.svg)](https://codecov.io/gh/xaviernogueira/Tabular_ML)#tabular_ml- tabular machine learning simplified!
I’ve packaged and open sourced my personal machine learning tools to speed up your next data science project.Train, evaluate, ensemble, and optimize hyperparameters from a standardized interface.![repo_schematic](images/readme_image.png)## Key Features
* Train models efficiently without worrying about library differences!tabular_mlimplements library specific, performance oriented, patterns/classes under-the-hood (i.e.,xgboost.DMatrix -> xgboost.Booster).
* Automate the K-Fold evaluation process across multiple models simultaneously (including ensembles).
* Rapidly optimize hyperparameters using [optuna](https://optuna.org/). Leverage our built-in parameter search spaces, or adjust to your needs.
* Plugin-able. Write your own plugins to extend functionality without forking (and consider contributing your plugins!).For full documentation see our GitHub ReadMe [here](https://github.com/xaviernogueira/Tabular_ML).
Package: tabular-pipeline
Data pipelineData pipeline to ingest, conform, normalise, validate and export tabular data files (for now) given yml schema(s) as the only source of truth.
It should be possible to easily plug it in modern orchestration tools such as Airflow and Dagster.:warning: This is a work in progressStepsRead - currently csv and xlsxConform - detect column headers, normalise (according to schema rules/accepted aliases) and ignore irrelevant onesNormalise - normalise columns content according to schema data typesdefine accepted data formats (int, float, str, date, year-month, categorical)allow schemas to extend said formatsTODOTry this with airflow - use S3 operator to store data in betweenTry this with dagster ?Try this with pyodide ?make it work for multiple datasets - many files and many tables within each fileallow other export formats - for now, data is transfered over csv, but we might want to use binary, like feather (which might require the usage of pandas)try with external data sources (like S3 bucket) - one should able to read and write from theme easilyreturn data directly - it might be the case that there's no need to store the data between steps - in that case it should be returned directly.
Package: tabular-time-series
Tabular Time SeriesSummaryThis repo was created as I did not find a function able to transform a time-series (1D) into a tabular format (X, y).UsageTimeSeriesGeneratorThe docstring is as follows. Given a 1D arraydata = [0, 1, 2, 3, 4, 5, 6], generatesX, yfollowing the parametersp(autoregressive),s(seasonal) andn(lenght of y).Therefore, it makes it possible to train a neural network (e.g.) that 2 autoregressive entries (e.g.p = 2) and predicts the next two (n = 2) using 2 (n = 2) entries with lag 4 (s = 4).>>data=[0,1,2,3,4,5,6]>>p,n=2,2>>ts=TimeSeriesGenerator(data,p,n)>>for_,X,yints:...print(X,y)[0,1][2,3][1,2][3,4][2,3][4,5][3,4][5,6]>>p,n,s=2,2,4>>ts=TimeSeriesGenerator(data,p,n,s)>>forX,yints:...# both y have their respective seasonal entry...print(data.index(y[0])-data.index(X[0])==s,data.index(y[1])-data.index(X[1])==s)...print(X,y)[0,1],[2,3][4,5][1,2],[3,4][5,6]TimeSeriesGeneratorOnlineTo support online learning (and streaming) applications,TimeSeriesGeneratorOnlineenables applications to give real time measurements and returns a boolbstating if it was possible to generate features, considering the given seasonals, autoregressivearand outputy.>>>fromtabular_time_series.tsgeneratoronlineimportTimeSeriesGeneratorOnline>>>data=[iforiinrange(10)]>>>p,n,s=2,2,4>>>tsgo=TimeSeriesGeneratorOnline(p,n,s)>>>forXindata:...b,(s,ar,y)=tsgo(X)...print(X,'|',b,s,ar,y)...0|FalseNoneNoneNone1|FalseNoneNoneNone2|FalseNoneNoneNone3|FalseNoneNoneNone4|FalseNoneNoneNone5|FalseNoneNoneNone6|True[0,1][2,3][4,5]7|True[1,2][3,4][5,6]8|True[2,3][4,5][6,7]9|True[3,4][5,6][7,8]timeseries2dfConsidering that many times a batch array is needed for training,timeseries2dfcan be used to generate apandasDataFrame that will contain columns in the format:>>>fromtabular_time_series.tsdfimporttimeseries2df>>>data=list(range(10))>>>p,n,s=2,2,4>>>df=timeseries2df(data,p,n,s)>>>dfy(ts4)_1y(ts4)_2y(t-1)y(t-0)y(t+1)y(t+2)00123451123456223456733456784456789
Package: tabular-trees
tabular-treesIntroductiontabular-treesis a package for making analysis on tree-based models easier.Tree based models (specifically GBMs) fromxgboost,lightgbmorscikit-learncan be exported toTabularTreesobjects for further analysis.Theexplainandvalidatemodules contain functions that operate onTabularTreesobjects.See thedocumentationfor more information.InstallThe easiest way to gettabular-treesis to install directly frompypi:pip install tabular_treestabular-treesworks with GBMs fromxgboost,lightgbmorscikit-learn. These packages must be installed to use the relevant functionality fromtabular-trees.[lightgbm, sklearn, xgboost]are optional depedencies that can be specified fortabular-trees. They can be installed along withtabular-treesas follows:pip install tabular_trees[lightgbm, sklearn]Buildtabular-treesusespoetryas the environment management and package build tool. Follow the instructionshereto install.Once installed runpoetry install --with devto install the development dependencies. Other dependency groups are;docs,lightgbm,sklearnandxgboost.