semvec/pypi-packages huggingface dataset:
adaptkeybert 0.0.2
AdaptKeyBERT extended keyphrase extraction with zero-shot and few-shot semi-supervised domain adaptation.
Requires Python: >=3.6
Keywords: nlp bert keyword extraction embeddings zeroshot fewshot semisupervised

<img src="https://github.com/AmanPriyanshu/AdaptKeyBERT/blob/master/images/keybert_logo.png" width="35%" height="35%" align="right" />

# AdaptKeyBERT

KeyBERT is a minimal and easy-to-use keyword extraction technique that leverages BERT embeddings to create keywords and keyphrases that are most similar to a document.

AdaptKeyBERT expands the aforementioned library by integrating semi-supervised attention for creating a few-shot domain adaptation technique for keyphrase extraction. Also extended the work by allowing zero-shot word seeding, allowing better performance on topic relevant documents

## Basic Use:

Take a look at `runner.py`

```py
from adaptkeybert import KeyBERT

doc = """
         Supervised learning is the machine learning task of learning a function that
         maps an input to an output based on example input-output pairs. It infers a
         function from labeled training data consisting of a set of training examples.
         In supervised learning, each example is a pair consisting of an input object
         (typically a vector) and a desired output value (also called the supervisory signal).
         A supervised learning algorithm analyzes the training data and produces an inferred function,
         which can be used for mapping new examples. An optimal scenario will allow for the
         algorithm to correctly determine the class labels for unseen instances. This requires
         the learning algorithm to generalize from the training data to unseen situations in a
         'reasonable' way (see inductive bias). But then what about supervision and unsupervision, what happens to unsupervised learning.
      """
kw_model = KeyBERT()
keywords = kw_model.extract_keywords(doc, top_n=10)
print(keywords)


kw_model = KeyBERT(domain_adapt=True)
kw_model.pre_train([doc], [['supervised', 'unsupervised']], lr=1e-3)
keywords = kw_model.extract_keywords(doc, top_n=10)
print(keywords)


kw_model = KeyBERT(zero_adapt=True)
kw_model.zeroshot_pre_train(['supervised', 'unsupervised'], adaptive_thr=0.15)
keywords = kw_model.extract_keywords(doc, top_n=10)
print(keywords)


kw_model = KeyBERT(domain_adapt=True, zero_adapt=True)
kw_model.pre_train([doc], [['supervised', 'unsupervised']], lr=1e-3)
kw_model.zeroshot_pre_train(['supervised', 'unsupervised'], adaptive_thr=0.15)
keywords = kw_model.extract_keywords(doc, top_n=10)
print(keywords)

```
windoz 0.0.8
Logic Controlling tool
Requires Python: >=3.7

# Windoz

## Example code

+ -: don't execute, just take the first argument as residual
+ r: repeat next time
+ j: jump in line
+ s: spawn


Frame controlling
``` python
from windoz.World import World
from windoz.windowsetting import *

print(get_fps(100))
data = World(30)
data.add_event(('r', print_average, [data]))
data.add_event(('s', spawn_timer,[], []))
data.run()
```
Nanoindentation 0.9.0
Investigation of nanoindentation data
Requires Python: >=3.7

# Main branch for Experimental Micromechanics
In source_code folder:
- nanoIndent.py for investigation of nanoindentation data

# Documentation
The documentation is at [Read the docs](https://micromechanics.readthedocs.io/en/main/)

# Contributors
- Steffen Brinckmann
- Velislava Yonkova
- Ruomeng (Nicole) Chen
gwmemory 1.1.0
Calculate the gravitational-wave memory for arbitrary time series
Requires Python: >=3.8

[![PyPI version](https://badge.fury.io/py/gwmemory.svg)](https://badge.fury.io/py/gwmemory)
[![Conda Version](https://img.shields.io/conda/vn/conda-forge/gwmemory.svg)](https://anaconda.org/conda-forge/gwmemory)
[![codecov](https://codecov.io/github/ColmTalbot/gwmemory/branch/master/graph/badge.svg?token=QAASCHZ7QI)](https://codecov.io/github/ColmTalbot/gwmemory)

# `GWMemory`

`GWMemory` calculates the nonlinear (Christodoulou) gravitational-wave memory waveform from arbitrary time-domain gravitational-waveforms.

## Installation

`GWMemory` is available via `conda-forge` and `pypi`

```console
$ conda install -c conda-forge gwmemory
$ python -m pip install gwmemory
```

You can also install from this repository in the usual way:

```console
$ git clone https://github.com/ColmTalbot/gwmemory.git
$ cd gwmemory
$ python -m pip install .
```

Note that it is no longer to install using
```bash
$ python setup.py install
```
The `pip` version is more stable.

**TODO: make pip/conda installable**

## Examples

Demonstrations of how to calculate memory waveforms can be found in the examples directory.

## Supported waveforms

- [NRSur7dq2](https://zenodo.org/record/1215824#.WzcMDuiFPEY) (Blackman _et al._ (2017), [Phys. Rev. D 96, 024058](https://journals.aps.org/prd/abstract/10.1103/PhysRevD.96.024058))
- Aligned spin waveforms in [`lalsimulation`](http://git.ligo.org/lscsoft/lalsuite), e.g., `IMRPhenomD` ( Khan _et al._ (2016), [Phys. Rev. D 93, 044007](https://journals.aps.org/prd/abstract/10.1103/PhysRevD.93.044007), `SEOBNRv4` (Bohe _et al._ (2017), [Phys. Rev. D 95, 044028](https://journals.aps.org/prd/abstract/10.1103/PhysRevD.95.044028)).
- Minimal waveform model (Favata (2010), [CQG, 27, 8](http://iopscience.iop.org/article/10.1088/0264-9381/27/8/084036/meta))
- Any surrogate model available in `gwsurrogate`

To use these waveform models, you may need to install extra packages, this should be described if the packages aren't available.

Additionally users can supply any waveform decomposed onto the basis of spin-2 weighted spherical harmonics.

There is basic support for loading numerical relativity waveforms, based on the format of the simulating extreme spacetimes [waveform catalog](https://www.black-holes.org/for-researchers/waveform-catalog).
binary4fun 0.2.1
binary4fun is a small game, which tries to guess a number between 1 and 100 by binary search.
Requires Python: >=3
Keywords: game,binary search

# binary4fun

binary4fun is a small game written in Python that can be played in the cli. The game basically tries to guess a number between 1 and 100 by binary search.

## Installation
### pip

You can install binary4fun from PyPI using pip:
```
$ pip install binary4fun
```

## Usage

To start the game, just run `binary4fun` in the command line:
```
$ binary4fun
```

## Release History

* 0.2.0: Allow running the game directly from the command line, switch to setuptools_scm for versioning
* 0.1.0: First release

The package on PyPI: https://pypi.org/project/binary4fun

Distributed under the MIT license. See ``LICENSE`` for more information.
helloworldfromodou 0.0.1
Say Hello world

## Hello World

This is an example project demonstrating how to piblish public module to PyPI.

## Installation

Run the following to install:

```python
pip install helloworldfromodou
```

## Usage 

``` python
from helloworldfromodou import say_hello

# Generate "Hello, world!"
say_hello()

# Generate "Hello, Everybody!
say_hello("Everybody")
```

# Developing Hello World fromodou

To install helloworldfromodou, along with the tools you need to develop and run tests, run the following in your virtualenv:

```bash
$ pip install -e ".[dev]"
```