semvec/pypi-packages huggingface dataset:
cs-mini-scikit-learn 0.1.2
A minimal implementation of scikit-learn like functionalities
Requires Python: >=3.6

# Mini-Scikit-Learn

Mini-Scikit-Learn is a lightweight machine learning library inspired by Scikit-Learn. This project aims to implement essential machine learning algorithms, preprocessing techniques, model evaluation methods, and utilities to provide a basic yet functional machine learning toolkit.

## Project Structure

The project is organized into several directories, each containing Python modules and Jupyter notebooks for different aspects of machine learning:

- **ensemble**: Contains implementations of various ensemble methods including Random Forest.
- **metrics**: Includes modules for evaluating model performance such as accuracy, precision, recall, F1 score, and confusion matrix.
- **model_selection**: Features tools for model selection and hyperparameter tuning, including train-test split and GridSearchCV.
- **neural_networks**: Dedicated to basic neural network architectures.
- **preprocessing**: Holds preprocessing utilities like data scaling and encoding.
- **supervised_learning**: Contains implementations of supervised learning algorithms like Logistic Regression, KNN, Decision Trees, etc.
- **utilities**: Utility functions and classes used across the project.

Each directory contains Jupyter notebooks that demonstrate the testing of the respective modules implemented in the project.

### Notebooks

- **ClassificationMetricsTest.ipynb**: Tests and comparisons of classification metrics.
- **DecisionTreeClassifier.ipynb**: Demonstrations of the Decision Tree classifier.
- **DecisionTreeRegressor.ipynb**: Demonstrations of the Decision Tree regressor.
- **GridSearchCVTest.ipynb**: Usage examples for GridSearchCV.
- Other notebooks follow a similar naming convention, each focusing on different components of the library.

## Installation

To use Mini-Scikit-Learn, clone this repository to your local machine. Ensure that you have Python installed, along with the necessary libraries.

```bash
git clone https://github.com/Basma-Arnaoui/Mini-Scikit-Learn.git
cd Mini-Scikit-Learn
```

## Usage

To use the components of Mini-Scikit-Learn, you can import the required modules into your Python scripts or Jupyter notebooks. For example:

```python
from supervised_learning.classification import LogisticRegression
from model_selection import GridSearchCV

# Your code to use these components goes here
```
mimllearning 1.0.11
MIML Learning Library
Requires Python: >=3.8
Keywords: data-science, machine-learning, miml, multi-instance, multilabel, python

# miml: Multi-Instance Multi-Label Learning Library for Python
The aim of the library is to ease the development, testing, and comparison of classification algorithms for multi-instance multi-label learning (MIML). 

## Table of Contents

