Saravanan666/pypi-org huggingface dataset:
Package: irrigation30
irrigation30- Python3 Packageirrigation30is a Python package designed to help researchers predict and visualize irrigation at 30m resolution for small regions at a time using Google Earth Engine.With this package, users can generate and visualize irrigation predictions with an interactive map powered by Google Earth Engine andfolium. The package also includes additional features to analyze relevant climate and satellite data like temperature, precipitation, NDVI signatures, and satellite images from Sentinel-2.This project was developed by a team of UC Berkeley students in the Master’s in Information and Data Science program.Website:https://groups.ischool.berkeley.edu/irrigation30/webdev/InstallationDependenciesirrigation30requires:Python (>= 3.6)pandas (>= 1.0.5)numpy (>= 1.19.0)scipy (>= 1.5.0)matplotlib (>= 3.2.2)earthengine-api (>= 0.1.227)folium (>= 0.11.0)shapely (>= 1.7.0)Our package also requires users to have a Google Earth Engine account. You can sign up for an accounthere. Note that it may take several days for Google to activate your account.Lastly, our package is intended to be used in Python Jupyter notebooks. For more instructions on how to install Jupyter and use Jupyter notebooks, seethis tutorial.User installationThe easiest way to installirrigation30is withpip3pip3 install irrigation30If you are having a hard time getting the right package versions installed, you can set up a virtual environment like so:Install withvirtualenvpip3 install virtualenvvirtualenv envsource env/bin/activatecurl https://bootstrap.pypa.io/get-pip.py | python3pip3 install irrigation30pip3 install ipykernelipython kernel install --user --name=envjupyter notebookWhen finished, deactivate your virtualenv withdeactivateUsageFor a full tutorial of how the package is used in Jupyter notebooks, see our Jupyter notebook demoDemo.ipynb.For more info on how to download TIF assets to Google Earth Engine and download TIF files to Google Drive, seedocs/download_TIF.md.Help and SupportFor help with using or installing the package, contact Weixin ("Angela") Wu:https://www.ischool.berkeley.edu/people/weixin-wu
Package: irritable
IrritableIrritable implements broken iterators called irritablesFree software: BSD licenseDocumentation:https://irritable.readthedocs.io.FeaturesIterators are defined in thedocs; the definition includes what
constitutes a broken implementation:4.5. Iterator Types[…]Once an iterator’s__next__()method raises StopIteration, it must
continue to do so on subsequent calls. Implementations that do not
obey this property are deemed broken.Irritablesare like iterables, but deliberately broken. The following
types of brokenness are supported:afternext()first raisesStopIteration, subsequent calls will
raiseStopIrritationinstead;if the irritator is instantiated withresume=True, callingnext()may raiseStopIterationwhen items remain still remain in
the container; subsequent calls tonext()will return the remaining
items as usual until none remain;if the irritator is instantiated withrepeat=True, after the
iterator has been exhausted and raisesStopIteration, the iterator
is reset and can be iterated over again ad infinitum; in this casenext()will never raiseStopIrritation;CreditsThe idea for irritators came during Trey Hunner’stalk“Loop better:
a deeper look at iteration in Python” at DjangoCon AU 2017.This package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2017-08-08)First release on PyPI.
Package: irrp
irrpBasicallyirrp.pybut
as a python module so you can integrate it easily with your Python
program.ExamplesTo record:importpigpiopi=pigpio.pi()gpio_pin=18# Record the IR dataimportirrprr=irrp.RecordReplayer(pi)print(rr.record(gpio_pin))# optionally, save to a file:importjsonjson.dump(open("data.json","wb"))To replay:importpigpiopi=pigpio.pi()gpio_pin=18# load the recorded dataimportjsondata=json(load(open("data.json")))# replay the dataimportirrprr=irrp.RecordReplayer(pi)rr.replay(gpio_pin,data)To record and compare data:importpigpiopi=pigpio.pi()gpio_pin=18# record dataimportirrprr=irrp.RecordReplayer(pi)rec=rr.record(gpio_pin)importjsondata=json(load(open("data.json")))irrp.compare(data,rec)
Package: ir-sim
Intelligent Robot Simulator (ir-sim)A python based robot simulator framework for the intelligent robotics navigation and learning.RobotCarFeatures:Simple and easy to run with python;All the models and parameters can be set directly in the yaml configure file;Environment can be built easily by line, circle model and png images;Various robot kinematics models: omni-wheel, differential wheel, arckermann;Support collision check with environment;Equipped with various sensors: Lidar, GPS, Odometry etc.;Support keyboard controller;Easy to reproduce the robotics algorithms and extend for your own project.PrerequisiteTest platform: Ubuntu20.04, windows10Python: >= 3.7numpymatplotlibscipyInstallationInstall this package by pip:pip install ir_simor install manually:Clone and install the packagegit clone https://github.com/hanruihua/ir_sim.git    
cd ir_sim   
pip install -e .UsageThe examples are in their_sim/usageAuthorHan RuihuaContact:hanrh@connect.hku.hk
Package: irspdf
READMEPresentationirspdf is a simple textual information retrieval system for pdf documents.Text is extracted from pdf withpdfplumber.Standard text preprocessing for information retrieval is applied:StopWord removalStemmingPunctuation removalLowercase conversionThe ranking function used is BM25.InstallationInstall with pippip install irspdfOR install from githubgit clone https://github.com/Jibril-Frej/irspdf.git
cd irspdf && python setup.py installUsageBuild a collectionfrom irspdf import build
build(folder_path, collection_path)folder_path : path of the folder that contains all the pdf files to include to the collection.collection_path : file where the collection will be savedQuery the collectionfrom irspdf import query
query(collection_path)collection_path : file where the collection is savedUpdate the collectionfrom irspdf import update
update(folder_path, collection_path)folder_path : path of the folder that contains all the pdf files to add to the collection.collection_path : file where the original collection is savedUseful linksDocumentation:https://irspdf.readthedocs.io/en/latest/.Source Code:https://github.com/Jibril-Frej/irspdfPackage:https://pypi.org/project/irspdf/
Package: ir-support
41013 Industrial Robotics SupportThis project is part of the subject 41013 Industrial Robotics at University of Technology Sydney (UTS), forRobotics Toolbox for Python®It is developed to provide equivalent support for the Python option of the subject, along with the Modified Robotics Toolbox in MATLAB.InstallationRequirement: Robotics Toolbox for Python$pip install rvc3pythonthen$pip install ir-supportCurrently, it works on Python 3.8 - 3.10Contactquang.ngohominh@gmail.com
Package: irt-data-utils
Infrared Thermal Data UtilsExamplesconvert ddt file to imagesimportirtdata.DDTFileasddtddt.convert_ddt_to_csv_png(ddt_path="data/test1.ddt",csv_path='outputs/test1.csv',png_path='outputs/test1.png',bmp_path='outputs/test1.bmp')Get temperature arrays from FLIR imagesimportirtdata.FLIRasflirflir_path='data/test2.jpg'flir.extract_temperature(flir_path,save_csv_path='outputs/test2.csv')temp_data=flir.get_heatmap('outputs/test2.csv',save_image_path='outputs/test2.jpg',show=True)Get Face Infoimportsrc.irtdata.face_detectionasfdlist_node=fd.get_face_info(optical_path,csv_path)print(list_node)Fetch temperature info from gray images with temperature infoimportsrc.irtdata.image_utilsasiutemp_image_path=r'data/FLIR_00004.jpeg'temps=iu.get_thermal_data_from_image(image_path=temp_image_path)print(temps)
Package: irtk
irtkirtkstands for Inverse-Rendering Toolkit. It is a simple framework for conducting inverse rendering experiments. Since there are a lot differentiable renderers in development, mastering them all and migrating between them can be a headache.irtkprovides a simple scene representation based onpytorchthat can be rendered byconnectorsthat connect to different differentiable renderers and get the graident of the scene parameters. Migrating between renderers is just a matter of changing the connector.Installationirtkdepends onpytorch. Since it is widely used and some projects might have specific requirements to it, we leave its installation to the user.After installingpytorch, you can installirtkviapip install irtk
Package: irtm
Information Retrieval & Text Mining ToolboxThis repository holds functions pivotal for IRTM processing. This repo. is staged for continuous development.Quick Install using 'pip/pip3' & GitHubpipinstallgit+https://github.com/KanishkNavale/IRTM-Toolbox.gitImport Modulefromirtm.toolboximport*Using FunctionsSoundex: A phonetic algorithm for indexing names by sound, as pronounced in English.print(soundex('Muller'))print(soundex('Mueller'))>>>'M466'>>>'M466'Tokenizer: Converts a sequence of characters into a sequence of tokens.print(tokenize('LINUX'))print(tokenize('Text Mining 2021'))>>>['linux']>>>['text','mining']Vectorize: Converts a string to token based weight tensor.vector=vectorize(['texts ([string]): a multiline or a single line string.','dict ([list], optional): list of tokens. Defaults to None.','enable_Idf (bool, optional): use IDF or not. Defaults to True.','normalize (str, optional): normalization of vector. Defaults to l2.','max_dim ([int], optional): dimension of vector. Defaults to None.','smooth (bool, optional): restricts value >0. Defaults to True.','weightedTf (bool, optional): Tf = 1+log(Tf). Defaults to True.','return_features (bool, optional): feature vector. Defaults to False.'])print(f'Vector Shape={vector.shape}')>>>VectorShape=(8,37)Predict Token Weights: Computes importance of a token based on classification optimization.dictionary=['vector','string','bool']vector=vectorize(['X ([np.array]): vectorized matrix columns arraged as per the dictionary.','y ([labels]): True classification labels.','epochs ([int]): Optimization epochs.','verbose (bool, optional): Enable verbose outputs. Defaults to False.','dict ([type], optional): list of tokens. Defaults to None.'],dict=dictionary)labels=np.random.randint(1,size=(vector.shape[0],1))weights=predict_weights(vector,labels,100,dict=dictionary)>>>Token-WeightsMappings:{'vector':0.22097790924850977,'string':0.39296369957440075,'bool':0.689853175081446}Page Rank: Computes page rank from a chain matrixchain_matrix=np.array([[0,0,1],[1,0,1],[0,1,0]])print(page_rank(chain_matrix))rank,TPM=page_rank(chain_matrix,return_TransMatrix=True)print(f'Page Rank:{rank}\nTransition Probablity Matrix:\n{TPM}')>>>[0.00470.9970.0767]>>>PageRank:[0.00470.9970.0767]TransitionProbablityMatrix:[[0.033333330.033333330.93333333][0.483333330.033333330.48333333][0.033333330.933333330.03333333]]
Package: irt-parameter-estimation
IRT Parameter Estimation routinesThis package implements parameter estimation for logistic Item Characteristic Curves (ICC) from Item Response Theory (IRT).Maximum likelihood estimation (MLE) fitting routines for the following logistic models are implemented:1PL - 1 parameter logistic (Rausch) modelb (difficulty)2PL - 2 parameter logistic modela (discrimination) and b (difficulty)3PL - 3 parameter logistic (Birnbaum) modela (discrimination), b (difficulty) and c (pseudo-guessing)In addition, fitting using the zeta/lamdba/c formulation is also implemented.
The difference here boils down to the logistic exponent.
The conversion is:a (θj- b) = ζ + λ θja * (theta_j - b) = zeta + lambda * theta_jThis seemingly insignificant change has drastic effects on the convergence
properties (especially in the 2PL case, but also the 3PL case).Many of the methods in this package are derived from work by
Frank B. Baker and Seock-Ho Kim:Item Response Theory: Parameter Estimation Techniqueshttp://www.crcpress.com/product/isbn/9780824758257The exception is the 3 parameter zeta/lambda/c implementation which to our
knowledge has not been derived or documented before.
For this reason, we include the mathematical derivations here:irt-zlc-formuation.pdfThe original BASIC code that work was derived from can be downloaded here:http://www.crcpress.com/downloads/DK2939/IRTPET.zipThe original python port of these hand-coded iterative schemes can be
found in the file baker_mle.py (imported as "baker").
These are mainly useful for comparative purposes (for instance, the 2PL
version matches 1-1 with the original routine's published values).The main routines in this package (zlc_mle.py and abc_mle.py)
use scipy.optimize.root instead for greater efficiency and accuracy.
zlc uses a hybrid (zeta, lambda, c) formulation which makes the 2PL
and 3PL systems converge much more much stably.
This version is the one imported at the top level.
This version also includes an "abc emulation" mode where zlc is still
used internally, but automatic conversion is used so that the function
takes a/b/c as arguments.abc (in abc_mle.py) uses the (a,b,c) formulation, which may also be
useful (try both for 3PL!).
If you want to really dig into this code, it is very informative to use
a side-by-side difference tool
(like Vimdiff, KDiff3, WinMerge, FileMerge, or Meld)
to compare abc_mle.py with zlc.mle.py.All common utilities are found in util.py.TutorialUpdated 2021To see a sample usage, check out theQuickTutorial notebook
Package: irun
IRUN: Indulgent Reiz User NotationA human-friendly query language (python-like DSL) for generatingReiz QLqueries.Examplewithopen(...)as$stream:tree=ast.parse($stream.read())The query above would match all of these potential cases (viaReiz):withopen('somefile.py')asfile_s:tree=ast.parse(file_s.read())withopen(some_path)asstream:tree=ast.parse(stream.read())withopen(pathlib_path/'file.py')ass_file:tree=ast.parse(s_file.read())and filter out the rest (stuff like this):withopen(pathlib_path/'file.py',encoding='x')asstream:tree=ast.parse(stream.read())withopen()asstream:tree=ast.parse(stream.read())withfoo(path)asstream:tree=ast.parse(stream.read())withopen(path)asstream:tree=ast.parse(other_stream.read())withopen(path)asstream:tree=ast.foo(stream.read())withopen(path)asstream:tree=bar.parse(stream.read())withopen(path)asstream:tree=bar.baz(stream.read())withopen(path)asxxx:tree=ast.parse(yyy.read())withopen(path)asxxx:zzz=ast.parse(xxx.read())
Package: irv
An ISMRMRD rawdata view and anaysis toolsThe module can run as a python modulepython-mirv.irv你好WIPWhyfor fun!TODOUpgrade to qml version in the future!Credit:1. https://ismrmrd.github.io/
2. https://github.com/ismrmrd/ismrmrd-python
3. https://github.com/ismrmrd/ismrmrdviewer
4. https://github.com/medlab/gadgetron-dataflow-monitor
5. https://github.com/ismrmrd/ismrmrd-python-toolsRef:1. https://doc.qt.io/qtforpython/tutorials/basictutorial/uifiles.html
Package: irv-autopkg-client
irv-autopkg-clientA client library for accessing the irv-autopkg API.The irv-autopkg service allows users to extract portions of global datasets pertaining to climate risk and resilience. This Python package is a client for communicating with the irv-autopkg API.InstallationInstall from PyPI with:pip install irv-autopkg-clientUsageCreate a client object to establish a sessionimport irv_autopkg_client
client = irv_autopkg_client.Client()For a list of available methods, try:help(client)Quick startIs the API responding?client.server_readiness()Which boundaries can we create extracts for?client.boundary_list()Which datasets are available?client.dataset_list()Get information on a specific dataset:client.dataset("wri_aqueduct.version_2")To submit an extract job:job_id = client.job_submit(
    country_iso,
    [
        "gri_osm.roads_and_rail_version_1",
        "wri_aqueduct.version_2"
    ]
)We can then check if the job is complete:client.job_complete(job_id)Get the boundary of a territory:boundary = client.boundary_geometry("bgd")Download some extracted data:client.extract_download(
    "bgd",
    "data",
    # there may be other datasets available, but only download the following
    dataset_filter=[
        "gri_osm.roads_and_rail_version_1",
        "wri_aqueduct.version_2"
    ],
    overwrite=True
)TestingTo run the bundled tests, try:python -m unittest
Package: irwin
IrwinPlotting data in the terminal.Project homepage:https://github.com/eerimoq/irwinInstallation$pipinstallirwinExamplesCommand lineThe plot subcommandRead all data from given file and plot it. Data points are separated
by any whitespace character.$ echo "0,2 1,1 2,0 3,-1 4,1 5,3 6,5 7,7" > data.txt
$ irwin plot data.txtGive-tscatterto create a scatter plot.$ python3 -c "import math, random, numpy ; \
      x = numpy.linspace(0, 3 * math.pi, 200) ; \
      y = [v + random.random() / 4 for v in numpy.cos(x)] ; \
      print(' '.join([f'{x},{y}' for x, y in zip(x, y)]))" > data.txt
$ irwin plot -t scatter data.txtAdd more samples by runningpython3-c"import random ;print(f'{random.random()},{random.random()}')periodically.$ irwin plot -t scatter \
      -c "python3 -c \"import random ; print(f'{random.random()},{random.random()}')\"" \
      data.txtThe watch subcommandRuncat /proc/uptime | awk '{ print \$1 }'periodically any plot
its output.$ irwin watch "cat /proc/uptime | awk '{ print \$1 }'"This is how to plot the CPU load on a machine with 4 CPUs.$ irwin watch -a delta -y 0 -Y 100 -s -0.25 -o 100 \
      "head -1 /proc/stat | awk '{ print \$5 }'"ScriptingUsing a canvasDraw on the canvas and render it. Print the rendered canvas.importirwincanvas=irwin.Canvas(width=40,height=20,x_min=0,x_max=10,y_min=0,y_max=10)# Draw the canvas edges.canvas.draw_line(0,0,0,10)canvas.draw_line(0,10,10,10)canvas.draw_line(10,10,10,0)canvas.draw_line(10,0,0,0)# Draw a cross.canvas.draw_line(0,0,10,10)canvas.draw_line(0,10,10,0)# Draw four points.canvas.draw_point(5,2.5)canvas.draw_point(5,7.5)canvas.draw_point(2.5,5)canvas.draw_point(7.5,5)print(canvas.render())The output:⡟⢍⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⡩⢻
⡇⠀⠑⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⢸
⡇⠀⠀⠀⠑⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⢸
⡇⠀⠀⠀⠀⠀⠑⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⢸
⡇⠀⠀⠀⠀⠀⠀⠀⠑⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⢸
⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠑⢄⠀⠀⠀⠀⠀⠀⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸
⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠑⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸
⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠑⢄⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸
⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠑⢄⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸
⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠑⢄⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸
⡇⠀⠀⠀⠀⠀⠀⠀⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠑⢄⠀⠀⠀⠀⠀⠀⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸
⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠑⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸
⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠑⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸
⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠑⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸
⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠑⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸
⡇⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠑⢄⠀⠀⠀⠀⠀⠀⠀⢸
⡇⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠑⢄⠀⠀⠀⠀⠀⢸
⡇⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠑⢄⠀⠀⠀⢸
⡇⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠑⢄⠀⢸
⣧⣊⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣑⣼Line plotNot yet implemented.importmathimportnumpyimportirwinx=numpy.linspace(0,2*math.pi)y=numpy.sin(x)print(irwin.plot(x,y))Scatter plotNot yet implemented.importmathimportrandomimportnumpyimportirwinx=numpy.linspace(0,2*math.pi)y=[v+random.random()/4forvinnumpy.cos(x)]print(irwin.scatter(x,y))
Package: isaac
isaacNewton - Accelerating NN Training with Input-based Approximate Curvature for Newton's MethodThis repository includes the official implementation of our ICLR 2023 Paper "ISAAC Newton: Input-based Approximate Curvature for Newton's Method".Paper @OpenReviewVideo @Youtube💻 Installationisaacis based on PyTorch and can be installed via pip from PyPI withpipinstallisaac👩‍💻 Usageisaac.Linearacts as a drop-in replacement fortorch.nn.Linear. It only requires additional specification of
the regularization parameter $\lambda_a$laas specified in the paper. A good starting point for $\lambda_a$
isla=1, but the optimal choice varies from experiment to experiment.
The method operates by efficiently modifying the gradient of the module in such a way that the input-based curvature
information is used when applying a gradient descent optimizer on the modified gradients.In the following, we specify an example MNIST neural network where ISAAC is applied to the first 3 out of 5 layers:importtorchimportisaacnet=torch.nn.Sequential(torch.nn.Flatten(),isaac.Linear(784,1_600,la=1),torch.nn.ReLU(),isaac.Linear(1_600,1_600,la=1),torch.nn.ReLU(),isaac.Linear(1_600,1_600,la=1),torch.nn.ReLU(),torch.nn.Linear(1_600,1_600),torch.nn.ReLU(),torch.nn.Linear(1_600,10))🧪 ExperimentsYou can find an example MNIST experiment inexamples/mnist.py, which is based on the experiment in Figure 5 in the paper.To run ISAAC applied to the firstXout of 5 layers, runpythonexamples/mnist.py-nil<X>To run the baseline, runpythonexamples/mnist.py-nil0The device can be specified, e.g., as--device cuda, the learning rate and $\lambda_a$ may be set via--lrand--la, respectively.📖 Citing@inproceedings{petersen2023isaac,title={ISAAC Newton: Input-based Approximate Curvature for Newton's Method},author={Petersen, Felix and Sutter, Tobias and Borgelt, Christian and Huh, Dongsung and Kuehne, Hilde and Sun, Yuekai and Deussen, Oliver},booktitle={International Conference on Learning Representations (ICLR)},year={2023}}Licenseisaacis released under the MIT license. SeeLICENSEfor additional details about it.
Package: isaacgym-stubs
Isaac Gym Python Stubs for Code CompletionCode completion for IsaacGym with one linepip install, even without IsaacGym itself.pip3installgit+https://github.com/yzqin/isaacgym-stubs.gitDepending on which IDE you are using, sometimes you may need to restart the IDE afterpip installfor re-indexing.The magic ofstubis that you evendo not need to pip install IsaacGym itselfto write the code.
For example, you may need to run IsaacGym on server for training but develop the code on your MacBook.
IsaacGym does not support Mac. But you can still install this repo and get smooth code completion to write IsaacGym
code on that MacBook!DemoVsCodePyCharmOverviewThis repository contains thepyistub for the IsaacGym library, which can be used for code completion and type
checking.
According to the guidelines outlined inPEP-561, Python stub files contain only
type information and no runtime code.
Thestubin this repo is generated based on IsaacGym version1.0rc4.
Package: isaac-lotr-sdk
Lord of the Rings Python SDKSDK Implementingthe-one-apiAPI to serve information on LOTR.Getting StartedSource code:https://github.com/cynepton/isaac-lotr-sdkRequirements:Python version 3.5 or laterAthe-one-api.devaccount access_token. (If you only wish to use the/bookendpoint you would not need this to use the API, but at the moment it is required by the SDK.)To use the module, first install with pip:pipinstallisaac-lotr-sdkIf you haven't already,create a the-one-api.dev accountand get an access token.The access token is private, so it is recommended that this is stored in the environment variables and not in version control.exportTHE_ONE_API_ACCESS_TOKEN=your_access_token_valueThe nameTHE_ONE_API_ACCESS_TOKENis arbitrary and this SDK does not impose any rules on what the environment value name should be.In your python script/application, import the API client and start making requests:# Import the API clientfromlotr_sdkimportLotrSDK# Import the python os module to get the environment variableimportos# Get the API access token from the environment variables.ACCESS_TOKEN=os.getenv("THE_ONE_API_ACCESS_TOKEN")# Initialize the API clientthe_one_api_client=LotrSDK(access_token=ACCESS_TOKEN)# Start making requestsall_movies=api_client.movie.getMovies()# Most endpoints allow for declaring multiple parameters and custom querieslow_budget_movies=api_client.movie.getMovies("budgetInMillions<100",limit=2)SDK Documentation