Saravanan666/pypi-org huggingface dataset:
Package: bigflow
BigFlowDocumentationWhat is BigFlow?Getting startedInstalling BigflowHelp meBigFlow tutorialCLIConfigurationProject structure and buildDeploymentWorkflow & JobStarterTechnologiesDevelopmentCookbookMonitoringAutomated end-to-end testingDockerized, GPU based ML prediction processWhat is BigFlow?BigFlow is a Python framework for data processing pipelines onGCP.The main features are:Dockerized deployment environmentPowerful CLIAutomated build,deployment,versioningandconfigurationUnified project structureSupport for GCP data processing technologies—Dataflow(Apache Beam) andBigQueryProject starterGetting startedStart from installing BigFlow on your local machine.
Next, go through the BigFlowtutorial.Installing BigFlowPrerequisites. Before you start, make sure you have the following software installed:Python= 3.8Google Cloud SDKDocker EngineYou can install thebigflowpackage globally, but we recommend
installing it locally withvenv, in your project's folder:python-mvenv.bigflow_envsource.bigflow_env/bin/activateInstall thebigflowPIP package:pipinstallbigflow[bigquery,dataflow]Test it:bigflow-hRead more aboutBigFlow CLI.To interact with GCP you need to set a default project and log in:gcloudconfigsetproject<your-gcp-project-id>
gcloudauthapplication-defaultloginFinally, check if your Docker is running:dockerinfoHelp meYou can ask questions on ourgitter channelorstackoverflow.
Package: bigger
Bigger is a program for computing big mapping classes and their actions on non-compact laminations via ideal triangulation coordinates.
It’s likeflipperandcurver, but can handle infinite-type surfaces by being lazy about the computations it performs.Bigger officially supports Python 3.7 – 3.9.QuickstartBigger is available onPyPI, so it can be installed via:$ pip install bigger --user --upgradeOnce installed, try it inside of Python:>>> import bigger
>>> S = bigger.load.spotted_ladder()  # The infinite-genus two-ended surface

# Let's make a finite curve
>>> c = S.triangulation({(0, 5): 1, (0, 6): 1})
>>> c
Lamination (0, 5): 1, (0, 6): 1

# Let's make an infinite lamination
>>> a = S.triangulation(lambda e: 2 if e[1] in {2, 3, 4, 6} else 0)
>>> a
Infinitely supported lamination (0, 0): 0, (0, 1): 0, (0, 2): 2, (0, 3): 2, (0, 4): 2, (0, 5): 0, (0, 6): 2, (0, 7): 0, (0, 8): 0, (-1, 0): 0 ...

