semvec/pypi-packages huggingface dataset:
databits 2.0.5
Text Classifier using LSTM, GRU, and Transformer BERT

Text Classifier using LSTM, GRU, and Transformer BERT

# Install Package
```python
!pip install databits
```

# Data preparation
Prepare the data X_train, y_train and X_test, y_test in list form. \
X_train -> list (text) \
X_test -> list (text) \
y_train -> lits label (integer starts from 1) \
y_test -> lits label (integer starts from 1) 

# Define Hyperparameters
```python
import torch
import torch.nn as nn
import numpy as np
from databits import CreateModel
from sklearn.metrics import confusion_matrix, precision_score, recall_score, f1_score, accuracy_score

BATCH_SIZE = 32
SEQUENCE_LENGTH = 100
EPOCHS = 5
EMBED_DIM = 512
N_LAYERS = 2
DROPOUT_RATE = 0.1
NUM_CLASSES = len(np.unique(np.array(y_train)))
OPTIMIZER = torch.optim.Adam
LR = 0.001
LOSS = nn.CrossEntropyLoss
```

# Define Model
```python
model = CreateModel(X_train, y_train,
                 X_test, y_test,
                 batch=BATCH_SIZE,
                 seq=SEQUENCE_LENGTH,
                 embedding_dim=EMBED_DIM,
                 n_layers=N_LAYERS,
                 dropout_rate=DROPOUT_RATE,
                 num_classes=NUM_CLASSES)
```
# Train Model
```python
model.LSTM() # lstm model
model.GRU() # gru model
model.TRANSFORMER() # tranformer model
model.BERT() # bert model
model.FASTTEXT() # fasttext model
```
example, use gru model:
```python
model.GRU()
history = model.fit(epochs=EPOCHS, optimizer=OPTIMIZER, lr=LR, loss=LOSS)
```
example, use bert model:
```python
model.BERT()
history = model.fit(epochs=EPOCHS, optimizer=OPTIMIZER, lr=LR, loss=LOSS)
```

# Get y_true and predict label
```python
y_true, y_pred = model.eval() # no argumen needed
```

# Compute Accuracy, Precisiom, Recall, F1, and Cofusion Matrix
```python
from sklearn.metrics import confusion_matrix, precision_score, recall_score, f1_score, accuracy_score

precision = precision_score(y_true, y_pred, average='macro')
recall = recall_score(y_true, y_pred, average='macro')
f1 = f1_score(y_true, y_pred, average='macro')
accuracy = accuracy_score(y_true, y_pred)

print(f"Precision: {precision:.4f}")
print(f"Recall: {recall:.4f}")
print(f"F1 Score: {f1:.4f}")
print(f"Akurasi: {accuracy:.4f}")

cm = confusion_matrix(y_true, y_pred)
print(cm)
```

# Inference
```python
text = "this is text"
pred = model.predict(text) # or
pred = model(text)
print(pred) # text label in int format
```
nakedSiteList-package 0.1.0
A package with functions for determining towers with no active or planned tenants, called 'Naked Sites'. Naked Sites should be prioritized in leasing out or decommissioning.
Requires Python: >=3.7

# Naked Site List Package

A package with functions for determining towers with no active or planned tenants, called "Naked Sites". Naked Sites should be prioritized in leasing out or decommissioning. 

## Installation

