semvec/pypi-packages huggingface dataset:
linlearn 0.1
linlear is a python package for machine learning with linear methods, including robust methods
Requires Python: >=3.6,<4.0
Keywords: python,machine-learning,classification,regression,linear-methods,robust-methods


[![Build Status](https://travis-ci.com/linlearn/linlearn.svg?branch=master)](https://travis-ci.com/linlearn/linlearn)
[![Documentation Status](https://readthedocs.org/projects/linlearn/badge/?version=latest)](https://linlearn.readthedocs.io/en/latest/?badge=latest)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/linlearn)
![PyPI - Wheel](https://img.shields.io/pypi/wheel/linlearn)
[![GitHub stars](https://img.shields.io/github/stars/linlearn/linlearn)](https://github.com/linlearn/linlearn/stargazers)
[![GitHub issues](https://img.shields.io/github/issues/linlearn/linlearn)](https://github.com/linlearn/linlearn/issues)
[![GitHub license](https://img.shields.io/github/license/linlearn/linlearn)](https://github.com/linlearn/linlearn/blob/master/LICENSE)
[![Coverage Status](https://coveralls.io/repos/github/linlearn/linlearn/badge.svg?branch=master)](https://coveralls.io/github/linlearn/linlearn?branch=master)

![linlearn](img/linlearn.png)

# linlearn: linear methods in Python

LinLearn is scikit-learn compatible python package for machine learning with linear methods. 
It includes in particular alternative "strategies" for robust training, including median-of-means for classification and regression.

[Documentation](https://linlearn.readthedocs.io) | [Reproduce experiments](https://linlearn.readthedocs.io/en/latest/linlearn.html) |

LinLearn simply stands for linear learning. It is a small scikit-learn compatible python package for **linear learning** 
with Python. It provides :

- Several strategies, including empirical risk minimization (which is the standard approach), 
median-of-means for robust regression and classification
- Several loss functions easily accessible from a single class (`BinaryClassifier` for classification and `Regressor` for regression)
- Several penalization functions, including standard L1, ridge and elastic-net, but also total-variation, slope, weighted L1, among many others
- All algorithms can use early stopping strategies during training
- Supports dense and sparse format, and includes fast solvers for large sparse datasets (using state-of-the-art stochastic optimization algorithms) 
- It is accelerated thanks to numba, leading to a very concise, small, but very fast library
  
## Installation

The easiest way to install linlearn is using pip

    pip install linlearn

But you can also use the latest development from github directly with

    pip install git+https://github.com/linlearn/linlearn.git

## References
cell-models 0.0.1
This package contains cell models and the ability to apply various protocols to them.
Requires Python: >=3.6

# Cell Models Package

This package is meant to contain all Christini Lab models that are implemented in Python. As of writing this, there are 3 models: O'Hara Rudy, Paci, and Kernik.

### Using and Installing this Project

This Python project is written in [Python Packaging format](https://packaging.python.org/tutorials/packaging-projects/). If you want to play around with the models quickly, you can `cd` into `cell-models/` and edit the `main.py` file. 

If you want to install these models locally, you can run `python3 setup.py` from the project root. This will make the files in `cell-models/` globally available. 

### Tutorial

Much of the code below can be found in `cell-models/main.py`. 

#### Instantiate and generate a response from models

The following will plot spontaneous Kernik and Paci models and a paced O'Hara Rudy model.

```py
# Spontaneous / Stimulated
KERNIK_PROTOCOL = protocols.SpontaneousProtocol(2000)
kernik_baseline = KernikModel()
tr_b = kernik_baseline.generate_response(KERNIK_PROTOCOL)
plt.plot(tr_b.t, tr_b.y)
plt.show()

PACI_PROTOCOL = protocols.SpontaneousProtocol(2)
paci_baseline = PaciModel()
tr_bp = paci_baseline.generate_response(PACI_PROTOCOL)
plt.plot(tr_bp.t, tr_bp.y)
plt.show()

OHARA_RUDY = protocols.PacedProtocol(model_name="OR")
or_baseline = OharaRudyModel()
tr = or_baseline.generate_response(OHARA_RUDY)
plt.plot(tr.t, tr.y)
plt.show()
```

#### Update parameters for a model
The code below will plot the baseline Kernik model and an example model with new parameter values.

```py
KERNIK_PROTOCOL = protocols.SpontaneousProtocol(2000)
kernik_baseline = KernikModel()
kernik_updated = KernikModel(
        updated_parameters={'G_K1': 1.2, 'G_Kr': 0.8, 'G_Na':2.2})
tr_baseline = kernik_baseline.generate_response(KERNIK_PROTOCOL)
tr_updated =  kernik_updated.generate_response(KERNIK_PROTOCOL)
plt.plot(tr_baseline.t, tr_baseline.y, label="Baseline")
plt.plot(tr_updated.t, tr_updated.y, label="Updated")
plt.legend()
plt.show()
```
PwdStore 20.11.18
A Package to store your Usernames, Password of a site in an encrypted file.
Requires Python: >=3.5
Keywords: AES Crypt encrypt decrypt password

# PwdStore

PwdStoreis a Python 3 file-encryption module and script that uses AES256-CBC to encrypt/decrypt your Username and Passwords.

PwdStore is compatible with the AES Crypt file format (version 2).

It is Free Software, released under MIT License

PwdStore is brought to you by Garvit Joshi - garvitjohi9@gmail.com

IMPORTANT SECURITY NOTE: version 2 of the AES Crypt file format does not authenticate the "file size modulo 16" byte. This implies that an attacker with write access to the encrypted file may alter the corresponding plaintext file size by up to 15 bytes.

NOTE: there is no low-level memory management in Python, hence it is not possible to wipe memory areas were sensitive information was stored.

## Module usage example:

### Encrypt Data:

#### If you want to store data in Data.txt.aes
```
import PwdStore
n=int(input("Enter the No. of Credentials you want to Save:"))
mPassword=input("Enter A Password You want to create for the file:")
PwdStore.fileEncrypt(mPassword,n)
```

#### If you want to store data in your own file:
Add a third Argument in  ```PwdStore.fileEncrypt()``` with the name of file you want to stre data in:
```
import PwdStore
n=int(input("Enter the No. of Credentials you want to Save:"))
mPassword=input("Enter A Password You want to create for the file:")
PwdStore.fileEncrypt(mPassword,n,"Hello.txt.aes")
```
**Please Enter Suffix ```.txt.aes``` at the end of file**

### Decrypt Data:

#### if you want to retrieve data from Data.txt.aes
```
import PwdStore
mPassword=input("Please Enter Your master Password:")
PwdStore.fileDecrypt(mPassword)
```

#### If you want to retrieve data from your own file
```
import PwdStore
mPassword=input("Please Enter Your master Password:")
PwdStore.fileDecrypt(mPassword,"Hello.txt.aes")
```

**Please Enter Suffix ```.txt.aes``` at the end of file**

#### Notes:
1. Buffer Size=64 * 1024
2. Data will be written in ```Data.txt.aes``` by default, may change name of file in later builds.