# Let's make the picture at the top
>>> b = S('b{n >= 0}.a[2].a.a')(a)  # Apply some mapping classes
# The edges that we are interested in
>>> edges = [(i, j) for i in range(-1, 2) for j in range(2, 9)] + [(i, 0) for i in range(2)]
>>> b.draw(edges, layout=S, w=800)External LinksPyPIReadTheDocsGitHubAppVeyorAzure
Package: biggles
Biggles is a Python module for creating publication-quality 2D scientific
plots. It supports multiple output formats (postscript, x11, png, svg, gif),
understands simple TeX, and sports a high-level, elegant interface. It’s
intended for technical users with sophisticated plotting needs.Simple ExampleHere’s a simple biggles script:>>> import biggles
>>> x = [1, 2, 3, 4, 5]
>>> y = [5, 4, 3, 2, 1]
>>> p = biggles.FramedPlot()
>>> p.add(biggles.Curve(x, y))
>>> p.show()This produces an X window with a framed plot of the curve y(x).
You can find more in theexamplesdirectory included with the source distribution. Also, see thegalleryon the web.See the fulldocumentationfor more details.InstallationBiggles requiresnumpyand GNUplotutils.Macports:$ sudo port install plotutils +x11
$ pip install bigglesHomebrew:$ brew install plotutils --with-x11
$ pip install bigglesDebian/Ubuntu:$ sudo apt-get libplot-dev plotutils
$ pip install bigglesWindowsThis kind of install is not well tested at the moment. Please report bugs if you find them!
Package: biggo-api
BigGo API Python ClientBigGo API Python Client is a video API written in python. We have two APIs included so far and will update more APIs and the function in each of them in the short future.This package also support asyncio, but theGetting Startedpart only illustrate synchronous usage.For asynchronous usage, seeasync docs.BigGo API Python Client currently support Python 3.9+.Getting StartedInstallaitonInitializing API ClientAccessing BigGo APIFeaturesVideo APIUser APIAPI ReferenceLICENSEGetting StartedInstallaitonInstallbiggo-apiin virtual environment.create and activate virtual environmentpython3-mvenv<venv-name>source<venv-name>/bin/activateinstallbiggo-apiusing pippython3-mpipinstallbiggo-apiInitializing API ClientBegin by importing the APIClient and ClientCredentials from biggo_api module:>>>frombiggo_api.clientsimportAPIClient,ClientCredentialsNext, initialize an authorized API client using client credentials:>>>credentials=ClientCredentials(...client_id='my_client_id',client_secret='my_client_secret',...)>>>api_client=APIClient(client_credentials=credentials)Accessing BigGo APIYou can use a similar approach to access all BigGo API resources using the api client. Simply access the instance client of the desired resource. For example:# access video api>>>video_client=api_client.video# get video information>>>info=video_client.get(video_id='video_id')# access user api>>>user_client=api_client.user# get client's own videos at page 1>>>own_videos=user_client.get_own_videos(page=1)# Use other resources in a similar way...FeaturesThis library currently supports the following BigGo APIs (see full usage guide indocs folder):/video-Video Api/user-User ApiVideo APIUploading videos.Getting video information - Using video ID to get the information for both video and the uploader. (ex: user ID, description, etc. )Editing video settings - Editing video title, description, accessibility, etc.Deleting videos.User APIGetting video information on all uploaded videos on the personal video list.API ReferenceSeeSphinx-docs folderLICENSEMIT:arrow_up: Back to top
Package: biggo-pms-api-python
BigGo API PMS Python ClientBigGo API PMS Python Client is a API written in Python.short future:Getting StartedInstallationUsageInitializingAccessing BigGo API PMSLicenseGetting StartedInstallationUsing pippipinstall-Ubiggo_pms_api_pythonUsageUsing:frombiggo_pms_api_pythonimportBiggoAPIPMSInitializingTo get started, first obtain a client id and secret from BigGo API. Then, use the following code to obtain an API object:api=BiggoAPIPMS(clientID=client_id,clientSecret=client_secret)You can refer to this guide to get the client id and secretFunmula-Corp/guideAccessing BigGo API PMSYou can access all BigGo API PMS resources using the api object. Simply use the object obtained fromnew BiggoAPIPMS(). For example://Getlistofplatformstheuserhasaccess.platformList=awaitapi.get_Platform_List()//Getlistofgroupsintheplatform.groupList=awaitapi.get_Group_List('<Platform ID>')//Getlistofreportsintheplatform.reportList=awaitapi.get_Report_List('<Platform ID>')//Getfilecontentorsavereportasfile.reportJson=awaitapi.get_Report('<Platform ID>','<Report ID>','json')if you need more information, you can refer to thisdocument.LicenseMIT
Package: biggraphite
[![Build Status](https://travis-ci.org/criteo/biggraphite.svg?branch=master)](https://travis-ci.org/criteo/biggraphite)
[![Coverage Status](https://coveralls.io/repos/github/criteo/biggraphite/badge.svg)](https://coveralls.io/github/criteo/biggraphite?branch=master)
[![PyPi version](https://img.shields.io/pypi/v/biggraphite.svg)](https://pypi.python.org/pypi/biggraphite/)
[![Supported Python versions](https://img.shields.io/pypi/pyversions/biggraphite.svg)](https://pypi.python.org/pypi/bigraphite/)BigGraphiteBigGraphite is a storage layer for timeseries data. It integrates with Graphite as a plugin.For usage information and how to contribute, please see [CONTRIBUTING.md](CONTRIBUTING.md).UsageSee [USAGE.md](USAGE.md) and [CONFIGURATION.md](CONFIGURATION.md).Contact[Mailing List](https://groups.google.com/forum/#!forum/biggraphite)BackendsThere is only one supported backend that provides all features: Cassandra, whose design is [described in CASSANDRA_DESIGN.md](CASSANDRA_DESIGN.md).Another backend supports metadata only, stored in Elasticsearch, [see ELASTICSEARCH_DESIGN.md](ELASTICSEARCH_DESIGN.md).
Using it, it is possible to use Cassandra to store data points and Elasticsearch to store metrics metadata.Code structurebiggraphite.accessorexposes the public API to store/retrieve metricsbiggraphite.metadata_cacheimplements a machine-local cache using [LMDB](https://lmdb.readthedocs.io) so that one does not need a round-trip for each call toaccessorbiggraphite.plugins.*implements integration with Carbon and Graphitebiggraphite.drivers.*implements the storage backends (eg: Cassandra-specific code)DisclaimerTHE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Package: big-holes-in-big-data
# big-holes-in-big-dataAn implementation of the methods in [this paper](https://arxiv.org/pdf/1704.00683.pdf) to find empty regions in high-dimensional point cloudsInstall withpython3 -m pip install big-holes-in-big-data, which gives you access to theHoleFinderandHyperRectangleclasses inside package bigholes. Then follow the [How to guide](https://pavelkomarov.com/big-holes-in-big-data/how_to_use.html) minimum viable example.![hole](hole.png)
Package: bigimg
bigimg======Easily create big images. With just a lambda expression.An image can be seen as a function that maps a real-valued (x, y)coordinate onto a color. With this in mind, I made bigimg.``bigimg.py`` allows you to define a canvas width and height, a vectorfunction which will conduct an element wise map over each element in thecanvas, and an output file. If your function returns a single floatingpoint value, the resulting image will be gray scale, if it returns a3-tuple, it will be color.Installation------------::$ git clone https://github.com/stephenbalaban/bigimg.git$ cd bigimg$ sudo pip install -e .You can also create pseudorandom images with:.. code:: bash./bigimg 128 128 pseudorandom.png --lambda randomThis is useful in a variety of contexts.Examples--------Check out the example images included. You can pull request a newexample image if you find an especially cool formula. Simply add thecode to the example set below, and place the image in the examples/folder.Only the best images, as determined by me, will be accepted.Grayscale~~~~~~~~~::bigimg 512 512 examples/1.png --lambda "lambda x, y: 2048. * np.sin(x/32.) + 2048. * np.sin(y/32.)".. figure:: examples/1.png:alt: lambda x, y: 2048. * np.sin(x/32.) + 2048. * np.sin(y/32.)Example 1::bigimg 512 512 examples/2.png --lambda "lambda x, y: y * np.cos(x/128.)".. figure:: examples/2.png:alt: lambda x, y: y * np.cos(x/128.)Example 2::bigimg 512 512 --lambda random examples/0.png.. figure:: examples/0.png:alt: randomExample 0Color~~~~~::bigimg 512 512 examples/3.png --lambda "lambda x, y: (x, x, y)".. figure:: examples/3.png:alt: lambda x, y: (x, x, y)Example 3::bigimg 512 512 examples/4.png --lambda "lambda x, y: (x, np.sin(x), np.sin(y))".. figure:: examples/4.png:alt: lambda x, y: (x, np.sin(x), np.sin(y))Example 4::bigimg 1024 1024 examples/5.png --lambda "lambda x, y: (512 * np.cos(y/32.), 512 * np.sin(x/32.), 512 * np.sin(y/32.))".. figure:: examples/5.png:alt: lambda x, y: (512 * np.cos(y/32.), 512 * np.sin(x/32.), 512 * np.sin(y/32.))Example 5
Package: bigiq-discovery
biqiq-discovery a Prometheus service discovery for F5 BigIQ management platformOverviewbiqiq-discovery is a Prometheus service discovery for F5 devices managed through BigIQ management platform.Labels naming (since 0.2.0)All labels are returned prefixed as__meta_bigip_ConfigurationExample:bigiq:host:www.bigiq.ioport:443username:userpassword:passwordEnvironment variablesBIGIQ_DISCOVERY_CONFIG - the path to the above config file, default is./config.ymlBIGIQ_DISCOVERY_PROMETHEUS_SD_FILE_DIRECTORY - the output directory for the file discovery files used in your Prometheus
configuration. Each adom will have its own file.BIGIQ_DISCOVERY_LOG_LEVEL - the log level, defaultWARNINGBIGIQ_DISCOVERY_LOG_FILE - the log file, defaultstdoutBIGIQ_DISCOVERY_HOST - the ip to expose the exporter on, default0.0.0.0- only applicable if running in server modeBIGIQ_DISCOVERY_PORT - the port to expose the exporter on, default9694BIGIQ_DISCOVERY_BASIC_AUTH_ENABLED - use basic auth if set to anything, defaultfalseBIGIQ_DISCOVERY_BASIC_AUTH_USERNAME - the usernameBIGIQ_DISCOVERY_BASIC_AUTH_PASSWORD - the passwordBIGIQ_DISCOVERY_CACHE_TTL - the ttl in seconds to keep the result from Fortimanager in cache, default60RunFile service discoverypipinstalltemp-discoveryBIGIQ_DISCOVERY_CONFIG=config.ymlBIGIQ_DISCOVERY_PROMETHEUS_SD_FILE_DIRECTORY=/etc/prometheus/file_sd/fortigate
python-mbigiq_discoveryHttp service discoverypipinstalltemp-discoveryBIGIQ_DISCOVERY_CONFIG=config.ymlBIGIQ_DISCOVERY_BASIC_AUTH_ENABLED=trueBIGIQ_DISCOVERY_BASIC_AUTH_USERNAME=fooBIGIQ_DISCOVERY_BASIC_AUTH_PASSWORD=barBIGIQ_DISCOVERY_LOG_LEVEL=INFO
python-mtemp_discovery--serverTest discovery by curlcurl-ufoo:barlocalhost:9694/prometheus-sd-targetsPrometheus job configurationExample using the discovery with blackbox exporter-job_name:'f5-cluster-ping'metrics_path:/probeparams:module:[icmp]http_sd_configs:-url:http://localhost:9694/prometheus-sd-targetsrefresh_interval:60sbasic_auth:username:foopassword:barrelabel_configs:-source_labels:-__meta_bigip_platformaction:replacetarget_label:product-source_labels:-__meta_bigip_versionaction:replacetarget_label:version-source_labels:-__meta_bigip_clusteredaction:replacetarget_label:clustered-source_labels:-__meta_bigip_virtualaction:replacetarget_label:virtual-source_labels:[__address__]regex:'(.+):.*'target_label:__param_target-source_labels:[__param_target]target_label:instance-target_label:__address__replacement:'localhost:9115'
Package: bigjpg
InstalationPypipip install bigjpgGitHubpip install git+https://github.com/1Marcuth/py.bigjpg.gitSimple use examplefrombigjpgimportBigjpg,Styles,Noises,EnlargeValuesbigjpg=Bigjpg("YOUR API TOKEN HERE")image_info=bigjpg.enlarge(style=Styles.Art,# Type of imagenoise=Noises._None,# Noise level to be removedenlarge_value=EnlargeValues._4x,# Enlargement valueimage_url="https://avatars.githubusercontent.com/u/91915075?v=4"# Url of image to be enlarged)image_url=image_info.get_url()# Enlarged image urlimage_info.download("enlarged_image.png")# Method to download enlarged imageprint(image_url)
Package: biglibrary
BIGlibraryA package with many functions that are repeated with developers or that help improve software performance or facilitate programming.Languages:* python3Supported Distributions:DistributionVersion CheckPython Test VersionSupportedStatusEverything worksUbuntu20.04.43.6, 3.7, 3.8, 3.9, 3.10YesWorkingYesWindwos10.0.203483.6, 3.7, 3.8, 3.9, 3.10YesWorkingYesMacOS11.6.63.6, 3.7, 3.8, 3.9, 3.10YesWorkingYesAndroid (termux)103.6, 3.7, 3.8, 3.9, 3.10YesWorkingYesPython Package Installation:pip install biglibraryUsage:frombiglibraryimport*bl=biglibrary()Examples:#START{frombiglibraryimport*# string:str="hello world!"# list:lslist=['orange','pear','kiwi','apple','banana','strawberry','watermelon','pineapple']# :bl=biglibrary()# Default returning=False, False for print, True for return.# Placing text in the middle of the command line interface:bl.center(str)# Arrange list and items according to the length of the command line interface:bl.lslist(lslist,separator=" | ")# Default separator=" | ".#}END.Screenshot:Changelog History:## 2.0.0 [10-08-2022]
 - New build.
 - More stability.
 - Bug fixes & performance improvements.

## 1.0.1
 - Fix bugs.

## 1.0.0
 - First public release.Don't forget to star ⭐ this repositoryall posts#yasserbdj96,all views my own.Go to this link to get more information.
Package: biglist
The packagebiglistprovides persisted, out-of-memory Python data structures
that implement theSequenceandIterableinterfaces with the capabilities of
concurrent and distributed reading and writing.
The main use case is sequentially processing large amounts of data that can not fit in memory.
Persistence can be on local disk or in cloud storage.Read thedocumentation.ReferenceA very early version of this work is described ina blog post.StatusProduction ready.Python version3.10 or newer.
Package: bigmax
BigmaxChangelog3.5.1 (2013-09-19)N-MAX/BigMAX compliant [Victor Fernandez de Alba]Updated script to fix missing regex chicken [Carles Bruguera]Update ignores [Victor Fernandez de Alba]Unversion .maxui_setup [Victor Fernandez de Alba]Update branch from widget build script [Victor Fernandez de Alba]3.5 (2013-09-10)Erradicate references to maxtalk Cleanup unused inis [Carles Bruguera]New build [Carles Bruguera]update ignore [Carles Bruguera]Really add bootstrap 3 to bigmax [Carles Bruguera]Delete fuckedup folder [Carles Bruguera]New maxui build [Carles Bruguera]Bump version [Carles Bruguera]Latest maxui [Carles Bruguera]Same [Victor Fernandez de Alba]Updated to bootstrap 3.0.0RC2, less based. Deleted old sass version. [Victor Fernandez de Alba]New 3.5 build [Victor Fernandez de Alba]Update Manifest [Victor Fernandez de Alba]Unignore tests in scan [Victor Fernandez de Alba]Updated to work with the MAX 3.5 version totalItemsless [Victor Fernandez de Alba]Added legacy mode work [Victor Fernandez de Alba]3.4 (2013-06-18)Update the maxui widget to the STOMP enabled version3.3 (2013-06-05)Added compatibility to use pyramid_osirisDeprecate the use of pyramid_ldap3.0 (2013-04-15)Conversations enabledAdd exceptions view2.0 (Summer 2012)First draft ready for productionBasic querys and DB management1.0 (2012-04-02)Stripped UI from max package
Package: bigmcl
bigmclLarge scale Markov clustering (MCL) via subgraph extractionbigmclwill isolate disconnected subgraphs from a large graph file and execute
MCL on the subgraphs. bigmcl enables MCL on large, highly disconnected graphs,
such as those used in orthogroup inference. Not recommended for graphs that are
manageable with typical MCL.Important to note that the inflation parameter is affected by this approach -
I have noted clusters are more granular if anything. In the future, I plan on
implementing a systematic approach option for identifying ideal inflations for
each subgraph.Please cite this git repository and MCL when this software contributes to your analysis.DISCLAIMERbigmclis currently in a beta state, and while I appreciate bringing issues to
my attention, I am currently focused on getting things working well for my own
research, so I cannot guarantee timely issue resolution. My hope isbigmclwill
be in a longterm stable state by publication 2022.INSTALLpip install bigmclClonemclfrom here, compile, and add to your path.USEInput and go:bigmcl -i <GRAPH.imx> -I 1.5More elaborate options:usage: bigmcl.py [-h] -i INPUT -I INFLATION [-s] [-r ROW_FILE] [-m] [-o OUTPUT] [-c CORES]
                 [-v]

Isolates disconnected graphs and runs MCL on the subgraphs. Input data must be numerical.

optional arguments:
  -h, --help            show this help message and exit
  -i INPUT, --input INPUT
                        MCL graph file in imx format
  -I INFLATION, --inflation INFLATION
  -s, --symmetric       Matrix is symmetric (throughput increase)
  -r ROW_FILE, --row_file ROW_FILE
                        Continue from finished row.txt
  -m, --mcl_format      Output clusters in MCL format
  -o OUTPUT, --output OUTPUT
                        Alternative output directory
  -c CORES, --cores CORES
  -v, --verbose
Package: bigml-chronos
Utilities for parsing time strings in Python.Building and installationBefore installing chronos you will have to generate some of its modules
as it is explained inChronos readmeThen, you can simply runpipinstallbigml-chronosRequirementsPython 2.7 and Python 3 are currently supported.The basic third-party dependencies areisoweekandpytz. These
libraries are automatically installed during the setup.Running the testsThe tests will be run using nose, that is installed on setup. You can
run the test suite simply by issuingpythonsetup.pynosetestsBasic methodsChronos offers the following main functions:Withparseyou can parse a date. You can specify a format name
withformat_name, a list of possible format names withformat_namesor not specify any format. In the last case,parsewill try all the possible formats until it finds the
correct one:frombigml_chronosimportchronoschronos.parse("1969-W29-1",format_name="week-date")frombigml_chronosimportchronoschronos.parse("1969-W29-1",format_names=["week-date","week-date-time"])frombigml_chronosimportchronoschronos.parse("7-14-1969 5:36 PM")You can also find the format_name from a date withfind_format:frombigml_chronosimportparserchronos.find_format("1969-07-14Z")Instead of the name of the format, you can also pass a string
containing someJoda-Timedirectives.frombigml_chronosimportchronoschronos.parse("1969-01-29",format_name="YYYY-MM-dd")If bothformat_nameandformat_namesare passed, it will try all
the possible formats informat_namesandformat_name.You can find all the supported formats, and an example for each one of
them inside thetest file.
Package: bigmlflow
BigMLFlowThis library defines the connectors needed for the integration and
deployment ofBigMLmodels usingMLFlow.IntroductionAll the resources generated by theBigMLAPI-first platform, including
models, are totally white-box, and they can be downloaded as JSON and used
to predict anywhere. Thebigmlflowlibrary usesBigML's Python bindingsto integrate withMLFlowtracking and deploying capacities.Theexamples/README.mdfile shows a few use cases
that cover some of the Supervised Models available in BigML and
a full training example to demo the logging and tracking ofBigML's modelsusingMLFlow.InstallationThis library is available as a PyPI package. To install it, just run:pipinstallbigmlflowTestsThetestsdirectory contains some tests for the logging of models.
We usePytestto run the tests, so you can install it separatelypipinstallpytestor as an extra for development and testing purposespipinstall-e.[tests]How to ContributePlease follow the next steps:Fork the project on github.com.Create a new branch.Commit changes to the new branch.Send apull request... :changelog:History1.0.2 (2022-11-29)- Adding documentation and updating MLFlow version.

1.0.1 (2022-11-02)Adding MANIFEST.in file to fix the distribution file.1.0.0 (2022-10-19)- First version of the library.
Package: bigmodelvis
BigModelVisA Tool to Visualize Big Models.OverviewYou can use this tool to visualize the tree structure of big models, with the name/shape of each layer showing in indents.A demo picture of using BigModelVis to show the structure of Bert (bert-base-uncased)Installationinstall the latest pip versionpip install bigmodelvisorbuild from source[TODO] add the git address
git clone xxx
cd bigmodelvis
python setup.py installUsagefrom bigmodelvis import Visualization
from transformers import BertForMaskedLM
model = BertForMaskedLM.from_pretrained('bert-base-uncased')
visobj = Visualization(model)
visobj.structure_graph()
Package: bigmultiplier
This repository created for matrix multiplication.The purpose is to prevent being out of memory on GPU.Doing matrix multiplication is a massive calculation for CPU. However generally GPU rams are not enough. Sometimes it is not possible to place the two of the matrix on the GPU ram.In this implementation you will find a Theano symbolic multiplication. This function will divide your big matrixes to smaller blocks in order to make possible the calculation on GPU.Just call the methodresult_sparse_matrix = calculate(sparse_matrix_1, sparse_matrix_2)Implementation is using scipy lil and csr sparse matrix.Installpip install bigmultiplier