```bash

pip install nakedSiteList_package
ebcc 1.6.1
Coupled cluster calculations on electron-boson systems
Requires Python: >=3.9
Keywords: quantum, chemistry, electronic, structure, coupled, cluster, electron, boson, ccsd

# ebcc: Coupled cluster calculations on electron-boson systems

[![CI](https://github.com/BoothGroup/ebcc/workflows/CI/badge.svg)](https://github.com/BoothGroup/ebcc/actions?query=workflow%3ACI+branch%3Amaster)
[![codecov](https://codecov.io/gh/BoothGroup/ebcc/branch/master/graph/badge.svg?token=QZQZQ2ZQ2Z)](https://codecov.io/gh/BoothGroup/ebcc)
[![PyPI version](https://badge.fury.io/py/ebcc.svg)](https://badge.fury.io/py/ebcc)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

The `ebcc` package implements various coupled cluster (CC) models for both purely electronic and coupled electron-boson models, with a focus on generality and model extensibility.

For a summary of the implemented models, see the [FEATURES.md](FEATURES.md) file.

### Installation

From PyPI:

```bash
pip install ebcc
```

From source:

```bash
git clone https://github.com/BoothGroup/ebcc
pip install .
```

### Usage

The implemented models are built upon the mean-field objects of [`pyscf`](https://github.com/pyscf/pyscf):

```python
from pyscf import gto, scf
from ebcc import EBCC
mol = gto.M(atom="H 0 0 0; H 0 0 1", basis="cc-pvdz")
mf = scf.RHF(mol)
mf.kernel()
ccsd = EBCC(mf, ansatz="CCSD")
ccsd.kernel()
```

Many ansatzes for both fermionic and electron-boson coupled cluster calculations are available. For more details see the `tutorials` and `examples` directories.

### Code generation

The models implemented are generated algorithmically from expressions over second quantized operators. The scripts for generating these models are found in the `codegen` directory on the `bootstrap` branch.
User-inputted models should operate seamlessly with the solvers by adding files under `ebcc/codegen`, so long as they satisfy the interface.
easyflex 0.3.0
API connector voor het ontsluiten van data met de Easyflex API
Requires Python: >=3.8
Keywords: python, easyflex, API

<p align="center"><img alt="logo" src="https://www.zypp.io/static/assets/img/logos/zypp/black/500px.png" width="200"></p>
<br>

[![Downloads](https://pepy.tech/badge/easyflex)](https://pepy.tech/project/easyflex)
![PyPI](https://img.shields.io/pypi/v/easyflex)
[![Open Source](https://badges.frapsoft.com/os/v1/open-source.svg?v=103)](https://opensource.org/)

# Easyflex dataservices API voor python
> Dit project bevat python scripts voor het ontsluiten van data uit de easyflex API.

## Project documentatie
- [Introductie](#introductie)
- [Hoe moet je dit project gebruiken?](#hoe-moet-je-dit-project-gebruiken?)
    - [Simpel voorbeeld](#simpel-voorbeeld-zonder-velden-of-parameters)
    - [Voorbeeld met parameters en velden](#voorbeeld-met-parameters-en-velden)

# Introductie
Easyflex heeft een API ontwikkeld voor het ontsluiten van data. Op basis van de [Easyflex web- en dataservices documentatie](https://confluence.easyflex.net/display/WEBDATAKLNT/Web-+en+dataservice) is dit python project ontstaan.
Het doel van het project is om snel en efficient data te ontsluiten van 1 of meerdere Easyflex administraties.

# Hoe moet je dit project gebruiken?
In twee stappen is het mogelijk om data te ontsluiten. De eerste stap is het initialiseren van de class `Easyflex`. In deze class registreren worden de API keys geregistreerd die gebruikt worden bij de uitvraag.
De tweede stap is het uitvragen van de dataservices of webservices. Hier moet een module naam worden opgegeven. Vervolgens kunnen de parameters en velden worden opgegeven, conform de [documentatie van de modules](https://confluence.easyflex.net/display/WEBDATAKLNT/1.2+ds_wm_medewerkers).

### Simpel voorbeeld zonder velden of parameters
```python
from easyflex import Easyflex
api_keys = {"<YOUR_ADM_CODE>": "<YOUR_API_KEY>","<YOUR_ADM_CODE_2>": "<YOUR_API_KEY_2>"}

ef = Easyflex(api_keys, service="dataservice")
data = ef.query(module="ds_wm_medewerkers")
```

### Voorbeeld met parameters en velden
```python
from easyflex import Easyflex
api_keys = {"<YOUR_ADM_CODE>": "<YOUR_API_KEY>","<YOUR_ADM_CODE_2>": "<YOUR_API_KEY_2>"}

ef = Easyflex(api_keys, service="dataservice")
data = ef.query(module="ds_wm_locaties",
                parameters={"status": 21690},
                velden=["wm_locatie_nummer", "wm_locatie_code", "wm_locatie_naam"])
```

## Onderhouden door:

- [Zypp](https://github.com/zypp-io)