semvec/pypi-packages huggingface dataset:
biobert-pytorch 0.9
Ready to use BioBert pytorch weights for HuggingFace pytorch BertModel.

# Biobertology

Ready to use [BioBert](https://arxiv.org/abs/1901.08746) pytorch weights for [HuggingFace](https://github.com/huggingface/transformers)
pytorch [BertModel](https://arxiv.org/abs/1810.04805).

To load the model:

```
from biobertology import get_biobert, get_tokenizer

biobert = get_biobert(model_dir=None, download=True)
tokenizer = get_tokenizer()
```

Example of fine tuning biobert [here](https://github.com/MeRajat/SolvingAlmostAnythingWithBert/tree/master/biobert_ner).

## How was it converted to pytorch?

Model weights have been downloaded from [here](https://github.com/naver/biobert-pretrained/releases/tag/v1.1-pubmed) and converted

by following the commands described [here](https://github.com/huggingface/transformers/issues/457#issuecomment-518403170).pytorch

Specifically, using the command:

```
pytorch_transformers bert biobert_v1.1_pubmed/model.ckpt-1000000 biobert_v1.1_pubmed/bert_config.json biobert_v1.1_pubmed/pytorch_model.bin
```

followed by the renaming of the config file:

```
mv biobert_v1.1_pubmed/bert_config.json biobert_v1.1_pubmed/config.json
```

all of the other files inside the original weights file have been deleted.
zd 0.0.4
file like object for zstandard

# read

```
import zd

with zd.open(
  "./test.zd"
) as f:
  for i in f:
    print(i)
```

# write

```
import zd


# argsument level is optional, default is 10
with zd.open( "./test.zd", "w", level=10) as f:
  for i in range(10):
    f.write(i)
```
PyLinearSolver 0.1.4
A python interface package for many well known linear solvers libraries in many languages, Julia, C++, etc...

.. image:: https://readthedocs.org/projects/pylinearsolver/badge/?version=latest
    :target: https://pylinearsolver.readthedocs.io/en/latest/?badge=latest
    :alt: Documentation Status

.. image:: https://github.com/AhmedMagdyHendawy/PyLinearSolver/workflows/Upload%20Python%20Package/badge.svg
    :target: https://pypi.org/project/PyLinearSolver/
    :alt: PyPI Package

About the Package
=================

PyLinearSolver is a python iterface for many well-known linear solvers packages written in different languages like C, C++, julia, etc...
The package uses the existing implementation from the original source and build a wrapper layer for a python development. 

**NOTE** All rights are preserved to the authers and developers of the original packages.


Installation
============

Dependencies
------------

To work with PyLinearSolver packages, you need to install the dependencies for them.

**Iterative Solvers**

    * Install `Julia <https://julialang.org/downloads/>`_


PyLinearSolver
--------------

Simply you need to call this command::

    pip install PyLinearSolver

**NOTE** In case of working with Iterative Solvers, you need to install the dependencies for PyJulia through the following::

    import julia
    julia.install()


Examples
========

Iterative Solvers
-----------------

An example for Iterative Solver Wrapper package in PyLinearSolver::

    from PyLinearSolver import IterativeSolvers
    import numpy as np

    n=10
    A = np.random.rand(n,n)
    b= np.random.rand(n)
    x= np.zeros(n)
    A = A + A.T +2*n*np.identity(n)

    x, ch=IterativeSolvers.cg(A,b,verbose=True, log=True)
more-kedro 0.2.0
A collection of utilities and extensions for Kedro
Requires Python: >=3.6

# more-kedro :hammer_and_wrench:

A collection of utilities and extensions for [Kedro](https://github.com/quantumblacklabs/kedro)

## Installation

    $ pip install more-kedro

## [hooks.TypedParameters](more_kedro/hooks.py)
Enables on the fly typing and validation of your parameter dictionaries.

#### Usage
Activate by adding the `TypedParameters` hook to your `KedroContext`:
```python
from more_kedro.hooks import TypedParameters

class ProjectContext(KedroContext):
    hooks = (
        TypedParameters(),
    )

    ...
```
Now you can specify types in your `parameters.yml`:
```yaml
training__type: my_project.nodes.model.TrainingParams
training:
  num_iter: 100
  learning_rate: 0.001
```
or if you pass `TypedParameters(inline=True)`:
```yaml
training:
  type: my_project.nodes.model.TrainingParams
  num_iter: 100
  learning_rate: 0.001
```
The benefit of the first approach is that you can overwrite your parameter values in `conf/local/`
without having to respecify the types.

Any node which has an input `params:training` will now be injected with the
equivalent of `TrainingParams(num_iter=100, learning_rate=0.001)` instead of a raw
dictionary. You can use any custom class, dataclass,
[pydantic](https://github.com/samuelcolvin/pydantic) model or any other
callable to get validation and typing of your parameters. The type must contain
the full location and name of your type object, so that it can be imported
from the root of your project.

The parameters are typed right after your `DataCatalog` is created, so any failures
will surface before your kedro run starts.

## [datasets.TryLoadDataSet](more_kedro/datasets.py)

A dataset which uses an underlying dataset definition to load and save, but if the load method
throws an exception it returns a default value instead. Can be used if the existence of some
data is optional to the pipeline.

### Usage
`TryLoadDataSet` takes two arguments, `dataset` which is a normal dataset definition,
and an optional `default_value` which is the value to return if the load fails
(defaults to `None`). Example of an entry in `catalog.yml`:

```yaml
companies:
  dataset:
    type: pandas.CSVDataSet
    filepath: "path/to/companies.csv"
  default_value: null
```

## Contributions
If you have any useful Kedro utilities such as runners, hooks, datasets or whatever it may be - PR's are very welcome!
inventorize-py 0.0.1
inventory analytics,revenue management and cost calculations for SKUs
Requires Python: >=3.6
Keywords: inventory,pricing

Package: inventorize_py
Title: Inventory Analytics and Cost Calculations
Version: 0.0.1
Authors person("Haytham", "Omar", email = "haytham@rescaleanalytics.com", role = c("aut", "cre"))
Description: Simulate inventory policies, facilitate inventory analysis calculations such as  stock levels and re-order points,pricing and promotions calculations. 
  The package includes calculations of inventory metrics, stock-out calculations and ABC analysis calculations.
    The package includes revenue management techniques such as Multi-product optimization,logit model optimization.
  The functions are referenced from :
  1-Harris, Ford W. (1913). "How many parts to make at once". Factory, The Magazine of Management. <isbn10: 135–136, 152>.
  2- Nahmias, S. Production and Operations Analysis. McGraw-Hill International Edition. <isbn: 0-07- 2231265-3. Chapter 4>.
  3-Silver, E.A., Pyke, D.F., Peterson, R. Inventory Management and Production Planning and Scheduling. <isbn: 978-0471119470>. 
  4-Ballou, R.H. Business Logistics Management. <isbn: 978-0130661845>. Chapter 9.
  5-MIT Micromasters Program.
  6- Columbia University  course for supply and demand analysis.
  8- Price Elasticity of Demand MATH 104,Mark Mac Lean (with assistance from Patrick Chan) 2011W
  For further details or correspondence :<www.linkedin.com/in/haythamomar>, <www.rescaleanalytics.com>.

Change Log
==========

0.0.1 (3/08/2020)
-------------------
- fourth Release