semvec/pypi-packages huggingface dataset:
vokab 0.0.2
vokab: named entity linking through hybrid (lexical and semantic) search engine.
Requires Python: >=3.9

# vokab

vokab is a python module for storing, searching and matching named entities on their name or aliases. This 
project is useful for auto-correcting or linking named entities in NLP information extraction use cases or 
when cleaning up user submitted data.

Supports:
- Exact Matching
- Case-insensitive Matching
- Lexical Matching (i.e. Fuzzy String Matching)
- Semantic Matching (i.e. Vector Similarity Searching)
- Hybrid (Lexical/Fuzzy + Semantic/Vector)


## Getting Started


## Installation

Available on [PyPI](https://pypi.org/project/vokab/):

```bash
pip install vokab
```


## Maintainer

vokab was created by [Ian Maurer](https://x.com/imaurer), the CTO of [GenomOncology](https://genomoncology.com).

This MIT-based open-source project was extracted from our product which includes the ability to normalize biomedical
data for use in precision oncology clinical decision support systems. Contact me to learn more about our product
offerings.
vot-trax 4.0.2
TraX protocol reference implementation wrapper for Python

`Visual Tracking eXchange protocol <http://prints.vicos.si/publications/311/>`_ is a simple protocol that enables easier evaluation of computer vision tracking algorithms. The basic idea is that a tracker communicates with the evaluation software using a set of text commands over the (standard) input/output streams or TCP sockets. 

This package contains a Python wrapper to C library (using CTypes) available in the `support/python` directory. More information and source code available at `Github <https://github.com/votchallenge/trax/>`_.
mcpi2 0.0.2
Special tools for Minecraft
Requires Python: >=3.9

# Special Tools for Minecraft

This repository contains source code with the implementation of the special tools for Minecraft, which are built on the top of mcpi

A package with the corresponding model can be downloaded from pypi: \
pip install mcpi2

Source code: https://github.com/GitHub-User228/mcpi2

An example usage of some tools is presented in [example.py](https://github.com/GitHub-User228/mcpi2/blob/master/src/example.py)
ArrowTextClassifier 1.0.3
ArrowTextClassifier is a simple text classification tool written in pytorch that allows you to train, summarize, and use text classification models for various tasks.
Requires Python: >=3.6
Keywords: text classification, natural language processing, NLP, PyTorch, machine learning, deep learning, text summarization, preprocessing, data science, artificial intelligence, dataset, discord

# ArrowTextClassifier

ArrowTextClassifier is a Python package for text classification tasks, offering functionalities to train, summarize, and classify text using convolutional neural network (CNN) architecture.

## Installation

You can install ArrowTextClassifier via pip:

```bash
pip install ArrowTextClassifier
```

## How it Works

ArrowTextClassifier implements a convolutional neural network (CNN) architecture for text classification. It tokenizes input text, embeds the tokens, applies convolutional filters over the embedded tokens to extract features, and then classifies the text into predefined categories.

## Usage

### Training

To train a text classification model, you can utilize the `train_model` method provided by the `Model` class:

```python
from ArrowTextClassifier import Model

model = Model(name="your_model_name")
model.train_model(dataset)
```

#### How to make a dataset

To make your own custom dataset for training you need to create a parquet file with the following format:

*Example Parquet File*

```json
{"label":"normal","example":"Hey there!"}
{"label":"normal","example":"Hi!"}
{"label":"toxic","example":"You suck!"}
```

After you have created the parquet file with the data in the format above, you can provide to the dataset to start training the model.

### Summarization

To summarize a trained model, you can use the `summarize` method:

```python
model.summarize(
    model_path="path_to_your_model",
    hyperparams_path="path_to_hyperparameters_file",
    vocabulary_path="path_to_vocabulary_file",
    modelSummary_write_path="path_to_write_model_summary"
)
```

### Classification

For classifying text using the trained model:

```python
result = model.classify(
    model_path="path_to_your_model",
    hyperparams_path="path_to_hyperparameters_file",
    text="your_input_text",
    vocabulary_path="path_to_vocabulary_file"
)
print(result)
```

## Getting Started

This package provides tools for text classification tasks. You can explore and customize it according to your requirements. Refer to the documentation for detailed usage instructions. We have also made our own colab [notebook](https://colab.research.google.com/drive/1fGDLICkctfdpTgLoh_Bouv-NY-q-kdlQ?usp=sharing) to help you train a custom offensive language classifier using this.

## License

This project is licensed under the MIT License - see the LICENSE file for details.

---

## Contact

For any questions or feedback, please contact technologypower24@gmail.com or you can contact me at discord - techpowerb.
panns-AT-inference 0.1.4
panns_AT_inference: audio tagging inference toolbox
Requires Python: >=3.6

# PANNs AT (Audio Tagging) inference

**panns_AT_inference** provides an easy to use Python interface for audio tagging. The audio tagging models are trained from PANNs: Large-Scale Pretrained Audio Neural Networks for Audio Pattern Recognition: https://github.com/qiuqiangkong/audioset_tagging_cnn

This is a forked repository/project w. the Top-3 models (see References)

## Installation
PyTorch>=1.0 is required.
```
$ pip install panns_AT_inference
```

## Usage
```
$ python3 example.py
```

For example:

```
import librosa
import panns_AT_inference
from panns_AT_inference import AudioTagging, labels

audio_path = 'examples/R9_ZSCveAHg_7s.wav'
(audio, _) = librosa.core.load(audio_path, sr=32000, mono=True)
audio = audio[None, :]  # (batch_size, segment_samples)

print('------ Audio tagging ------')
at = AudioTagging(model_name=None, device='cuda')
(clipwise_output, embedding) = at.inference(audio)
```


## Results
<pre>
------ Audio tagging ------
Checkpoint path: /root/panns_data/Cnn14_mAP=0.431.pth
GPU number: 1
Speech: 0.893
Telephone bell ringing: 0.754
Inside, small room: 0.235
Telephone: 0.183
Music: 0.092
Ringtone: 0.047
Inside, large room or hall: 0.028
Alarm: 0.014
Animal: 0.009
Vehicle: 0.008
</pre>

## References
[1] Kong, Qiuqiang, Yin Cao, Turab Iqbal, Yuxuan Wang, Wenwu Wang, and Mark D. Plumbley. "PANNs: Large-Scale Pretrained Audio Neural Networks for Audio Pattern Recognition." arXiv preprint arXiv:1912.10211 (2019).

[2] 
```
@article{9229505,
  author={Kong, Qiuqiang and Cao, Yin and Iqbal, Turab and Wang, Yuxuan and Wang, Wenwu and Plumbley, Mark D.},
  journal={IEEE/ACM Transactions on Audio, Speech, and Language Processing}, 
  title={PANNs: Large-Scale Pretrained Audio Neural Networks for Audio Pattern Recognition}, 
  year={2020},
  volume={28},
  number={},
  pages={2880 -- 2894},
  doi={10.1109/TASLP.2020.3030497}
  }
```

[3] Official GitHub repository: https://github.com/qiuqiangkong/audioset_tagging_cnn , https://github.com/qiuqiangkong/panns_inference