semvec/pypi-packages huggingface dataset:
sailenv 0.5b0
Python API for interfacing with SAILenv
Requires Python: >=3.6

# SAILenv Client - SAILab Virtual Environment 

SAILenv is a Virtual Environment powered by Unity3D, developed by SAILab in Siena. This repository contains a Python client for SAILenv.

Have a look at the project page - [SAILenv](https://sailab.diism.unisi.it/sailenv/) for more details.

[Technical report here](https://arxiv.org/abs/2007.08224) -  accepted at ICPR2020. 


## Agent API

SAILenv is accessible through an instance of the Agent class, which acts as the API between Python scripts and the environment. The API is designed to be as easy as possible to integrate with most known computer vision frameworks.

Through the API, a Python script can access many views of the environment with configurable resolution scaling (aspect ratio is fixed, at the moment):

* Realistic rendering of the environment
* Pixel-wise segmentation at category level
* Pixel-wise segmentation at instance level
* Pixel-wise depth
* Pixel-wise optical flow

A script can also:
* Obtain the list of object categories available in the scene
* Obtain the list of available scenes
* Transfer the Agent in one of the available scenes
* Manually set the Agent position and orientation
* Enable automatic movement through a predetermined track inside the scene

### Optical Flow
The optical flow is obtained directly from the Unity Physics Engine, meaning that it is both highly accurate while still achieving greats speed.  

### Agent and Environment communication
The Agent and the Environment communicate through low-level sockets, allowing highly performant exchange of information. 

### Cite
    @article{meloni2020sailenv,
      title={SAILenv: Learning in Virtual Visual Environments Made Simple},
      author={Meloni, Enrico and Pasqualini, Luca and Tiezzi, Matteo and Gori, Marco and Melacci, Stefano},
      journal={arXiv preprint arXiv:2007.08224},
      year={2020}
    }



## Download
[![PyPI version](https://badge.fury.io/py/sailenv.svg)](https://badge.fury.io/py/sailenv)
effmap 0.0.15
Custom regressor and HST object
Requires Python: >=3.6

# Effmap

Effmap is the python library, which introduces two classes: hydro-static transmission (HST) and regression models (Regressor). The former serves to initialize an HST object for a certain displacement, oil and an engine. Included methods allow to size, to calculate efficiencies as well as performance characteristics for a given operational regime and to create, print and save an efficiency map - a contour or a surface plot for ranges of speeds and torques required. 

The latter class loads the collected catalogue data of displacements, speeds and masses of axial-piston machines from the data.csv file. Then it fits regression models to the data in order to provide inter- and extrapolating predictions. The data and the regression models could then be printed and saved.

## Installation
```
pip install effmap
```

## Usage
```
from effmap.hst import HST
from effmap.regressor import Regressor

hst = HST(displ)
hst.compute_sizes()
hst.compute_speed_limit(models['pump_speed'])
hst.load_oil()
hst.plot_oil()
hst.compute_eff(input_speed, pressure_discharge)
hst.compute_loads(pressure_discharge)
hst.plot_eff_maps(max_speed, max_pressure)
```

## Web app
https://effmap.herokuapp.com/

Code for the web app: https://github.com/ivanokhotnikov/effmap_demo
pyjob-jdockerty 0.1.2
Job searching through code, interaction to the Reed API.

# PyJob

PyJob is an abstraction around the [Reed](https://reed.co.uk) API for job searching.

After providing an API key you can interact with the API for finding jobs that have been posted to Reed, either by companies or agencies, as well as the various other functionality that they provide.

You can:
* **Search** for jobs
* Find **details** of particular jobs using their IDs, this is used to grab an *extended* description of the job.

## Installation

    pip install pyjob-jdockerty

You will also need to register for a [Reed API](https://www.reed.co.uk/developers/jobseeker) key and export this, e.g.

    export REED_API_KEY=<your_key>

## CLI Usage

A simple search can be conducted using the command

    pyjob search --term "software engineer" --max-results 3

This displays results for jobs which match the term `software engineer` according to Reed's API, displaying the first 3 results to you.

To view available flags, use the `--help` flag

    pyjob search --help

This provides a greater list of options to pass into the CLI.

## TODO

* ~~Finish **Search** class for API interaction.~~
* Add CI pipeline.
* Add custom exceptions for raising errors, currently just exiting on error and printing a log message with `sys.exit`. Instead will raise exception and move the current logging message to the raised exception.
* ~~Build out a **Detail** class for finding more information around a job with the ID. [Response is similar, just with extended description, using this for now.~~
* ~~Create CLI wrapper for this API for job searches on the command line.~~
pytorch-grad-cam 1.0.0
Grad-CAM visualization tool for PyTorch models.
Requires Python: >=3.6

## Grad-CAM implementation in Pytorch ##

### What makes the network think the image label is 'pug, pug-dog' and 'tabby, tabby cat':
![Dog](https://github.com/jacobgil/pytorch-grad-cam/blob/master/examples/dog.jpg?raw=true) ![Cat](https://github.com/jacobgil/pytorch-grad-cam/blob/master/examples/cat.jpg?raw=true)

### Combining Grad-CAM with Guided Backpropagation for the 'pug, pug-dog' class:
![Combined](https://github.com/jacobgil/pytorch-grad-cam/blob/master/examples/cam_gb_dog.jpg?raw=true)

Gradient class activation maps are a visualization technique for deep learning networks.

See the paper: https://arxiv.org/pdf/1610.02391v1.pdf

The paper authors' torch implementation: https://github.com/ramprs/grad-cam

My Keras implementation: https://github.com/jacobgil/keras-grad-cam


----------


This uses Resnet50 from torchvision. It will be downloaded when used for the first time.
The code can be modified to work with any model.

----------


Usage: `python gradcam.py --image-path <path_to_image>`

To use with CUDA:
`python gradcam.py --image-path <path_to_image> --use-cuda`