- [Installation](#installation)
- [Documentation](#documentation)
- [Usage](#usage)
- [License](#license)

### Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install miml.

```bash
$ pip install mimllearning
```
#### Requirements
The requirement packages for miml library are: numpy and scikit-learn.
Installing miml with the package manager does not install the package dependencies.
So install them with the package manager manually if not already downloaded.

    $ pip install numpy
    $ pip install scikit-learn

### Documentation

We can find the documentation of the project in this link: [Documentation](https://p82maavd.github.io/MIML/)


### Usage


#### Datasets

``` python
from miml.data.load_datasets import load_dataset

dataset_train = load_dataset("miml_birds_random_80train.arff", from_library=True)
dataset_test = load_dataset("C:/Users/Damián/Desktop/miml_birds_random_20test.arff")
```

#### Classifier

``` python
from miml.classifier import MIMLtoMIBRClassifier, AllPositiveAPRClassifier

classifier_mi = MIMLtoMIBRClassifier(AllPositiveAPRClassifier())
classifier_mi.fit(dataset_train)
results_mi=classifier_mi.evaluate(dataset_test)
probs_mi = classifier_mi.predict_proba(dataset_test)
```

#### Report

``` python
from miml.report import Report

report = Report(results_mi, probs_mi, dataset_test)
report.to_string()
print("")
report.to_csv()
```

### License
MIML library is released under the GNU General Public License [GPLv3](https://www.gnu.org/licenses/gpl-3.0.html).
m-o-mini-scikit-learn-ai-project 0.1.1
A mini implementation of scikit-learn with various machine learning models and utilities.

# Lightweight Machine Learning Library

## Overview

This project aims to create a lightweight machine learning library inspired by the architecture of scikit-learn. The library provides users with powerful and easy-to-use tools for building machine learning models and analyzing data. It emphasizes modularity, ease of use, and efficient implementation.

## Features

- **Modular Design**: The library is designed with a modular architecture, separating different machine learning algorithms, utilities, and data processing functionalities into distinct modules or classes.
- **Preprocessing**: Handles data preprocessing tasks such as feature scaling, normalization, imputation of missing values, encoding categorical variables, and feature selection.
- **Supervised Learning**: Implementations of supervised learning algorithms for classification and regression tasks, including linear models, neighbors (KNN), Naive Bayes, Decision trees, Random forests, and Neural Networks.
- **Model Selection and Evaluation**: Provides utilities for model selection, hyperparameter tuning, and model evaluation. Includes tools for cross-validation, train-test split, grid search, and performance metrics such as accuracy, precision, recall, F1-score, ROC-AUC, and mean squared error.
- **Ensemble Methods**: Implementations of bagging, boosting, and stacking techniques, along with ensemble models such as random forests, AdaBoost, and gradient boosting machines.
- **Neural Networks**: Basic neural network architectures, such as feedforward neural networks.
- **Utilities**: Data loading utilities, visualization tools, helper functions for common tasks, and integration with external libraries like NumPy and pandas.

## Installation

You can install the library using pip:

```bash
pip install lightweight-ml
typstdiff 1.0.1
Tool made with Pandoc to compare two files with typst extension.
Requires Python: <4.0,>=3.10

# TypstDiff
### Dominika Ferfecka, Sara Fojt, Małgorzata Kozłowska

## Introduction
Tool created with Pandoc to compare two typst files. It marks things
deleted from first file and marks differently things added to the second file.

## Run documentation
All information about tool, its working process and how to use it is located
in documentation written in mkdocs. To run documentation server use command
`mkdocs serve` 
in the folder `documentation`.
If mkdocs is not installed use command `pip install mkdocs` or run virtual environment
`poetry shell` and install all dependencies with `poetry install` (poetry can be installed
with `pip install poetry`)

### Issues
As both tools - Pandoc and Typst are new and still developing there is no full support
for typst in Pandoc. Because of that it is not possible to notice all changes made
in files, but tool will be developed.
M-O-Mini-SCIKIT-Learn-AI-Project 0.1.0
A mini implementation of scikit-learn with various machine learning models and utilities.

# Lightweight Machine Learning Library

## Overview

This project aims to create a lightweight machine learning library inspired by the architecture of scikit-learn. The library provides users with powerful and easy-to-use tools for building machine learning models and analyzing data. It emphasizes modularity, ease of use, and efficient implementation.

## Features

- **Modular Design**: The library is designed with a modular architecture, separating different machine learning algorithms, utilities, and data processing functionalities into distinct modules or classes.
- **Preprocessing**: Handles data preprocessing tasks such as feature scaling, normalization, imputation of missing values, encoding categorical variables, and feature selection.
- **Supervised Learning**: Implementations of supervised learning algorithms for classification and regression tasks, including linear models, neighbors (KNN), Naive Bayes, Decision trees, Random forests, and Neural Networks.
- **Model Selection and Evaluation**: Provides utilities for model selection, hyperparameter tuning, and model evaluation. Includes tools for cross-validation, train-test split, grid search, and performance metrics such as accuracy, precision, recall, F1-score, ROC-AUC, and mean squared error.
- **Ensemble Methods**: Implementations of bagging, boosting, and stacking techniques, along with ensemble models such as random forests, AdaBoost, and gradient boosting machines.
- **Neural Networks**: Basic neural network architectures, such as feedforward neural networks.
- **Utilities**: Data loading utilities, visualization tools, helper functions for common tasks, and integration with external libraries like NumPy and pandas.

## Installation

You can install the library using pip:

```bash
pip install lightweight-ml
vysp-python 0.2.5
Python Client Library for VYSP.AI
Requires Python: >=3.8

# VYSP Client Library

## Installation
First, install the library using pip:

```
pip install vysp-python
```

## Usage Example

```
from vysp import VYSPClient

# Initialize the client
client = VYSPClient(tenant_api_key='your_tenant_key', gate_api_key='your_gate_key')

prompt = 'What is VYSP.AI?'

# Perform an input check
input_response = client.check_input(client_ref_user_id='123', prompt=prompt)
print(response)

model_output = 'VYSP.AI is a product that allows you to configure AI guardrails easier.'

# Perform an output check
output_response = client.check_output(client_ref_user_id='123', prompt=prompt, model_output=model_output)
print(response)
```
odeintw 1.0.2
Solve complex and matrix differential equations with scipy.integrate.odeint.
Keywords: scipy odeint


odeintw
=======

`odeintw` provides a wrapper of `scipy.integrate.odeint` that allows it to
handle complex and matrix differential equations.  That is, it can solve
equations of the form

    dZ/dt = F(Z, t, param1, param2, ...)

where `t` is real and `Z` is a real or complex array.

Since `odeintw` is just a wrapper of `scipy.integrate.odeint`, it requires
`scipy` to be installed.  SciPy 0.15 or greater is required, to avoid a
bug in `scipy.integrate.odeint` in older versions of SciPy.

See README.md at https://github.com/WarrenWeckesser/odeintw for examples.
socketbee 0.1.4
A Python wrapper for the SocketBee.
Requires Python: >=3.7

# SocketBee for Python

SocketBee is a Python client for interacting with the SocketBee API. This library allows you to easily send events to your SocketBee application.

## Installation

You can install the SocketBee library via pip:

```bash
pip install socketbee
```

## Usage

To use SocketBee in your Python application, you need to create an instance of the `SocketBee` class with your application credentials. Then, you can use this instance to send events to your SocketBee channels.

### Example

```python
import socketbee

# Initialize the SocketBee instance with your credentials
app_id = 'your_app_id'
secret = 'your_secret'
key = 'your_key'

# Optionally, you can provide additional configuration
config = {
    'protocol': 'https',
    'host': 'east-1.socket.socketbee.com',
    'port': 443,
}

socketbee_instance = socketbee.SocketBee(app_id, secret, key, config)

# Send an event
channel = 'my_channel'
event = 'my_event'
data = {
    'message': 'Hello, world!',
}

response = socketbee_instance.send_event(channel, event, data)

# Check the response
print(response)
```

### Parameters

- **app_id**: Your SocketBee application ID.
- **secret**: Your SocketBee secret key.
- **key**: Your SocketBee key.
- **config** (optional): A dictionary containing the following optional configuration parameters:
  - `protocol`: The protocol to use (default: `https`).
  - `host`: The host of the SocketBee server (default: `east-1.socket.socketbee.com`).
  - `port`: The port of the SocketBee server (default: `443`).

### Methods

#### `send_event(channel, event, data)`

Sends an event to the specified channel.

- **channel**: The channel to send the event to.
- **event**: The name of the event.
- **data**: A dictionary containing the event data.

### Response

The `send_event` method returns a dictionary with the following keys:

- **status**: The HTTP status code of the response.
- **body**: The body of the response.
- **errors** (optional): The error message, if an error occurred.
- **error_message** (optional): The error message, if a request exception occurred.

### Error Handling

If a `requests.exceptions.RequestException` is raised during the API call, the `send_event` method will return a dictionary containing the `status` set to `0` and an `error_message` describing the exception.

## Links

- [SocketBee Website](https://socketbee.com)
- [Documentation](https://socketbee.com/docs/sdks/python.html)
- [Dashboard](https://platform.socketbee.com/)

## License

This project is licensed under the MIT License. See the LICENSE file for more details.

---

For more information and detailed documentation, please refer to the official [SocketBee documentation](https://socketbee.com/docs/sdks/python.html).

Happy coding with SocketBee!
fixpoint-sdk 0.10.0
Python SDK for Fixpoint - Auto-improvement to make your LLM apps smarter
Requires Python: >=3.8

# Fixpoint Python SDK

The `FixpointClient` wraps the OpenAI API Client. You can call it just like OpenAI API Client. The sdk will intercept calls to certain OpenAI APIs, record input / outputs and forward that information to Fixpoint's api server.

## Installation

You can view the package on [pypi](https://pypi.org/project/fixpoint/). To install:

`pip install fixpoint_sdk`

## Usage

To use the sdk make sure that you have the following variables set in your environment: `FIXPOINT_API_KEY` and `OPENAI_API_KEY`.

## Development

### Virtual Env

To create a virtual environment called `venv` from your terminal run `python3 -m venv venv`.

#### Activate

`source venv/bin/activate`

#### Install packages

To install the package locally for development:

```
# in "editable mode" so your install changes as you update the source code:
pip install -e .

# and to install dev dependencies
pip install -e '.[dev]'
```

If you get an error like:

> ERROR: File "setup.py" not found. Directory cannot be installed in editable mode: /home/dbmikus/workspace/github.com/gofixpoint/python-sdk
> (A "pyproject.toml" file was found, but editable mode currently requires a setup.py based build.)

Try upgrading pip and retrying:

```
pip install --upgrade pip
pip install -e .
```


In general, you should not install from the `requirements.txt` file, instead
following the installation method suggested above.

#### Deactivate

`deactivate`

### Git hooks

Set up your Githooks via:

```
git config core.hooksPath githooks/
```

## Examples

You can find examples of how to use the API in `examples`.