code stringlengths 114 1.05M | path stringlengths 3 312 | quality_prob float64 0.5 0.99 | learning_prob float64 0.2 1 | filename stringlengths 3 168 | kind stringclasses 1
value |
|---|---|---|---|---|---|
from pathlib import Path
from dash import register_page
import dash
from dash_bootstrap_templates import load_figure_template
# SageWorks Imports
from sageworks.web_components import confusion_matrix, table, scatter_plot
from sageworks.web_components import (
mock_feature_importance,
mock_model_data,
mock_model_details,
mock_feature_details,
)
from sageworks.views.model_web_view import ModelWebView
# Local Imports
from .layout import models_layout
from . import callbacks
register_page(
__name__,
path="/models",
name="SageWorks - Models",
)
# Okay feels a bit weird but Dash pages just have a bunch of top level code (no classes/methods)
# Put the components into 'dark' mode
load_figure_template("darkly")
# Grab a view that gives us a summary of the FeatureSets in SageWorks
model_broker = ModelWebView()
models_rows = model_broker.models_summary()
# Read in our fake model data
data_path = str(Path(__file__).resolve().parent.parent / "data/toy_data.csv")
fake_model_info = mock_model_data.ModelData(data_path)
# Create a table to display the models
models_table = table.create(
"models_table",
models_rows,
header_color="rgb(60, 100, 60)",
row_select="single",
markdown_columns=["Model Group"],
)
# Create all the other components on this page
model_df = fake_model_info.get_model_df()
details = mock_model_details.create(fake_model_info.get_model_details(0))
c_matrix = confusion_matrix.create(fake_model_info.get_model_confusion_matrix(0))
scatter = scatter_plot.create("model performance", model_df)
my_feature_importance = mock_feature_importance.create(fake_model_info.get_model_feature_importance(0))
my_feature_details = mock_feature_details.create(fake_model_info.get_model_feature_importance(0))
components = {
"models_table": models_table,
"model_details": details,
"confusion_matrix": c_matrix,
"scatter_plot": scatter,
"feature_importance": my_feature_importance,
"feature_details": my_feature_details,
}
# Set up our layout (Dash looks for a var called layout)
layout = models_layout(**components)
# Setup our callbacks/connections
app = dash.get_app()
callbacks.refresh_data_timer(app)
callbacks.update_models_table(app, model_broker)
# Callback for the model table
callbacks.table_row_select(app, "models_table")
callbacks.update_figures(app, fake_model_info)
callbacks.update_model_details(app, fake_model_info)
callbacks.update_feature_details(app, fake_model_info) | /sageworks-0.1.5.3.tar.gz/sageworks-0.1.5.3/applications/aws_dashboard/pages/models/page.py | 0.516595 | 0.151592 | page.py | pypi |
import dash
from dash import Dash
from dash.dependencies import Input, Output
from datetime import datetime
# SageWorks Imports
from sageworks.web_components.mock_model_data import ModelData
from sageworks.web_components import (
mock_feature_importance,
confusion_matrix,
mock_model_details,
mock_feature_details,
)
from sageworks.views.model_web_view import ModelWebView
def refresh_data_timer(app: Dash):
@app.callback(
Output("last-updated-models", "children"),
Input("models-updater", "n_intervals"),
)
def time_updated(_n):
return datetime.now().strftime("Last Updated: %Y-%m-%d %H:%M:%S")
def update_models_table(app: Dash, model_broker: ModelWebView):
@app.callback(Output("models_table", "data"), Input("models-updater", "n_intervals"))
def feature_sets_update(_n):
"""Return the table data as a dictionary"""
model_broker.refresh()
model_rows = model_broker.models_summary()
model_rows["id"] = model_rows.index
return model_rows.to_dict("records")
# Highlights the selected row in the table
def table_row_select(app: Dash, table_name: str):
@app.callback(
Output(table_name, "style_data_conditional"),
Input(table_name, "derived_viewport_selected_row_ids"),
)
def style_selected_rows(selected_rows):
print(f"Selected Rows: {selected_rows}")
if not selected_rows or selected_rows[0] is None:
return dash.no_update
row_style = [
{
"if": {"filter_query": "{{id}} ={}".format(i)},
"backgroundColor": "rgb(80, 80, 80)",
}
for i in selected_rows
]
return row_style
# Updates the feature importance and confusion matrix figures when a model is selected
def update_figures(app: Dash, model_data: ModelData):
@app.callback(
[Output("feature_importance", "figure"), Output("confusion_matrix", "figure")],
Input("models_table", "derived_viewport_selected_row_ids"),
)
def generate_new_figures(selected_rows):
print(f"Selected Rows: {selected_rows}")
# If there's no selection we're going to return figures for the first row (0)
if not selected_rows or selected_rows[0] is None:
selected_rows = [0]
# Grab the data for this row
model_row_index = selected_rows[0]
# Generate a figure for the feature importance component
feature_info = model_data.get_model_feature_importance(model_row_index)
feature_figure = mock_feature_importance.create_figure(feature_info)
# Generate a figure for the confusion matrix component
c_matrix = model_data.get_model_confusion_matrix(model_row_index)
matrix_figure = confusion_matrix.create_figure(c_matrix)
# Now return both of the new figures
return [feature_figure, matrix_figure]
# Updates the model details when a model row is selected
def update_model_details(app: Dash, model_data: ModelData):
@app.callback(
Output("model_details", "children"),
Input("models_table", "derived_viewport_selected_row_ids"),
)
def generate_new_markdown(selected_rows):
print(f"Selected Rows: {selected_rows}")
# If there's no selection we're going to return the model details for the first row (0)
if not selected_rows or selected_rows[0] is None:
selected_rows = [0]
# Grab the data for this row
model_row_index = selected_rows[0]
# Generate new Details (Markdown) for the selected model
model_info = model_data.get_model_details(model_row_index)
model_markdown = mock_model_details.create_markdown(model_info)
# Return the details/markdown for this model
return model_markdown
# Updates the feature details when a model row is selected
def update_feature_details(app: Dash, model_data: ModelData):
@app.callback(
Output("feature_details", "children"),
Input("models_table", "derived_viewport_selected_row_ids"),
)
def generate_new_markdown(selected_rows):
print(f"Selected Rows: {selected_rows}")
# If there's no selection we're going to return the feature details for the first row (0)
if not selected_rows or selected_rows[0] is None:
selected_rows = [0]
# Grab the data for this row
model_row_index = selected_rows[0]
# Generate new Details (Markdown) for the features for this model
feature_info = model_data.get_model_feature_importance(model_row_index)
feature_markdown = mock_feature_details.create_markdown(feature_info)
# Return the details/markdown for these features
return feature_markdown | /sageworks-0.1.5.3.tar.gz/sageworks-0.1.5.3/applications/aws_dashboard/pages/models/callbacks.py | 0.631594 | 0.330552 | callbacks.py | pypi |
from dash import dcc, html, dash_table
import dash_bootstrap_components as dbc
def models_layout(
models_table: dash_table.DataTable,
model_details: dcc.Markdown,
confusion_matrix: dcc.Graph,
scatter_plot: dcc.Graph,
feature_importance: dcc.Graph,
feature_details: dcc.Markdown,
) -> html.Div:
layout = html.Div(
children=[
dbc.Row(html.H2("SageWorks: Models (Alpha)")),
html.Div(
"Last Updated: ",
id="last-updated-models",
style={
"color": "rgb(140, 200, 140)",
"fontSize": 15,
"padding": "0px 0px 0px 160px",
},
),
dbc.Row(style={"padding": "30px 0px 0px 0px"}),
dbc.Row(
[
# Model Table and Model Details
dbc.Col(
[
dbc.Row(models_table),
dbc.Row(
html.H3("Model Details"),
style={"padding": "50px 0px 0px 20px"},
),
dbc.Row(
[
dbc.Col(model_details),
dbc.Col(confusion_matrix),
]
),
dbc.Row(scatter_plot),
],
width=8,
),
# Feature Importance and Details
dbc.Col(
[
dbc.Row(html.H3("Feature Importance")),
dbc.Row(feature_importance),
dbc.Row(
html.H3(
"Feature Details",
style={"padding": "20px 0px 0px 20px"},
)
),
dbc.Row(
feature_details,
style={"padding": "0px 0px 0px 20px"},
),
],
width=4,
),
]
),
dcc.Interval(id="models-updater", interval=5000, n_intervals=0),
],
style={"margin": "30px"},
)
return layout | /sageworks-0.1.5.3.tar.gz/sageworks-0.1.5.3/applications/aws_dashboard/pages/models/layout.py | 0.481454 | 0.181354 | layout.py | pypi |
from dash import register_page
import dash
from dash_bootstrap_templates import load_figure_template
# SageWorks Imports
from sageworks.web_components import table, data_and_feature_details, distribution_plots
from sageworks.views.feature_set_web_view import FeatureSetWebView
# Local Imports
from .layout import feature_sets_layout
from . import callbacks
register_page(__name__, path="/feature_sets", name="SageWorks - Feature Sets")
# Okay feels a bit weird but Dash pages just have a bunch of top level code (no classes/methods)
# Put the components into 'dark' mode
load_figure_template("darkly")
# Grab a view that gives us a summary of the FeatureSets in SageWorks
feature_set_broker = FeatureSetWebView()
feature_set_rows = feature_set_broker.feature_sets_summary()
# Create a table to display the data sources
feature_sets_table = table.create(
"feature_sets_table",
feature_set_rows,
header_color="rgb(100, 100, 60)",
row_select="single",
markdown_columns=["Feature Group"],
)
# Grab sample rows from the first data source
sample_rows = feature_set_broker.feature_set_sample(0)
feature_set_sample_rows = table.create(
"feature_set_sample_rows",
sample_rows,
header_color="rgb(60, 60, 100)",
max_height="200px",
)
# Data Source Details
details = feature_set_broker.feature_set_details(0)
data_details = data_and_feature_details.create("feature_set_details", details)
# Create a box plot of all the numeric columns in the sample rows
smart_sample_rows = feature_set_broker.feature_set_smart_sample(0)
violin = distribution_plots.create(
"feature_set_violin_plot",
smart_sample_rows,
plot_type="violin",
figure_args={
"box_visible": True,
"meanline_visible": True,
"showlegend": False,
"points": "all",
},
max_plots=48,
)
# Create our components
components = {
"feature_sets_table": feature_sets_table,
"feature_set_sample_rows": feature_set_sample_rows,
"feature_set_details": data_details,
"violin_plot": violin,
}
# Set up our layout (Dash looks for a var called layout)
layout = feature_sets_layout(**components)
# Setup our callbacks/connections
app = dash.get_app()
# Refresh our data timer
callbacks.refresh_data_timer(app)
# Periodic update to the data sources summary table
callbacks.update_feature_sets_table(app, feature_set_broker)
# Callbacks for when a data source is selected
callbacks.table_row_select(app, "feature_sets_table")
callbacks.update_feature_set_details(app, feature_set_broker)
callbacks.update_feature_set_sample_rows(app, feature_set_broker)
callbacks.update_violin_plots(app, feature_set_broker) | /sageworks-0.1.5.3.tar.gz/sageworks-0.1.5.3/applications/aws_dashboard/pages/feature_sets/page.py | 0.534612 | 0.25856 | page.py | pypi |
from datetime import datetime
import dash
from dash import Dash
from dash.dependencies import Input, Output
# SageWorks Imports
from sageworks.views.feature_set_web_view import FeatureSetWebView
from sageworks.web_components import data_and_feature_details, distribution_plots, table
def refresh_data_timer(app: Dash):
@app.callback(
Output("last-updated-feature-sets", "children"),
Input("feature-sets-updater", "n_intervals"),
)
def time_updated(_n):
return datetime.now().strftime("Last Updated: %Y-%m-%d %H:%M:%S")
def update_feature_sets_table(app: Dash, feature_set_broker: FeatureSetWebView):
@app.callback(
Output("feature_sets_table", "data"),
Input("feature-sets-updater", "n_intervals"),
)
def feature_sets_update(_n):
"""Return the table data for the FeatureSets Table"""
feature_set_broker.refresh()
feature_set_rows = feature_set_broker.feature_sets_summary()
feature_set_rows["id"] = feature_set_rows.index
return feature_set_rows.to_dict("records")
# Highlights the selected row in the table
def table_row_select(app: Dash, table_name: str):
@app.callback(
Output(table_name, "style_data_conditional"),
Input(table_name, "derived_viewport_selected_row_ids"),
)
def style_selected_rows(selected_rows):
print(f"Selected Rows: {selected_rows}")
if not selected_rows or selected_rows[0] is None:
return dash.no_update
row_style = [
{
"if": {"filter_query": "{{id}} ={}".format(i)},
"backgroundColor": "rgb(80, 80, 80)",
}
for i in selected_rows
]
return row_style
# Updates the data source details when a row is selected in the summary
def update_feature_set_details(app: Dash, feature_set_web_view: FeatureSetWebView):
@app.callback(
[
Output("feature_details_header", "children"),
Output("feature_set_details", "children"),
],
Input("feature_sets_table", "derived_viewport_selected_row_ids"),
)
def generate_new_markdown(selected_rows):
print(f"Selected Rows: {selected_rows}")
if not selected_rows or selected_rows[0] is None:
return dash.no_update
print("Calling FeatureSet Details...")
feature_details = feature_set_web_view.feature_set_details(selected_rows[0])
feature_details_markdown = data_and_feature_details.create_markdown(feature_details)
# Name of the data source for the Header
feature_set_name = feature_set_web_view.feature_set_name(selected_rows[0])
header = f"Details: {feature_set_name}"
# Return the details/markdown for these data details
return [header, feature_details_markdown]
def update_feature_set_sample_rows(app: Dash, feature_set_web_view: FeatureSetWebView):
@app.callback(
[
Output("feature_sample_rows_header", "children"),
Output("feature_set_sample_rows", "columns"),
Output("feature_set_sample_rows", "data"),
],
Input("feature_sets_table", "derived_viewport_selected_row_ids"),
prevent_initial_call=True,
)
def sample_rows_update(selected_rows):
print(f"Selected Rows: {selected_rows}")
if not selected_rows or selected_rows[0] is None:
return dash.no_update
print("Calling FeatureSet Sample Rows...")
sample_rows = feature_set_web_view.feature_set_sample(selected_rows[0])
# Name of the data source
feature_set_name = feature_set_web_view.feature_set_name(selected_rows[0])
header = f"Sampled Rows: {feature_set_name}"
# The columns need to be in a special format for the DataTable
column_setup = table.column_setup(sample_rows)
# Return the columns and the data
return [header, column_setup, sample_rows.to_dict("records")]
def update_violin_plots(app: Dash, feature_set_web_view: FeatureSetWebView):
"""Updates the Violin Plots when a new data source is selected"""
@app.callback(
Output("feature_set_violin_plot", "figure"),
Input("feature_sets_table", "derived_viewport_selected_row_ids"),
prevent_initial_call=True,
)
def generate_new_violin_plot(selected_rows):
print(f"Selected Rows: {selected_rows}")
if not selected_rows or selected_rows[0] is None:
return dash.no_update
print("Calling FeatureSet Sample Rows Refresh...")
smart_sample_rows = feature_set_web_view.feature_set_smart_sample(selected_rows[0])
return distribution_plots.create_figure(
smart_sample_rows,
plot_type="violin",
figure_args={
"box_visible": True,
"meanline_visible": True,
"showlegend": False,
"points": "all",
},
max_plots=48,
) | /sageworks-0.1.5.3.tar.gz/sageworks-0.1.5.3/applications/aws_dashboard/pages/feature_sets/callbacks.py | 0.754553 | 0.262871 | callbacks.py | pypi |
**Build Status**
master: [](https://app.travis-ci.com/github/Kenza-AI/sagify)
# sagify
A command-line utility to train and deploy Machine Learning/Deep Learning models on [AWS SageMaker](https://aws.amazon.com/sagemaker/) in a few simple steps! It hides all the details of Sagemaker so that you can focus 100% on Machine Learning, and not in low level engineering tasks.
For detailed reference to Sagify commands please go to: [Read the Docs](https://Kenza-AI.github.io/sagify/)
## Installation
### Prerequisites
sagify requires the following:
1. Python (3.7, 3.8)
2. [Docker](https://www.docker.com/) installed and running
3. Configured [awscli](https://pypi.python.org/pypi/awscli)
### Install sagify
At the command line:
pip install sagify
## Getting started - No code deployment
1. Create a file with name `huggingface_config.json` with the following content:
{
"transformers_version": "4.6.1",
"pytorch_version": "1.7.1",
"hub": {
"HF_MODEL_ID": "gpt2",
"HF_TASK": "text-generation"
}
}
2. Then, make sure to configure your AWS account by following the instructions at section [Configure AWS Account](#configure-aws-account)
3. Finally, run the following command:
sagify cloud lightning-deploy --framework huggingface -n 1 -e ml.c4.2xlarge --extra-config-file huggingface_config.json --aws-region us-east-1 --aws-profile sagemaker-dev
You can change the values for ec2 type (-e), aws region and aws profile with your preferred ones.
4. Once the Hugging Face model is deployed, you can go to https://console.aws.amazon.com/sagemaker/home?region=us-east-1#/endpoints (make sure you're on your preferred region) and find your deployed endpoint. For example:
5. Then, you can click on your deployed endpoint and copy the endpoint url. For example:
6. Postman is a good app to call the deployed endpoint. Here's an example on how to set up the AWS signature in order to call the endpoint:
7. Finally, you can call the endpoint from Postman:
## Getting started - Custom Training and Deployment
### Step 1: Clone Machine Learning demo repository
You're going to clone and train a Machine Learning codebase to train a classifier for the Iris data set.
Clone repository:
git clone https://github.com/Kenza-AI/sagify-demo.git
Create environment:
mkvirtualenv -p python3.7 sagify-demo
or
mkvirtualenv -p python3.8 sagify-demo
Don't forget to activate the virtualenv after the creation of environment by executing `workon sagify-demo`.
Install dependencies:
make requirements
### Step 2: Initialize sagify
sagify init
Type in `sagify-demo` for SageMaker app name, `N` in question `Are you starting a new project?`, `src` for question `Type in the directory where your code lives` and make sure to choose your preferred Python version, AWS profile and region. Finally, type `requirements.txt` in question `Type in the path to requirements.txt`.
A module called `sagify` is created under the directory you provided. The structure is:
sagify_base/
local_test/
test_dir/
input/
config/
hyperparameters.json
data/
training/
model/
output/
deploy_local.sh
train_local.sh
prediction/
__init__.py
nginx.conf
predict.py
prediction.py
predictor.py
serve
wsgi.py
training/
__init__.py
train
training.py
__init__.py
build.sh
Dockerfile
executor.sh
push.sh
### Step 3: Integrate sagify
As a Data Scientist, you only need to conduct a few actions. Sagify takes care of the rest:
1. Copy a subset of training data under `sagify_base/local_test/test_dir/input/data/training/` to test that training works locally
2. Implement `train(...)` function in `sagify_base/training/training.py`
3. Implement `predict(...)` function in `sagify_base/prediction/prediction.py`
4. Optionally, specify hyperparameters in `sagify_base/local_test/test_dir/input/config/hyperparameters.json`
Hence,
1. Copy `iris.data` files from `data` to `sagify_base/local_test/test_dir/input/data/training/`
2. Replace the `TODOs` in the `train(...)` function in `sagify_base/training/training.py` file with:
```python
input_file_path = os.path.join(input_data_path, 'iris.data')
clf, accuracy = training_logic(input_file_path=input_file_path)
output_model_file_path = os.path.join(model_save_path, 'model.pkl')
joblib.dump(clf, output_model_file_path)
accuracy_report_file_path = os.path.join(model_save_path, 'report.txt')
with open(accuracy_report_file_path, 'w') as _out:
_out.write(str(accuracy))
```
and at the top of the file, add:
```python
import os
import joblib
from iris_training import train as training_logic
```
3. Replace the body of `predict(...)` function in `sagify_base/prediction/prediction.py` with:
```python
model_input = json_input['features']
prediction = ModelService.predict(model_input)
return {
"prediction": prediction.item()
}
```
and replace the body of `get_model()` function in `ModelService` class in the same file with:
```python
if cls.model is None:
import joblib
cls.model = joblib.load(os.path.join(_MODEL_PATH, 'model.pkl'))
return cls.model
```
### Step 4: Build Docker image
It's time to build the Docker image that will contain the Machine Learning codebase:
sagify build
If you run `docker images | grep sagify-demo` in your terminal, you'll see the created Sagify-Demo image.
### Step 5: Train model
Time to train the model for the Iris data set in the newly built Docker image:
sagify local train
Model file `model.pkl` and report file `report.txt` are now under `sagify_base/local_test/test_dir/model/`
### Step 6: Deploy model
Finally, serve the model as a REST Service:
sagify local deploy
Run the following curl command on your terminal to verify that the REST Service works:
```bash
curl -X POST \
http://localhost:8080/invocations \
-H 'Cache-Control: no-cache' \
-H 'Content-Type: application/json' \
-H 'Postman-Token: 41189b9a-40e2-abcf-b981-c31ae692072e' \
-d '{
"features":[[0.34, 0.45, 0.45, 0.3]]
}'
```
It will be slow in the first couple of calls as it loads the model in a lazy manner.
Voila! That's a proof that this Machine Learning model is going to be trained and deployed on AWS SageMaker successfully. Now, go to the *Usage* section in [Sagify Docs](https://Kenza-AI.github.io/sagify/) to see how to train and deploy this Machine Learning model to AWS SageMaker!
## Hyperparameter Optimization
Given that you have configured your AWS Account as described in the previous section, you're now ready to perform Bayesian Hyperparameter Optimization on AWS SageMaker! The process is similar to training step.
### Step 1: Define Hyperparameter Configuration File
Define the Hyperparameter Configuration File. More specifically, you need to specify in a local JSON file the ranges for the hyperparameters, the name of the objective metric and its type (i.e. `Maximize` or `Minimize`). For example:
```json
{
"ParameterRanges": {
"CategoricalParameterRanges": [
{
"Name": "kernel",
"Values": ["linear", "rbf"]
}
],
"ContinuousParameterRanges": [
{
"MinValue": 0.001,
"MaxValue": 10,
"Name": "gamma"
}
],
"IntegerParameterRanges": [
{
"Name": "C",
"MinValue": 1,
"MaxValue": 10
}
]
},
"ObjectiveMetric": {
"Name": "Precision",
"Type": "Maximize"
}
}
```
### Step 2: Implement Train function
Replace the `TODOs` in the `train(...)` function in `sagify_base/training/training.py` file with your logic. For example:
```python
from sklearn import datasets
iris = datasets.load_iris()
# Read the hyperparameter config json file
import json
with open(hyperparams_path) as _in_file:
hyperparams_dict = json.load(_in_file)
from sklearn import svm
clf = svm.SVC(
gamma=float(hyperparams_dict['gamma']), # Values will be read as strings, so make sure to convert them to the right data type
C=float(hyperparams_dict['C']),
kernel=hyperparams_dict['kernel']
)
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
iris.data, iris.target, test_size=0.3, random_state=42)
clf.fit(X_train, y_train)
from sklearn.metrics import precision_score
predictions = clf.predict(X_test)
precision = precision_score(y_test, predictions, average='weighted')
# Log the objective metric name with its calculated value. In tis example is Precision.
# The objective name should be exactly the same with the one specified in the hyperparams congig json file.
# The value must be a numeric (float or int).
from sagify.api.hyperparameter_tuning import log_metric
name = "Precision"
log_metric(name, precision)
from joblib import dump
dump(clf, os.path.join(model_save_path, 'model.pkl'))
print('Training complete.')
```
### Step 3: Build and Push Docker image
1. `sagify build` Make sure sagify is in your `requirements.txt` file.
2. `sagify push`
### Step 4: Call The CLI Command
And, finally, call the hyperparameter-optimization CLI command. For example:
sagify cloud hyperparameter-optimization -i s3://my-bucket/training-data/ -o s3://my-bucket/output/ -e ml.m4.xlarge -h local/path/to/hyperparam_ranges.json
### Step 5: Monitor Progress
You can monitor the progress via the SageMaker UI console. Here is an example of a finished Hyperparameter Optimization job:
## Commands
### Initialize
#### Name
Initializes a sagify module
#### Synopsis
sagify init
#### Description
This command initializes a sagify module in the directory you provide when asked after you invoke the `init` command.
### Example
sagify init
### Configure
#### Description
Updates an existing configuration value e.g. `python version` or `AWS region`.
#### Synopsis
sagify configure [--aws-region AWS_REGION] [--aws-profile AWS_PROFILE] [--image-name IMAGE_NAME] [--python-version PYTHON_VERSION]
#### Optional Flags
`--aws-region AWS_REGION`: _AWS_ region where _Docker_ images are pushed and _SageMaker_ operations (_train_, _deploy_) are performed.
`--aws-profile AWS_PROFILE`: _AWS_ profile to use when interacting with _AWS_.
`--image-name IMAGE_NAME`: _Docker_ image name used when building for use with _SageMaker_. This shows up as an _AWS ECR_ repository on your _AWS_ account.
`--python-version PYTHON_VERSION`: _Python_ version used when building _SageMaker's_ _Docker_ images. Currently supported versions: `3.6`.
### Example
sagify configure --aws-region us-east-2 --aws-profile default --image-name sage-docker-image-name --python-version 3.6
### Build
#### Name
Builds a Docker image
#### Synopsis
sagify build
#### Description
This command builds a Docker image from code under the directory sagify is installed in. A `REQUIREMENTS_FILE` needs to be specified during `sagify init` or later via `sagify configure --requirements-dir` for all required dependencies to be installed in the Docker image.
#### Example
sagify build
### Local Train
#### Name
Executes a Docker image in train mode
#### Synopsis
sagify local train
#### Description
This command executes a Docker image in train mode. More specifically, it executes the `train(...)` function in `sagify_base/training/training.py` inside an already built Docker image (see Build command section).
#### Example
sagify local train
### Local Deploy
#### Name
Executes a Docker image in serve mode
#### Synopsis
sagify local deploy
#### Description
This command executes a Docker image in serve mode. More specifically, it runs a Flask REST app in Docker image and directs HTTP requests to `/invocations` endpoint. Then, the `/invocations` endpoint calls the `predict(...)` function in `sagify_base/prediction/prediction.py` (see Build command section on how to build a Docker image).
#### Example
sagify local deploy
### Push
#### Name
Pushes a Docker image to AWS Elastic Container Service
#### Synopsis
sagify push [--aws-profile PROFILE_NAME] [--aws-region AWS_REGION] [--iam-role-arn IAM_ROLE] [--external-id EXTERNAL_ID]
#### Description
This command pushes an already built Docker image to AWS Elastic Container Service. Later on, AWS SageMaker will consume that image from AWS Elastic Container Service for train and serve mode.
> Only one of _iam-role-arn_ and _aws_profile_ can be provided. _external-id_ is ignored when no _iam-role-arn_ is provided.
#### Optional Flags
`--iam-role-arn IAM_ROLE` or `-i IAM_ROLE`: AWS IAM role to use for pushing to ECR
`--aws-region AWS_REGION` or `-r AWS_REGION`: The AWS region to push the image to
`--aws-profile PROFILE_NAME` or `-p PROFILE_NAME`: AWS profile to use for pushing to ECR
`--external-id EXTERNAL_ID` or `-e EXTERNAL_ID`: Optional external id used when using an IAM role
#### Example
sagify push
### Cloud Upload Data
#### Name
Uploads data to AWS S3
#### Synopsis
sagify cloud upload-data --input-dir LOCAL_INPUT_DATA_DIR --s3-dir S3_TARGET_DATA_LOCATION
#### Description
This command uploads content under `LOCAL_INPUT_DATA_DIR` to S3 under `S3_TARGET_DATA_LOCATION`
#### Required Flags
`--input-dir LOCAL_INPUT_DATA_DIR` or `-i LOCAL_INPUT_DATA_DIR`: Local input directory
`--s3-dir S3_TARGET_DATA_LOCATION` or `-s S3_TARGET_DATA_LOCATION`: S3 target location
#### Example
sagify cloud upload-data -i ./training_data/ -s s3://my-bucket/training-data/
### Cloud Train
#### Name
Trains your ML/DL model using a Docker image on AWS SageMaker with input from S3
#### Synopsis
sagify cloud train --input-s3-dir INPUT_DATA_S3_LOCATION --output-s3-dir S3_LOCATION_TO_SAVE_OUTPUT --ec2-type EC2_TYPE [--hyperparams-file HYPERPARAMS_JSON_FILE] [--volume-size EBS_SIZE_IN_GB] [--time-out TIME_OUT_IN_SECS] [--aws-tags TAGS] [--iam-role-arn IAM_ROLE] [--external-id EXTERNAL_ID] [--base-job-name BASE_JOB_NAME] [--job-name JOB_NAME] [--metric-names COMMA_SEPARATED_METRIC_NAMES] [--use-spot-instances FLAG_TO_USE_SPOT_INSTANCES]
#### Description
This command retrieves a Docker image from AWS Elastic Container Service and executes it on AWS SageMaker in train mode
#### Required Flags
`--input-s3-dir INPUT_DATA_S3_LOCATION` or `-i INPUT_DATA_S3_LOCATION`: S3 location to input data
`--output-s3-dir S3_LOCATION_TO_SAVE_OUTPUT` or `-o S3_LOCATION_TO_SAVE_OUTPUT`: S3 location to save output (models, reports, etc). Make sure that the output bucket already exists. Any not existing key prefix will be created by sagify.
`--ec2-type EC2_TYPE` or `-e EC2_TYPE`: ec2 type. Refer to <https://aws.amazon.com/sagemaker/pricing/instance-types/>
#### Optional Flags
`--hyperparams-file HYPERPARAMS_JSON_FILE` or `-h HYPERPARAMS_JSON_FILE`: Path to hyperparams JSON file
`--volume-size EBS_SIZE_IN_GB` or `-v EBS_SIZE_IN_GB`: Size in GB of the EBS volume (default: 30)
`--time-out TIME_OUT_IN_SECS` or `-s TIME_OUT_IN_SECS`: Time-out in seconds (default: 24 * 60 * 60)
`--aws-tags TAGS` or `-a TAGS`: Tags for labeling a training job of the form `tag1=value1;tag2=value2`. For more, see https://docs.aws.amazon.com/sagemaker/latest/dg/API_Tag.html.
`--iam-role-arn IAM_ROLE` or `-r IAM_ROLE`: AWS IAM role to use for training with *SageMaker*
`--external-id EXTERNAL_ID` or `-x EXTERNAL_ID`: Optional external id used when using an IAM role
`--base-job-name BASE_JOB_NAME` or `-n BASE_JOB_NAME`: Optional prefix for the SageMaker training job
`--job-name JOB_NAME`: Optional name for the SageMaker training job. NOTE: if a `--base-job-name` is passed along with this option, it will be ignored.
`--use-spot-instances FLAG_TO_USE_SPOT_INSTANCES`: Optional flag that specifies whether to use SageMaker Managed Spot instances for training. It should be used only for training jobs that take less than 1 hour. More information: https://docs.aws.amazon.com/sagemaker/latest/dg/model-managed-spot-training.html (default: False).
`--metric-names COMMA_SEPARATED_METRIC_NAMES`: Optional comma-separated metric names for tracking performance of training jobs. Example: `Precision,Recall,AUC`. Then, make sure you log these metric values using the `log_metric` function in the `train` function:
```python
...
from sagify.api.hyperparameter_tuning import log_metric
log_metric("Precision:, precision)
log_metric("Accuracy", accuracy)
...
```
When the training jobs finishes, they will be stored in the CloudWatch algorithm metrics logs of the SageMaker training job:
#### Example
sagify cloud train -i s3://my-bucket/training-data/ -o s3://my-bucket/output/ -e ml.m4.xlarge -h local/path/to/hyperparams.json -v 60 -t 86400 --metric-names Accuracy,Precision
### Cloud Hyperparameter Optimization
#### Name
Executes a Docker image in hyperparameter-optimization mode on AWS SageMaker
#### Synopsis
sagify cloud hyperparameter-optimization --input-s3-dir INPUT_DATA_S3_LOCATION --output-s3-dir S3_LOCATION_TO_SAVE_MULTIPLE_TRAINED_MODELS --ec2-type EC2_TYPE [--hyperparams-config-file HYPERPARAM_RANGES_JSON_FILE] [--max-jobs MAX_NUMBER_OF_TRAINING_JOBS] [--max-parallel-jobs MAX_NUMBER_OF_PARALLEL_TRAINING_JOBS] [--volume-size EBS_SIZE_IN_GB] [--time-out TIME_OUT_IN_SECS] [--aws-tags TAGS] [--iam-role-arn IAM_ROLE] [--external-id EXTERNAL_ID] [--base-job-name BASE_JOB_NAME] [--job-name JOB_NAME] [--wait WAIT_UNTIL_HYPERPARAM_JOB_IS_FINISHED] [--use-spot-instances FLAG_TO_USE_SPOT_INSTANCES]
#### Description
This command retrieves a Docker image from AWS Elastic Container Service and executes it on AWS SageMaker in hyperparameter-optimization mode
#### Required Flags
`--input-s3-dir INPUT_DATA_S3_LOCATION` or `-i INPUT_DATA_S3_LOCATION`: S3 location to input data
`--output-s3-dir S3_LOCATION_TO_SAVE_OUTPUT` or `-o S3_LOCATION_TO_SAVE_OUTPUT`: S3 location to save output (models, reports, etc). Make sure that the output bucket already exists. Any not existing key prefix will be created by sagify.
`--ec2-type EC2_TYPE` or `-e EC2_TYPE`: ec2 type. Refer to <https://aws.amazon.com/sagemaker/pricing/instance-types/>
`--hyperparams-config-file HYPERPARAM_RANGES_JSON_FILE` or `-h HYPERPARAM_RANGES_JSON_FILE`: Local path to hyperparameters configuration file. Example:
```json
{
"ParameterRanges": {
"CategoricalParameterRanges": [
{
"Name": "kernel",
"Values": ["linear", "rbf"]
}
],
"ContinuousParameterRanges": [
{
"MinValue": 0.001,
"MaxValue": 10,
"Name": "gamma"
}
],
"IntegerParameterRanges": [
{
"Name": "C",
"MinValue": 1,
"MaxValue": 10
}
]
},
"ObjectiveMetric": {
"Name": "Precision",
"Type": "Maximize"
}
}
```
#### Optional Flags
`--max-jobs MAX_NUMBER_OF_TRAINING_JOBS` or `-m MAX_NUMBER_OF_TRAINING_JOBS`: Maximum total number of training jobs to start for the hyperparameter tuning job (default: 3)
`--max-parallel-jobs MAX_NUMBER_OF_PARALLEL_TRAINING_JOBS` or `-p MAX_NUMBER_OF_PARALLEL_TRAINING_JOBS`: Maximum number of parallel training jobs to start (default: 1)
`--volume-size EBS_SIZE_IN_GB` or `-v EBS_SIZE_IN_GB`: Size in GB of the EBS volume (default: 30)
`--time-out TIME_OUT_IN_SECS` or `-s TIME_OUT_IN_SECS`: Time-out in seconds (default: 24 * 60 * 60)
`--aws-tags TAGS` or `-a TAGS`: Tags for labeling a training job of the form `tag1=value1;tag2=value2`. For more, see https://docs.aws.amazon.com/sagemaker/latest/dg/API_Tag.html.
`--iam-role-arn IAM_ROLE` or `-r IAM_ROLE`: AWS IAM role to use for training with *SageMaker*
`--external-id EXTERNAL_ID` or `-x EXTERNAL_ID`: Optional external id used when using an IAM role
`--base-job-name BASE_JOB_NAME` or `-n BASE_JOB_NAME`: Optional prefix for the SageMaker training job
`--job-name JOB_NAME`: Optional name for the SageMaker training job. NOTE: if a `--base-job-name` is passed along with this option, it will be ignored.
`--wait WAIT_UNTIL_HYPERPARAM_JOB_IS_FINISHED` or `-w WAIT_UNTIL_HYPERPARAM_JOB_IS_FINISHED`: Optional flag to wait until Hyperparameter Tuning is finished. (default: don't wait)
`--use-spot-instances FLAG_TO_USE_SPOT_INSTANCES`: Optional flag that specifies whether to use SageMaker Managed Spot instances for training. It should be used only for training jobs that take less than 1 hour. More information: https://docs.aws.amazon.com/sagemaker/latest/dg/model-managed-spot-training.html (default: False).
#### Example
sagify cloud hyperparameter-optimization -i s3://my-bucket/training-data/ -o s3://my-bucket/output/ -e ml.m4.xlarge -h local/path/to/hyperparam_ranges.json -v 60 -t 86400
### Cloud Deploy
#### Name
Executes a Docker image in serve mode on AWS SageMaker
#### Synopsis
sagify cloud deploy --s3-model-location S3_LOCATION_TO_MODEL_TAR_GZ --num-instance NUMBER_OF_EC2_INSTANCES --ec2-type EC2_TYPE [--aws-tags TAGS] [--iam-role-arn IAM_ROLE] [--external-id EXTERNAL_ID] [--endpoint-name ENDPOINT_NAME]
#### Description
This command retrieves a Docker image from AWS Elastic Container Service and executes it on AWS SageMaker in serve mode. You can update an endpoint (model or number of instances) by specifying the endpoint-name.
#### Required Flags
`--s3-model-location S3_LOCATION_TO_MODEL_TAR_GZ` or `-m S3_LOCATION_TO_MODEL_TAR_GZ`: S3 location to to model tar.gz
`--num-instances NUMBER_OF_EC2_INSTANCES` or `n NUMBER_OF_EC2_INSTANCES`: Number of ec2 instances
`--ec2-type EC2_TYPE` or `e EC2_TYPE`: ec2 type. Refer to https://aws.amazon.com/sagemaker/pricing/instance-types/
#### Optional Flags
`--aws-tags TAGS` or `-a TAGS`: Tags for labeling a training job of the form `tag1=value1;tag2=value2`. For more, see https://docs.aws.amazon.com/sagemaker/latest/dg/API_Tag.html.
`--iam-role-arn IAM_ROLE` or `-r IAM_ROLE`: AWS IAM role to use for deploying with *SageMaker*
`--external-id EXTERNAL_ID` or `-x EXTERNAL_ID`: Optional external id used when using an IAM role
`--endpoint-name ENDPOINT_NAME`: Optional name for the SageMaker endpoint
#### Example
sagify cloud deploy -m s3://my-bucket/output/model.tar.gz -n 3 -e ml.m4.xlarge
### Cloud Batch Transform
#### Name
Executes a Docker image in batch transform mode on AWS SageMaker, i.e. runs batch predictions on user defined S3 data
#### Synopsis
sagify cloud batch-transform --s3-model-location S3_LOCATION_TO_MODEL_TAR_GZ --s3-input-location S3_INPUT_LOCATION --s3-output-location S3_OUTPUT_LOCATION --num-instance NUMBER_OF_EC2_INSTANCES --ec2-type EC2_TYPE [--aws-tags TAGS] [--iam-role-arn IAM_ROLE] [--external-id EXTERNAL_ID] [--wait WAIT_UNTIL_BATCH_TRANSFORM_JOB_IS_FINISHED] [--job-name JOB_NAME]
#### Description
This command retrieves a Docker image from AWS Elastic Container Service and executes it on AWS SageMaker in batch transform mode, i.e. runs batch predictions on user defined S3 data. SageMaker will spin up REST container(s) and call it/them with input data(features) from a user defined S3 path.
Things to do:
- You should implement the predict function that expects a JSON containing the required feature values. It's the same predict function used for deploying the model as a REST service. Example of a JSON:
```json
{
"features": [5.1,3.5,1.4,0.2]
}
```
- The input S3 path should contain a file or multiple files where each line is a JSON, the same JSON format as the one expected in the predict function. Example of a file:
```json
{"features": [[5.1,3.5,1.4,0.2]]}
{"features": [[4.9,3.0,1.4,0.2]]}
{"features": [[4.7,3.2,1.3,0.2]]}
{"features": [[4.6,3.1,1.5,0.2]]}
```
#### Required Flags
`--s3-model-location S3_LOCATION_TO_MODEL_TAR_GZ` or `-m S3_LOCATION_TO_MODEL_TAR_GZ`: S3 location to to model tar.gz
`--s3-input-location S3_INPUT_LOCATION` or `-i S3_INPUT_LOCATION`: s3 input data location
`--s3-output-location S3_OUTPUT_LOCATION` or `-o S3_OUTPUT_LOCATION`: s3 location to save predictions
`--num-instances NUMBER_OF_EC2_INSTANCES` or `n NUMBER_OF_EC2_INSTANCES`: Number of ec2 instances
`--ec2-type EC2_TYPE` or `e EC2_TYPE`: ec2 type. Refer to https://aws.amazon.com/sagemaker/pricing/instance-types/
#### Optional Flags
`--aws-tags TAGS` or `-a TAGS`: Tags for labeling a training job of the form `tag1=value1;tag2=value2`. For more, see https://docs.aws.amazon.com/sagemaker/latest/dg/API_Tag.html.
`--iam-role-arn IAM_ROLE` or `-r IAM_ROLE`: AWS IAM role to use for deploying with *SageMaker*
`--external-id EXTERNAL_ID` or `-x EXTERNAL_ID`: Optional external id used when using an IAM role
`--wait WAIT_UNTIL_BATCH_TRANSFORM_JOB_IS_FINISHED` or `-w WAIT_UNTIL_BATCH_TRANSFORM_JOB_IS_FINISHED`: Optional flag to wait until Batch Transform is finished. (default: don't wait)
`--job-name JOB_NAME`: Optional name for the SageMaker batch transform job
#### Example
sagify cloud batch-transform -m s3://my-bucket/output/model.tar.gz -i s3://my-bucket/input_features -o s3://my-bucket/predictions -n 3 -e ml.m4.xlarge
### Cloud Create Streaming Inference
NOTE: THIS IS AN EXPERIMENTAL FEATURE
Make sure that the following 2 policies are attached to the role you created in section "Configure AWS Account":
#### Name
Creates streaming inference pipelines
#### Synopsis
sagify cloud create-streaming-inference --name WORKER_NAME --endpoint-name ENDPOINT_NAME --input-topic-name FEATURES_INPUT_TOPIC_NAME --output-topic-name PREDICTIONS_OUTPUT_TOPIC_NAME --type STREAMING_INFERENCE_TYPE
#### Description
This command creates a worker as a Lambda function that listens to features in the `FEATURES_INPUT_TOPIC_NAME`, calls the the endpoint `ENDPOINT_NAME` and, finally, forwards predictions to `PREDICTIONS_OUTPUT_TOPIC_NAME`.
#### Required Flags
`--name WORKER_NAME`: The name of the Lambda function
`--endpoint-name ENDPOINT_NAME`: The name of the endpoint of the deployed model
`--input-topic-name FEATURES_INPUT_TOPIC_NAME`: Topic name where features will be landed
`--output-topic-name PREDICTIONS_OUTPUT_TOPIC_NAME`: Topic name where model predictions will be forwarded
`--type STREAMING_INFERENCE_TYPE`: The type of streaming inference. At the moment, only `SQS` is supported!
#### Example
sagify cloud create-streaming-inference --name recommender-worker --endpoint-name my-recommender-endpoint-1 --input-topic-name features --output-topic-name model-predictions --type SQS
### Cloud Delete Streaming Inference
NOTE: THIS IS AN EXPERIMENTAL FEATURE
Make sure that the following 2 policies are attached to the role you created in section "Configure AWS Account":
#### Name
Deletes streaming inference pipelines
#### Synopsis
sagify cloud delete-streaming-inference --name WORKER_NAME --input-topic-name FEATURES_INPUT_TOPIC_NAME --output-topic-name PREDICTIONS_OUTPUT_TOPIC_NAME --type STREAMING_INFERENCE_TYPE
#### Description
This command deletes the worker (i.e. Lambda function), input topic `FEATURES_INPUT_TOPIC_NAME` and output topic `PREDICTIONS_OUTPUT_TOPIC_NAME`.
#### Required Flags
`--name WORKER_NAME`: The name of the Lambda function
`--input-topic-name FEATURES_INPUT_TOPIC_NAME`: Topic name where features will be landed
`--output-topic-name PREDICTIONS_OUTPUT_TOPIC_NAME`: Topic name where model predictions will be forwarded
`--type STREAMING_INFERENCE_TYPE`: The type of streaming inference. At the moment, only `SQS` is supported!
#### Example
sagify cloud delete-streaming-inference --name recommender-worker --input-topic-name features --output-topic-name model-predictions --type SQS
### Cloud Lightning Deploy
#### Name
Command for lightning deployment of pre-trained ML model(s) on AWS SageMaker without code
#### Synopsis
sagify cloud lightning-deploy --framework FRAMEWORK --num-instances NUMBER_OF_EC2_INSTANCES --ec2-type EC2_TYPE --aws-profile AWS_PROFILE --aws-region AWS_REGION --extra-config-file EXTRA_CONFIG_FILE [--model-server-workers MODEL_SERVER_WORKERS] [--s3-model-location S3_LOCATION_TO_MODEL_TAR_GZ] [--aws-tags TAGS] [--iam-role-arn IAM_ROLE] [--external-id EXTERNAL_ID] [--endpoint-name ENDPOINT_NAME]
#### Description
This command deploys a pre-trained ML model without code.
#### Required Flags
`--framework FRAMEWORK`: Name of the ML framework. Valid values: `sklearn`, `huggingface`, `xgboost`
`--num-instances NUMBER_OF_EC2_INSTANCES` or `n NUMBER_OF_EC2_INSTANCES`: Number of ec2 instances
`--ec2-type EC2_TYPE` or `e EC2_TYPE`: ec2 type. Refer to https://aws.amazon.com/sagemaker/pricing/instance-types/
`--aws-profile AWS_PROFILE`: The AWS profile to use for the lightning deploy command
`--aws-region AWS_REGION`: The AWS region to use for the lightning deploy command
`--extra-config-file EXTRA_CONFIG_FILE`: Json file with ML framework specific arguments
For SKLearn, you have to specify the `framework_version` in the EXTRA_CONFIG_FILE and specify the S3 location to model tar.gz (i.e. tar gzip your sklearn pickled file
#### Optional Flags
`--s3-model-location S3_LOCATION_TO_MODEL_TAR_GZ` or `-m S3_LOCATION_TO_MODEL_TAR_GZ`: Optional S3 location to model tar.gz
`--aws-tags TAGS` or `-a TAGS`: Tags for labeling a training job of the form `tag1=value1;tag2=value2`. For more, see https://docs.aws.amazon.com/sagemaker/latest/dg/API_Tag.html.
`--iam-role-arn IAM_ROLE` or `-r IAM_ROLE`: AWS IAM role to use for deploying with *SageMaker*
`--external-id EXTERNAL_ID` or `-x EXTERNAL_ID`: Optional external id used when using an IAM role
`--endpoint-name ENDPOINT_NAME`: Optional name for the SageMaker endpoint
#### Example for SKLearn
Compress your pre-trained sklearn model to a GZIP tar archive with command `!tar czvf model.tar.gz $your_sklearn_model_name`.
sagify cloud lightning-deploy --framework sklearn -n 1 -e ml.c4.2xlarge --extra-config-file sklearn_config.json --aws-region us-east-1 --aws-profile sagemaker-dev -m s3://my-bucket/output/model.tar.gz
The `sklearn_config.json` must contain the following flag `framework_version`. Supported sklearn version(s): 0.20.0, 0.23-1.
Example of `sklearn_config.json`:
{
"framework_version": "0.23-1"
}
#### Example for HuggingFace by specifying the `S3_LOCATION_TO_MODEL_TAR_GZ`
Compress your pre-trained HuggingFace model to a GZIP tar archive with command `!tar czvf model.tar.gz $your_hg_model_name`.
sagify cloud lightning-deploy --framework huggingface -n 1 -e ml.c4.2xlarge --extra-config-file huggingface_config.json --aws-region us-east-1 --aws-profile sagemaker-dev -m s3://my-bucket/output/model.tar.gz
The `huggingface_config.json` must contain the following flags `pytorch_version` or `tensorflow_version` (not both), and `transformers_version`. For more info: https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/sagemaker.huggingface.html#hugging-face-model.
Example of `huggingface_config.json`:
{
"transformers_version": "4.6.1",
"pytorch_version": "1.7.1"
}
#### Example for HuggingFace without specifying the `S3_LOCATION_TO_MODEL_TAR_GZ`
sagify cloud lightning-deploy --framework huggingface -n 1 -e ml.c4.2xlarge --extra-config-file huggingface_config.json --aws-region us-east-1 --aws-profile sagemaker-dev
The `huggingface_config.json` must contain the following flags `pytorch_version` or `tensorflow_version` (not both), `transformers_version` and `hub`. For more info: https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/sagemaker.huggingface.html#hugging-face-model.
Example of `huggingface_config.json`:
{
"transformers_version": "4.6.1",
"pytorch_version": "1.7.1",
"hub": {
"HF_MODEL_ID": "gpt2",
"HF_TASK": "text-generation"
}
}
#### Example for XGBoost
Compress your pre-trained XGBoost model to a GZIP tar archive with command `!tar czvf model.tar.gz $your_xgboost_model_name`.
sagify cloud lightning-deploy --framework xgboost -n 1 -e ml.c4.2xlarge --extra-config-file xgboost_config.json --aws-region us-east-1 --aws-profile sagemaker-dev -m s3://my-bucket/output/model.tar.gz
The `xgboost_config.json` must contain the following flag `framework_version`. Supported xgboost version(s): 0.90-2, 1.0-1, and later.
Example of `xgboost_config.json`:
{
"framework_version": "0.23-1"
}
| /sagify-0.23.0.tar.gz/sagify-0.23.0/README.md | 0.807992 | 0.906694 | README.md | pypi |
# SAGOD:Static Attributed Graph Outlier Detection
中文README : [cnREADME.md](./cnREADME.md).
SAGOD (**S**tatic **A**ttributed **G**raph **O**utlier **D**etection) is an implementation of anomaly detection models on static attributed graph. Inspierd by [PyOD](https://github.com/yzhao062/pyod) and [PyGOD](https://github.com/pygod-team/pygod), we designed convenient interface to train model and make prediction. SAGOD support the following models:
- [x] [AdONE](paper/done&adone.pdf) : Adversarial Outlier Aware Network Embedding;
- [x] [ALARM](papaer/alarm.pdf) : A deep multi-view framework for anomaly detection;
- [x] [ANOMALOUS](paper/anomalous.pdf) : A Joint Modeling Approach for Anomaly Detection on Attributed Networks;
- [x] [AnomalyDAE](paper/AnomalyDAE.pdf) : Anomaly Detection through a Dual Autoencoder;
- [x] [ComGA](paper/comga.pdf) : Community-Aware Attributed Graph Anomaly Detection;
- [x] [DeepAE](paper/deepae.pdf) : Anomaly Detection with Deep Graph Autoencoders on Attributed Networks.
- [x] [DOMINANT](paper/dominant.pdf) : Deep Anomaly Detection on Attributed Networks;
- [x] [DONE](paper/done&adone.pdf) : Deep Outlier Aware Network Embedding;
- [x] [GAAN](paper/gaan.pdf) : Generative Adversarial Attributed Network;
- [x] [OCGNN](paper/ocgnn.pdf) : One-Class GNN;
- [x] [ONE](paper/one.pdf) : Outlier Aware Network Embedding;
- [x] [Radar](paper/radar.pdf) : Residual Analysis for Anomaly Detection in Attributed Networks.
- [x] [ResGCN](paper/resgcn.pdf) : Residual Graph Convolutional Network.
- [x] [SADAG](paper/sadag.pdf) : Semi-supervised Anomaly Detection on Attributed Graphs.
We are still updating and adding models. It's worth nothing that the original purpose of SAGOD is to implement anomaly detection models on graph, in order to help researchers who are interested in this area (including me).
## Overview
In `test.py`, we generate anomaly data from MUTAG, and use different models to train it. The ROC curve is shown below:
<div align=center><img src="src/eval.png" alt="eval" width="550"/></div>
## Install
```bash
pip3 install sagod
```
or
```bash
git clone https://github.com/Kaslanarian/SAGOD
cd SAGOD
python3 setup.py install
```
## Example
Here is an example to use SAGOD:
```python
from sagod import DOMINANT
from sagod.utils import struct_ano_injection, attr_ano_injection
data = ... # Graph data, type:torch_geometric.data.Data
data.y = torch.zeros(data.num_nodes)
data = struct_ano_injection(data, 10, 10) # Structrual anomaly injection.
data = attr_ano_injection(data, 100, 50) # Attributed anmaly injection.
model = DOMINANT(verbose=True).fit(data, data.y)
fpr, tpr, _ = roc_curve(data.y.numpy(), model.decision_scores_)[:2]
plt.plot(fpr, tpr, label='DOMINANT') # plot ROC curve
plt.legend()
plt.show()
```
## Highlight
Though SAGOD is similar to PyGOD, we keep innovating and improving:
- The model "ONE" in PyGOD was implemented based on [authors' responsitory](https://github.com/sambaranban/ONE). We improved it with vectorization, achieving a 100% performance improvement;
- We implemented ALARM, which can detect anomaly in multi-view graph;
- We implemented more models including ComGA, DeepAE, etc, which is not included in PyGOD;
- ...
## Future Plan
- Support batch mechanism and huge graph input;
- Support GPU;
- More models implementation;
- Annotation and manual;
- ...
## Reference
- Bandyopadhyay, Sambaran, Saley Vishal Vivek, and M. N. Murty. ["Outlier resistant unsupervised deep architectures for attributed network embedding."](paper/done&adone.pdf) Proceedings of the 13th international conference on web search and data mining. 2020.
- Bandyopadhyay, Sambaran, N. Lokesh, and M. Narasimha Murty. ["Outlier aware network embedding for attributed networks."](paper/one.pdf) Proceedings of the AAAI conference on artificial intelligence. Vol. 33. No. 01. 2019.
- Fan, Haoyi, Fengbin Zhang, and Zuoyong Li. ["AnomalyDAE: Dual autoencoder for anomaly detection on attributed networks."](paper/AnomalyDAE.pdf) ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP). IEEE, 2020.
- Chen, Zhenxing, et al. ["Generative adversarial attributed network anomaly detection."](paper/gaan.pdf) Proceedings of the 29th ACM International Conference on Information & Knowledge Management. 2020.
- Ding, Kaize, et al. ["Deep anomaly detection on attributed networks."](paper/dominant.pdf) Proceedings of the 2019 SIAM International Conference on Data Mining. Society for Industrial and Applied Mathematics, 2019.
- Kumagai, Atsutoshi, Tomoharu Iwata, and Yasuhiro Fujiwara. ["Semi-supervised anomaly detection on attributed graphs."](paper/sadag.pdf) 2021 International Joint Conference on Neural Networks (IJCNN). IEEE, 2021.
- Li, Jundong, et al. ["Radar: Residual Analysis for Anomaly Detection in Attributed Networks."](paper/radar.pdf) IJCAI. 2017.
- Luo, Xuexiong, et al. ["ComGA: Community-Aware Attributed Graph Anomaly Detection."](paper/comga.pdf) Proceedings of the Fifteenth ACM International Conference on Web Search and Data Mining. 2022.
- Pei, Yulong, et al. ["ResGCN: attention-based deep residual modeling for anomaly detection on attributed networks."](paper/resgcn.pdf) Machine Learning 111.2 (2022): 519-541.
- Peng, Zhen, et al. ["A deep multi-view framework for anomaly detection on attributed networks."](paper/alarm.pdf) IEEE Transactions on Knowledge and Data Engineering (2020).
- Peng, Zhen, et al. ["ANOMALOUS: A Joint Modeling Approach for Anomaly Detection on Attributed Networks."](paper/anomalous.pdf) IJCAI. 2018.
- Wang, Xuhong, et al. ["One-class graph neural networks for anomaly detection in attributed networks."](paper/ocgnn.pdf) Neural computing and applications 33.18 (2021): 12073-12085.
- Zhu, Dali, Yuchen Ma, and Yinlong Liu. ["Anomaly detection with deep graph autoencoders on attributed networks."](paper/deepae.pdf) 2020 IEEE Symposium on Computers and Communications (ISCC). IEEE, 2020.
| /sagod-0.0.2.tar.gz/sagod-0.0.2/README.md | 0.665411 | 0.980894 | README.md | pypi |
import base64
import copy
from urllib import parse
def serialize(obj):
"""Serialize the given object
:param obj: string representation of the object
:return: encoded object (its type is unicode string)
"""
result = base64.urlsafe_b64encode(obj)
# this workaround is needed because in case of python 3 the
# urlsafe_b64encode method returns string of 'bytes' class.
result = result.decode()
return result
def deserialize(obj):
"""Deserialize the given object
:param obj: string representation of the encoded object
:return: decoded object (its type is unicode string)
"""
result = base64.urlsafe_b64decode(obj)
# this workaround is needed because in case of python 3 the
# urlsafe_b64decode method returns string of 'bytes' class
result = result.decode()
return result
def delete_pagination_params_from_request(request, save_limit=None):
"""Delete marker and limit parameters from GET requests
:param request: instance of GET request
:param save_limit: if True, 'limit' will not be deleted
:return: instance of GET request without marker or limit
"""
request = copy.copy(request)
request.GET = request.GET.copy()
params = ['marker']
if not save_limit:
params.append('limit')
for param in ['marker', 'limit']:
if param in request.GET:
del(request.GET[param])
query_string = request.META.get('QUERY_STRING', '')
query_dict = parse.parse_qs(query_string)
if param in query_dict:
del(query_dict[param])
query_string = parse.urlencode(query_dict, doseq=True)
request.META['QUERY_STRING'] = query_string
return request
def smart_sort_helper(version):
"""Allows intelligent sorting of plugin versions, for example when
minor version of a plugin is 11, sort numerically so that 11 > 10,
instead of alphabetically so that 2 > 11
"""
def _safe_cast_to_int(obj):
try:
return int(obj)
except ValueError:
return obj
return [_safe_cast_to_int(part) for part in version.split('.')] | /sahara_dashboard-18.0.0-py3-none-any.whl/sahara_dashboard/utils.py | 0.610453 | 0.260104 | utils.py | pypi |
from django.utils.translation import gettext_lazy as _
from django.utils.translation import ngettext_lazy
from horizon import tables
from horizon.tabs import base as tabs_base
from sahara_dashboard.api import sahara as saharaclient
from sahara_dashboard.content.data_processing \
import tables as sahara_table
from sahara_dashboard.content.data_processing.utils \
import acl as acl_utils
class CreateDataSource(tables.LinkAction):
name = "create data source"
verbose_name = _("Create Data Source")
url = "horizon:project:data_processing.jobs:create-data-source"
classes = ("ajax-modal",)
icon = "plus"
class DeleteDataSource(tables.DeleteAction):
@staticmethod
def action_present(count):
return ngettext_lazy(
u"Delete Data Source",
u"Delete Data Sources",
count
)
@staticmethod
def action_past(count):
return ngettext_lazy(
u"Deleted Data Source",
u"Deleted Data Sources",
count
)
def delete(self, request, obj_id):
saharaclient.data_source_delete(request, obj_id)
class EditDataSource(tables.LinkAction):
name = "edit data source"
verbose_name = _("Edit Data Source")
url = "horizon:project:data_processing.jobs:edit-data-source"
classes = ("ajax-modal",)
class MakePublic(acl_utils.MakePublic):
def change_rule_method(self, request, datum_id, **update_kwargs):
saharaclient.data_source_update(
request, datum_id, update_kwargs)
class MakePrivate(acl_utils.MakePrivate):
def change_rule_method(self, request, datum_id, **update_kwargs):
saharaclient.data_source_update(
request, datum_id, update_kwargs)
class MakeProtected(acl_utils.MakeProtected):
def change_rule_method(self, request, datum_id, **update_kwargs):
saharaclient.data_source_update(
request, datum_id, update_kwargs)
class MakeUnProtected(acl_utils.MakeUnProtected):
def change_rule_method(self, request, datum_id, **update_kwargs):
saharaclient.data_source_update(
request, datum_id, update_kwargs)
class DataSourcesTable(sahara_table.SaharaPaginateTabbedTable):
tab_name = 'job_tabs%sdata_sources_tab' % tabs_base.SEPARATOR
name = tables.Column("name",
verbose_name=_("Name"),
link=("horizon:project:data_processing."
"jobs:ds-details"))
type = tables.Column("type",
verbose_name=_("Type"))
description = tables.Column("description",
verbose_name=_("Description"))
class Meta(object):
name = "data_sources"
verbose_name = _("Data Sources")
table_actions = (CreateDataSource,
DeleteDataSource)
table_actions_menu = (MakePublic,
MakePrivate,
MakeProtected,
MakeUnProtected)
row_actions = (DeleteDataSource,
EditDataSource,
MakePublic,
MakePrivate,
MakeProtected,
MakeUnProtected) | /sahara_dashboard-18.0.0-py3-none-any.whl/sahara_dashboard/content/data_processing/jobs/data_sources/tables.py | 0.494629 | 0.155655 | tables.py | pypi |
from oslo_serialization import jsonutils
from sahara.plugins import provisioning
from sahara.plugins import swift_helper
from sahara.plugins import utils
from sahara_plugin_ambari.i18n import _
from sahara_plugin_ambari.plugins.ambari import common
CONFIGS = {}
OBJ_CONFIGS = {}
CFG_PROCESS_MAP = {
"admin-properties": common.RANGER_SERVICE,
"ams-env": common.AMBARI_SERVICE,
"ams-hbase-env": common.AMBARI_SERVICE,
"ams-hbase-policy": common.AMBARI_SERVICE,
"ams-hbase-security-site": common.AMBARI_SERVICE,
"ams-hbase-site": common.AMBARI_SERVICE,
"ams-site": common.AMBARI_SERVICE,
"capacity-scheduler": common.YARN_SERVICE,
"cluster-env": "general",
"core-site": common.HDFS_SERVICE,
"falcon-env": common.FALCON_SERVICE,
"falcon-runtime.properties": common.FALCON_SERVICE,
"falcon-startup.properties": common.FALCON_SERVICE,
"flume-env": common.FLUME_SERVICE,
"gateway-site": common.KNOX_SERVICE,
"hadoop-env": common.HDFS_SERVICE,
"hadoop-policy": common.HDFS_SERVICE,
"hbase-env": common.HBASE_SERVICE,
"hbase-policy": common.HBASE_SERVICE,
"hbase-site": common.HBASE_SERVICE,
"hdfs-site": common.HDFS_SERVICE,
"hive-env": common.HIVE_SERVICE,
"hive-site": common.HIVE_SERVICE,
"hiveserver2-site": common.HIVE_SERVICE,
"kafka-broker": common.KAFKA_SERVICE,
"kafka-env": common.KAFKA_SERVICE,
"knox-env": common.KNOX_SERVICE,
"mapred-env": common.YARN_SERVICE,
"mapred-site": common.YARN_SERVICE,
"oozie-env": common.OOZIE_SERVICE,
"oozie-site": common.OOZIE_SERVICE,
"ranger-env": common.RANGER_SERVICE,
"ranger-hbase-plugin-properties": common.HBASE_SERVICE,
"ranger-hdfs-plugin-properties": common.HDFS_SERVICE,
"ranger-hive-plugin-properties": common.HIVE_SERVICE,
"ranger-knox-plugin-properties": common.KNOX_SERVICE,
"ranger-site": common.RANGER_SERVICE,
"ranger-storm-plugin-properties": common.STORM_SERVICE,
"spark-defaults": common.SPARK_SERVICE,
"spark-env": common.SPARK_SERVICE,
"sqoop-env": common.SQOOP_SERVICE,
"storm-env": common.STORM_SERVICE,
"storm-site": common.STORM_SERVICE,
"tez-site": common.OOZIE_SERVICE,
"usersync-properties": common.RANGER_SERVICE,
"yarn-env": common.YARN_SERVICE,
"yarn-site": common.YARN_SERVICE,
"zoo.cfg": common.ZOOKEEPER_SERVICE,
"zookeeper-env": common.ZOOKEEPER_SERVICE
}
SERVICES_TO_CONFIGS_MAP = None
def get_service_to_configs_map():
global SERVICES_TO_CONFIGS_MAP
if SERVICES_TO_CONFIGS_MAP:
return SERVICES_TO_CONFIGS_MAP
data = {}
for (key, item) in CFG_PROCESS_MAP.items():
if item not in data:
data[item] = []
data[item].append(key)
SERVICES_TO_CONFIGS_MAP = data
return SERVICES_TO_CONFIGS_MAP
ng_confs = [
"dfs.datanode.data.dir",
"dtnode_heapsize",
"mapreduce.map.java.opts",
"mapreduce.map.memory.mb",
"mapreduce.reduce.java.opts",
"mapreduce.reduce.memory.mb",
"mapreduce.task.io.sort.mb",
"nodemanager_heapsize",
"yarn.app.mapreduce.am.command-opts",
"yarn.app.mapreduce.am.resource.mb",
"yarn.nodemanager.resource.cpu-vcores",
"yarn.nodemanager.resource.memory-mb",
"yarn.scheduler.maximum-allocation-mb",
"yarn.scheduler.minimum-allocation-mb"
]
use_base_repos_cfg = provisioning.Config(
"Enable external repos on instances", 'general', 'cluster', priority=1,
default_value=True, config_type="bool")
hdp_repo_cfg = provisioning.Config(
"HDP repo URL", "general", "cluster", priority=1, default_value="")
hdp_utils_repo_cfg = provisioning.Config(
"HDP-UTILS repo URL", "general", "cluster", priority=1, default_value="")
autoconfigs_strategy = provisioning.Config(
"Auto-configuration strategy", 'general', 'cluster', priority=1,
config_type='dropdown',
default_value='NEVER_APPLY',
config_values=[(v, v) for v in [
'NEVER_APPLY', 'ALWAYS_APPLY', 'ONLY_STACK_DEFAULTS_APPLY',
]],
)
ambari_pkg_install_timeout = provisioning.Config(
"Ambari Agent Package Install timeout", "general", "cluster",
priority=1, default_value="1800")
def _get_service_name(service):
return CFG_PROCESS_MAP.get(service, service)
def _get_config_group(group, param, plugin_version):
if not CONFIGS or plugin_version not in CONFIGS:
load_configs(plugin_version)
for section, process in CFG_PROCESS_MAP.items():
if process == group and param in CONFIGS[plugin_version][section]:
return section
def _get_param_scope(param):
if param in ng_confs:
return "node"
else:
return "cluster"
def _get_ha_params():
enable_namenode_ha = provisioning.Config(
name=common.NAMENODE_HA,
applicable_target="general",
scope="cluster",
config_type="bool",
default_value=False,
is_optional=True,
description=_("Enable NameNode HA"),
priority=1)
enable_resourcemanager_ha = provisioning.Config(
name=common.RESOURCEMANAGER_HA,
applicable_target="general",
scope="cluster",
config_type="bool",
default_value=False,
is_optional=True,
description=_("Enable ResourceManager HA"),
priority=1)
enable_regionserver_ha = provisioning.Config(
name=common.HBASE_REGIONSERVER_HA,
applicable_target="general",
scope="cluster",
config_type="bool",
default_value=False,
is_optional=True,
description=_("Enable HBase RegionServer HA"),
priority=1)
return [enable_namenode_ha,
enable_resourcemanager_ha,
enable_regionserver_ha]
def load_configs(version):
if OBJ_CONFIGS.get(version):
return OBJ_CONFIGS[version]
cfg_path = "plugins/ambari/resources/configs-%s.json" % version
vanilla_cfg = jsonutils.loads(utils.get_file_text(cfg_path,
'sahara_plugin_ambari'))
CONFIGS[version] = vanilla_cfg
sahara_cfg = [hdp_repo_cfg, hdp_utils_repo_cfg, use_base_repos_cfg,
autoconfigs_strategy, ambari_pkg_install_timeout]
for service, confs in vanilla_cfg.items():
for k, v in confs.items():
sahara_cfg.append(provisioning.Config(
k, _get_service_name(service), _get_param_scope(k),
default_value=v))
sahara_cfg.extend(_get_ha_params())
OBJ_CONFIGS[version] = sahara_cfg
return sahara_cfg
def _get_config_value(cluster, key):
return cluster.cluster_configs.get("general", {}).get(key.name,
key.default_value)
def use_base_repos_needed(cluster):
return _get_config_value(cluster, use_base_repos_cfg)
def get_hdp_repo_url(cluster):
return _get_config_value(cluster, hdp_repo_cfg)
def get_hdp_utils_repo_url(cluster):
return _get_config_value(cluster, hdp_utils_repo_cfg)
def get_auto_configuration_strategy(cluster):
return _get_config_value(cluster, autoconfigs_strategy)
def get_ambari_pkg_install_timeout(cluster):
return _get_config_value(cluster, ambari_pkg_install_timeout)
def _serialize_ambari_configs(configs):
return list(map(lambda x: {x: configs[x]}, configs))
def _create_ambari_configs(sahara_configs, plugin_version):
configs = {}
for service, params in sahara_configs.items():
if service == "general" or service == "Kerberos":
# General and Kerberos configs are designed for Sahara, not for
# the plugin
continue
for k, v in params.items():
group = _get_config_group(service, k, plugin_version)
configs.setdefault(group, {})
configs[group].update({k: v})
return configs
def _make_paths(dirs, suffix):
return ",".join([d + suffix for d in dirs])
def get_instance_params_mapping(inst):
configs = _create_ambari_configs(inst.node_group.node_configs,
inst.node_group.cluster.hadoop_version)
storage_paths = inst.storage_paths()
configs.setdefault("hdfs-site", {})
configs["hdfs-site"]["dfs.datanode.data.dir"] = _make_paths(
storage_paths, "/hdfs/data")
configs["hdfs-site"]["dfs.journalnode.edits.dir"] = _make_paths(
storage_paths, "/hdfs/journalnode")
configs["hdfs-site"]["dfs.namenode.checkpoint.dir"] = _make_paths(
storage_paths, "/hdfs/namesecondary")
configs["hdfs-site"]["dfs.namenode.name.dir"] = _make_paths(
storage_paths, "/hdfs/namenode")
configs.setdefault("yarn-site", {})
configs["yarn-site"]["yarn.nodemanager.local-dirs"] = _make_paths(
storage_paths, "/yarn/local")
configs["yarn-site"]["yarn.nodemanager.log-dirs"] = _make_paths(
storage_paths, "/yarn/log")
configs["yarn-site"][
"yarn.timeline-service.leveldb-timeline-store.path"] = _make_paths(
storage_paths, "/yarn/timeline")
configs.setdefault("oozie-site", {})
configs["oozie-site"][
"oozie.service.AuthorizationService.security.enabled"] = "false"
return configs
def get_instance_params(inst):
return _serialize_ambari_configs(get_instance_params_mapping(inst))
def get_cluster_params(cluster):
configs = _create_ambari_configs(cluster.cluster_configs,
cluster.hadoop_version)
swift_configs = {x["name"]: x["value"]
for x in swift_helper.get_swift_configs()}
configs.setdefault("core-site", {})
configs["core-site"].update(swift_configs)
if utils.get_instance(cluster, common.RANGER_ADMIN):
configs.setdefault("admin-properties", {})
configs["admin-properties"]["db_root_password"] = (
cluster.extra["ranger_db_password"])
return _serialize_ambari_configs(configs)
def get_config_group(instance):
params = get_instance_params_mapping(instance)
groups = []
for (service, targets) in get_service_to_configs_map().items():
current_group = {
'cluster_name': instance.cluster.name,
'group_name': "%s:%s" % (
instance.cluster.name, instance.instance_name),
'tag': service,
'description': "Config group for scaled "
"node %s" % instance.instance_name,
'hosts': [
{
'host_name': instance.fqdn()
}
],
'desired_configs': []
}
at_least_one_added = False
for target in targets:
configs = params.get(target, {})
if configs:
current_group['desired_configs'].append({
'type': target,
'properties': configs,
'tag': instance.instance_name
})
at_least_one_added = True
if at_least_one_added:
# Config Group without overridden data is not interesting
groups.append({'ConfigGroup': current_group})
return groups | /sahara_plugin_ambari-9.0.0-py3-none-any.whl/sahara_plugin_ambari/plugins/ambari/configs.py | 0.416203 | 0.159938 | configs.py | pypi |
import eventlet
EVENTLET_MONKEY_PATCH_MODULES = dict(os=True,
select=True,
socket=True,
thread=True,
time=True)
def patch_all():
"""Apply all patches.
List of patches:
* eventlet's monkey patch for all cases;
* minidom's writexml patch for py < 2.7.3 only.
"""
eventlet_monkey_patch()
patch_minidom_writexml()
def eventlet_monkey_patch():
"""Apply eventlet's monkey patch.
This call should be the first call in application. It's safe to call
monkey_patch multiple times.
"""
eventlet.monkey_patch(**EVENTLET_MONKEY_PATCH_MODULES)
def eventlet_import_monkey_patched(module):
"""Returns module monkey patched by eventlet.
It's needed for some tests, for example, context test.
"""
return eventlet.import_patched(module, **EVENTLET_MONKEY_PATCH_MODULES)
def patch_minidom_writexml():
"""Patch for xml.dom.minidom toprettyxml bug with whitespaces around text
We apply the patch to avoid excess whitespaces in generated xml
configuration files that brakes Hadoop.
(This patch will be applied for all Python versions < 2.7.3)
Issue: http://bugs.python.org/issue4147
Patch: http://hg.python.org/cpython/rev/cb6614e3438b/
Description: http://ronrothman.com/public/leftbraned/xml-dom-minidom-\
toprettyxml-and-silly-whitespace/#best-solution
"""
import sys
if sys.version_info >= (2, 7, 3):
return
import xml.dom.minidom as md
def element_writexml(self, writer, indent="", addindent="", newl=""):
# indent = current indentation
# addindent = indentation to add to higher levels
# newl = newline string
writer.write(indent + "<" + self.tagName)
attrs = self._get_attributes()
a_names = list(attrs.keys())
a_names.sort()
for a_name in a_names:
writer.write(" %s=\"" % a_name)
md._write_data(writer, attrs[a_name].value)
writer.write("\"")
if self.childNodes:
writer.write(">")
if (len(self.childNodes) == 1
and self.childNodes[0].nodeType == md.Node.TEXT_NODE):
self.childNodes[0].writexml(writer, '', '', '')
else:
writer.write(newl)
for node in self.childNodes:
node.writexml(writer, indent + addindent, addindent, newl)
writer.write(indent)
writer.write("</%s>%s" % (self.tagName, newl))
else:
writer.write("/>%s" % (newl))
md.Element.writexml = element_writexml
def text_writexml(self, writer, indent="", addindent="", newl=""):
md._write_data(writer, "%s%s%s" % (indent, self.data, newl))
md.Text.writexml = text_writexml | /sahara_plugin_ambari-9.0.0-py3-none-any.whl/sahara_plugin_ambari/utils/patches.py | 0.444324 | 0.22133 | patches.py | pypi |
import copy
from sahara.plugins import provisioning as p
from sahara_plugin_cdh.i18n import _
from sahara_plugin_cdh.plugins.cdh import versionfactory as vhf
class CDHPluginProvider(p.ProvisioningPluginBase):
def __init__(self):
self.version_factory = vhf.VersionFactory.get_instance()
def get_title(self):
return "Cloudera Plugin"
def get_description(self):
return _('The Cloudera Sahara plugin provides the ability to '
'launch the Cloudera distribution of Apache Hadoop '
'(CDH) with Cloudera Manager management console.')
def get_labels(self):
default = {'enabled': {'status': True}, 'stable': {'status': True}}
result = {'plugin_labels': copy.deepcopy(default)}
deprecated = {'enabled': {'status': True},
'deprecated': {'status': True}}
result['version_labels'] = {
'5.13.0': copy.deepcopy(default),
'5.11.0': copy.deepcopy(default),
'5.9.0': copy.deepcopy(default),
'5.7.0': copy.deepcopy(deprecated)
}
return result
def _get_version_handler(self, hadoop_version):
return self.version_factory.get_version_handler(hadoop_version)
def get_versions(self):
return self.version_factory.get_versions()
def get_node_processes(self, hadoop_version):
return self._get_version_handler(hadoop_version).get_node_processes()
def get_configs(self, hadoop_version):
return self._get_version_handler(hadoop_version).get_plugin_configs()
def configure_cluster(self, cluster):
return self._get_version_handler(
cluster.hadoop_version).configure_cluster(cluster)
def start_cluster(self, cluster):
return self._get_version_handler(
cluster.hadoop_version).start_cluster(cluster)
def validate(self, cluster):
return self._get_version_handler(
cluster.hadoop_version).validate(cluster)
def scale_cluster(self, cluster, instances):
return self._get_version_handler(
cluster.hadoop_version).scale_cluster(cluster, instances)
def decommission_nodes(self, cluster, instances):
return self._get_version_handler(
cluster.hadoop_version).decommission_nodes(cluster, instances)
def validate_scaling(self, cluster, existing, additional):
return self._get_version_handler(
cluster.hadoop_version).validate_scaling(cluster, existing,
additional)
def get_edp_engine(self, cluster, job_type):
return self._get_version_handler(
cluster.hadoop_version).get_edp_engine(cluster, job_type)
def get_edp_job_types(self, versions=None):
res = {}
for vers in self.version_factory.get_versions():
if not versions or vers in versions:
vh = self.version_factory.get_version_handler(vers)
res[vers] = vh.get_edp_job_types()
return res
def get_edp_config_hints(self, job_type, version):
version_handler = (
self.version_factory.get_version_handler(version))
return version_handler.get_edp_config_hints(job_type)
def get_open_ports(self, node_group):
return self._get_version_handler(
node_group.cluster.hadoop_version).get_open_ports(node_group)
def recommend_configs(self, cluster, scaling=False):
return self._get_version_handler(
cluster.hadoop_version).recommend_configs(cluster, scaling)
def get_health_checks(self, cluster):
return self._get_version_handler(
cluster.hadoop_version).get_health_checks(cluster)
def get_image_arguments(self, hadoop_version):
return self._get_version_handler(hadoop_version).get_image_arguments()
def pack_image(self, hadoop_version, remote,
test_only=False, image_arguments=None):
version = self._get_version_handler(hadoop_version)
version.pack_image(hadoop_version, remote, test_only=test_only,
image_arguments=image_arguments)
def validate_images(self, cluster, test_only=False, image_arguments=None):
self._get_version_handler(cluster.hadoop_version).validate_images(
cluster, test_only=test_only, image_arguments=image_arguments) | /sahara_plugin_cdh-9.0.0.0rc1-py3-none-any.whl/sahara_plugin_cdh/plugins/cdh/plugin.py | 0.510985 | 0.190894 | plugin.py | pypi |
from sahara.plugins import edp
from sahara.plugins import exceptions as pl_ex
from sahara.plugins import kerberos
from sahara.plugins import utils as u
from sahara_plugin_cdh.i18n import _
class EdpOozieEngine(edp.PluginsOozieJobEngine):
def __init__(self, cluster):
super(EdpOozieEngine, self).__init__(cluster)
# will be defined in derived classes
self.cloudera_utils = None
def get_client(self):
if kerberos.is_kerberos_security_enabled(self.cluster):
return super(EdpOozieEngine, self).get_remote_client()
return super(EdpOozieEngine, self).get_client()
def get_hdfs_user(self):
return 'hdfs'
def create_hdfs_dir(self, remote, dir_name):
edp.create_dir_hadoop2(remote, dir_name, self.get_hdfs_user())
def get_oozie_server_uri(self, cluster):
oozie_ip = self.cloudera_utils.pu.get_oozie(cluster).management_ip
return 'http://%s:11000/oozie' % oozie_ip
def get_name_node_uri(self, cluster):
if len(self.cloudera_utils.pu.get_jns(cluster)) > 0:
return 'hdfs://%s' % self.cloudera_utils.NAME_SERVICE
else:
namenode_ip = self.cloudera_utils.pu.get_namenode(cluster).fqdn()
return 'hdfs://%s:8020' % namenode_ip
def get_resource_manager_uri(self, cluster):
resourcemanager = self.cloudera_utils.pu.get_resourcemanager(cluster)
return '%s:8032' % resourcemanager.fqdn()
def get_oozie_server(self, cluster):
return self.cloudera_utils.pu.get_oozie(cluster)
def validate_job_execution(self, cluster, job, data):
oo_count = u.get_instances_count(cluster, 'OOZIE_SERVER')
if oo_count != 1:
raise pl_ex.InvalidComponentCountException(
'OOZIE_SERVER', '1', oo_count)
super(EdpOozieEngine, self).validate_job_execution(cluster, job, data)
class EdpSparkEngine(edp.PluginsSparkJobEngine):
edp_base_version = ""
def __init__(self, cluster):
super(EdpSparkEngine, self).__init__(cluster)
self.master = u.get_instance(cluster, "SPARK_YARN_HISTORY_SERVER")
self.plugin_params["spark-user"] = "sudo -u spark "
self.plugin_params["spark-submit"] = "spark-submit"
self.plugin_params["deploy-mode"] = "cluster"
self.plugin_params["master"] = "yarn-cluster"
driver_cp = u.get_config_value_or_default(
"Spark", "Executor extra classpath", self.cluster)
self.plugin_params["driver-class-path"] = driver_cp
@classmethod
def edp_supported(cls, version):
return version >= cls.edp_base_version
def validate_job_execution(self, cluster, job, data):
if not self.edp_supported(cluster.hadoop_version):
raise pl_ex.PluginInvalidDataException(
_('Cloudera {base} or higher required to run {type}'
'jobs').format(base=self.edp_base_version, type=job.type))
shs_count = u.get_instances_count(
cluster, 'SPARK_YARN_HISTORY_SERVER')
if shs_count != 1:
raise pl_ex.InvalidComponentCountException(
'SPARK_YARN_HISTORY_SERVER', '1', shs_count)
super(EdpSparkEngine, self).validate_job_execution(
cluster, job, data) | /sahara_plugin_cdh-9.0.0.0rc1-py3-none-any.whl/sahara_plugin_cdh/plugins/cdh/edp_engine.py | 0.422505 | 0.169303 | edp_engine.py | pypi |
from oslo_utils import uuidutils
from sahara.plugins import castellan_utils as key_manager
from sahara.plugins import conductor
from sahara.plugins import context
from sahara.plugins import utils
CM_PASSWORD = 'cm_password'
HIVE_DB_PASSWORD = 'hive_db_password'
SENTRY_DB_PASSWORD = 'sentry_db_password'
def delete_password_from_keymanager(cluster, pwname):
"""delete the named password from the key manager
This function will lookup the named password in the cluster entry
and delete it from the key manager.
:param cluster: The cluster record containing the password
:param pwname: The name associated with the password
"""
ctx = context.ctx()
cluster = conductor.cluster_get(ctx, cluster.id)
key_id = cluster.extra.get(pwname) if cluster.extra else None
if key_id is not None:
key_manager.delete_key(key_id, ctx)
def delete_passwords_from_keymanager(cluster):
"""delete all passwords associated with a cluster
This function will remove all passwords stored in a cluster database
entry from the key manager.
:param cluster: The cluster record containing the passwords
"""
delete_password_from_keymanager(cluster, CM_PASSWORD)
delete_password_from_keymanager(cluster, HIVE_DB_PASSWORD)
delete_password_from_keymanager(cluster, SENTRY_DB_PASSWORD)
def get_password_from_db(cluster, pwname):
"""return a password for the named entry
This function will return, or create and return, a password for the
named entry. It will store the password in the key manager and use
the ID in the database entry.
:param cluster: The cluster record containing the password
:param pwname: The entry name associated with the password
:returns: The cleartext password
"""
ctx = context.ctx()
cluster = conductor.cluster_get(ctx, cluster.id)
passwd = cluster.extra.get(pwname) if cluster.extra else None
if passwd:
return key_manager.get_secret(passwd, ctx)
passwd = uuidutils.generate_uuid()
extra = cluster.extra.to_dict() if cluster.extra else {}
extra[pwname] = key_manager.store_secret(passwd, ctx)
conductor.cluster_update(ctx, cluster, {'extra': extra})
return passwd
def get_cm_password(cluster):
return get_password_from_db(cluster, CM_PASSWORD)
def remote_execute_db_script(remote, script_content):
script_name = 'script_to_exec.sql'
remote.write_file_to(script_name, script_content)
psql_cmd = ('PGPASSWORD=$(sudo head -1 /var/lib/cloudera-scm-server-db'
'/data/generated_password.txt) psql -U cloudera-scm '
'-h localhost -p 7432 -d scm -f %s') % script_name
remote.execute_command(psql_cmd)
remote.execute_command('rm %s' % script_name)
def get_hive_db_password(cluster):
return get_password_from_db(cluster, 'hive_db_password')
def get_sentry_db_password(cluster):
return get_password_from_db(cluster, 'sentry_db_password')
def create_hive_database(cluster, remote):
db_password = get_hive_db_password(cluster)
create_db_script = utils.try_get_file_text(
'plugins/cdh/db_resources/create_hive_db.sql', 'sahara_plugin_cdh')
create_db_script = create_db_script % db_password.encode('utf-8')
remote_execute_db_script(remote, create_db_script)
def create_sentry_database(cluster, remote):
db_password = get_sentry_db_password(cluster)
create_db_script = utils.try_get_file_text(
'plugins/cdh/db_resources/create_sentry_db.sql', 'sahara_plugin_cdh')
create_db_script = create_db_script % db_password.encode('utf-8')
remote_execute_db_script(remote, create_db_script) | /sahara_plugin_cdh-9.0.0.0rc1-py3-none-any.whl/sahara_plugin_cdh/plugins/cdh/db_helper.py | 0.552057 | 0.175998 | db_helper.py | pypi |
import abc
from sahara.plugins import conductor
from sahara.plugins import context
from sahara.plugins import kerberos
from sahara_plugin_cdh.plugins.cdh import db_helper as dh
from sahara_plugin_cdh.plugins.cdh import health
class AbstractVersionHandler(object, metaclass=abc.ABCMeta):
@abc.abstractmethod
def get_node_processes(self):
return
@abc.abstractmethod
def get_plugin_configs(self):
return
@abc.abstractmethod
def configure_cluster(self, cluster):
return
@abc.abstractmethod
def start_cluster(self, cluster):
return
@abc.abstractmethod
def validate(self, cluster):
return
@abc.abstractmethod
def scale_cluster(self, cluster, instances):
return
@abc.abstractmethod
def decommission_nodes(self, cluster, instances):
return
@abc.abstractmethod
def validate_scaling(self, cluster, existing, additional):
return
@abc.abstractmethod
def get_edp_engine(self, cluster, job_type):
return
@abc.abstractmethod
def get_edp_job_types(self):
return []
@abc.abstractmethod
def get_edp_config_hints(self, job_type):
return {}
@abc.abstractmethod
def get_open_ports(self, node_group):
return
def on_terminate_cluster(self, cluster):
dh.delete_passwords_from_keymanager(cluster)
@abc.abstractmethod
def get_image_arguments(self):
return NotImplemented
@abc.abstractmethod
def pack_image(self, hadoop_version, remote, test_only=False,
image_arguments=None):
pass
@abc.abstractmethod
def validate_images(self, cluster, test_only=False, image_arguments=None):
pass
class BaseVersionHandler(AbstractVersionHandler):
def __init__(self):
# Need to be specified in subclass
self.config_helper = None # config helper
self.cloudera_utils = None # ClouderaUtils
self.deploy = None # to deploy
self.edp_engine = None
self.plugin_utils = None # PluginUtils
self.validation = None # to validate
def get_plugin_configs(self):
result = self.config_helper.get_plugin_configs()
result.extend(kerberos.get_config_list())
return result
def get_node_processes(self):
return {
"CLOUDERA": ['CLOUDERA_MANAGER'],
"HDFS": ['HDFS_NAMENODE', 'HDFS_DATANODE',
'HDFS_SECONDARYNAMENODE', 'HDFS_JOURNALNODE'],
"YARN": ['YARN_RESOURCEMANAGER', 'YARN_NODEMANAGER',
'YARN_JOBHISTORY', 'YARN_STANDBYRM'],
"OOZIE": ['OOZIE_SERVER'],
"HIVE": ['HIVE_SERVER2', 'HIVE_METASTORE', 'HIVE_WEBHCAT'],
"HUE": ['HUE_SERVER'],
"SPARK_ON_YARN": ['SPARK_YARN_HISTORY_SERVER'],
"ZOOKEEPER": ['ZOOKEEPER_SERVER'],
"HBASE": ['HBASE_MASTER', 'HBASE_REGIONSERVER'],
"FLUME": ['FLUME_AGENT'],
"IMPALA": ['IMPALA_CATALOGSERVER', 'IMPALA_STATESTORE', 'IMPALAD'],
"KS_INDEXER": ['KEY_VALUE_STORE_INDEXER'],
"SOLR": ['SOLR_SERVER'],
"SQOOP": ['SQOOP_SERVER'],
"SENTRY": ['SENTRY_SERVER'],
"KMS": ['KMS'],
"KAFKA": ['KAFKA_BROKER'],
"YARN_GATEWAY": [],
"RESOURCEMANAGER": [],
"NODEMANAGER": [],
"JOBHISTORY": [],
"HDFS_GATEWAY": [],
'DATANODE': [],
'NAMENODE': [],
'SECONDARYNAMENODE': [],
'JOURNALNODE': [],
'REGIONSERVER': [],
'MASTER': [],
'HIVEMETASTORE': [],
'HIVESERVER': [],
'WEBCAT': [],
'CATALOGSERVER': [],
'STATESTORE': [],
'IMPALAD': [],
'Kerberos': [],
}
def validate(self, cluster):
self.validation.validate_cluster_creating(cluster)
def configure_cluster(self, cluster):
self.deploy.configure_cluster(cluster)
conductor.cluster_update(
context.ctx(), cluster, {
'info':
self.cloudera_utils.get_cloudera_manager_info(cluster)})
def start_cluster(self, cluster):
self.deploy.start_cluster(cluster)
self._set_cluster_info(cluster)
def decommission_nodes(self, cluster, instances):
self.deploy.decommission_cluster(cluster, instances)
def validate_scaling(self, cluster, existing, additional):
self.validation.validate_existing_ng_scaling(cluster, existing)
self.validation.validate_additional_ng_scaling(cluster, additional)
def scale_cluster(self, cluster, instances):
self.deploy.scale_cluster(cluster, instances)
def _set_cluster_info(self, cluster):
info = self.cloudera_utils.get_cloudera_manager_info(cluster)
hue = self.cloudera_utils.pu.get_hue(cluster)
if hue:
info['Hue Dashboard'] = {
'Web UI': 'http://%s:8888' % hue.get_ip_or_dns_name()
}
ctx = context.ctx()
conductor.cluster_update(ctx, cluster, {'info': info})
def get_edp_engine(self, cluster, job_type):
oozie_type = self.edp_engine.EdpOozieEngine.get_supported_job_types()
spark_type = self.edp_engine.EdpSparkEngine.get_supported_job_types()
if job_type in oozie_type:
return self.edp_engine.EdpOozieEngine(cluster)
if job_type in spark_type:
return self.edp_engine.EdpSparkEngine(cluster)
return None
def get_edp_job_types(self):
return (self.edp_engine.EdpOozieEngine.get_supported_job_types() +
self.edp_engine.EdpSparkEngine.get_supported_job_types())
def get_edp_config_hints(self, job_type):
return self.edp_engine.EdpOozieEngine.get_possible_job_config(job_type)
def get_open_ports(self, node_group):
return self.deploy.get_open_ports(node_group)
def recommend_configs(self, cluster, scaling):
self.plugin_utils.recommend_configs(
cluster, self.get_plugin_configs(), scaling)
def get_health_checks(self, cluster):
return health.get_health_checks(cluster, self.cloudera_utils)
def get_image_arguments(self):
if hasattr(self, 'images'):
return self.images.get_image_arguments()
else:
return NotImplemented
def pack_image(self, hadoop_version, remote, test_only=False,
image_arguments=None):
if hasattr(self, 'images'):
self.images.pack_image(
remote, test_only=test_only, image_arguments=image_arguments)
def validate_images(self, cluster, test_only=False, image_arguments=None):
if hasattr(self, 'images'):
self.images.validate_images(
cluster, test_only=test_only, image_arguments=image_arguments) | /sahara_plugin_cdh-9.0.0.0rc1-py3-none-any.whl/sahara_plugin_cdh/plugins/cdh/abstractversionhandler.py | 0.555918 | 0.201165 | abstractversionhandler.py | pypi |
import eventlet
EVENTLET_MONKEY_PATCH_MODULES = dict(os=True,
select=True,
socket=True,
thread=True,
time=True)
def patch_all():
"""Apply all patches.
List of patches:
* eventlet's monkey patch for all cases;
* minidom's writexml patch for py < 2.7.3 only.
"""
eventlet_monkey_patch()
patch_minidom_writexml()
def eventlet_monkey_patch():
"""Apply eventlet's monkey patch.
This call should be the first call in application. It's safe to call
monkey_patch multiple times.
"""
eventlet.monkey_patch(**EVENTLET_MONKEY_PATCH_MODULES)
def eventlet_import_monkey_patched(module):
"""Returns module monkey patched by eventlet.
It's needed for some tests, for example, context test.
"""
return eventlet.import_patched(module, **EVENTLET_MONKEY_PATCH_MODULES)
def patch_minidom_writexml():
"""Patch for xml.dom.minidom toprettyxml bug with whitespaces around text
We apply the patch to avoid excess whitespaces in generated xml
configuration files that brakes Hadoop.
(This patch will be applied for all Python versions < 2.7.3)
Issue: http://bugs.python.org/issue4147
Patch: http://hg.python.org/cpython/rev/cb6614e3438b/
Description: http://ronrothman.com/public/leftbraned/xml-dom-minidom-\
toprettyxml-and-silly-whitespace/#best-solution
"""
import sys
if sys.version_info >= (2, 7, 3):
return
import xml.dom.minidom as md
def element_writexml(self, writer, indent="", addindent="", newl=""):
# indent = current indentation
# addindent = indentation to add to higher levels
# newl = newline string
writer.write(indent + "<" + self.tagName)
attrs = self._get_attributes()
a_names = list(attrs.keys())
a_names.sort()
for a_name in a_names:
writer.write(" %s=\"" % a_name)
md._write_data(writer, attrs[a_name].value)
writer.write("\"")
if self.childNodes:
writer.write(">")
if (len(self.childNodes) == 1
and self.childNodes[0].nodeType == md.Node.TEXT_NODE):
self.childNodes[0].writexml(writer, '', '', '')
else:
writer.write(newl)
for node in self.childNodes:
node.writexml(writer, indent + addindent, addindent, newl)
writer.write(indent)
writer.write("</%s>%s" % (self.tagName, newl))
else:
writer.write("/>%s" % (newl))
md.Element.writexml = element_writexml
def text_writexml(self, writer, indent="", addindent="", newl=""):
md._write_data(writer, "%s%s%s" % (indent, self.data, newl))
md.Text.writexml = text_writexml | /sahara_plugin_cdh-9.0.0.0rc1-py3-none-any.whl/sahara_plugin_cdh/utils/patches.py | 0.444324 | 0.22133 | patches.py | pypi |
import sahara.plugins.provisioning as p
from sahara_plugin_mapr.i18n import _
import sahara_plugin_mapr.plugins.mapr.versions.version_handler_factory as vhf
class MapRPlugin(p.ProvisioningPluginBase):
title = 'MapR Hadoop Distribution'
description = _('The MapR Distribution provides a full Hadoop stack that'
' includes the MapR File System (MapR-FS), MapReduce,'
' a complete Hadoop ecosystem, and the MapR Control System'
' user interface')
def _get_handler(self, hadoop_version):
return vhf.VersionHandlerFactory.get().get_handler(hadoop_version)
def get_title(self):
return MapRPlugin.title
def get_description(self):
return MapRPlugin.description
def get_labels(self):
return {
'plugin_labels': {'enabled': {'status': True}},
'version_labels': {
'5.2.0.mrv2': {'enabled': {'status': True}},
}
}
def get_versions(self):
return vhf.VersionHandlerFactory.get().get_versions()
def get_node_processes(self, hadoop_version):
return self._get_handler(hadoop_version).get_node_processes()
def get_configs(self, hadoop_version):
return self._get_handler(hadoop_version).get_configs()
def configure_cluster(self, cluster):
self._get_handler(cluster.hadoop_version).configure_cluster(cluster)
def start_cluster(self, cluster):
self._get_handler(cluster.hadoop_version).start_cluster(cluster)
def validate(self, cluster):
self._get_handler(cluster.hadoop_version).validate(cluster)
def validate_scaling(self, cluster, existing, additional):
v_handler = self._get_handler(cluster.hadoop_version)
v_handler.validate_scaling(cluster, existing, additional)
def scale_cluster(self, cluster, instances):
v_handler = self._get_handler(cluster.hadoop_version)
v_handler.scale_cluster(cluster, instances)
def decommission_nodes(self, cluster, instances):
v_handler = self._get_handler(cluster.hadoop_version)
v_handler.decommission_nodes(cluster, instances)
def get_edp_engine(self, cluster, job_type):
v_handler = self._get_handler(cluster.hadoop_version)
return v_handler.get_edp_engine(cluster, job_type)
def get_edp_job_types(self, versions=None):
res = {}
for vers in self.get_versions():
if not versions or vers in versions:
vh = self._get_handler(vers)
res[vers] = vh.get_edp_job_types()
return res
def get_edp_config_hints(self, job_type, version):
v_handler = self._get_handler(version)
return v_handler.get_edp_config_hints(job_type)
def get_open_ports(self, node_group):
v_handler = self._get_handler(node_group.cluster.hadoop_version)
return v_handler.get_open_ports(node_group)
def get_health_checks(self, cluster):
v_handler = self._get_handler(cluster.hadoop_version)
return v_handler.get_cluster_checks(cluster)
def get_image_arguments(self, hadoop_version):
return self._get_handler(hadoop_version).get_image_arguments()
def pack_image(self, hadoop_version, remote,
test_only=False, image_arguments=None):
version = self._get_handler(hadoop_version)
version.pack_image(hadoop_version, remote, test_only=test_only,
image_arguments=image_arguments)
def validate_images(self, cluster, test_only=False, image_arguments=None):
self._get_handler(cluster.hadoop_version).validate_images(
cluster, test_only=test_only, image_arguments=image_arguments) | /sahara_plugin_mapr-9.0.0.0rc1-py3-none-any.whl/sahara_plugin_mapr/plugins/mapr/plugin.py | 0.540196 | 0.220384 | plugin.py | pypi |
import functools as ft
import sahara.plugins.exceptions as e
from sahara.plugins import resource as r
from sahara.plugins import service_api as api
import sahara.plugins.utils as utils
from sahara_plugin_mapr.i18n import _
class LessThanCountException(e.InvalidComponentCountException):
MESSAGE = _("Hadoop cluster should contain at least"
" %(expected_count)d %(component)s component(s)."
" Actual %(component)s count is %(actual_count)d")
def __init__(self, component, expected_count, count):
super(LessThanCountException, self).__init__(
component, expected_count, count)
args = {
'expected_count': expected_count,
'component': component,
'actual_count': count,
}
self.message = LessThanCountException.MESSAGE % args
class MoreThanCountException(e.InvalidComponentCountException):
MESSAGE = _("Hadoop cluster should contain at most"
" %(expected_count)d %(component)s component(s)."
" Actual %(component)s count is %(actual_count)d")
def __init__(self, component, expected_count, count):
super(MoreThanCountException, self).__init__(
component, expected_count, count)
args = {
"expected_count": expected_count,
"component": component,
"actual_count": count,
}
self.message = MoreThanCountException.MESSAGE % args
class EvenCountException(e.SaharaPluginException):
MESSAGE = _("Hadoop cluster should contain odd number of %(component)s"
" but %(actual_count)s found.")
def __init__(self, component, count):
super(EvenCountException, self).__init__()
args = {'component': component, 'actual_count': count}
self.message = EvenCountException.MESSAGE % args
class NodeRequiredServiceMissingException(e.RequiredServiceMissingException):
MISSING_MSG = _('Node "%(ng_name)s" is missing component %(component)s')
REQUIRED_MSG = _('%(message)s, required by %(required_by)s')
def __init__(self, service_name, ng_name, required_by=None):
super(NodeRequiredServiceMissingException, self).__init__(
service_name, required_by)
args = {'ng_name': ng_name, 'component': service_name}
self.message = (
NodeRequiredServiceMissingException.MISSING_MSG % args)
if required_by:
args = {'message': self.message, 'required_by': required_by}
self.message = (
NodeRequiredServiceMissingException.REQUIRED_MSG % args)
class NodeServiceConflictException(e.SaharaPluginException):
MESSAGE = _('%(service)s service cannot be installed alongside'
' %(package)s package')
ERROR_CODE = "NODE_PROCESS_CONFLICT"
def __init__(self, service_name, conflicted_package):
super(NodeServiceConflictException, self).__init__()
args = {
'service': service_name,
'package': conflicted_package,
}
self.message = NodeServiceConflictException.MESSAGE % args
self.code = NodeServiceConflictException.ERROR_CODE
class NoVolumesException(e.SaharaPluginException):
MESSAGE = _('%s must have at least 1 volume or ephemeral drive')
ERROR_CODE = "NO_VOLUMES"
def __init__(self, ng_name):
super(NoVolumesException, self).__init__()
self.message = NoVolumesException.MESSAGE % ng_name
self.code = NoVolumesException.ERROR_CODE
class NotRequiredImageException(e.SaharaPluginException):
MESSAGE = _('Service %(service)s requires %(os)s OS.'
' Use %(os)s image and add "%(os)s" tag to it.')
ERROR_CODE = "INVALID_IMAGE"
def __init__(self, service, os):
super(NotRequiredImageException, self).__init__()
self.message = NotRequiredImageException.MESSAGE % {'service': service,
'os': os}
self.code = NotRequiredImageException.ERROR_CODE
def at_least(count, component):
def validate(cluster_context, component, count):
actual_count = cluster_context.get_instances_count(component)
if not actual_count >= count:
raise LessThanCountException(
component.ui_name, count, actual_count)
return ft.partial(validate, component=component, count=count)
def at_most(count, component):
def validate(cluster_context, component, count):
actual_count = cluster_context.get_instances_count(component)
if actual_count > count:
raise MoreThanCountException(
component.ui_name, count, actual_count)
return ft.partial(validate, component=component, count=count)
def exactly(count, component):
def validate(cluster_context, component, count):
actual_count = cluster_context.get_instances_count(component)
if not actual_count == count:
raise e.InvalidComponentCountException(
component.ui_name, count, actual_count)
return ft.partial(validate, component=component, count=count)
def each_node_has(component):
def validate(cluster_context, component):
for node_group in cluster_context.cluster.node_groups:
if component.ui_name not in node_group.node_processes:
raise NodeRequiredServiceMissingException(
component.ui_name, node_group.name)
return ft.partial(validate, component=component)
def odd_count_of(component):
def validate(cluster_context, component):
actual_count = cluster_context.get_instances_count(component)
if actual_count > 1 and actual_count % 2 == 0:
raise EvenCountException(component.ui_name, actual_count)
return ft.partial(validate, component=component)
def on_same_node(component, dependency):
def validate(cluster_context, component, dependency):
for ng in cluster_context.get_node_groups(component):
if dependency.ui_name not in ng.node_processes:
raise NodeRequiredServiceMissingException(
dependency.ui_name, ng.name, component.ui_name)
return ft.partial(validate, component=component, dependency=dependency)
def depends_on(service, required_by):
def validate(cluster_context, service, required_by):
if not cluster_context.is_present(service):
service_name = service.ui_name
if service.version:
service_name += " %s" % service.version
raise e.RequiredServiceMissingException(
service_name, required_by.ui_name)
return ft.partial(validate, service=service, required_by=required_by)
def node_client_package_conflict_vr(components, client_component):
def validate(cluster_context, components):
for ng in cluster_context.get_node_groups():
for c in components:
nps = ng.node_processes
if c in nps and client_component in nps:
raise NodeServiceConflictException(c, client_component)
return ft.partial(validate, components=components)
def assert_present(service, cluster_context):
if not cluster_context.is_present(service):
raise e.RequiredServiceMissingException(service.ui_name)
def required_os(os, required_by):
def validate(cluster_context, os, required_by):
for ng in cluster_context.get_node_groups():
nps = ng.node_processes
for node_process in required_by.node_processes:
if node_process.ui_name in nps:
image_id = (ng.image_id or
cluster_context.cluster.default_image_id)
if not image_has_tag(image_id, os):
raise NotRequiredImageException(required_by.ui_name,
os)
return ft.partial(validate, os=os, required_by=required_by)
def create_fake_cluster(cluster, existing, additional):
counts = existing.copy()
counts.update(additional)
def update_ng(node_group):
ng_dict = node_group.to_dict()
count = counts[node_group.id]
ng_dict.update(dict(count=count))
return r.create_node_group_resource(ng_dict)
def need_upd(node_group):
return node_group.id in counts and counts[node_group.id] > 0
updated = list(map(update_ng, filter(need_upd, cluster.node_groups)))
not_updated = list(
filter(lambda ng: not need_upd(ng) and ng is not None,
cluster.node_groups))
cluster_dict = cluster.to_dict()
cluster_dict.update({'node_groups': updated + not_updated})
fake = r.create_cluster_resource(cluster_dict)
return fake
def get_ephemeral(node_group):
return utils.get_flavor(id=node_group.flavor_id).ephemeral
def has_volumes():
def validate(cluster_context):
for node_group in cluster_context.cluster.node_groups:
if not (node_group.volumes_per_node or get_ephemeral(node_group)):
raise NoVolumesException(node_group.name)
return validate
def image_has_tag(image_id, tag):
image = api.get_registered_image(image_id)
return tag in image.tags | /sahara_plugin_mapr-9.0.0.0rc1-py3-none-any.whl/sahara_plugin_mapr/plugins/mapr/util/validation_utils.py | 0.59972 | 0.288369 | validation_utils.py | pypi |
import abc
class AbstractClusterContext(object, metaclass=abc.ABCMeta):
@abc.abstractproperty
def mapr_home(self):
return
@abc.abstractproperty
def configure_sh_path(self):
return
@abc.abstractproperty
def configure_sh(self):
return
@abc.abstractproperty
def hadoop_version(self):
return
@abc.abstractproperty
def hadoop_home(self):
return
@abc.abstractproperty
def hadoop_lib(self):
return
@abc.abstractproperty
def hadoop_conf(self):
return
@abc.abstractproperty
def cluster(self):
return
@abc.abstractproperty
def name_node_uri(self):
return
@abc.abstractproperty
def resource_manager_uri(self):
return
@abc.abstractproperty
def oozie_server_uri(self):
return
@abc.abstractproperty
def oozie_server(self):
return
@abc.abstractproperty
def oozie_http(self):
return
@abc.abstractproperty
def cluster_mode(self):
return
@abc.abstractproperty
def is_node_aware(self):
return
@abc.abstractproperty
def some_instance(self):
return
@abc.abstractproperty
def distro(self):
return
@abc.abstractproperty
def mapr_db(self):
return
@abc.abstractmethod
def filter_instances(self, instances, node_process=None, service=None):
return
@abc.abstractmethod
def removed_instances(self, node_process=None, service=None):
return
@abc.abstractmethod
def added_instances(self, node_process=None, service=None):
return
@abc.abstractmethod
def changed_instances(self, node_process=None, service=None):
return
@abc.abstractmethod
def existing_instances(self, node_process=None, service=None):
return
@abc.abstractproperty
def should_be_restarted(self):
return
@abc.abstractproperty
def mapr_repos(self):
return
@abc.abstractproperty
def is_prebuilt(self):
return
@abc.abstractproperty
def local_repo(self):
return
@abc.abstractproperty
def required_services(self):
return
@abc.abstractproperty
def all_services(self):
return
@abc.abstractproperty
def mapr_version(self):
return
@abc.abstractproperty
def ubuntu_base_repo(self):
return
@abc.abstractproperty
def ubuntu_ecosystem_repo(self):
return
@abc.abstractproperty
def centos_base_repo(self):
return
@abc.abstractproperty
def centos_ecosystem_repo(self):
return | /sahara_plugin_mapr-9.0.0.0rc1-py3-none-any.whl/sahara_plugin_mapr/plugins/mapr/abstract/cluster_context.py | 0.588653 | 0.158858 | cluster_context.py | pypi |
import eventlet
EVENTLET_MONKEY_PATCH_MODULES = dict(os=True,
select=True,
socket=True,
thread=True,
time=True)
def patch_all():
"""Apply all patches.
List of patches:
* eventlet's monkey patch for all cases;
* minidom's writexml patch for py < 2.7.3 only.
"""
eventlet_monkey_patch()
patch_minidom_writexml()
def eventlet_monkey_patch():
"""Apply eventlet's monkey patch.
This call should be the first call in application. It's safe to call
monkey_patch multiple times.
"""
eventlet.monkey_patch(**EVENTLET_MONKEY_PATCH_MODULES)
def eventlet_import_monkey_patched(module):
"""Returns module monkey patched by eventlet.
It's needed for some tests, for example, context test.
"""
return eventlet.import_patched(module, **EVENTLET_MONKEY_PATCH_MODULES)
def patch_minidom_writexml():
"""Patch for xml.dom.minidom toprettyxml bug with whitespaces around text
We apply the patch to avoid excess whitespaces in generated xml
configuration files that brakes Hadoop.
(This patch will be applied for all Python versions < 2.7.3)
Issue: http://bugs.python.org/issue4147
Patch: http://hg.python.org/cpython/rev/cb6614e3438b/
Description: http://ronrothman.com/public/leftbraned/xml-dom-minidom-\
toprettyxml-and-silly-whitespace/#best-solution
"""
import sys
if sys.version_info >= (2, 7, 3):
return
import xml.dom.minidom as md
def element_writexml(self, writer, indent="", addindent="", newl=""):
# indent = current indentation
# addindent = indentation to add to higher levels
# newl = newline string
writer.write(indent + "<" + self.tagName)
attrs = self._get_attributes()
a_names = list(attrs.keys())
a_names.sort()
for a_name in a_names:
writer.write(" %s=\"" % a_name)
md._write_data(writer, attrs[a_name].value)
writer.write("\"")
if self.childNodes:
writer.write(">")
if (len(self.childNodes) == 1
and self.childNodes[0].nodeType == md.Node.TEXT_NODE):
self.childNodes[0].writexml(writer, '', '', '')
else:
writer.write(newl)
for node in self.childNodes:
node.writexml(writer, indent + addindent, addindent, newl)
writer.write(indent)
writer.write("</%s>%s" % (self.tagName, newl))
else:
writer.write("/>%s" % (newl))
md.Element.writexml = element_writexml
def text_writexml(self, writer, indent="", addindent="", newl=""):
md._write_data(writer, "%s%s%s" % (indent, self.data, newl))
md.Text.writexml = text_writexml | /sahara_plugin_mapr-9.0.0.0rc1-py3-none-any.whl/sahara_plugin_mapr/utils/patches.py | 0.444324 | 0.22133 | patches.py | pypi |
import eventlet
EVENTLET_MONKEY_PATCH_MODULES = dict(os=True,
select=True,
socket=True,
thread=True,
time=True)
def patch_all():
"""Apply all patches.
List of patches:
* eventlet's monkey patch for all cases;
* minidom's writexml patch for py < 2.7.3 only.
"""
eventlet_monkey_patch()
patch_minidom_writexml()
def eventlet_monkey_patch():
"""Apply eventlet's monkey patch.
This call should be the first call in application. It's safe to call
monkey_patch multiple times.
"""
eventlet.monkey_patch(**EVENTLET_MONKEY_PATCH_MODULES)
def eventlet_import_monkey_patched(module):
"""Returns module monkey patched by eventlet.
It's needed for some tests, for example, context test.
"""
return eventlet.import_patched(module, **EVENTLET_MONKEY_PATCH_MODULES)
def patch_minidom_writexml():
"""Patch for xml.dom.minidom toprettyxml bug with whitespaces around text
We apply the patch to avoid excess whitespaces in generated xml
configuration files that brakes Hadoop.
(This patch will be applied for all Python versions < 2.7.3)
Issue: http://bugs.python.org/issue4147
Patch: http://hg.python.org/cpython/rev/cb6614e3438b/
Description: http://ronrothman.com/public/leftbraned/xml-dom-minidom-\
toprettyxml-and-silly-whitespace/#best-solution
"""
import sys
if sys.version_info >= (2, 7, 3):
return
import xml.dom.minidom as md
def element_writexml(self, writer, indent="", addindent="", newl=""):
# indent = current indentation
# addindent = indentation to add to higher levels
# newl = newline string
writer.write(indent + "<" + self.tagName)
attrs = self._get_attributes()
a_names = list(attrs.keys())
a_names.sort()
for a_name in a_names:
writer.write(" %s=\"" % a_name)
md._write_data(writer, attrs[a_name].value)
writer.write("\"")
if self.childNodes:
writer.write(">")
if (len(self.childNodes) == 1
and self.childNodes[0].nodeType == md.Node.TEXT_NODE):
self.childNodes[0].writexml(writer, '', '', '')
else:
writer.write(newl)
for node in self.childNodes:
node.writexml(writer, indent + addindent, addindent, newl)
writer.write(indent)
writer.write("</%s>%s" % (self.tagName, newl))
else:
writer.write("/>%s" % (newl))
md.Element.writexml = element_writexml
def text_writexml(self, writer, indent="", addindent="", newl=""):
md._write_data(writer, "%s%s%s" % (indent, self.data, newl))
md.Text.writexml = text_writexml | /sahara_plugin_spark-9.0.0.0rc1-py3-none-any.whl/sahara_plugin_spark/utils/patches.py | 0.444324 | 0.22133 | patches.py | pypi |
import eventlet
EVENTLET_MONKEY_PATCH_MODULES = dict(os=True,
select=True,
socket=True,
thread=True,
time=True)
def patch_all():
"""Apply all patches.
List of patches:
* eventlet's monkey patch for all cases;
* minidom's writexml patch for py < 2.7.3 only.
"""
eventlet_monkey_patch()
patch_minidom_writexml()
def eventlet_monkey_patch():
"""Apply eventlet's monkey patch.
This call should be the first call in application. It's safe to call
monkey_patch multiple times.
"""
eventlet.monkey_patch(**EVENTLET_MONKEY_PATCH_MODULES)
def eventlet_import_monkey_patched(module):
"""Returns module monkey patched by eventlet.
It's needed for some tests, for example, context test.
"""
return eventlet.import_patched(module, **EVENTLET_MONKEY_PATCH_MODULES)
def patch_minidom_writexml():
"""Patch for xml.dom.minidom toprettyxml bug with whitespaces around text
We apply the patch to avoid excess whitespaces in generated xml
configuration files that brakes Hadoop.
(This patch will be applied for all Python versions < 2.7.3)
Issue: http://bugs.python.org/issue4147
Patch: http://hg.python.org/cpython/rev/cb6614e3438b/
Description: http://ronrothman.com/public/leftbraned/xml-dom-minidom-\
toprettyxml-and-silly-whitespace/#best-solution
"""
import sys
if sys.version_info >= (2, 7, 3):
return
import xml.dom.minidom as md
def element_writexml(self, writer, indent="", addindent="", newl=""):
# indent = current indentation
# addindent = indentation to add to higher levels
# newl = newline string
writer.write(indent + "<" + self.tagName)
attrs = self._get_attributes()
a_names = list(attrs.keys())
a_names.sort()
for a_name in a_names:
writer.write(" %s=\"" % a_name)
md._write_data(writer, attrs[a_name].value)
writer.write("\"")
if self.childNodes:
writer.write(">")
if (len(self.childNodes) == 1
and self.childNodes[0].nodeType == md.Node.TEXT_NODE):
self.childNodes[0].writexml(writer, '', '', '')
else:
writer.write(newl)
for node in self.childNodes:
node.writexml(writer, indent + addindent, addindent, newl)
writer.write(indent)
writer.write("</%s>%s" % (self.tagName, newl))
else:
writer.write("/>%s" % (newl))
md.Element.writexml = element_writexml
def text_writexml(self, writer, indent="", addindent="", newl=""):
md._write_data(writer, "%s%s%s" % (indent, self.data, newl))
md.Text.writexml = text_writexml | /sahara-plugin-storm-9.0.0.tar.gz/sahara-plugin-storm-9.0.0/sahara_plugin_storm/utils/patches.py | 0.444324 | 0.22133 | patches.py | pypi |
import copy
from sahara.plugins import provisioning as p
from sahara_plugin_vanilla.i18n import _
from sahara_plugin_vanilla.plugins.vanilla import versionfactory as vhf
class VanillaProvider(p.ProvisioningPluginBase):
def __init__(self):
self.version_factory = vhf.VersionFactory.get_instance()
def get_description(self):
return _('The Apache Vanilla plugin provides the ability to launch '
'upstream Vanilla Apache Hadoop cluster without any '
'management consoles. It can also deploy the Oozie '
'component.')
def _get_version_handler(self, hadoop_version):
return self.version_factory.get_version_handler(hadoop_version)
def get_node_processes(self, hadoop_version):
return self._get_version_handler(hadoop_version).get_node_processes()
def get_labels(self):
default = {'enabled': {'status': True}, 'stable': {'status': True}}
result = {'plugin_labels': copy.deepcopy(default)}
result['version_labels'] = {
version: copy.deepcopy(default) for version in self.get_versions()
}
return result
def get_versions(self):
return self.version_factory.get_versions()
def get_title(self):
return "Vanilla Apache Hadoop"
def get_configs(self, hadoop_version):
return self._get_version_handler(hadoop_version).get_plugin_configs()
def configure_cluster(self, cluster):
return self._get_version_handler(
cluster.hadoop_version).configure_cluster(cluster)
def start_cluster(self, cluster):
return self._get_version_handler(
cluster.hadoop_version).start_cluster(cluster)
def validate(self, cluster):
return self._get_version_handler(
cluster.hadoop_version).validate(cluster)
def scale_cluster(self, cluster, instances):
return self._get_version_handler(
cluster.hadoop_version).scale_cluster(cluster, instances)
def decommission_nodes(self, cluster, instances):
return self._get_version_handler(
cluster.hadoop_version).decommission_nodes(cluster, instances)
def validate_scaling(self, cluster, existing, additional):
return self._get_version_handler(
cluster.hadoop_version).validate_scaling(cluster, existing,
additional)
def get_edp_engine(self, cluster, job_type):
return self._get_version_handler(
cluster.hadoop_version).get_edp_engine(cluster, job_type)
def get_edp_job_types(self, versions=None):
res = {}
for vers in self.version_factory.get_versions():
if not versions or vers in versions:
vh = self.version_factory.get_version_handler(vers)
res[vers] = vh.get_edp_job_types()
return res
def get_edp_config_hints(self, job_type, version):
version_handler = (
self.version_factory.get_version_handler(version))
return version_handler.get_edp_config_hints(job_type)
def get_open_ports(self, node_group):
return self._get_version_handler(
node_group.cluster.hadoop_version).get_open_ports(node_group)
def on_terminate_cluster(self, cluster):
return self._get_version_handler(
cluster.hadoop_version).on_terminate_cluster(cluster)
def recommend_configs(self, cluster, scaling=False):
return self._get_version_handler(
cluster.hadoop_version).recommend_configs(cluster, scaling) | /sahara_plugin_vanilla-9.0.0-py3-none-any.whl/sahara_plugin_vanilla/plugins/vanilla/plugin.py | 0.562657 | 0.1982 | plugin.py | pypi |
import eventlet
EVENTLET_MONKEY_PATCH_MODULES = dict(os=True,
select=True,
socket=True,
thread=True,
time=True)
def patch_all():
"""Apply all patches.
List of patches:
* eventlet's monkey patch for all cases;
* minidom's writexml patch for py < 2.7.3 only.
"""
eventlet_monkey_patch()
patch_minidom_writexml()
def eventlet_monkey_patch():
"""Apply eventlet's monkey patch.
This call should be the first call in application. It's safe to call
monkey_patch multiple times.
"""
eventlet.monkey_patch(**EVENTLET_MONKEY_PATCH_MODULES)
def eventlet_import_monkey_patched(module):
"""Returns module monkey patched by eventlet.
It's needed for some tests, for example, context test.
"""
return eventlet.import_patched(module, **EVENTLET_MONKEY_PATCH_MODULES)
def patch_minidom_writexml():
"""Patch for xml.dom.minidom toprettyxml bug with whitespaces around text
We apply the patch to avoid excess whitespaces in generated xml
configuration files that brakes Hadoop.
(This patch will be applied for all Python versions < 2.7.3)
Issue: http://bugs.python.org/issue4147
Patch: http://hg.python.org/cpython/rev/cb6614e3438b/
Description: http://ronrothman.com/public/leftbraned/xml-dom-minidom-\
toprettyxml-and-silly-whitespace/#best-solution
"""
import sys
if sys.version_info >= (2, 7, 3):
return
import xml.dom.minidom as md
def element_writexml(self, writer, indent="", addindent="", newl=""):
# indent = current indentation
# addindent = indentation to add to higher levels
# newl = newline string
writer.write(indent + "<" + self.tagName)
attrs = self._get_attributes()
a_names = list(attrs.keys())
a_names.sort()
for a_name in a_names:
writer.write(" %s=\"" % a_name)
md._write_data(writer, attrs[a_name].value)
writer.write("\"")
if self.childNodes:
writer.write(">")
if (len(self.childNodes) == 1
and self.childNodes[0].nodeType == md.Node.TEXT_NODE):
self.childNodes[0].writexml(writer, '', '', '')
else:
writer.write(newl)
for node in self.childNodes:
node.writexml(writer, indent + addindent, addindent, newl)
writer.write(indent)
writer.write("</%s>%s" % (self.tagName, newl))
else:
writer.write("/>%s" % (newl))
md.Element.writexml = element_writexml
def text_writexml(self, writer, indent="", addindent="", newl=""):
md._write_data(writer, "%s%s%s" % (indent, self.data, newl))
md.Text.writexml = text_writexml | /sahara_plugin_vanilla-9.0.0-py3-none-any.whl/sahara_plugin_vanilla/utils/patches.py | 0.444324 | 0.22133 | patches.py | pypi |
Rationale
=========
Introduction
------------
Apache Hadoop is an industry standard and widely adopted MapReduce
implementation, it is one among a growing number of data processing
frameworks. The aim of this project is to enable users to easily provision
and manage clusters with Hadoop and other data processing frameworks on
OpenStack. It is worth mentioning that Amazon has provided Hadoop for
several years as Amazon Elastic MapReduce (EMR) service.
Sahara aims to provide users with a simple means to provision Hadoop, Spark,
and Storm clusters by specifying several parameters such as the framework
version, cluster topology, hardware node details and more. After a user fills
in all the parameters, sahara deploys the cluster in a few minutes. Also sahara
provides means to scale an already provisioned cluster by adding or removing
worker nodes on demand.
The solution will address the following use cases:
* fast provisioning of data processing clusters on OpenStack for development
and quality assurance(QA).
* utilization of unused compute power from a general purpose OpenStack IaaS
cloud.
* "Analytics as a Service" for ad-hoc or bursty analytic workloads (similar
to AWS EMR).
Key features are:
* designed as an OpenStack component.
* managed through a REST API with a user interface(UI) available as part of
OpenStack Dashboard.
* support for a variety of data processing frameworks:
* multiple Hadoop vendor distributions.
* Apache Spark and Storm.
* pluggable system of Hadoop installation engines.
* integration with vendor specific management tools, such as Apache
Ambari and Cloudera Management Console.
* predefined configuration templates with the ability to modify parameters.
Details
-------
The sahara product communicates with the following OpenStack services:
* Dashboard (horizon) - provides a GUI with ability to use all of sahara's
features.
* Identity (keystone) - authenticates users and provides security tokens that
are used to work with OpenStack, limiting a user's abilities in sahara to
their OpenStack privileges.
* Compute (nova) - used to provision VMs for data processing clusters.
* Bare metal (ironic) - used to provision Baremetal nodes for data processing
clusters.
* Orchestration (heat) - used to provision and orchestrate the deployment of
data processing clusters.
* Image (glance) - stores VM images, each image containing an operating system
and a pre-installed data processing distribution or framework.
* Object Storage (swift) - can be used as storage for job binaries and data
that will be processed or created by framework jobs.
* Block Storage (cinder) - can be used to provision block storage for VM
instances.
* Networking (neutron) - provides networking services to data processing
clusters.
* DNS service (designate) - provides ability to communicate with cluster
instances and Hadoop services by their hostnames.
* Telemetry (ceilometer) - used to collect measures of cluster usage for
metering and monitoring purposes.
* Shared file systems (manila) - can be used for storage of framework job
binaries and data that will be processed or created by jobs.
* Key manager (barbican & castellan) - persists the authentication data
like passwords and private keys in a secure storage.
.. image:: ../images/openstack-interop.png
:width: 960
:height: 720
:scale: 83 %
:align: left
General Workflow
----------------
Sahara will provide two levels of abstraction for the API and UI based on the
addressed use cases: cluster provisioning and analytics as a service.
For fast cluster provisioning a generic workflow will be as following:
* select a Hadoop (or framework) version.
* select a base image with or without pre-installed data processing framework:
* for base images without a pre-installed framework, sahara will support
pluggable deployment engines that integrate with vendor tooling.
* define cluster configuration, including cluster size, topology, and
framework parameters (for example, heap size):
* to ease the configuration of such parameters, configurable templates
are provided.
* provision the cluster; sahara will provision nodes (VMs or baremetal),
install and configure the data processing framework.
* perform operations on the cluster; add or remove nodes.
* terminate the cluster when it is no longer needed.
For analytics as a service, a generic workflow will be as following:
* select one of the predefined data processing framework versions.
* configure a job:
* choose the type of job: pig, hive, jar-file, etc.
* provide the job script source or jar location.
* select input and output data location.
* set the limit for the cluster size.
* execute the job:
* all cluster provisioning and job execution will happen transparently
to the user.
* if using a transient cluster, it will be removed automatically after job
completion.
* get the results of computations (for example, from swift).
User's Perspective
------------------
While provisioning clusters through sahara, the user operates on three types
of entities: Node Group Templates, Cluster Templates and Clusters.
A Node Group Template describes a group of nodes within cluster. It contains
a list of processes that will be launched on each instance in a group.
Also a Node Group Template may provide node scoped configurations for those
processes. This kind of template encapsulates hardware parameters (flavor)
for the node instance and configuration for data processing framework processes
running on the node.
A Cluster Template is designed to bring Node Group Templates together to
form a Cluster. A Cluster Template defines what Node Groups will be included
and how many instances will be created for each. Some data processing framework
configurations can not be applied to a single node, but to a whole Cluster.
A user can specify these kinds of configurations in a Cluster Template. Sahara
enables users to specify which processes should be added to an anti-affinity
group within a Cluster Template. If a process is included into an
anti-affinity group, it means that instances where this process is going to be
launched should be scheduled to different hardware hosts.
The Cluster entity represents a collection of instances that all have the
same data processing framework installed. It is mainly characterized by an
image with a pre-installed framework which will be used for cluster
deployment. Users may choose one of the pre-configured Cluster Templates to
start a Cluster. To get access to instances after a Cluster has started, the
user should specify a keypair.
Sahara provides several constraints on cluster framework topology. You can see
all constraints in the documentation for the appropriate plugin.
Each Cluster belongs to an Identity service project determined by the user.
Users have access only to objects located in projects they have access to.
Users can edit and delete only objects they have created or exist in their
projects. Naturally, admin users have full access to every object. In this
manner, sahara complies with general OpenStack access policy.
Integration with Object Storage
-------------------------------
The swift project provides the standard Object Storage service for OpenStack
environments; it is an analog of the Amazon S3 service. As a rule it is
deployed on bare metal machines. It is natural to expect data processing on
OpenStack to access data stored there. Sahara provides this option with a
file system implementation for swift
`HADOOP-8545 <https://issues.apache.org/jira/browse/HADOOP-8545>`_ and
`Change I6b1ba25b <https://review.opendev.org/#/c/21015/>`_ which
implements the ability to list endpoints for an object, account or container.
This makes it possible to integrate swift with software that relies on data
locality information to avoid network overhead.
To get more information on how to enable swift support see
:doc:`../user/hadoop-swift`.
Pluggable Deployment and Monitoring
-----------------------------------
In addition to the monitoring capabilities provided by vendor-specific
Hadoop management tooling, sahara provides pluggable integration with
external monitoring systems such as Nagios or Zabbix.
Both deployment and monitoring tools can be installed on standalone VMs,
thus allowing a single instance to manage and monitor several clusters at
once.
| /sahara-18.0.0.0rc1.tar.gz/sahara-18.0.0.0rc1/doc/source/intro/overview.rst | 0.889577 | 0.874292 | overview.rst | pypi |
Elastic Data Processing (EDP) SPI
=================================
The EDP job engine objects provide methods for creating, monitoring, and
terminating jobs on Sahara clusters. Provisioning plugins that support EDP
must return an EDP job engine object from the :ref:`get_edp_engine` method
described in :doc:`plugin-spi`.
Sahara provides subclasses of the base job engine interface that support EDP
on clusters running Oozie, Spark, and/or Storm. These are described below.
.. _edp_spi_job_types:
Job Types
---------
Some of the methods below test job type. Sahara supports the following string
values for job types:
* Hive
* Java
* Pig
* MapReduce
* MapReduce.Streaming
* Spark
* Shell
* Storm
.. note::
Constants for job types are defined in *sahara.utils.edp*.
Job Status Values
-----------------
Several of the methods below return a job status value. A job status value is
a dictionary of the form:
{'status': *job_status_value*}
where *job_status_value* is one of the following string values:
* DONEWITHERROR
* FAILED
* TOBEKILLED
* KILLED
* PENDING
* RUNNING
* SUCCEEDED
Note, constants for job status are defined in *sahara.utils.edp*
EDP Job Engine Interface
------------------------
The sahara.service.edp.base_engine.JobEngine class is an
abstract class with the following interface:
cancel_job(job_execution)
~~~~~~~~~~~~~~~~~~~~~~~~~
Stops the running job whose id is stored in the job_execution object.
*Returns*: None if the operation was unsuccessful or an updated job status
value.
get_job_status(job_execution)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Returns the current status of the job whose id is stored in the job_execution
object.
*Returns*: a job status value.
run_job(job_execution)
~~~~~~~~~~~~~~~~~~~~~~
Starts the job described by the job_execution object
*Returns*: a tuple of the form (job_id, job_status_value, job_extra_info).
* *job_id* is required and must be a string that allows the EDP engine to
uniquely identify the job.
* *job_status_value* may be None or a job status value
* *job_extra_info* may be None or optionally a dictionary that the EDP engine
uses to store extra information on the job_execution_object.
validate_job_execution(cluster, job, data)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Checks whether or not the job can run on the cluster with the specified data.
Data contains values passed to the */jobs/<job_id>/execute* REST API method
during job launch. If the job cannot run for any reason, including job
configuration, cluster configuration, or invalid data, this method should
raise an exception.
*Returns*: None
get_possible_job_config(job_type)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Returns hints used by the Sahara UI to prompt users for values when
configuring and launching a job. Note that no hints are required.
See :doc:`../user/edp` for more information on how configuration values,
parameters, and arguments are used by different job types.
*Returns*: a dictionary of the following form, containing hints for configs,
parameters, and arguments for the job type:
{'job_config': {'configs': [], 'params': {}, 'args': []}}
* *args* is a list of strings
* *params* contains simple key/value pairs
* each item in *configs* is a dictionary with entries
for 'name' (required), 'value', and 'description'
get_supported_job_types()
~~~~~~~~~~~~~~~~~~~~~~~~~
This method returns the job types that the engine supports. Not all engines
will support all job types.
*Returns*: a list of job types supported by the engine.
Oozie Job Engine Interface
--------------------------
The sahara.service.edp.oozie.engine.OozieJobEngine class is derived from
JobEngine. It provides implementations for all of the methods in the base
interface but adds a few more abstract methods.
Note that the *validate_job_execution(cluster, job, data)* method does basic
checks on the job configuration but probably should be overloaded to include
additional checks on the cluster configuration. For example, the job engines
for plugins that support Oozie add checks to make sure that the Oozie service
is up and running.
get_hdfs_user()
~~~~~~~~~~~~~~~
Oozie uses HDFS to distribute job files. This method gives the name of the
account that is used on the data nodes to access HDFS (such as 'hadoop' or
'hdfs'). The Oozie job engine expects that HDFS contains a directory for this
user under */user/*.
*Returns*: a string giving the username for the account used to access HDFS on
the cluster.
create_hdfs_dir(remote, dir_name)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The remote object *remote* references a node in the cluster. This method
creates the HDFS directory *dir_name* under the user specified by
*get_hdfs_user()* in the HDFS accessible from the specified node. For example,
if the HDFS user is 'hadoop' and the dir_name is 'test' this method would
create '/user/hadoop/test'.
The reason that this method is broken out in the interface as an abstract
method is that different versions of Hadoop treat path creation differently.
*Returns*: None
get_oozie_server_uri(cluster)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Returns the full URI for the Oozie server, for example
*http://my_oozie_host:11000/oozie*. This URI is used by an Oozie client to
send commands and queries to the Oozie server.
*Returns*: a string giving the Oozie server URI.
get_oozie_server(self, cluster)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Returns the node instance for the host in the cluster running the Oozie
server.
*Returns*: a node instance.
get_name_node_uri(self, cluster)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Returns the full URI for the Hadoop NameNode, for example
*http://master_node:8020*.
*Returns*: a string giving the NameNode URI.
get_resource_manager_uri(self, cluster)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Returns the full URI for the Hadoop JobTracker for Hadoop version 1 or the
Hadoop ResourceManager for Hadoop version 2.
*Returns*: a string giving the JobTracker or ResourceManager URI.
Spark Job Engine
----------------
The sahara.service.edp.spark.engine.SparkJobEngine class provides a full EDP
implementation for Spark standalone clusters.
.. note::
The *validate_job_execution(cluster, job, data)* method does basic
checks on the job configuration but probably should be overloaded to
include additional checks on the cluster configuration. For example, the
job engine returned by the Spark plugin checks that the Spark version is
>= 1.0.0 to ensure that *spark-submit* is available.
get_driver_classpath(self)
~~~~~~~~~~~~~~~~~~~~~~~~~~
Returns driver class path.
*Returns*: a string of the following format ' --driver-class-path
*class_path_value*'.
| /sahara-18.0.0.0rc1.tar.gz/sahara-18.0.0.0rc1/doc/source/reference/edp-spi.rst | 0.884439 | 0.69537 | edp-spi.rst | pypi |
Elastic Data Processing (EDP)
=============================
Overview
--------
Sahara's Elastic Data Processing facility or :dfn:`EDP` allows the execution
of jobs on clusters created from sahara. EDP supports:
* Hive, Pig, MapReduce, MapReduce.Streaming, Java, and Shell job types on
Hadoop clusters
* Spark jobs on Spark standalone clusters, MapR (v5.0.0 - v5.2.0) clusters,
Vanilla clusters (v2.7.1) and CDH clusters (v5.3.0 or higher).
* storage of job binaries in the OpenStack Object Storage service (swift),
the OpenStack Shared file systems service (manila), sahara's own database,
or any S3-like object store
* access to input and output data sources in
+ HDFS for all job types
+ swift for all types excluding Hive
+ manila (NFS shares only) for all types excluding Pig
+ Any S3-like object store
* configuration of jobs at submission time
* execution of jobs on existing clusters or transient clusters
Interfaces
----------
The EDP features can be used from the sahara web UI which is described in the
:doc:`dashboard-user-guide`.
The EDP features also can be used directly by a client through the
`REST api <https://docs.openstack.org/api-ref/data-processing/>`_
EDP Concepts
------------
Sahara EDP uses a collection of simple objects to define and execute jobs.
These objects are stored in the sahara database when they are created,
allowing them to be reused. This modular approach with database persistence
allows code and data to be reused across multiple jobs.
The essential components of a job are:
* executable code to run
* input and output data paths, as needed for the job
* any additional configuration values needed for the job run
These components are supplied through the objects described below.
Job Binaries
++++++++++++
A :dfn:`Job Binary` object stores a URL to a single script or Jar file and
any credentials needed to retrieve the file. The file itself may be stored
in the sahara internal database (**only API v1.1**), in swift,
or in manila.
Files in the sahara database are stored as raw bytes in a
:dfn:`Job Binary Internal` object. This object's sole purpose is to store a
file for later retrieval. No extra credentials need to be supplied for files
stored internally.
Sahara requires credentials (username and password) to access files stored in
swift unless swift proxy users are configured as described in
:doc:`../admin/advanced-configuration-guide`. The swift service must be
running in the same OpenStack installation referenced by sahara.
Sahara requires the following credentials/configs to access files stored in an
S3-like object store: ``accesskey``, ``secretkey``, ``endpoint``.
These credentials are specified through the `extra` in the body of the request
when creating a job binary referencing S3. The value of ``endpoint`` should
include a protocol: *http* or *https*.
To reference a binary file stored in manila, create the job binary with the
URL ``manila://{share_id}/{path}``. This assumes that you have already stored
that file in the appropriate path on the share. The share will be
automatically mounted to any cluster nodes which require access to the file,
if it is not mounted already.
There is a configurable limit on the size of a single job binary that may be
retrieved by sahara. This limit is 5MB and may be set with the
*job_binary_max_KB* setting in the :file:`sahara.conf` configuration file.
Jobs
++++
A :dfn:`Job` object specifies the type of the job and lists all of the
individual Job Binary objects that are required for execution. An individual
Job Binary may be referenced by multiple Jobs. A Job object specifies a main
binary and/or supporting libraries depending on its type:
+-------------------------+-------------+-----------+
| Job type | Main binary | Libraries |
+=========================+=============+===========+
| ``Hive`` | required | optional |
+-------------------------+-------------+-----------+
| ``Pig`` | required | optional |
+-------------------------+-------------+-----------+
| ``MapReduce`` | not used | required |
+-------------------------+-------------+-----------+
| ``MapReduce.Streaming`` | not used | optional |
+-------------------------+-------------+-----------+
| ``Java`` | not used | required |
+-------------------------+-------------+-----------+
| ``Shell`` | required | optional |
+-------------------------+-------------+-----------+
| ``Spark`` | required | optional |
+-------------------------+-------------+-----------+
| ``Storm`` | required | not used |
+-------------------------+-------------+-----------+
| ``Storm Pyelus`` | required | not used |
+-------------------------+-------------+-----------+
Data Sources
++++++++++++
A :dfn:`Data Source` object stores a URL which designates the location of
input or output data and any credentials needed to access the location.
Sahara supports data sources in swift. The swift service must be running in
the same OpenStack installation referenced by sahara.
Sahara also supports data sources in HDFS. Any HDFS instance running on a
sahara cluster in the same OpenStack installation is accessible without
manual configuration. Other instances of HDFS may be used as well provided
that the URL is resolvable from the node executing the job.
Sahara supports data sources in manila as well. To reference a path on an NFS
share as a data source, create the data source with the URL
``manila://{share_id}/{path}``. As in the case of job binaries, the specified
share will be automatically mounted to your cluster's nodes as needed to
access the data source.
Finally, Sahara supports data sources referring to S3-like object stores. The
URL should be of the form ``s3://{bucket}/{path}``. Also, the following
credentials/configs are understood: ``accesskey``, ``secretkey``,
``endpoint``, ``bucket_in_path``, and ``ssl``. These credentials are specified
through the ``credentials`` attribute of the body of the request when creating
a data source referencing S3. The value of ``endpoint`` should **NOT** include
a protocol (*http* or *https*), unlike when referencing an S3 job binary. It
can also be noted that Sahara clusters can interact with S3-like stores even
when not using EDP, i.e. when manually operating the cluster instead. Consult
the `hadoop-aws documentation <https://hadoop.apache.org/docs/stable/hadoop-aws/tools/hadoop-aws/index.html>`_
for more information. Also, be advised that hadoop-aws will only write a job's
output into a bucket which already exists: it does not create new buckets.
Some job types require the use of data source objects to specify input and
output when a job is launched. For example, when running a Pig job the UI will
prompt the user for input and output data source objects.
Other job types like Java or Spark do not require the user to specify data
sources. For these job types, data paths are passed as arguments. For
convenience, sahara allows data source objects to be referenced by name or id.
The section `Using Data Source References as Arguments`_ gives further
details.
Job Execution
+++++++++++++
Job objects must be *launched* or *executed* in order for them to run on the
cluster. During job launch, a user specifies execution details including data
sources, configuration values, and program arguments. The relevant details
will vary by job type. The launch will create a :dfn:`Job Execution` object in
sahara which is used to monitor and manage the job.
To execute Hadoop jobs, sahara generates an Oozie workflow and submits it to
the Oozie server running on the cluster. Familiarity with Oozie is not
necessary for using sahara but it may be beneficial to the user. A link to
the Oozie web console can be found in the sahara web UI in the cluster
details.
For Spark jobs, sahara uses the *spark-submit* shell script and executes the
Spark job from the master node in case of Spark cluster and from the Spark
Job History server in other cases. Logs of spark jobs run by sahara can be
found on this node under the */tmp/spark-edp* directory.
.. _edp_workflow:
General Workflow
----------------
The general workflow for defining and executing a job in sahara is essentially
the same whether using the web UI or the REST API.
1. Launch a cluster from sahara if there is not one already available
2. Create all of the Job Binaries needed to run the job, stored in the sahara
database, in swift, or in manila
+ When using the REST API and internal storage of job binaries, the Job
Binary Internal objects must be created first
+ Once the Job Binary Internal objects are created, Job Binary objects may
be created which refer to them by URL
3. Create a Job object which references the Job Binaries created in step 2
4. Create an input Data Source which points to the data you wish to process
5. Create an output Data Source which points to the location for output data
6. Create a Job Execution object specifying the cluster and Job object plus
relevant data sources, configuration values, and program arguments
+ When using the web UI this is done with the
:guilabel:`Launch On Existing Cluster` or
:guilabel:`Launch on New Cluster` buttons on the Jobs tab
+ When using the REST API this is done via the */jobs/<job_id>/execute*
method
The workflow is simpler when using existing objects. For example, to
construct a new job which uses existing binaries and input data a user may
only need to perform steps 3, 5, and 6 above. Of course, to repeat the same
job multiple times a user would need only step 6.
Specifying Configuration Values, Parameters, and Arguments
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Jobs can be configured at launch. The job type determines the kinds of values
that may be set:
+--------------------------+---------------+------------+-----------+
| Job type | Configuration | Parameters | Arguments |
| | Values | | |
+==========================+===============+============+===========+
| ``Hive`` | Yes | Yes | No |
+--------------------------+---------------+------------+-----------+
| ``Pig`` | Yes | Yes | Yes |
+--------------------------+---------------+------------+-----------+
| ``MapReduce`` | Yes | No | No |
+--------------------------+---------------+------------+-----------+
| ``MapReduce.Streaming`` | Yes | No | No |
+--------------------------+---------------+------------+-----------+
| ``Java`` | Yes | No | Yes |
+--------------------------+---------------+------------+-----------+
| ``Shell`` | Yes | Yes | Yes |
+--------------------------+---------------+------------+-----------+
| ``Spark`` | Yes | No | Yes |
+--------------------------+---------------+------------+-----------+
| ``Storm`` | Yes | No | Yes |
+--------------------------+---------------+------------+-----------+
| ``Storm Pyelus`` | Yes | No | Yes |
+--------------------------+---------------+------------+-----------+
* :dfn:`Configuration values` are key/value pairs.
+ The EDP configuration values have names beginning with *edp.* and are
consumed by sahara
+ Other configuration values may be read at runtime by Hadoop jobs
+ Currently additional configuration values are not available to Spark jobs
at runtime
* :dfn:`Parameters` are key/value pairs. They supply values for the Hive and
Pig parameter substitution mechanisms. In Shell jobs, they are passed as
environment variables.
* :dfn:`Arguments` are strings passed as command line arguments to a shell or
main program
These values can be set on the :guilabel:`Configure` tab during job launch
through the web UI or through the *job_configs* parameter when using the
*/jobs/<job_id>/execute* REST method.
In some cases sahara generates configuration values or parameters
automatically. Values set explicitly by the user during launch will override
those generated by sahara.
Using Data Source References as Arguments
+++++++++++++++++++++++++++++++++++++++++
Sometimes it's necessary or desirable to pass a data path as an argument to a
job. In these cases, a user may simply type out the path as an argument when
launching a job. If the path requires credentials, the user can manually add
the credentials as configuration values. However, if a data source object has
been created that contains the desired path and credentials there is no need
to specify this information manually.
As a convenience, sahara allows data source objects to be referenced by name
or id in arguments, configuration values, or parameters. When the job is
executed, sahara will replace the reference with the path stored in the data
source object and will add any necessary credentials to the job configuration.
Referencing an existing data source object is much faster than adding this
information by hand. This is particularly useful for job types like Java or
Spark that do not use data source objects directly.
There are two job configuration parameters that enable data source references.
They may be used with any job type and are set on the ``Configuration`` tab
when the job is launched:
* ``edp.substitute_data_source_for_name`` (default **False**) If set to
**True**, causes sahara to look for data source object name references in
configuration values, arguments, and parameters when a job is launched. Name
references have the form **datasource://name_of_the_object**.
For example, assume a user has a WordCount application that takes an input
path as an argument. If there is a data source object named **my_input**, a
user may simply set the **edp.substitute_data_source_for_name**
configuration parameter to **True** and add **datasource://my_input** as an
argument when launching the job.
* ``edp.substitute_data_source_for_uuid`` (default **False**) If set to
**True**, causes sahara to look for data source object ids in configuration
values, arguments, and parameters when a job is launched. A data source
object id is a uuid, so they are unique. The id of a data source object is
available through the UI or the sahara command line client. A user may
simply use the id as a value.
Creating an Interface for Your Job
++++++++++++++++++++++++++++++++++
In order to better document your job for cluster operators (or for yourself
in the future), sahara allows the addition of an interface (or method
signature) to your job template. A sample interface for the Teragen Hadoop
example might be:
+---------+---------+-----------+-------------+----------+--------------------+
| Name | Mapping | Location | Value | Required | Default |
| | Type | | Type | | |
+=========+=========+===========+=============+==========+====================+
| Example | args | 0 | string | false | teragen |
| Class | | | | | |
+---------+---------+-----------+-------------+----------+--------------------+
| Rows | args | 1 | number | true | unset |
+---------+---------+-----------+-------------+----------+--------------------+
| Output | args | 2 | data_source | false | hdfs://ip:port/path|
| Path | | | | | |
+---------+---------+-----------+-------------+----------+--------------------+
| Mapper | configs | mapred. | number | false | unset |
| Count | | map.tasks | | | |
+---------+---------+-----------+-------------+----------+--------------------+
A "Description" field may also be added to each interface argument.
To create such an interface via the REST API, provide an "interface" argument,
the value of which consists of a list of JSON objects, as below:
.. code-block::
[
{
"name": "Example Class",
"description": "Indicates which example job class should be used.",
"mapping_type": "args",
"location": "0",
"value_type": "string",
"required": false,
"default": "teragen"
},
]
Creating this interface would allow you to specify a configuration for any
execution of the job template by passing an "interface" map similar to:
.. code-block::
{
"Rows": "1000000",
"Mapper Count": "3",
"Output Path": "hdfs://mycluster:8020/user/myuser/teragen-output"
}
The specified arguments would be automatically placed into the args, configs,
and params for the job, according to the mapping type and location fields of
each interface argument. The final ``job_configs`` map would be:
.. code-block::
{
"job_configs": {
"configs":
{
"mapred.map.tasks": "3"
},
"args":
[
"teragen",
"1000000",
"hdfs://mycluster:8020/user/myuser/teragen-output"
]
}
}
Rules for specifying an interface are as follows:
- Mapping Type must be one of ``configs``, ``params``, or ``args``. Only types
supported for your job type are allowed (see above.)
- Location must be a string for ``configs`` and ``params``, and an integer for
``args``. The set of ``args`` locations must be an unbroken series of
integers starting from 0.
- Value Type must be one of ``string``, ``number``, or ``data_source``. Data
sources may be passed as UUIDs or as valid paths (see above.) All values
should be sent as JSON strings. (Note that booleans and null values are
serialized differently in different languages. Please specify them as a
string representation of the appropriate constants for your data processing
engine.)
- ``args`` that are not required must be given a default value.
The additional one-time complexity of specifying an interface on your template
allows a simpler repeated execution path, and also allows us to generate a
customized form for your job in the Horizon UI. This may be particularly
useful in cases in which an operator who is not a data processing job
developer will be running and administering the jobs.
Generation of Swift Properties for Data Sources
+++++++++++++++++++++++++++++++++++++++++++++++
If swift proxy users are not configured (see
:doc:`../admin/advanced-configuration-guide`) and a job is run with data
source objects containing swift paths, sahara will automatically generate
swift username and password configuration values based on the credentials
in the data sources. If the input and output data sources are both in swift,
it is expected that they specify the same credentials.
The swift credentials may be set explicitly with the following configuration
values:
+------------------------------------+
| Name |
+====================================+
| fs.swift.service.sahara.username |
+------------------------------------+
| fs.swift.service.sahara.password |
+------------------------------------+
Setting the swift credentials explicitly is required when passing literal
swift paths as arguments instead of using data source references. When
possible, use data source references as described in
`Using Data Source References as Arguments`_.
Additional Details for Hive jobs
++++++++++++++++++++++++++++++++
Sahara will automatically generate values for the ``INPUT`` and ``OUTPUT``
parameters required by Hive based on the specified data sources.
Additional Details for Pig jobs
+++++++++++++++++++++++++++++++
Sahara will automatically generate values for the ``INPUT`` and ``OUTPUT``
parameters required by Pig based on the specified data sources.
For Pig jobs, ``arguments`` should be thought of as command line arguments
separated by spaces and passed to the ``pig`` shell.
``Parameters`` are a shorthand and are actually translated to the arguments
``-param name=value``
Additional Details for MapReduce jobs
+++++++++++++++++++++++++++++++++++++
**Important!**
If the job type is MapReduce, the mapper and reducer classes *must* be
specified as configuration values.
Note that the UI will not prompt the user for these required values; they must
be added manually with the ``Configure`` tab.
Make sure to add these values with the correct names:
+-----------------------------+----------------------------------------+
| Name | Example Value |
+=============================+========================================+
| mapred.mapper.new-api | true |
+-----------------------------+----------------------------------------+
| mapred.reducer.new-api | true |
+-----------------------------+----------------------------------------+
| mapreduce.job.map.class | org.apache.oozie.example.SampleMapper |
+-----------------------------+----------------------------------------+
| mapreduce.job.reduce.class | org.apache.oozie.example.SampleReducer |
+-----------------------------+----------------------------------------+
Additional Details for MapReduce.Streaming jobs
+++++++++++++++++++++++++++++++++++++++++++++++
**Important!**
If the job type is MapReduce.Streaming, the streaming mapper and reducer
classes *must* be specified.
In this case, the UI *will* prompt the user to enter mapper and reducer
values on the form and will take care of adding them to the job configuration
with the appropriate names. If using the python client, however, be certain to
add these values to the job configuration manually with the correct names:
+-------------------------+---------------+
| Name | Example Value |
+=========================+===============+
| edp.streaming.mapper | /bin/cat |
+-------------------------+---------------+
| edp.streaming.reducer | /usr/bin/wc |
+-------------------------+---------------+
Additional Details for Java jobs
++++++++++++++++++++++++++++++++
Data Source objects are not used directly with Java job types. Instead, any
input or output paths must be specified as arguments at job launch either
explicitly or by reference as described in
`Using Data Source References as Arguments`_. Using data source references is
the recommended way to pass paths to Java jobs.
If configuration values are specified, they must be added to the job's
Hadoop configuration at runtime. There are two methods of doing this. The
simplest way is to use the **edp.java.adapt_for_oozie** option described
below. The other method is to use the code from
`this example <https://opendev.org/openstack/sahara-tests/src/branch/master/sahara_tests/scenario/defaults/edp-examples/edp-java/README.rst>`_
to explicitly load the values.
The following special configuration values are read by sahara and affect how
Java jobs are run:
* ``edp.java.main_class`` (required) Specifies the full name of the class
containing ``main(String[] args)``
A Java job will execute the **main** method of the specified main class. Any
arguments set during job launch will be passed to the program through the
**args** array.
* ``oozie.libpath`` (optional) Specifies configuration values for the Oozie
share libs, these libs can be shared by different workflows
* ``edp.java.java_opts`` (optional) Specifies configuration values for the JVM
* ``edp.java.adapt_for_oozie`` (optional) Specifies that sahara should perform
special handling of configuration values and exit conditions. The default is
**False**.
If this configuration value is set to **True**, sahara will modify
the job's Hadoop configuration before invoking the specified **main** method.
Any configuration values specified during job launch (excluding those
beginning with **edp.**) will be automatically set in the job's Hadoop
configuration and will be available through standard methods.
Secondly, setting this option to **True** ensures that Oozie will handle
program exit conditions correctly.
At this time, the following special configuration value only applies when
running jobs on a cluster generated by the Cloudera plugin with the
**Enable Hbase Common Lib** cluster config set to **True** (the default value):
* ``edp.hbase_common_lib`` (optional) Specifies that a common Hbase lib
generated by sahara in HDFS be added to the **oozie.libpath**. This for use
when an Hbase application is driven from a Java job. Default is **False**.
The **edp-wordcount** example bundled with sahara shows how to use
configuration values, arguments, and swift data paths in a Java job type. Note
that the example does not use the **edp.java.adapt_for_oozie** option but
includes the code to load the configuration values explicitly.
Additional Details for Shell jobs
+++++++++++++++++++++++++++++++++
A shell job will execute the script specified as ``main``, and will place any
files specified as ``libs`` in the same working directory (on both the
filesystem and in HDFS). Command line arguments may be passed to the script
through the ``args`` array, and any ``params`` values will be passed as
environment variables.
Data Source objects are not used directly with Shell job types but data source
references may be used as described in
`Using Data Source References as Arguments`_.
The **edp-shell** example bundled with sahara contains a script which will
output the executing user to a file specified by the first command line
argument.
Additional Details for Spark jobs
+++++++++++++++++++++++++++++++++
Data Source objects are not used directly with Spark job types. Instead, any
input or output paths must be specified as arguments at job launch either
explicitly or by reference as described in
`Using Data Source References as Arguments`_. Using data source references
is the recommended way to pass paths to Spark jobs.
Spark jobs use some special configuration values:
* ``edp.java.main_class`` (required) Specifies the full name of the class
containing the Java or Scala main method:
+ ``main(String[] args)`` for Java
+ ``main(args: Array[String]`` for Scala
A Spark job will execute the **main** method of the specified main class.
Any arguments set during job launch will be passed to the program through the
**args** array.
* ``edp.spark.adapt_for_swift`` (optional) If set to **True**, instructs
sahara to modify the job's Hadoop configuration so that swift paths may be
accessed. Without this configuration value, swift paths will not be
accessible to Spark jobs. The default is **False**. Despite the name, the
same principle applies to jobs which reference paths in S3-like stores.
* ``edp.spark.driver.classpath`` (optional) If set to empty string sahara
will use default classpath for the cluster during job execution.
Otherwise this will override default value for the cluster for particular
job execution.
The **edp-spark** example bundled with sahara contains a Spark program for
estimating Pi.
Special Sahara URLs
-------------------
Sahara uses custom URLs to refer to objects stored in swift, in manila, in the
sahara internal database, or in S3-like storage. These URLs are usually not
meant to be used outside of sahara.
Sahara swift URLs passed to running jobs as input or output sources include a
".sahara" suffix on the container, for example:
``swift://container.sahara/object``
You may notice these swift URLs in job logs, however, you do not need to add
the suffix to the containers yourself. sahara will add the suffix if
necessary, so when using the UI or the python client you may write the above
URL simply as:
``swift://container/object``
Sahara internal database URLs have the form:
``internal-db://sahara-generated-uuid``
This indicates a file object in the sahara database which has the given uuid
as a key.
Manila NFS filesystem reference URLS take the form:
``manila://share-uuid/path``
This format should be used when referring to a job binary or a data source
stored in a manila NFS share.
For both job binaries and data sources, S3 urls take the form:
``s3://bucket/path/to/object``
Despite the above URL format, the current implementation of EDP will still
use the Hadoop ``s3a`` driver to access data sources. Botocore is used to
access job binaries.
EDP Requirements
================
The OpenStack installation and the cluster launched from sahara must meet the
following minimum requirements in order for EDP to function:
OpenStack Services
------------------
When a Hadoop job is executed, binaries are first uploaded to a cluster node
and then moved from the node local filesystem to HDFS. Therefore, there must
be an instance of HDFS available to the nodes in the sahara cluster.
If the swift service *is not* running in the OpenStack installation:
+ Job binaries may only be stored in the sahara internal database
+ Data sources require a long-running HDFS
If the swift service *is* running in the OpenStack installation:
+ Job binaries may be stored in swift or the sahara internal database
+ Data sources may be in swift or a long-running HDFS
Cluster Processes
-----------------
Requirements for EDP support depend on the EDP job type and plugin used for
the cluster. For example a Vanilla sahara cluster must run at least one
instance of these processes to support EDP:
* For Hadoop version 1:
+ jobtracker
+ namenode
+ oozie
+ tasktracker
+ datanode
* For Hadoop version 2:
+ namenode
+ datanode
+ resourcemanager
+ nodemanager
+ historyserver
+ oozie
+ spark history server
EDP Technical Considerations
============================
There are several things in EDP which require attention in order
to work properly. They are listed on this page.
Transient Clusters
------------------
EDP allows running jobs on transient clusters. In this case the cluster is
created specifically for the job and is shut down automatically once the job
is finished.
Two config parameters control the behaviour of periodic clusters:
* periodic_enable - if set to 'false', sahara will do nothing to a transient
cluster once the job it was created for is completed. If it is set to
'true', then the behaviour depends on the value of the next parameter.
* use_identity_api_v3 - set it to 'false' if your OpenStack installation
does not provide keystone API v3. In that case sahara will not terminate
unneeded clusters. Instead it will set their state to 'AwaitingTermination'
meaning that they could be manually deleted by a user. If the parameter is
set to 'true', sahara will itself terminate the cluster. The limitation is
caused by lack of 'trusts' feature in Keystone API older than v3.
If both parameters are set to 'true', sahara works with transient clusters in
the following manner:
1. When a user requests for a job to be executed on a transient cluster,
sahara creates such a cluster.
2. Sahara drops the user's credentials once the cluster is created but
prior to that it creates a trust allowing it to operate with the
cluster instances in the future without user credentials.
3. Once a cluster is not needed, sahara terminates its instances using the
stored trust. sahara drops the trust after that.
| /sahara-18.0.0.0rc1.tar.gz/sahara-18.0.0.0rc1/doc/source/user/edp.rst | 0.890821 | 0.82386 | edp.rst | pypi |
Features Overview
=================
This page highlights some of the most prominent features available in
sahara. The guidance provided here is primarily focused on the
runtime aspects of sahara. For discussions about configuring the sahara
server processes please see the :doc:`../admin/configuration-guide` and
:doc:`../admin/advanced-configuration-guide`.
Anti-affinity
-------------
One of the problems with running data processing applications on OpenStack
is the inability to control where an instance is actually running. It is
not always possible to ensure that two new virtual machines are started on
different physical machines. As a result, any replication within the cluster
is not reliable because all replicas may be co-located on one physical
machine. To remedy this, sahara provides the anti-affinity feature to
explicitly command all instances of the specified processes to spawn on
different Compute nodes. This is especially useful for Hadoop data node
processes to increase HDFS replica reliability.
Starting with the Juno release, sahara can create server groups with the
``anti-affinity`` policy to enable this feature. Sahara creates one server
group per cluster and assigns all instances with affected processes to
this server group. Refer to the :nova-doc:`Nova Anti-Affinity documentation
<admin/configuration/schedulers.html#servergroupantiaffinityfilter>`
on how server group affinity filters work.
This feature is supported by all plugins out of the box, and can be enabled
during the cluster template creation.
Block Storage support
---------------------
OpenStack Block Storage (cinder) can be used as an alternative for
ephemeral drives on instances. Using Block Storage volumes increases the
reliability of data which is important for HDFS services.
A user can set how many volumes will be attached to each instance in a
node group and the size of each volume. All volumes are attached during
cluster creation and scaling operations.
If volumes are used for the HDFS storage it's important to make sure that
the linear read-write operations as well as IOpS level are high enough to
handle the workload. Volumes placed on the same compute host provide a higher
level of performance.
In some cases cinder volumes can be backed by a distributed storage like Ceph.
In this type of installation it's important to make sure that the network
latency and speed do not become a blocker for HDFS. Distributed storage
solutions usually provide their own replication mechanism. HDFS replication
should be disabled so that it does not generate redundant traffic across the
cloud.
Cluster scaling
---------------
Cluster scaling allows users to change the number of running instances
in a cluster without needing to recreate the cluster. Users may
increase or decrease the number of instances in node groups or add
new node groups to existing clusters. If a cluster fails to scale
properly, all changes will be rolled back.
Data locality
-------------
For optimal performance, it is best for data processing applications
to work on data local to the same rack, OpenStack Compute node, or
virtual machine. Hadoop supports a data locality feature and can schedule
jobs to task tracker nodes that are local for the input stream. In this
manner the task tracker nodes can communicate directly with the local
data nodes.
Sahara supports topology configuration for HDFS and Object Storage
data sources. For more information on configuring this option please
see the :ref:`data_locality_configuration` documentation.
Volume-to-instance locality
---------------------------
Having an instance and an attached volume on the same physical host can
be very helpful in order to achieve high-performance disk I/O operations.
To achieve this, sahara provides access to the Block Storage
volume instance locality functionality.
For more information on using volume instance locality with sahara,
please see the :ref:`volume_instance_locality_configuration`
documentation.
Distributed Mode
----------------
The :doc:`../install/installation-guide` suggests launching sahara in
distributed mode with ``sahara-api`` and ``sahara-engine`` processes
potentially running on several machines simultaneously.
Running in distributed mode allows sahara to
offload intensive tasks to the engine processes while keeping the API
process free to handle requests.
For an expanded discussion of configuring sahara to run in distributed
mode please see the :ref:`distributed-mode-configuration` documentation.
Hadoop HDFS and YARN High Availability
--------------------------------------
Currently HDFS and YARN HA are supported with the HDP 2.4 plugin and CDH 5.7
plugins.
Hadoop HDFS and YARN High Availability provide an architecture to ensure
that HDFS or YARN will continue to work in the result of an active namenode or
resourcemanager failure. They use 2 namenodes and 2 resourcemanagers in an
active/passive state to provide this availability.
In the HDP 2.4 plugin, the feature can be enabled through dashboard in the
Cluster Template creation form. High availability is achieved by using a set
of journalnodes, Zookeeper servers, and ZooKeeper Failover Controllers (ZKFC),
as well as additional configuration changes to HDFS and other services that
use HDFS.
In the CDH 5.7 plugin, HA for HDFS and YARN is enabled through adding several
HDFS_JOURNALNODE roles in the node group templates of cluster template.
The HDFS HA is enabled when HDFS_JOURNALNODE roles are added and the roles
setup meets below requirements:
* HDFS_JOURNALNODE number is odd, and at least 3.
* Zookeeper is enabled.
* NameNode and SecondaryNameNode are on different physical hosts by setting
anti-affinity.
* Cluster has both ResourceManager and StandByResourceManager.
In this case, the original SecondaryNameNode node will be used as the
Standby NameNode.
Networking support
------------------
Sahara supports neutron implementations of OpenStack Networking.
Object Storage support
----------------------
Sahara can use OpenStack Object Storage (swift) to store job binaries and data
sources utilized by its job executions and clusters. In order to
leverage this support within Hadoop, including using Object Storage
for data sources for EDP, Hadoop requires the application of
a patch. For additional information about enabling this support,
including patching Hadoop and configuring sahara, please refer to
the :doc:`hadoop-swift` documentation.
Shared Filesystem support
-------------------------
Sahara can also use NFS shares through the OpenStack Shared Filesystem service
(manila) to store job binaries and data sources. See :doc:`edp` for more
information on this feature.
Orchestration support
---------------------
Sahara may use the
`OpenStack Orchestration engine <https://wiki.openstack.org/wiki/Heat>`_
(heat) to provision nodes for clusters. For more information about
enabling Orchestration usage in sahara please see
:ref:`orchestration-configuration`.
DNS support
-----------
Sahara can resolve hostnames of cluster instances by using DNS. For this Sahara
uses designate. For additional details see
:doc:`../admin/advanced-configuration-guide`.
Kerberos support
----------------
You can protect your HDP or CDH cluster using MIT Kerberos security. To get
more details about this, please, see documentation for the appropriate plugin.
Plugin Capabilities
-------------------
The following table provides a plugin capability matrix:
+--------------------------+---------+----------+----------+-------+
| Feature/Plugin | Vanilla | HDP | Cloudera | Spark |
+==========================+=========+==========+==========+=======+
| Neutron network | x | x | x | x |
+--------------------------+---------+----------+----------+-------+
| Cluster Scaling | x | x | x | x |
+--------------------------+---------+----------+----------+-------+
| Swift Integration | x | x | x | x |
+--------------------------+---------+----------+----------+-------+
| Cinder Support | x | x | x | x |
+--------------------------+---------+----------+----------+-------+
| Data Locality | x | x | x | x |
+--------------------------+---------+----------+----------+-------+
| DNS | x | x | x | x |
+--------------------------+---------+----------+----------+-------+
| Kerberos | \- | x | x | \- |
+--------------------------+---------+----------+----------+-------+
| HDFS HA | \- | x | x | \- |
+--------------------------+---------+----------+----------+-------+
| EDP | x | x | x | x |
+--------------------------+---------+----------+----------+-------+
Security group management
-------------------------
Security groups are sets of IP filter rules that are applied to an instance's
networking. They are project specified, and project members can edit the
default rules for their group and add new rules sets. All projects have a
"default" security group, which is applied to instances that have no other
security group defined. Unless changed, this security group denies all incoming
traffic.
Sahara allows you to control which security groups will be used for created
instances. This can be done by providing the ``security_groups`` parameter for
the node group or node group template. The default for this option is an
empty list, which will result in the default project security group being
used for the instances.
Sahara may also create a security group for instances in the node group
automatically. This security group will only contain open ports for required
instance processes and the sahara engine. This option is useful
for development and for when your installation is secured from outside
environments. For production environments we recommend controlling the
security group policy manually.
Shared and protected resources support
--------------------------------------
Sahara allows you to create resources that can be shared across projects and
protected from modifications.
To provide this feature all sahara objects that can be accessed through
REST API have ``is_public`` and ``is_protected`` boolean fields. They can be
initially created with enabled ``is_public`` and ``is_protected``
parameters or these parameters can be updated after creation. Both fields are
set to ``False`` by default.
If some object has its ``is_public`` field set to ``True``, it means that it's
visible not only from the project in which it was created, but from any other
projects too.
If some object has its ``is_protected`` field set to ``True``, it means that it
can not be modified (updated, scaled, canceled or deleted) unless this field
is set to ``False``.
Public objects created in one project can be used from other projects (for
example, a cluster can be created from a public cluster template which is
created in another project), but modification operations are possible only from
the project in which object was created.
Data source placeholders support
--------------------------------
Sahara supports special strings that can be used in data source URLs. These
strings will be replaced with appropriate values during job execution which
allows the use of the same data source as an output multiple times.
There are 2 types of string currently supported:
* ``%JOB_EXEC_ID%`` - this string will be replaced with the job execution ID.
* ``%RANDSTR(len)%`` - this string will be replaced with random string of
lowercase letters of length ``len``. ``len`` must be less than 1024.
After placeholders are replaced, the real URLs are stored in the
``data_source_urls`` field of the job execution object. This is used later to
find objects created by a particular job run.
Keypair replacement
-------------------
A cluster allows users to create a new keypair to access to the running cluster
when the cluster's keypair is deleted. But the name of new keypair should be
same as the deleted one, and the new keypair will be available for cluster
scaling.
| /sahara-18.0.0.0rc1.tar.gz/sahara-18.0.0.0rc1/doc/source/user/features.rst | 0.889093 | 0.75584 | features.rst | pypi |
Sahara (Data Processing) UI User Guide
======================================
This guide assumes that you already have the sahara service and Horizon
dashboard up and running. Don't forget to make sure that sahara is
registered in Keystone. If you require assistance with that, please see the
`installation guide <../install/installation-guide.html>`_.
The sections below give a panel by panel overview of setting up clusters
and running jobs. For a description of using the guided cluster and job tools,
look at `Launching a cluster via the Cluster Creation Guide`_ and
`Running a job via the Job Execution Guide`_.
Launching a cluster via the sahara UI
-------------------------------------
Registering an Image
--------------------
1) Navigate to the "Project" dashboard, then to the "Data Processing" tab, then
click on the "Clusters" panel and finally the "Image Registry" tab.
2) From that page, click on the "Register Image" button at the top right
3) Choose the image that you'd like to register with sahara
4) Enter the username of the cloud-init user on the image
5) Choose plugin and version to make the image available only for the intended
clusters
6) Click the "Done" button to finish the registration
Create Node Group Templates
---------------------------
1) Navigate to the "Project" dashboard, then to the "Data Processing" tab, then
click on the "Clusters" panel and then the "Node Group Templates" tab.
2) From that page, click on the "Create Template" button at the top right
3) Choose your desired Plugin name and Version from the dropdowns and click
"Next"
4) Give your Node Group Template a name (description is optional)
5) Choose a flavor for this template (based on your CPU/memory/disk needs)
6) Choose the storage location for your instance, this can be either "Ephemeral
Drive" or "Cinder Volume". If you choose "Cinder Volume", you will need to
add additional configuration
7) Switch to the Node processes tab and choose which processes should be run
for all instances that are spawned from this Node Group Template
8) Click on the "Create" button to finish creating your Node Group Template
Create a Cluster Template
-------------------------
1) Navigate to the "Project" dashboard, then to the "Data Processing" tab, then
click on the "Clusters" panel and finally the "Cluster Templates" tab.
2) From that page, click on the "Create Template" button at the top right
3) Choose your desired Plugin name and Version from the dropdowns and click
"Next"
4) Under the "Details" tab, you must give your template a name
5) Under the "Node Groups" tab, you should add one or more nodes that can be
based on one or more templates
- To do this, start by choosing a Node Group Template from the dropdown and
click the "+" button
- You can adjust the number of nodes to be spawned for this node group via
the text box or the "-" and "+" buttons
- Repeat these steps if you need nodes from additional node group templates
6) Optionally, you can adjust your configuration further by using the "General
Parameters", "HDFS Parameters" and "MapReduce Parameters" tabs
7) If you have Designate DNS service you can choose the domain name in "DNS"
tab for internal and external hostname resolution
8) Click on the "Create" button to finish creating your Cluster Template
Launching a Cluster
-------------------
1) Navigate to the "Project" dashboard, then to the "Data Processing" tab, then
click on the "Clusters" panel and lastly, click on the "Clusters" tab.
2) Click on the "Launch Cluster" button at the top right
3) Choose your desired Plugin name and Version from the dropdowns and click
"Next"
4) Give your cluster a name (required)
5) Choose which cluster template should be used for your cluster
6) Choose the image that should be used for your cluster (if you do not see any
options here, see `Registering an Image`_ above)
7) Optionally choose a keypair that can be used to authenticate to your cluster
instances
8) Click on the "Create" button to start your cluster
- Your cluster's status will display on the Clusters table
- It will likely take several minutes to reach the "Active" state
Scaling a Cluster
-----------------
1) From the Data Processing/Clusters page (Clusters tab), click on the
"Scale Cluster" button of the row that contains the cluster that you want to
scale
2) You can adjust the numbers of instances for existing Node Group Templates
3) You can also add a new Node Group Template and choose a number of instances
to launch
- This can be done by selecting your desired Node Group Template from the
dropdown and clicking the "+" button
- Your new Node Group will appear below and you can adjust the number of
instances via the text box or the "+" and "-" buttons
4) To confirm the scaling settings and trigger the spawning/deletion of
instances, click on "Scale"
Elastic Data Processing (EDP)
-----------------------------
Data Sources
------------
Data Sources are where the input and output from your jobs are housed.
1) From the Data Processing/Jobs page (Data Sources tab), click on the
"Create Data Source" button at the top right
2) Give your Data Source a name
3) Enter the URL of the Data Source
- For a swift object, enter <container>/<path> (ie: *mycontainer/inputfile*).
sahara will prepend *swift://* for you
- For an HDFS object, enter an absolute path, a relative path or a full URL:
+ */my/absolute/path* indicates an absolute path in the cluster HDFS
+ *my/path* indicates the path */user/hadoop/my/path* in the cluster HDFS
assuming the defined HDFS user is *hadoop*
+ *hdfs://host:port/path* can be used to indicate any HDFS location
4) Enter the username and password for the Data Source (also see
`Additional Notes`_)
5) Enter an optional description
6) Click on "Create"
7) Repeat for additional Data Sources
Job Binaries
------------
Job Binaries are where you define/upload the source code (mains and libraries)
for your job.
1) From the Data Processing/Jobs (Job Binaries tab), click on the
"Create Job Binary" button at the top right
2) Give your Job Binary a name (this can be different than the actual filename)
3) Choose the type of storage for your Job Binary
- For "swift", enter the URL of your binary (<container>/<path>) as well as
the username and password (also see `Additional Notes`_)
- For "manila", choose the share and enter the path for the binary in this
share. This assumes that you have already stored that file in the
appropriate path on the share. The share will be automatically mounted to
any cluster nodes which require access to the file, if it is not mounted
already.
- For "Internal database", you can choose from "Create a script" or "Upload
a new file" (**only API v1.1**)
4) Enter an optional description
5) Click on "Create"
6) Repeat for additional Job Binaries
Job Templates (Known as "Jobs" in the API)
------------------------------------------
Job templates are where you define the type of job you'd like to run as well
as which "Job Binaries" are required.
1) From the Data Processing/Jobs page (Job Templates tab),
click on the "Create Job Template" button at the top right
2) Give your Job Template a name
3) Choose the type of job you'd like to run
4) Choose the main binary from the dropdown
- This is required for Hive, Pig, and Spark jobs
- Other job types do not use a main binary
5) Enter an optional description for your Job Template
6) Click on the "Libs" tab and choose any libraries needed by your job template
- MapReduce and Java jobs require at least one library
- Other job types may optionally use libraries
7) Click on "Create"
Jobs (Known as "Job Executions" in the API)
-------------------------------------------
Jobs are what you get by "Launching" a job template. You can monitor the
status of your job to see when it has completed its run
1) From the Data Processing/Jobs page (Job Templates tab), find the row
that contains the job template you want to launch and click either
"Launch on New Cluster" or "Launch on Existing Cluster" the right side
of that row
2) Choose the cluster (already running--see `Launching a Cluster`_ above) on
which you would like the job to run
3) Choose the Input and Output Data Sources (Data Sources defined above)
4) If additional configuration is required, click on the "Configure" tab
- Additional configuration properties can be defined by clicking on the "Add"
button
- An example configuration entry might be mapred.mapper.class for the Name
and org.apache.oozie.example.SampleMapper for the Value
5) Click on "Launch". To monitor the status of your job, you can navigate to
the Data Processing/Jobs panel and click on the Jobs tab.
6) You can relaunch a Job from the Jobs page by using the
"Relaunch on New Cluster" or "Relaunch on Existing Cluster" links
- Relaunch on New Cluster will take you through the forms to start a new
cluster before letting you specify input/output Data Sources and job
configuration
- Relaunch on Existing Cluster will prompt you for input/output Data Sources
as well as allow you to change job configuration before launching the job
Example Jobs
------------
There are sample jobs located in the sahara repository. In this section, we
will give a walkthrough on how to run those jobs via the Horizon UI. These
steps assume that you already have a cluster up and running (in the "Active"
state). You may want to clone into https://opendev.org/openstack/sahara-tests/
so that you will have all of the source code and inputs stored locally.
1) Sample Pig job -
https://opendev.org/openstack/sahara-tests/src/branch/master/sahara_tests/scenario/defaults/edp-examples/edp-pig/cleanup-string/example.pig
- Load the input data file from
https://opendev.org/openstack/sahara-tests/src/branch/master/sahara_tests/scenario/defaults/edp-examples/edp-pig/cleanup-string/data/input
into swift
- Click on Project/Object Store/Containers and create a container with any
name ("samplecontainer" for our purposes here)
- Click on Upload Object and give the object a name
("piginput" in this case)
- Navigate to Data Processing/Jobs/Data Sources, Click on Create Data Source
- Name your Data Source ("pig-input-ds" in this sample)
- Type = Swift, URL samplecontainer/piginput, fill-in the Source
username/password fields with your username/password and click "Create"
- Create another Data Source to use as output for the job
- Name = pig-output-ds, Type = Swift, URL = samplecontainer/pigoutput,
Source username/password, "Create"
- Store your Job Binaries in Swift (you can choose another type of storage
if you want)
- Navigate to Project/Object Store/Containers, choose "samplecontainer"
- Click on Upload Object and find example.pig at
<sahara-tests root>/sahara-tests/scenario/defaults/edp-examples/
edp-pig/cleanup-string/, name it "example.pig" (or other name).
The Swift path will be swift://samplecontainer/example.pig
- Click on Upload Object and find edp-pig-udf-stringcleaner.jar at
<sahara-tests root>/sahara-tests/scenario/defaults/edp-examples/
edp-pig/cleanup-string/, name it "edp-pig-udf-stringcleaner.jar"
(or other name). The Swift path will be
swift://samplecontainer/edp-pig-udf-stringcleaner.jar
- Navigate to Data Processing/Jobs/Job Binaries, Click on Create Job Binary
- Name = example.pig, Storage type = Swift,
URL = samplecontainer/example.pig, Username = <your username>,
Password = <your password>
- Create another Job Binary: Name = edp-pig-udf-stringcleaner.jar,
Storage type = Swift,
URL = samplecontainer/edp-pig-udf-stringcleaner.jar,
Username = <your username>, Password = <your password>
- Create a Job Template
- Navigate to Data Processing/Jobs/Job Templates, Click on
Create Job Template
- Name = pigsample, Job Type = Pig, Choose "example.pig" as the main binary
- Click on the "Libs" tab and choose "edp-pig-udf-stringcleaner.jar",
then hit the "Choose" button beneath the dropdown, then click
on "Create"
- Launch your job
- To launch your job from the Job Templates page, click on the down
arrow at the far right of the screen and choose
"Launch on Existing Cluster"
- For the input, choose "pig-input-ds", for output choose "pig-output-ds".
Also choose whichever cluster you'd like to run the job on
- For this job, no additional configuration is necessary, so you can just
click on "Launch"
- You will be taken to the "Jobs" page where you can see your job
progress through "PENDING, RUNNING, SUCCEEDED" phases
- When your job finishes with "SUCCEEDED", you can navigate back to Object
Store/Containers and browse to the samplecontainer to see your output.
It should be in the "pigoutput" folder
2) Sample Spark job -
https://opendev.org/openstack/sahara-tests/src/branch/master/sahara_tests/scenario/defaults/edp-examples/edp-spark
You can clone into https://opendev.org/openstack/sahara-tests/ for quicker
access to the files for this sample job.
- Store the Job Binary in Swift (you can choose another type of storage if
you want)
- Click on Project/Object Store/Containers and create a container with any
name ("samplecontainer" for our purposes here)
- Click on Upload Object and find spark-wordcount.jar at
<sahara-tests root>/sahara-tests/scenario/defaults/edp-examples/
edp-spark/, name it "spark-wordcount.jar" (or other name).
The Swift path will be swift://samplecontainer/spark-wordcount.jar
- Navigate to Data Processing/Jobs/Job Binaries, Click on Create Job Binary
- Name = sparkexample.jar, Storage type = Swift,
URL = samplecontainer/spark-wordcount.jar, Username = <your username>,
Password = <your password>
- Create a Job Template
- Name = sparkexamplejob, Job Type = Spark,
Main binary = Choose sparkexample.jar, Click "Create"
- Launch your job
- To launch your job from the Job Templates page, click on the
down arrow at the far right of the screen and choose
"Launch on Existing Cluster"
- Choose whichever cluster you'd like to run the job on
- Click on the "Configure" tab
- Set the main class to be: sahara.edp.spark.SparkWordCount
- Under Arguments, click Add and fill url for the input file,
once more click Add and fill url for the output file.
- Click on Launch
- You will be taken to the "Jobs" page where you can see your job
progress through "PENDING, RUNNING, SUCCEEDED" phases
- When your job finishes with "SUCCEEDED", you can see your results in
your output file.
- The stdout and stderr files of the command used for executing your job
are located at /tmp/spark-edp/<name of job template>/<job id>
on Spark master node in case of Spark clusters, or on Spark JobHistory
node in other cases like Vanilla, CDH and so on.
Additional Notes
----------------
1) Throughout the sahara UI, you will find that if you try to delete an object
that you will not be able to delete it if another object depends on it.
An example of this would be trying to delete a Job Template that has an
existing Job. In order to be able to delete that job, you would
first need to delete any Job Templates that relate to that job.
2) In the examples above, we mention adding your username/password for the
swift Data Sources. It should be noted that it is possible to configure
sahara such that the username/password credentials are *not* required. For
more information on that, please refer to: :doc:`Sahara Advanced
Configuration Guide <../admin/advanced-configuration-guide>`
Launching a cluster via the Cluster Creation Guide
--------------------------------------------------
1) Under the Data Processing group, choose "Clusters" and then click on the
"Clusters" tab. The "Cluster Creation Guide" button is above that table.
Click on it.
2) Click on the "Choose Plugin" button then select the cluster type from the
Plugin Name dropdown and choose your target version. When done, click
on "Select" to proceed.
3) Click on "Create a Master Node Group Template". Give your template a name,
choose a flavor and choose which processes should run on nodes launched
for this node group. The processes chosen here should be things that are
more server-like in nature (namenode, oozieserver, spark master, etc).
Optionally, you can set other options here such as availability zone,
storage, security and process specific parameters. Click on "Create"
to proceed.
4) Click on "Create a Worker Node Group Template". Give your template a name,
choose a flavor and choose which processes should run on nodes launched
for this node group. Processes chosen here should be more worker-like in
nature (datanode, spark slave, task tracker, etc). Optionally, you can set
other options here such as availability zone, storage, security and process
specific parameters. Click on "Create" to proceed.
5) Click on "Create a Cluster Template". Give your template a name. Next,
click on the "Node Groups" tab and enter the count for each of the node
groups (these are pre-populated from steps 3 and 4). It would be common
to have 1 for the "master" node group type and some larger number of
"worker" instances depending on you desired cluster size. Optionally,
you can also set additional parameters for cluster-wide settings via
the other tabs on this page. Click on "Create" to proceed.
6) Click on "Launch a Cluster". Give your cluster a name and choose the image
that you want to use for all instances in your cluster. The cluster
template that you created in step 5 is already pre-populated. If you want
ssh access to the instances of your cluster, select a keypair from the
dropdown. Click on "Launch" to proceed. You will be taken to the Clusters
panel where you can see your cluster progress toward the Active state.
Running a job via the Job Execution Guide
-----------------------------------------
1) Under the Data Processing group, choose "Jobs" and then click on the
"Jobs" tab. The "Job Execution Guide" button is above that table. Click
on it.
2) Click on "Select type" and choose the type of job that you want to run.
3) If your job requires input/output data sources, you will have the option
to create them via the "Create a Data Source" button (Note: This button will
not be shown for job types that do not require data sources). Give your
data source a name and choose the type. If you have chosen swift, you
may also enter the username and password. Enter the URL for your data
source. For more details on what the URL should look like, see
`Data Sources`_.
4) Click on "Create a job template". Give your job template a name.
Depending on the type of job that you've chosen, you may need to select
your main binary and/or additional libraries (available from the "Libs"
tab). If you have not yet uploaded the files to run your program, you
can add them via the "+" icon next to the "Choose a main binary" select box.
5) Click on "Launch job". Choose the active cluster where you want to run you
job. Optionally, you can click on the "Configure" tab and provide any
required configuration, arguments or parameters for your job. Click on
"Launch" to execute your job. You will be taken to the Jobs tab where
you can monitor the state of your job as it progresses.
| /sahara-18.0.0.0rc1.tar.gz/sahara-18.0.0.0rc1/doc/source/user/dashboard-user-guide.rst | 0.804713 | 0.695726 | dashboard-user-guide.rst | pypi |
# Getting started
## How to Build
You must have Python ```2 >=2.7.9``` or Python ```3 >=3.4``` installed on your system to install and run this SDK. This SDK package depends on other Python packages like nose, jsonpickle etc.
These dependencies are defined in the ```requirements.txt``` file that comes with the SDK.
To resolve these dependencies, you can use the PIP Dependency manager. Install it by following steps at [https://pip.pypa.io/en/stable/installing/](https://pip.pypa.io/en/stable/installing/).
Python and PIP executables should be defined in your PATH. Open command prompt and type ```pip --version```.
This should display the version of the PIP Dependency Manager installed if your installation was successful and the paths are properly defined.
* Using command line, navigate to the directory containing the generated files (including ```requirements.txt```) for the SDK.
* Run the command ```pip install -r requirements.txt```. This should install all the required dependencies.
## How to Use
The following section explains how to use the Batester SDK package in a new project.
### 1. Open Project in an IDE
Open up a Python IDE like PyCharm. The basic workflow presented here is also applicable if you prefer using a different editor or IDE.
Click on ```Open``` in PyCharm to browse to your generated SDK directory and then click ```OK```.
The project files will be displayed in the side bar as follows:
### 2. Add a new Test Project
Create a new directory by right clicking on the solution name as shown below:
Name the directory as "test"
Add a python file to this project with the name "testsdk"
Name it "testsdk"
In your python file you will be required to import the generated python library using the following code lines
```Python
from sahfqgbwmy.sahfqgbwmy_client import SahfqgbwmyClient
```
After this you can write code to instantiate an API client object, get a controller object and make API calls. Sample code is given in the subsequent sections.
### 3. Run the Test Project
To run the file within your test project, right click on your Python file inside your Test project and click on ```Run```
## How to Test
You can test the generated SDK and the server with automatically generated test
cases. unittest is used as the testing framework and nose is used as the test
runner. You can run the tests as follows:
1. From terminal/cmd navigate to the root directory of the SDK.
2. Invoke ```pip install -r test-requirements.txt```
3. Invoke ```nosetests```
## Initialization
### Authentication
In order to setup authentication and initialization of the API client, you need the following information.
| Parameter | Description |
|-----------|-------------|
| basic_auth_user_name | The username to use with basic authentication |
| basic_auth_password | The password to use with basic authentication |
API client can be initialized as following.
```python
# Configuration parameters and credentials
basic_auth_user_name = 'basic_auth_user_name' # The username to use with basic authentication
basic_auth_password = 'basic_auth_password' # The password to use with basic authentication
client = SahfqgbwmyClient(basic_auth_user_name, basic_auth_password)
```
# Class Reference
## <a name="list_of_controllers"></a>List of Controllers
* [APIController](#api_controller)
## <a name="api_controller"></a> APIController
### Get controller instance
An instance of the ``` APIController ``` class can be accessed from the API Client.
```python
client_controller = client.client
```
### <a name="get_basic_auth_test"></a> get_basic_auth_test
> TODO: Add a method description
```python
def get_basic_auth_test(self)
```
#### Example Usage
```python
result = client_controller.get_basic_auth_test()
```
[Back to List of Controllers](#list_of_controllers)
| /sahfqgbwmy-1.1.tar.gz/sahfqgbwmy-1.1/README.md | 0.622115 | 0.942876 | README.md | pypi |
<div align="center">
<h1>
SAHI: Slicing Aided Hyper Inference
</h1>
<h4>
A lightweight vision library for performing large scale object detection & instance segmentation
</h4>
<h4>
<img width="700" alt="teaser" src="https://raw.githubusercontent.com/obss/sahi/main/resources/sliced_inference.gif">
</h4>
<div>
<a href="https://pepy.tech/project/sahi"><img src="https://pepy.tech/badge/sahi" alt="downloads"></a>
<a href="https://pepy.tech/project/sahi"><img src="https://pepy.tech/badge/sahi/month" alt="downloads"></a>
<br>
<a href="https://badge.fury.io/py/sahi"><img src="https://badge.fury.io/py/sahi.svg" alt="pypi version"></a>
<a href="https://anaconda.org/conda-forge/sahi"><img src="https://anaconda.org/conda-forge/sahi/badges/version.svg" alt="conda version"></a>
<a href="https://github.com/obss/sahi/actions/workflows/package_testing.yml"><img src="https://github.com/obss/sahi/actions/workflows/package_testing.yml/badge.svg" alt="package testing"></a>
<br>
<a href="https://ieeexplore.ieee.org/document/9897990"><img src="https://img.shields.io/badge/DOI-10.1109%2FICIP46576.2022.9897990-orange.svg" alt="ci"></a>
<br>
<a href="https://colab.research.google.com/github/obss/sahi/blob/main/demo/inference_for_yolov5.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a>
<a href="https://huggingface.co/spaces/fcakyon/sahi-yolox"><img src="https://raw.githubusercontent.com/obss/sahi/main/resources/hf_spaces_badge.svg" alt="HuggingFace Spaces"></a>
</div>
</div>
## <div align="center">Overview</div>
Object detection and instance segmentation are by far the most important fields of applications in Computer Vision. However, detection of small objects and inference on large images are still major issues in practical usage. Here comes the SAHI to help developers overcome these real-world problems with many vision utilities.
| Command | Description |
|---|---|
| [predict](https://github.com/obss/sahi/blob/main/docs/cli.md#predict-command-usage) | perform sliced/standard video/image prediction using any [yolov5](https://github.com/ultralytics/yolov5)/[mmdet](https://github.com/open-mmlab/mmdetection)/[detectron2](https://github.com/facebookresearch/detectron2)/[huggingface](https://huggingface.co/models?pipeline_tag=object-detection&sort=downloads) model |
| [predict-fiftyone](https://github.com/obss/sahi/blob/main/docs/cli.md#predict-fiftyone-command-usage) | perform sliced/standard prediction using any [yolov5](https://github.com/ultralytics/yolov5)/[mmdet](https://github.com/open-mmlab/mmdetection)/[detectron2](https://github.com/facebookresearch/detectron2)/[huggingface](https://huggingface.co/models?pipeline_tag=object-detection&sort=downloads) model and explore results in [fiftyone app](https://github.com/voxel51/fiftyone) |
| [coco slice](https://github.com/obss/sahi/blob/main/docs/cli.md#coco-slice-command-usage) | automatically slice COCO annotation and image files |
| [coco fiftyone](https://github.com/obss/sahi/blob/main/docs/cli.md#coco-fiftyone-command-usage) | explore multiple prediction results on your COCO dataset with [fiftyone ui](https://github.com/voxel51/fiftyone) ordered by number of misdetections |
| [coco evaluate](https://github.com/obss/sahi/blob/main/docs/cli.md#coco-evaluate-command-usage) | evaluate classwise COCO AP and AR for given predictions and ground truth |
| [coco analyse](https://github.com/obss/sahi/blob/main/docs/cli.md#coco-analyse-command-usage) | calcualate and export many error analysis plots |
| [coco yolov5](https://github.com/obss/sahi/blob/main/docs/cli.md#coco-yolov5-command-usage) | automatically convert any COCO dataset to [yolov5](https://github.com/ultralytics/yolov5) format |
## <div align="center">Quick Start Examples</div>
[📜 List of publications that cite SAHI (currently 40+)](https://scholar.google.com/scholar?hl=en&as_sdt=2005&sciodt=0,5&cites=14065474760484865747&scipsc=&q=&scisbd=1)
[🏆 List of competition winners that used SAHI](https://github.com/obss/sahi/discussions/688)
### Tutorials
- [Introduction to SAHI](https://medium.com/codable/sahi-a-vision-library-for-performing-sliced-inference-on-large-images-small-objects-c8b086af3b80)
- [Official paper](https://ieeexplore.ieee.org/document/9897990) (ICIP 2022 oral) (NEW)
- [Pretrained weights and ICIP 2022 paper files](https://github.com/fcakyon/small-object-detection-benchmark)
- [Video inference support is live](https://github.com/obss/sahi/discussions/626)
- [Kaggle notebook](https://www.kaggle.com/remekkinas/sahi-slicing-aided-hyper-inference-yv5-and-yx)
- [Satellite object detection](https://blog.ml6.eu/how-to-detect-small-objects-in-very-large-images-70234bab0f98)
- [Error analysis plots & evaluation](https://github.com/obss/sahi/discussions/622) (NEW)
- [Interactive result visualization and inspection](https://github.com/obss/sahi/discussions/624) (NEW)
- [COCO dataset conversion](https://medium.com/codable/convert-any-dataset-to-coco-object-detection-format-with-sahi-95349e1fe2b7)
- [Slicing operation notebook](demo/slicing.ipynb)
- `YOLOX` + `SAHI` demo: <a href="https://huggingface.co/spaces/fcakyon/sahi-yolox"><img src="https://raw.githubusercontent.com/obss/sahi/main/resources/hf_spaces_badge.svg" alt="sahi-yolox"></a> (RECOMMENDED)
- `YOLOv5` + `SAHI` walkthrough: <a href="https://colab.research.google.com/github/obss/sahi/blob/main/demo/inference_for_yolov5.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="sahi-yolov5"></a>
- `MMDetection` + `SAHI` walkthrough: <a href="https://colab.research.google.com/github/obss/sahi/blob/main/demo/inference_for_mmdetection.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="sahi-mmdetection"></a>
- `Detectron2` + `SAHI` walkthrough: <a href="https://colab.research.google.com/github/obss/sahi/blob/main/demo/inference_for_detectron2.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="sahi-detectron2"></a>
- `HuggingFace` + `SAHI` walkthrough: <a href="https://colab.research.google.com/github/obss/sahi/blob/main/demo/inference_for_huggingface.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="sahi-huggingface"></a> (NEW)
- `TorchVision` + `SAHI` walkthrough: <a href="https://colab.research.google.com/github/obss/sahi/blob/main/demo/inference_for_torchvision.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="sahi-torchvision"></a> (NEW)
<a href="https://huggingface.co/spaces/fcakyon/sahi-yolox"><img width="600" src="https://user-images.githubusercontent.com/34196005/144092739-c1d9bade-a128-4346-947f-424ce00e5c4f.gif" alt="sahi-yolox"></a>
</details>
### Installation
<img width="700" alt="sahi-installation" src="https://user-images.githubusercontent.com/34196005/149311602-b44e6fe1-f496-40f2-a7ae-5ea1f66e1550.gif">
<details closed>
<summary>
<big><b>Installation details:</b></big>
</summary>
- Install `sahi` using pip:
```console
pip install sahi
```
- On Windows, `Shapely` needs to be installed via Conda:
```console
conda install -c conda-forge shapely
```
- Install your desired version of pytorch and torchvision (cuda 11.3 for detectron2, cuda 11.7 for rest):
```console
conda install pytorch=1.10.2 torchvision=0.11.3 cudatoolkit=11.3 -c pytorch
```
```console
conda install pytorch=1.13.1 torchvision=0.14.1 pytorch-cuda=11.7 -c pytorch -c nvidia
```
- Install your desired detection framework (yolov5):
```console
pip install yolov5==7.0.4
```
- Install your desired detection framework (mmdet):
```console
pip install mmcv-full==1.7.0 -f https://download.openmmlab.com/mmcv/dist/cu117/torch1.13.0/index.html
```
```console
pip install mmdet==2.26.0
```
- Install your desired detection framework (detectron2):
```console
pip install detectron2 -f https://dl.fbaipublicfiles.com/detectron2/wheels/cu113/torch1.10/index.html
```
- Install your desired detection framework (huggingface):
```console
pip install transformers timm
```
</details>
### Framework Agnostic Sliced/Standard Prediction
<img width="700" alt="sahi-predict" src="https://user-images.githubusercontent.com/34196005/149310540-e32f504c-6c9e-4691-8afd-59f3a1a457f0.gif">
Find detailed info on `sahi predict` command at [cli.md](docs/cli.md#predict-command-usage).
Find detailed info on video inference at [video inference tutorial](https://github.com/obss/sahi/discussions/626).
Find detailed info on image/dataset slicing utilities at [slicing.md](docs/slicing.md).
### Error Analysis Plots & Evaluation
<img width="700" alt="sahi-analyse" src="https://user-images.githubusercontent.com/34196005/149537858-22b2e274-04e8-4e10-8139-6bdcea32feab.gif">
Find detailed info at [Error Analysis Plots & Evaluation](https://github.com/obss/sahi/discussions/622).
### Interactive Visualization & Inspection
<img width="700" alt="sahi-fiftyone" src="https://user-images.githubusercontent.com/34196005/149321540-e6ddd5f3-36dc-4267-8574-a985dd0c6578.gif">
Find detailed info at [Interactive Result Visualization and Inspection](https://github.com/obss/sahi/discussions/624).
### Other utilities
Find detailed info on COCO utilities (yolov5 conversion, slicing, subsampling, filtering, merging, splitting) at [coco.md](docs/coco.md).
Find detailed info on MOT utilities (ground truth dataset creation, exporting tracker metrics in mot challenge format) at [mot.md](docs/mot.md).
## <div align="center">Citation</div>
If you use this package in your work, please cite it as:
```
@article{akyon2022sahi,
title={Slicing Aided Hyper Inference and Fine-tuning for Small Object Detection},
author={Akyon, Fatih Cagatay and Altinuc, Sinan Onur and Temizel, Alptekin},
journal={2022 IEEE International Conference on Image Processing (ICIP)},
doi={10.1109/ICIP46576.2022.9897990},
pages={966-970},
year={2022}
}
```
```
@software{obss2021sahi,
author = {Akyon, Fatih Cagatay and Cengiz, Cemil and Altinuc, Sinan Onur and Cavusoglu, Devrim and Sahin, Kadir and Eryuksel, Ogulcan},
title = {{SAHI: A lightweight vision library for performing large scale object detection and instance segmentation}},
month = nov,
year = 2021,
publisher = {Zenodo},
doi = {10.5281/zenodo.5718950},
url = {https://doi.org/10.5281/zenodo.5718950}
}
```
## <div align="center">Contributing</div>
`sahi` library currently supports all [YOLOv5 models](https://github.com/ultralytics/yolov5/releases), [MMDetection models](https://github.com/open-mmlab/mmdetection/blob/master/docs/en/model_zoo.md), [Detectron2 models](https://github.com/facebookresearch/detectron2/blob/main/MODEL_ZOO.md), and [HuggingFace object detection models](https://huggingface.co/models?pipeline_tag=object-detection&sort=downloads). Moreover, it is easy to add new frameworks.
All you need to do is, create a new .py file under [sahi/models/](https://github.com/obss/sahi/tree/main/sahi/models) folder and create a new class in that .py file that implements [DetectionModel class](https://github.com/obss/sahi/blob/7e48bdb6afda26f977b763abdd7d8c9c170636bd/sahi/models/base.py#L12). You can take the [MMDetection wrapper](https://github.com/obss/sahi/blob/7e48bdb6afda26f977b763abdd7d8c9c170636bd/sahi/models/mmdet.py#L18) or [YOLOv5 wrapper](https://github.com/obss/sahi/blob/7e48bdb6afda26f977b763abdd7d8c9c170636bd/sahi/models/yolov5.py#L17) as a reference.
Before opening a PR:
- Install required development packages:
```bash
pip install -e ."[dev]"
```
- Reformat with black and isort:
```bash
python -m scripts.run_code_style format
```
## <div align="center">Contributors</div>
<div align="center">
<a align="left" href="https://github.com/fcakyon" target="_blank">Fatih Cagatay Akyon</a>
<a align="left" href="https://github.com/sinanonur" target="_blank">Sinan Onur Altinuc</a>
<a align="left" href="https://github.com/devrimcavusoglu" target="_blank">Devrim Cavusoglu</a>
<a align="left" href="https://github.com/cemilcengiz" target="_blank">Cemil Cengiz</a>
<a align="left" href="https://github.com/oulcan" target="_blank">Ogulcan Eryuksel</a>
<a align="left" href="https://github.com/kadirnar" target="_blank">Kadir Nar</a>
<a align="left" href="https://github.com/madenburak" target="_blank">Burak Maden</a>
<a align="left" href="https://github.com/PushpakBhoge" target="_blank">Pushpak Bhoge</a>
<a align="left" href="https://github.com/mcvarer" target="_blank">M. Can V.</a>
<a align="left" href="https://github.com/ChristofferEdlund" target="_blank">Christoffer Edlund</a>
<a align="left" href="https://github.com/ishworii" target="_blank">Ishwor</a>
<a align="left" href="https://github.com/mecevit" target="_blank">Mehmet Ecevit</a>
<a align="left" href="https://github.com/ssahinnkadir" target="_blank">Kadir Sahin</a>
<a align="left" href="https://github.com/weypro" target="_blank">Wey</a>
<a align="left" href="https://github.com/youngjae-avikus" target="_blank">Youngjae</a>
<a align="left" href="https://github.com/tureckova" target="_blank">Alzbeta Tureckova</a>
<a align="left" href="https://github.com/weiji14" target="_blank">Wei Ji</a>
<a align="left" href="https://github.com/aynursusuz" target="_blank">Aynur Susuz</a>
</div>
| /sahi-0.11.14.tar.gz/sahi-0.11.14/README.md | 0.671255 | 0.754192 | README.md | pypi |
from attrs import define
from dotenv import load_dotenv
import httpx
import jwt
from rich import print
import base64
from datetime import datetime, timedelta
import os
import constants
load_dotenv()
API_VERSION = "1.13"
CBI_USECASES = [14]
CBI_DEFAULT_MESSAGE_TEMPLATE = 101
DEFAULT_FILENAME = "download.zip"
@define
class CBiClientInteractionReply:
link: str
request_id: str
reference: str
@define
class CBiClientInteractionData:
"""Data required to initiate a CBi client interaction session"""
customer_id_number: int
customer_name: str
customer_phone_number: str
reference: str
customer_id_type: constants.IDType = constants.IDType.IDNumber
purpose: constants.CBiPurpose = constants.CBiPurpose.AffordabilityAssessment
engagement_method: constants.EngagementMethod = (
constants.EngagementMethod.CallCenter
)
message_template: int = CBI_DEFAULT_MESSAGE_TEMPLATE
services: [constants.CBIService] = [
constants.CBIService.TransactionHistory90,
constants.CBIService.BankStatement90,
constants.CBIService.Beneficiaries,
constants.CBIService.AccountInfo,
constants.CBIService.PersonalInfo,
constants.CBIService.ContactInfo,
constants.CBIService.Address,
]
data_insight_services: [constants.CBiInsight] = [
constants.CBiInsight.Affordability,
constants.CBiInsight.DebitOrder,
constants.CBiInsight.IncomeVerification,
constants.CBiInsight.StrikeDate,
]
def get_dict(self):
return {
"Request": {
"CustomerReference": data.reference,
"Surname": data.customer_name,
"IdentityType": data.customer_id_type.value,
"IdentityNumber": data.customer_id_number,
"MobileNumber": data.customer_phone_number,
"PurposeId": data.purpose.value,
"EngagedCustomer": 1,
"EngagementMethodId": data.engagement_method.value,
"MessageTemplateId": data.message_template,
"CBiServices": ",".join([f"{c.value}" for c in data.services]),
"CBiDataInsightServices": ",".join(
[f"{c.value}" for c in data.data_insight_services]
),
"UseCases": CBI_USECASES,
},
}
@define
class CBiClientInteractionResult:
status: str
file_written: bool = False
file_name: str = None
@define(slots=False)
class AuthentifiAPI:
username: str = os.getenv("API_USERNAME")
password: str = os.getenv("API_PASSWORD")
base_url: str = os.getenv("API_BASE_URL")
usercode: str = os.getenv("API_USERCODE")
debug: bool = False
def __attrs_post_init__(self):
self.token = None
self.client = httpx.Client()
self.client.headers = {
"X-Version": API_VERSION,
}
self.authenticate()
def authenticate(self):
"""Acquire a new token if the current token is None
or will expire in less than 10 minutes
"""
if self.token is None or (
datetime.now()
> (
datetime.fromtimestamp(
jwt.decode(self.token, options={"verify_signature": False})["exp"]
)
- timedelta(minutes=10)
)
):
if self.debug:
print("Token expiring soon or not set, renewing")
data = {
"username": self.username,
"password": self.password,
"accepttnc": 1,
}
res = self.client.post(
f"{self.base_url}/user/authenticate",
json=data,
)
self.token = res.json()["token"]
else:
if self.debug:
print("Token not expiring soon, not renewing")
if self.debug:
print(f"Authentication Token: {self.token}")
self.client.headers["Authorization"] = f"Bearer {self.token}"
def initiate_client_interaction_whatsapp(
self, data: CBiClientInteractionData
) -> str:
self.authenticate()
d = data.get_dict()
d["Usercode"] = self.usercode
d["Request"]["DeliveryMethod"] = constants.DeliveryMethod.WhatsApp.value
res = self.client.post(
f"{self.base_url}/Request/Process/",
json=d,
timeout=20,
)
res.raise_for_status()
j = res.json()
if self.debug:
print(j)
return CBiClientInteractionReply(
link=j["cBi"]["landingPageURL"],
request_id=j["requestId"],
reference=j["customerReference"],
)
def retrieve_client_interaction_results(self, request_id, fn=None):
self.authenticate()
res = self.client.get(f"{self.base_url}/Request/View/{request_id}")
res.raise_for_status()
j = res.json()
if self.debug:
print(j)
result = CBiClientInteractionResult(status=j["cBi"]["status"])
if result.status == "FilesReady":
# use the reference for the file name, or a fallback if that isn't given
if fn is None:
if j["customerReference"]:
fn = f'{j["customerReference"].lower().replace(" ", "").replace("-","")}.zip'
else:
fn = DEFAULT_FILENAME
result.file_name = fn
with open(fn, "wb") as fh:
fh.write(base64.b64decode(j["cBi"]["resultFile"]["file"]))
result.file_written = True
return result
if __name__ == "__main__":
api = AuthentifiAPI(debug=True)
if 0:
data = CBiClientInteractionData(
customer_id_number="8712195262086",
customer_name="Kim van Wyk",
customer_phone_number="0833844260",
reference="test1",
)
res = api.initiate_client_interaction_whatsapp(data)
if 1:
res = api.retrieve_client_interaction_results(
"0401f151-cc23-4c15-b20f-7be6aed5d0cf"
)
print(res) | /sahl_nutun_common-0.2.0-py3-none-any.whl/sahl_nutun_common/api.py | 0.40204 | 0.165694 | api.py | pypi |
import json
from typing import Optional, List, Dict, Any
from airflow.exceptions import AirflowException
from airflow.hooks.http_hook import HttpHook
class MattermostWebhookHook(HttpHook):
"""
This hook allows you to post messages to Mattermost using incoming webhooks.
It takes either a Mattermost webhook token directly or a connection that has a Mattermost webhook token.
If both are supplied, http_conn_id will be used as base_url, and webhook_token will be taken as endpoint,
the relative path of the url.
Each Mattermost webhook token can be pre-configured to use a specific channel, username and icon. You can override
these defaults in this hook.
This hook is based on `airflow.contrib.hooks.SlackWebhookHook` as the Mattermost interface is largely similar
to that of Slack.
:param http_conn_id: connection that optionally has a Mattermost webhook token in the extra field
:param webhook_token: Mattermost webhook token. If http_conn_id isn't supplied this should be the full webhook url.
:param message: The message you want to send on Mattermost
:param attachments: The attachments to send on Mattermost. Should be a list of dictionaries representing
Mattermost attachments.
:param props: The props to send on Mattermost. Should be a dictionary representing Mattermost props.
:param post_type: Sets an optional Mattermost post type, mainly for use by plugins. If supplied, must begin with
``custom_``
:param channel: The channel the message should be posted to
:param username: The username to post with
:param icon_emoji: The emoji to use as icon for the user posting to Mattermost
:param icon_url: The icon image URL string to use in place of the default icon.
:param proxy: Proxy to use to make the Mattermost webhook call
:param extra_options: Extra options for http hook
"""
def __init__(self,
http_conn_id: Optional[str] = None,
webhook_token: Optional[str] = None,
message: str = "",
attachments: Optional[List[Dict[str, Any]]] = None,
props: Optional[Dict[str, Any]] = None,
post_type: Optional[str] = None,
channel: Optional[str] = None,
username: Optional[str] = None,
icon_emoji: Optional[str] = None,
icon_url: Optional[str] = None,
proxy: Optional[str] = None,
extra_options: Optional[Dict[str, Any]] = None,
*args,
**kwargs):
super().__init__(http_conn_id=http_conn_id, *args, **kwargs)
self.webhook_token = self._get_token(webhook_token, http_conn_id)
self.message = message
self.attachments = attachments
self.props = props
self.post_type = post_type
self.channel = channel
self.username = username
self.icon_emoji = icon_emoji
self.icon_url = icon_url
self.proxy = proxy
self.extra_options = extra_options or {}
def _get_token(self, token: str, http_conn_id: str) -> str:
"""
Given either a manually set token or a conn_id, return the webhook_token to use.
:param token: The manually provided token
:param http_conn_id: The conn_id provided
:return: webhook_token to use
"""
if token:
return token
elif http_conn_id:
conn = self.get_connection(http_conn_id)
extra = conn.extra_dejson
return extra.get("webhook_token", "")
else:
raise AirflowException("Cannot get webhook token: no valid Mattermost webhook token nor conn_id supplied")
def _build_mattermost_message(self) -> str:
"""
Construct the Mattermost message. All relevant parameters are combined here to a valid Mattermost json body.
:return: Mattermost JSON body to send
"""
cmd = {}
if self.channel:
cmd["channel"] = self.channel
if self.username:
cmd["username"] = self.username
if self.icon_emoji:
cmd["icon_emoji"] = self.icon_emoji
if self.icon_url:
cmd["icon_url"] = self.icon_url
if self.attachments:
cmd["attachments"] = self.attachments
if self.props:
cmd["props"] = self.props
if self.post_type:
cmd["type"] = self.post_type
cmd["text"] = self.message
return json.dumps(cmd)
def execute(self):
"""
Execute the Mattermost webhook call
"""
if self.proxy:
# we only need https proxy for Mattermost, as the endpoint is https
self.extra_options.update({"proxies": {"https": self.proxy}})
mattermost_message = self._build_mattermost_message()
self.run(endpoint=self.webhook_token,
data=mattermost_message,
headers={"Content-type": "application/json"},
extra_options=self.extra_options) | /sai_airflow_plugins-0.2.1-py3-none-any.whl/sai_airflow_plugins/hooks/mattermost_webhook_hook.py | 0.841337 | 0.24751 | mattermost_webhook_hook.py | pypi |
from airflow.contrib.hooks.ssh_hook import SSHHook
from airflow.exceptions import AirflowException
from fabric import Connection
from invoke import FailingResponder
class FabricHook(SSHHook):
"""
This hook allows you to connect to an SSH remote host and run commands on it using the
[Fabric](https://www.fabfile.org) library. It inherits from `SSHHook` and uses its input arguments for setting
up the connection.
:param ssh_conn_id: connection id from airflow Connections
:param inline_ssh_env: whether to send environment variables "inline" as prefixes in front of command strings
(export VARNAME=value && mycommand here), instead of trying to submit them through the SSH
protocol itself (which is the default behavior). This is necessary if the remote server
has a restricted AcceptEnv setting (which is the common default).
"""
def __init__(self,
ssh_conn_id: str = None,
inline_ssh_env: bool = False,
*args,
**kwargs):
kwargs["ssh_conn_id"] = ssh_conn_id
super().__init__(*args, **kwargs)
self.inline_ssh_env = inline_ssh_env
def get_fabric_conn(self) -> Connection:
"""
Creates a Fabric `Connection` object using the settings in this hook.
:return: `Connection` object
"""
self.log.info(
f"Setting up fabric connection for conn_id: {self.ssh_conn_id} to remote host: {self.remote_host}"
)
connect_kwargs = {
"compress": self.compress
}
if self.password:
password = self.password.strip()
connect_kwargs["password"] = password
if self.pkey:
connect_kwargs["pkey"] = self.pkey
if self.key_file:
connect_kwargs["key_filename"] = self.key_file
if self.host_proxy:
connect_kwargs["sock"] = self.host_proxy
return Connection(
host=self.remote_host,
user=self.username,
port=self.port,
connect_timeout=self.timeout,
connect_kwargs=connect_kwargs,
inline_ssh_env=self.inline_ssh_env
)
def get_sudo_pass_responder(self) -> FailingResponder:
"""
Creates a responder for the sudo password prompt. It replies with the password of the SSH connection.
Note: only use this if the SSH connection is configured with a password and not a key.
:return: `FailingResponder` object; raises `AirflowException` if no password was configured in the connection
"""
if not self.password:
raise AirflowException("`add_sudo_password_responder` requires an SSH connection with a password.")
return FailingResponder(
pattern=r"\[sudo\] password for ",
response=f"{self.password}\n",
sentinel="Sorry, try again.\n"
)
def get_generic_pass_responder(self) -> FailingResponder:
"""
Creates a responder for a generic password prompt. It replies with the password of the SSH connection. This is
useful if you execute other ssh commands on the remote host, for example scp and rsync.
Note: only use this if the SSH connection is configured with a password and not a key.
:return: `FailingResponder` object; raises `AirflowException` if no password was configured in the connection
"""
if not self.password:
raise AirflowException("`add_generic_password_responder` requires an SSH connection with a password.")
return FailingResponder(
pattern=r"password: ",
response=f"{self.password}\n",
sentinel="Permission denied"
)
@staticmethod
def get_unknown_host_key_responder() -> FailingResponder:
"""
Creates a responder for a host authenticity check with an unknown key. It replies ``yes`` to continue
connecting. This is useful if you execute other ssh commands on the remote host, for example scp and rsync.
:return: `FailingResponder` object
"""
return FailingResponder(
pattern=r"Are you sure you want to continue connecting \(yes/no\)\? ",
response="yes\n",
sentinel="Host key verification failed.\n"
) | /sai_airflow_plugins-0.2.1-py3-none-any.whl/sai_airflow_plugins/hooks/fabric_hook.py | 0.834643 | 0.314143 | fabric_hook.py | pypi |
from typing import Optional, List, Dict, Any
from airflow.operators.http_operator import SimpleHttpOperator
from airflow.utils.decorators import apply_defaults
from sai_airflow_plugins.hooks.mattermost_webhook_hook import MattermostWebhookHook
class MattermostWebhookOperator(SimpleHttpOperator):
"""
This operator allows you to post messages to Mattermost using incoming webhooks.
It takes either a Mattermost webhook token directly or a connection that has a Mattermost webhook token.
If both are supplied, http_conn_id will be used as base_url, and webhook_token will be taken as endpoint,
the relative path of the url.
Each Mattermost webhook token can be pre-configured to use a specific channel, username and icon. You can override
these defaults in this operator.
This operator is based on `airflow.contrib.operators.SlackWebhookOperator` as the Mattermost interface is largely
similar to that of Slack.
:param http_conn_id: connection that optionally has a Mattermost webhook token in the extra field
:param webhook_token: Mattermost webhook token. If http_conn_id isn't supplied this should be the full webhook url.
:param message: The message you want to send on Mattermost
:param attachments: The attachments to send on Mattermost. Should be a list of dictionaries representing
Mattermost attachments.
:param props: The props to send on Mattermost. Should be a dictionary representing Mattermost props.
:param post_type: Sets an optional Mattermost post type, mainly for use by plugins. If supplied, must begin with
``custom_``
:param channel: The channel the message should be posted to
:param username: The username to post with
:param icon_emoji: The emoji to use as icon for the user posting to Mattermost
:param icon_url: The icon image URL string to use in place of the default icon.
:param proxy: Proxy to use to make the Mattermost webhook call
:param extra_options: Extra options for http hook
"""
template_fields = ["webhook_token", "message", "attachments", "props", "post_type", "channel", "username",
"proxy", "extra_options"]
@apply_defaults
def __init__(self,
http_conn_id: Optional[str] = None,
webhook_token: Optional[str] = None,
message: str = "",
attachments: Optional[List[Dict[str, Any]]] = None,
props: Optional[Dict[str, Any]] = None,
post_type: Optional[str] = None,
channel: Optional[str] = None,
username: Optional[str] = None,
icon_emoji: Optional[str] = None,
icon_url: Optional[str] = None,
proxy: Optional[str] = None,
extra_options: Optional[Dict[str, Any]] = None,
*args,
**kwargs):
super().__init__(endpoint=webhook_token, *args, **kwargs)
self.http_conn_id = http_conn_id
self.webhook_token = webhook_token
self.message = message
self.attachments = attachments
self.props = props
self.post_type = post_type
self.channel = channel
self.username = username
self.icon_emoji = icon_emoji
self.icon_url = icon_url
self.proxy = proxy
self.hook = None
self.extra_options = extra_options
def execute(self, context: Dict):
"""
Call the MattermostWebhookHook to post the provided Mattermost message
"""
self.hook = MattermostWebhookHook(
self.http_conn_id,
self.webhook_token,
self.message,
self.attachments,
self.props,
self.post_type,
self.channel,
self.username,
self.icon_emoji,
self.icon_url,
self.proxy,
self.extra_options
)
self.hook.execute() | /sai_airflow_plugins-0.2.1-py3-none-any.whl/sai_airflow_plugins/operators/mattermost_webhook_operator.py | 0.925676 | 0.304778 | mattermost_webhook_operator.py | pypi |
from airflow.operators.bash_operator import BashOperator
from airflow.operators.dagrun_operator import TriggerDagRunOperator
from airflow.operators.python_operator import PythonOperator
from sai_airflow_plugins.operators.conditional_skip_mixin import ConditionalSkipMixin
from sai_airflow_plugins.operators.fabric_operator import FabricOperator
class ConditionalBashOperator(ConditionalSkipMixin, BashOperator):
"""
Conditional bash operator.
.. seealso:: :class:`~sai_airflow_plugins.operators.conditional_skip_mixin.ConditionalSkipMixin` and
:class:`~airflow.operators.bash_operator.BashOperator`
"""
template_fields = BashOperator.template_fields + ConditionalSkipMixin.template_fields
template_ext = BashOperator.template_ext
ui_color = "#ede4ff"
class ConditionalPythonOperator(ConditionalSkipMixin, PythonOperator):
"""
Conditional python operator.
.. seealso:: :class:`~sai_airflow_plugins.operators.conditional_skip_mixin.ConditionalSkipMixin` and
:class:`~airflow.operators.python_operator.PythonOperator`
"""
template_fields = PythonOperator.template_fields + ConditionalSkipMixin.template_fields
ui_color = "#ffebff"
class ConditionalTriggerDagRunOperator(ConditionalSkipMixin, TriggerDagRunOperator):
"""
Conditional trigger DAG run operator.
.. seealso:: :class:`~sai_airflow_plugins.operators.conditional_skip_mixin.ConditionalSkipMixin` and
:class:`~airflow.operators.dagrun_operator.TriggerDagRunOperator`
"""
template_fields = TriggerDagRunOperator.template_fields + ConditionalSkipMixin.template_fields
ui_color = "#efeaff"
class ConditionalFabricOperator(ConditionalSkipMixin, FabricOperator):
"""
Conditional Fabric operator.
.. seealso:: :class:`~sai_airflow_plugins.operators.conditional_skip_mixin.ConditionalSkipMixin` and
:class:`~sai_airflow_plugins.operators.fabric_operator.FabricOperator`
"""
template_fields = FabricOperator.template_fields + ConditionalSkipMixin.template_fields
template_ext = FabricOperator.template_ext
ui_color = "#feffe5" | /sai_airflow_plugins-0.2.1-py3-none-any.whl/sai_airflow_plugins/operators/conditional_operators.py | 0.758153 | 0.285472 | conditional_operators.py | pypi |
from typing import Dict, List, Any, Optional
from airflow.exceptions import AirflowException
from airflow.models.baseoperator import BaseOperator
from airflow.utils.decorators import apply_defaults
from fabric import Result
from invoke import Responder, StreamWatcher
from sai_airflow_plugins.hooks.fabric_hook import FabricHook
class FabricOperator(BaseOperator):
"""
Operator to execute commands on a remote host using the [Fabric](https://www.fabfile.org) library.
It uses `FabricHook` for the connection configuration, which is derived from the standard `SSHHook`.
The advantage of this operator over the standard `SSHOperator` is that you can add watchers that respond to
specific command output. A number of predefined watchers are included in this operator. Note, however, that
some of these require the FabricHook to be configured with a password and not a private key.
:param fabric_hook: predefined fabric_hook to use for remote execution. Either `fabric_hook` or `ssh_conn_id` needs
to be provided.
:param ssh_conn_id: connection id from airflow Connections. `ssh_conn_id` will be ignored if `fabric_hook` is
provided. (templated)
:param remote_host: remote host to connect. (templated) Nullable. If provided, it will replace the `remote_host`
which was defined in `fabric_hook` or predefined in the connection of `ssh_conn_id`.
:param command: command to execute on remote host. (templated)
:param use_sudo: uses Fabric's sudo function instead of run. Because this function automatically adds a responder
for the password prompt, parameter `add_sudo_password_responder` will be ignored. It uses the
SSH connection's password as reply.
:param use_sudo_shell: wraps the command in a sudo shell. The difference with `use_sudo` is that Fabric's sudo
function only executes a single command as sudo. Within a sudo shell a full script can be
run, e.g. a templated script file. This does *not* automatically add a sudo responder
for the password prompt. Use `add_sudo_password_responder` as necessary.
This parameter can't be used at the same time as `use_sudo`.
:param sudo_user: If `use_sudo` or `use_sudo_shell` is `True`, run the command as this user. If not supplied it will
run as root. This parameter is ignored if `use_sudo` and `use_sudo_shell` are `False`.
:param watchers: Watchers for responding to specific command output. This is a list of dicts specifying a class
of type ``StreamWatcher`` and its arguments. For each dict the corresponding object is created
and added to Fabric's run function. It's done this way because arguments to an operator are
pickled and StreamWatcher objects are derived from thread.local which can't be pickled.
Example:
>>> {"watchers": [{"class": Responder, "pattern": r"Continue\\?", "response": "yes\\n"}]}
See also: http://docs.pyinvoke.org/en/latest/concepts/watchers.html
:param add_sudo_password_responder: adds a responder for the sudo password prompt. It replies with the password of
the SSH connection. Set this to True if your command contains one or more sudo
statements. If you use `use_sudo` instead, then don't use this parameter.
:param add_generic_password_responder: adds a responder for a generic password prompt. It replies with the password
of the SSH connection. This is useful if you execute other ssh commands on
the remote host, for example scp and rsync.
:param add_unknown_host_key_responder: adds a responder for a host authenticity check with an unknown key.
It replies ``yes`` to continue connecting. This is useful if you execute
other ssh commands on the remote host, for example scp and rsync.
:param connect_timeout: Connection timeout, in seconds. The default is 10.
:param environment: a dict of shell environment variables. Note that the server will reject them silently if
`AcceptEnv` is not set in SSH config. In such cases setting `inline_ssh_env` to True may help.
(templated)
:param inline_ssh_env: whether to send environment variables "inline" as prefixes in front of command strings
(export VARNAME=value && mycommand here), instead of trying to submit them through the SSH
protocol itself (which is the default behavior). This is necessary if the remote server
has a restricted AcceptEnv setting (which is the common default).
:param xcom_push_key: push stdout to an XCom with this key. If None (default), or stdout is empty, then no XCom
will be pushed.
:param strip_stdout: strip leading and trailing whitespace from stdout. Useful, for example, when pushing stdout
to an XCom and you don't want a trailing newline in it.
:param get_pty: request a pseudo-terminal from the server, instead of connecting directly to the stdout/stderr
streams. This may be necessary when running programs that require a terminal. Note that stderr
output will be included in stdout, and thus added to an XCom when using `xcom_push_key`.
:param keepalive: The number of seconds to send keepalive packets to the server. This corresponds to the ssh option
``ServerAliveInterval``. The default is 0, which disables keepalive.
"""
template_fields = ("ssh_conn_id", "command", "remote_host", "environment")
template_ext = (".sh",)
ui_color = "#ebfaff"
@apply_defaults
def __init__(self,
fabric_hook: Optional[FabricHook] = None,
ssh_conn_id: Optional[str] = None,
remote_host: Optional[str] = None,
command: str = None,
use_sudo: Optional[bool] = False,
use_sudo_shell: Optional[bool] = False,
sudo_user: Optional[str] = None,
watchers: Optional[List[Dict[str, Any]]] = None,
add_sudo_password_responder: Optional[bool] = False,
add_generic_password_responder: Optional[bool] = False,
add_unknown_host_key_responder: Optional[bool] = False,
connect_timeout: Optional[int] = 10,
environment: Optional[Dict[str, Any]] = None,
inline_ssh_env: Optional[bool] = False,
xcom_push_key: Optional[str] = None,
strip_stdout: Optional[bool] = False,
get_pty: Optional[bool] = False,
keepalive: Optional[int] = 0,
*args,
**kwargs):
super().__init__(*args, **kwargs)
self.fabric_hook = fabric_hook
self.ssh_conn_id = ssh_conn_id
self.remote_host = remote_host
self.command = command
self.use_sudo = use_sudo
self.use_sudo_shell = use_sudo_shell
self.sudo_user = sudo_user
self.watchers = watchers or []
self.add_sudo_password_responder = False if self.use_sudo else add_sudo_password_responder
self.add_generic_password_responder = add_generic_password_responder
self.add_unknown_host_key_responder = add_unknown_host_key_responder
self.connect_timeout = connect_timeout
self.environment = environment or {}
self.inline_ssh_env = inline_ssh_env
self.xcom_push_key = xcom_push_key
self.strip_stdout = strip_stdout
self.get_pty = get_pty
self.keepalive = keepalive
def execute(self, context: Dict):
"""
Executes ``self.command`` over the configured SSH connection.
:param context: Context dict provided by airflow
:return: True if the command executed correctly.
On an error, raises AirflowException.
"""
result = self.execute_fabric_command()
if result.exited == 0:
# Push the output to an XCom if requested
if self.xcom_push_key and result.stdout:
task_inst = context["task_instance"]
task_inst.xcom_push(self.xcom_push_key, result.stdout)
return True
else:
raise AirflowException(f"Command exited with return code {result.exited}. See log output for details.")
def execute_fabric_command(self) -> Result:
"""
Executes ``self.command`` over the configured SSH connection.
:return: The `Result` object from Fabric's `run` method
"""
try:
if self.fabric_hook and isinstance(self.fabric_hook, FabricHook):
if self.ssh_conn_id:
self.log.info("ssh_conn_id is ignored when fabric_hook is provided.")
if self.remote_host is not None:
self.log.info("remote_host is provided explicitly. It will replace the remote_host which was "
"defined in fabric_hook.")
self.fabric_hook.remote_host = self.remote_host
elif self.ssh_conn_id:
self.log.info("fabric_hook is not provided or invalid. Trying ssh_conn_id to create FabricHook.")
if self.remote_host is None:
self.fabric_hook = FabricHook(ssh_conn_id=self.ssh_conn_id,
timeout=self.connect_timeout,
inline_ssh_env=self.inline_ssh_env)
else:
# Prevent empty `SSHHook.remote_host` field which would otherwise raise an exception
self.log.info("remote_host is provided explicitly. It will replace the remote_host which was "
"predefined in the connection specified by ssh_conn_id.")
self.fabric_hook = FabricHook(ssh_conn_id=self.ssh_conn_id,
remote_host=self.remote_host,
timeout=self.connect_timeout,
inline_ssh_env=self.inline_ssh_env)
else:
raise AirflowException("Cannot operate without fabric_hook or ssh_conn_id.")
if not self.command:
raise AirflowException("SSH command not specified. Aborting.")
if self.use_sudo and self.use_sudo_shell:
raise AirflowException("Cannot use use_sudo and use_sudo_shell at the same time. Aborting.")
conn = self.fabric_hook.get_fabric_conn()
# Create watcher objects, using the provided dictionary to instantiate the class and supply its kwargs
watchers = []
for watcher_dict in self.watchers:
try:
watcher_class = watcher_dict.pop("class")
except KeyError:
self.log.info(f"Watcher class missing. Defaulting to {Responder}.")
watcher_class = Responder
if not issubclass(watcher_class, StreamWatcher):
raise AirflowException(
f"The class attribute of a watcher dict must contain a subclass of {StreamWatcher}."
)
watcher = watcher_class(**watcher_dict)
watchers.append(watcher)
# Add predefined watchers
if self.add_sudo_password_responder:
watchers.append(self.fabric_hook.get_sudo_pass_responder())
if self.add_generic_password_responder:
watchers.append(self.fabric_hook.get_generic_pass_responder())
if self.add_unknown_host_key_responder:
watchers.append(self.fabric_hook.get_unknown_host_key_responder())
# Wrap command in sudo shell if requested
if self.use_sudo_shell:
sudo_params = f"-su {self.sudo_user}" if self.sudo_user else "-s"
command = f"sudo {sudo_params} -- <<'__end_of_sudo_shell__'\n" \
f"{self.command}\n" \
f"__end_of_sudo_shell__"
else:
command = self.command
if self.use_sudo:
if self.sudo_user:
self.log.info(f"Running sudo command as '{self.sudo_user}': {command}")
else:
self.log.info(f"Running sudo command: {command}")
else:
self.log.info(f"Running command: {command}")
if self.environment:
formatted_env_msg = "\n".join(f"{k}={v}" for k, v in self.environment.items())
self.log.info(f"With environment variables:\n{formatted_env_msg}")
# Open connection and set transport-specific options
conn.open()
conn.transport.set_keepalive(self.keepalive)
# Set up runtime options and run the command
run_kwargs = dict(
command=command,
pty=self.get_pty,
env=self.environment,
watchers=watchers,
warn=True # don't directly raise an UnexpectedExit when the exit code is non-zero
)
if self.use_sudo:
run_kwargs["password"] = self.fabric_hook.password
if self.sudo_user:
run_kwargs["user"] = self.sudo_user
res = conn.sudo(**run_kwargs)
else:
res = conn.run(**run_kwargs)
if res.stdout:
# Strip sudo prompt from stdout when using sudo and a pty
if self.use_sudo and self.get_pty:
res.stdout = res.stdout.replace(conn.config.sudo.prompt, "")
# Strip stdout if requested
if self.strip_stdout:
res.stdout = res.stdout.strip()
return res
except Exception as e:
raise AirflowException(f"Fabric operator error: {e}") | /sai_airflow_plugins-0.2.1-py3-none-any.whl/sai_airflow_plugins/operators/fabric_operator.py | 0.908041 | 0.478833 | fabric_operator.py | pypi |
from typing import Callable, Optional, Iterable, Dict
from airflow.exceptions import AirflowSkipException
from airflow.utils.decorators import apply_defaults
class ConditionalSkipMixin(object):
"""
Mixin for making operators and sensors conditional. If the condition evaluates to True the operator or sensor
executes normally, otherwise it skips the task.
Note that you should correctly set the `template_field` in a derived class to include both the operator's
and this mixin's templated fields. Example:
class MyConditionalOperator(ConditionalSkipMixin, MyOperator):
template_fields = MyOperator.template_fields + ConditionalSkipMixin.template_fields
:param condition_callable: A callable that should evaluate to a truthy or falsy value to execute or skip the
task respectively. Note that Airflow's context is also passed as keyword arguments so
you need to define `**kwargs` in your function header. (templated)
:param condition_kwargs: a dictionary of keyword arguments that will get unpacked in `condition_callable`.
(templated)
:param condition_args: a list of positional arguments that will get unpacked in `condition_callable`. (templated)
:param condition_provide_context: if set to true, Airflow will pass a set of keyword arguments that can be used in
your condition callable. This set of kwargs correspond exactly to what you can
use in your jinja templates. For this to work, you need to define `**kwargs` in
your function header.
"""
template_fields = ("condition_callable", "condition_args", "condition_kwargs")
@apply_defaults
def __init__(self,
condition_callable: Callable = False,
condition_args: Optional[Iterable] = None,
condition_kwargs: Optional[Dict] = None,
condition_provide_context: Optional[bool] = False,
*args,
**kwargs):
super().__init__(*args, **kwargs)
self.condition_callable = condition_callable
self.condition_args = condition_args or []
self.condition_kwargs = condition_kwargs or {}
self.condition_provide_context = condition_provide_context
self._condition_evaluated = False
self._condition_value = None
def execute(self, context: Dict):
"""
If the condition evaluates to True execute the superclass `execute` method, otherwise skip the task.
:param context: Context dict provided by airflow
"""
if self._get_evaluated_condition_or_skip(context):
super().execute(context)
def poke(self, context: Dict) -> bool:
"""
If the condition evaluates to True execute the superclass `poke` method, otherwise skip the task.
:param context: Context dict provided by airflow
:return: The result of the superclass `poke` method
"""
if self._get_evaluated_condition_or_skip(context):
return super().poke(context)
def _get_evaluated_condition_or_skip(self, context: Dict):
"""
Lazily evaluates `condition_callable` and raises `AirflowSkipException` if it's falsy.
This is done because the `poke` method of a sensor may call the `execute` method as well.
:param context: Context dict provided by airflow
:return: The (cached) result of `condition_callable` if truthy, otherwise raises `AirflowSkipException`
"""
if not self._condition_evaluated:
if self.condition_provide_context:
# Merge airflow's context and the callable's kwargs
context.update(self.condition_kwargs)
self.condition_kwargs = context
self._condition_value = self.condition_callable(*self.condition_args, **self.condition_kwargs)
if self._condition_value:
return self._condition_value
else:
raise AirflowSkipException(
f"Condition callable {self.condition_callable.__name__} evaluated to False. Skipping this task."
) | /sai_airflow_plugins-0.2.1-py3-none-any.whl/sai_airflow_plugins/operators/conditional_skip_mixin.py | 0.947721 | 0.433322 | conditional_skip_mixin.py | pypi |
import dataclasses
import time
from enum import Enum, auto
from typing import List
class JudgeEventType(Enum):
JUDGE_START = auto()
AI_CONNECTED = auto()
LOGIC_BOOTED = auto()
NEW_ROUND = auto()
AI_RE = auto()
AI_TLE = auto()
AI_OLE = auto()
LOGIC_CRASHED = auto()
GAME_OVER = auto()
INTERNAL_ERROR = auto()
@dataclasses.dataclass
class JudgeEvent:
type: JudgeEventType
time: float
round: int
ai_id: int # For AI_xxx
elapsed_time: float # For new round
comment: str
class JudgeState(Enum):
GAME_OVER = auto()
LOGIC_CRASHED = auto()
INTERNAL_ERROR = auto()
@dataclasses.dataclass
class JudgeSummary:
start_time: float
total_time: float
final_state: JudgeState
final_score: List[int]
total_round: int
event_list: List[JudgeEvent] = dataclasses.field(repr=False)
def __init__(self):
self.start_time = time.time()
self.total_time = 0
self.final_state = JudgeState.INTERNAL_ERROR
self.final_score = []
self.event_list = [JudgeEvent(JudgeEventType.JUDGE_START, self.start_time, -1, -1, 0, "")]
def appendAiConnected(self, ai_id: int):
self.event_list.append(
JudgeEvent(JudgeEventType.AI_CONNECTED, time.time(), -1, ai_id, 0, "")
)
def appendLogicBooted(self):
self.event_list.append(
JudgeEvent(JudgeEventType.LOGIC_BOOTED, time.time(), -1, -1, 0, "")
)
def appendNewRound(self, round: int, last_elapsed_time: float):
self.event_list.append(
JudgeEvent(JudgeEventType.NEW_ROUND, time.time(), round, -1, last_elapsed_time, "")
)
def appendAiRe(self, round: int, ai_id: int):
self.event_list.append(
JudgeEvent(JudgeEventType.AI_RE, time.time(), round, ai_id, 0, "")
)
def appendAiTle(self, round: int, ai_id: int):
self.event_list.append(
JudgeEvent(JudgeEventType.AI_TLE, time.time(), round, ai_id, 0, "")
)
def appendAiOle(self, round: int, ai_id: int):
self.event_list.append(
JudgeEvent(JudgeEventType.AI_OLE, time.time(), round, ai_id, 0, "")
)
def __judge_end(self, state: JudgeState):
self.total_time = time.time() - self.start_time
for entry in reversed(self.event_list):
if entry.round != -1:
self.total_round = entry.round
break
self.final_state = state
def appendLogicCrashed(self):
self.event_list.append(
JudgeEvent(JudgeEventType.LOGIC_CRASHED, time.time(), -1, -1, 0, "")
)
self.__judge_end(JudgeState.LOGIC_CRASHED)
def appendGameOver(self, score: List[int]):
self.event_list.append(
JudgeEvent(JudgeEventType.GAME_OVER, time.time(), -1, -1, 0, "")
)
self.final_score = score.copy()
self.__judge_end(JudgeState.GAME_OVER)
def appendInternalError(self):
self.event_list.append(
JudgeEvent(JudgeEventType.INTERNAL_ERROR, time.time(), -1, -1, 0, "")
)
self.__judge_end(JudgeState.INTERNAL_ERROR) | /saiblo_local_judger-0.0.2-py3-none-any.whl/core/summary.py | 0.540196 | 0.18924 | summary.py | pypi |
import functools
import json
from dataclasses import dataclass
from enum import Enum
from pathlib import Path
from typing import Callable, Union, List, TypeVar
from .logger import LOG
from .utils import int2bytes
@dataclass
class RoundConfig:
state: int
time: int
length: int
@dataclass
class RoundInfo:
state: int
listen: List[int]
player: List[int]
content: List[str]
class AiErrorType(Enum):
RunError = (0, "runError")
TimeOutError = (1, "timeOutError")
OutputLimitError = (2, "outputLimitError")
EndInfo = List[int]
ValueAccessor = Callable[[str], any]
T = TypeVar('T')
def json_object_receiver(desc):
def inner(func: Callable[[ValueAccessor], T]) -> Callable[[bytes], T]:
@functools.wraps(func)
def wrapper(data: bytes) -> T:
json_obj = json.loads(data.decode("utf-8"))
def value(key: str) -> any:
v = json_obj.get(key)
if v is None:
LOG.error("Missing [%s] in %s", key, desc)
raise ValueError
return v
return func(value)
return wrapper
return inner
def json_object_sender(func: Callable[[any], any]) -> Callable[[any], bytes]:
def wrapper(*args) -> bytes:
obj = func(*args)
json_str: str = json.dumps(obj)
json_bytes: bytes = json_str.encode("utf-8")
return int2bytes(len(json_bytes)) + json_bytes
return wrapper
class Protocol:
"""
Current Saiblo judger protocol implement
to_xxx methods will append the package size information
from_xxx methods should accept data without the size information
In fact you can directly pass away the bytes across current designed classes
"""
@staticmethod
@json_object_receiver("logic data")
def from_logic_data(value: ValueAccessor) -> Union[RoundConfig, RoundInfo, EndInfo]:
if value("state") == -1:
end_info: str = value("end_info")
end_info_obj = json.loads(end_info)
scores: EndInfo = []
for i in range(10):
score = end_info_obj.get(str(i))
if score is None:
break
scores.append(score)
return scores
elif value("state") == 0:
return RoundConfig(value("state"), value("time"), value("length"))
else:
return RoundInfo(value("state"), value("listen"), value("player"), value("content"))
@staticmethod
@json_object_sender
def to_logic_init_info(player_list: List[int], config: object, replay_path: Path) -> any:
return {
"player_list": player_list,
"player_num": len(player_list),
"config": config,
"replay": str(replay_path)
}
@staticmethod
@json_object_sender
def to_logic_ai_normal_message(ai_id: int, content: str, time: int):
return {
"player": ai_id,
"content": content,
"time": time
}
@staticmethod
@json_object_sender
def to_logic_ai_error(error_ai: int, state: int, error_type: AiErrorType):
return {
"player": -1,
"content": json.dumps({
"player": error_ai,
"state": state,
"error": error_type.value[0],
"error_log": error_type.value[1]
})
} | /saiblo_local_judger-0.0.2-py3-none-any.whl/core/protocol.py | 0.800107 | 0.225246 | protocol.py | pypi |
import json
import time
import requests
from saic_ismart_client.ota_v2_1.data_model import OtaRvmVehicleStatusResp25857, RvsPosition, RvsBasicStatus25857
from saic_ismart_client.ota_v3_0.data_model import OtaChrgMangDataResp
class AbrpApiException(Exception):
def __init__(self, msg: str):
self.message = msg
def __str__(self):
return self.message
class AbrpApi:
def __init__(self, abrp_api_key: str, abrp_user_token: str) -> None:
self.abrp_api_key = abrp_api_key
self.abrp_user_token = abrp_user_token
def update_abrp(self, vehicle_status: OtaRvmVehicleStatusResp25857, charge_status: OtaChrgMangDataResp) -> str:
if (
self.abrp_api_key is not None
and self.abrp_user_token is not None
and vehicle_status is not None
and charge_status is not None
):
# Request
tlm_send_url = 'https://api.iternio.com/1/tlm/send'
data = {
'utc': int(time.time()), # We assume the timestamp is now, we will update it later from GPS if available
'soc': (charge_status.bmsPackSOCDsp / 10.0),
'power': charge_status.get_power(),
'voltage': charge_status.get_voltage(),
'current': charge_status.get_current(),
'is_charging': vehicle_status.is_charging(),
'is_parked': vehicle_status.is_parked(),
}
basic_vehicle_status = vehicle_status.get_basic_vehicle_status()
if basic_vehicle_status is not None:
data.update(self.__extract_basic_vehicle_status(basic_vehicle_status))
gps_position = vehicle_status.get_gps_position()
if gps_position is not None:
data.update(self.__extract_gps_position(gps_position))
headers = {
'Authorization': f'APIKEY {self.abrp_api_key}'
}
try:
response = requests.post(url=tlm_send_url, headers=headers, params={
'token': self.abrp_user_token,
'tlm': json.dumps(data)
})
return response.content.decode()
except requests.exceptions.ConnectionError as ece:
raise AbrpApiException(f'Connection error: {ece}')
except requests.exceptions.Timeout as et:
raise AbrpApiException(f'Timeout error {et}')
except requests.exceptions.HTTPError as ehttp:
raise AbrpApiException(f'HTTP error {ehttp}')
except requests.exceptions.RequestException as e:
raise AbrpApiException(f'{e}')
else:
return 'ABRP request skipped because of missing configuration'
@staticmethod
def __extract_basic_vehicle_status(basic_vehicle_status: RvsBasicStatus25857) -> dict:
data = {}
exterior_temperature = basic_vehicle_status.exterior_temperature
if exterior_temperature is not None and exterior_temperature != -128:
data['ext_temp'] = exterior_temperature
mileage = basic_vehicle_status.mileage
if mileage is not None and mileage > 0:
data['odometer'] = mileage / 10.0
range_elec = basic_vehicle_status.fuel_range_elec
if range_elec is not None and range_elec > 0:
data['est_battery_range'] = float(range_elec) / 10.0
return data
@staticmethod
def __extract_gps_position(gps_position: RvsPosition) -> dict:
# Do not transmit GPS data if we have no timestamp
if gps_position.timestamp_4_short is None:
return {}
way_point = gps_position.get_way_point()
# Do not transmit GPS data if we have no speed info
if way_point is None:
return {}
data = {
'utc': gps_position.timestamp_4_short.seconds,
'speed': (way_point.speed / 10.0),
'heading': way_point.heading,
}
position = way_point.get_position()
if position is None or position.latitude <= 0 or position.longitude <= 0:
return data
data.update({
'lat': (position.latitude / 1000000.0),
'lon': (position.longitude / 1000000.0),
'elevation': position.altitude,
})
return data | /saic_ismart_client-1.6.0.tar.gz/saic_ismart_client-1.6.0/src/saic_ismart_client/abrp_api.py | 0.613931 | 0.184143 | abrp_api.py | pypi |
from typing import cast
from saic_ismart_client.common_model import Asn1Type, ApplicationData
FIELD_FAILURE_TYPE = 'failureType'
FIELD_RVC_REQ_STS = 'rvcReqSts'
FIELD_VALUE = 'value'
FIELD_ID = 'id'
FIELD_VEHICLE_ALERTS = 'vehicleAlerts'
FIELD_SECONDS = 'seconds'
FIELD_ALTITUDE = 'altitude'
FIELD_LONGITUDE = 'longitude'
FIELD_LATITUDE = 'latitude'
FIELD_SATELLITES = 'satellites'
FIELD_HDOP = 'hdop'
FIELD_SPEED = 'speed'
FIELD_HEADING = 'heading'
FIELD_POSITION = 'position'
FIELD_GPS_STATUS = 'gpsStatus'
FIELD_TIMESTAMP_4_SHORT = 'timestamp4Short'
FIELD_WAY_POINT = 'wayPoint'
FIELD_EXTENDED_VEHICLE_STATUS = 'extendedVehicleStatus'
FIELD_BASIC_VEHICLE_STATUS = 'basicVehicleStatus'
FIELD_GPS_POSITION = 'gpsPosition'
FIELD_STATUS_TIME = 'statusTime'
FIELD_PARAM_VALUE = 'paramValue'
FIELD_PARAM_ID = 'paramId'
FIELD_RVC_PARAMS = 'rvcParams'
FIELD_RVC_REQ_TYPE = 'rvcReqType'
FIELD_VEH_STATUS_REQ_TYPE = 'vehStatusReqType'
class OtaRvmVehicleStatusReq(ApplicationData):
def __init__(self):
super().__init__('OTARVMVehicleStatusReq')
self.veh_status_req_type = None
def get_data(self) -> dict:
return {FIELD_VEH_STATUS_REQ_TYPE: self.veh_status_req_type}
def init_from_dict(self, data: dict):
self.veh_status_req_type = data.get(FIELD_VEH_STATUS_REQ_TYPE)
class RvsWgs84Point(Asn1Type):
def __init__(self):
super().__init__('RvsWGS84Point')
self.latitude = None
self.longitude = None
self.altitude = None
def get_data(self) -> dict:
return {
FIELD_LATITUDE: self.latitude,
FIELD_LONGITUDE: self.longitude,
FIELD_ALTITUDE: self.altitude
}
def init_from_dict(self, data: dict):
self.latitude = data.get(FIELD_LATITUDE)
self.longitude = data.get(FIELD_LONGITUDE)
self.altitude = data.get(FIELD_ALTITUDE)
class RvsWayPoint(Asn1Type):
def __init__(self):
super().__init__('RvsWayPoint')
self.position = None
self.heading = None
self.speed = None
self.hdop = None
self.satellites = None
def get_data(self) -> dict:
return {
FIELD_POSITION: self.position.get_data(),
FIELD_HEADING: self.heading,
FIELD_SPEED: self.speed,
FIELD_HDOP: self.hdop,
FIELD_SATELLITES: self.satellites
}
def init_from_dict(self, data: dict):
self.position = RvsWgs84Point()
self.position.init_from_dict(data.get(FIELD_POSITION))
self.heading = data.get(FIELD_HEADING)
self.speed = data.get(FIELD_SPEED)
self.hdop = data.get(FIELD_HDOP)
self.satellites = data.get(FIELD_SATELLITES)
def get_position(self) -> RvsWgs84Point:
return cast(RvsWgs84Point, self.position)
class RvsPosition(Asn1Type):
def __init__(self):
super().__init__('RvsPosition')
self.way_point = None
self.timestamp_4_short = None
self.gps_status = None
def get_data(self) -> dict:
return {
FIELD_WAY_POINT: self.way_point.get_data(),
FIELD_TIMESTAMP_4_SHORT: self.timestamp_4_short.get_data(),
FIELD_GPS_STATUS: self.gps_status
}
def init_from_dict(self, data: dict):
self.way_point = RvsWayPoint()
self.way_point.init_from_dict(data.get(FIELD_WAY_POINT))
self.timestamp_4_short = Timestamp4Short()
self.timestamp_4_short.init_from_dict(data.get(FIELD_TIMESTAMP_4_SHORT))
self.gps_status = data.get(FIELD_GPS_STATUS)
def get_way_point(self) -> RvsWayPoint:
return cast(RvsWayPoint, self.way_point)
class Timestamp4Short(Asn1Type):
def __init__(self):
super().__init__('Timestamp4Short')
self.seconds = None
def get_data(self) -> dict:
return {
FIELD_SECONDS: self.seconds
}
def init_from_dict(self, data: dict):
self.seconds = data.get(FIELD_SECONDS)
class RvsBasicStatus25857(Asn1Type):
def __init__(self):
super().__init__('RvsBasicStatus25857')
self.driver_door = None # BOOLEAN
self.passenger_door = None # BOOLEAN
self.rear_left_door = None # BOOLEAN
self.rear_right_door = None # BOOLEAN
self.boot_status = None # BOOLEAN
self.bonnet_status = None # BOOLEAN
self.lock_status = None # BOOLEAN
self.driver_window = None # BOOLEAN OPTIONAL
self.passenger_window = None # BOOLEAN OPTIONAL,
self.rear_left_window = None # BOOLEAN OPTIONAL,
self.rear_right_window = None # BOOLEAN OPTIONAL,
self.sun_roof_status = None # BOOLEAN OPTIONAL,
self.front_right_tyre_pressure = None # INTEGER(0..255) OPTIONAL,
self.front_left_tyre_pressure = None # INTEGER(0..255) OPTIONAL,
self.rear_right_tyre_pressure = None # INTEGER(0..255) OPTIONAL,
self.rear_left_tyre_pressure = None # INTEGER(0..255) OPTIONAL,
self.wheel_tyre_monitor_status = None # INTEGER(0..255) OPTIONAL,
self.side_light_status = None # BOOLEAN,
self.dipped_beam_status = None # BOOLEAN,
self.main_beam_status = None # BOOLEAN,
self.vehicle_alarm_status = None # INTEGER(0..255) OPTIONAL,
self.engine_status = None # INTEGER(0..255),
self.power_mode = None # INTEGER(0..255),
self.last_key_seen = None # INTEGER(0..65535),
self.current_journey_distance = None # INTEGER(0..65535),
self.current_journey_id = None # INTEGER(0..2147483647),
self.interior_temperature = None # INTEGER(-128..127),
self.exterior_temperature = None # INTEGER(-128..127),
self.fuel_level_prc = None # INTEGER(0..255),
self.fuel_range = None # INTEGER(0..65535),
self.remote_climate_status = None # INTEGER(0..255),
self.front_left_seat_heat_level = None # INTEGER(0..255) OPTIONAL,
self.front_right_seat_heat_level = None # INTEGER(0..255) OPTIONAL,
self.can_bus_active = None # BOOLEAN,
self.time_of_last_canbus_activity = None # INTEGER(0..2147483647),
self.clstr_dspd_fuel_lvl_sgmt = None # INTEGER(0..255),
self.mileage = None # INTEGER(0..2147483647),
self.battery_voltage = None # INTEGER(0..65535),
self.hand_brake = None # BOOLEAN,
self.veh_elec_rng_dsp = None # INTEGER(0..255),
self.fuel_range_elec = None # INTEGER(0..65535) OPTIONAL,
self.rmt_htd_rr_wnd_st = None # INTEGER(0..255),
self.extended_data1 = None # INTEGER(0..2147483647) OPTIONAL,
self.extended_data2 = None # INTEGER(0..2147483647) OPTIONAL
def get_data(self) -> dict:
data = {
'driverDoor': self.driver_door,
'passengerDoor': self.passenger_door,
'rearLeftDoor': self.rear_left_door,
'rearRightDoor': self.rear_right_door,
'bootStatus': self.boot_status,
'bonnetStatus': self.bonnet_status,
'lockStatus': self.lock_status,
'sideLightStatus': self.side_light_status,
'dippedBeamStatus': self.dipped_beam_status,
'mainBeamStatus': self.main_beam_status,
'engineStatus': self.engine_status,
'powerMode': self.power_mode,
'lastKeySeen': self.last_key_seen,
'currentjourneyDistance': self.current_journey_distance,
'currentJourneyID': self.current_journey_id,
'interiorTemperature': self.interior_temperature,
'exteriorTemperature': self.exterior_temperature,
'fuelLevelPrc': self.fuel_level_prc,
'fuelRange': self.fuel_range,
'remoteClimateStatus': self.remote_climate_status,
'canBusActive': self.can_bus_active,
'timeOfLastCANBUSActivity': self.time_of_last_canbus_activity,
'clstrDspdFuelLvlSgmt': self.clstr_dspd_fuel_lvl_sgmt,
'mileage': self.mileage,
'batteryVoltage': self.battery_voltage,
'handBrake': self.hand_brake,
'vehElecRngDsp': self.veh_elec_rng_dsp,
'rmtHtdRrWndSt': self.rmt_htd_rr_wnd_st
}
self.add_optional_field_to_data(data, 'driverWindow', self.driver_window)
self.add_optional_field_to_data(data, 'passengerWindow', self.passenger_window)
self.add_optional_field_to_data(data, 'rearLeftWindow', self.rear_left_window)
self.add_optional_field_to_data(data, 'rearRightWindow', self.rear_right_window)
self.add_optional_field_to_data(data, 'sunroofStatus', self.sun_roof_status)
self.add_optional_field_to_data(data, 'frontRrightTyrePressure', self.front_right_tyre_pressure)
self.add_optional_field_to_data(data, 'frontLeftTyrePressure', self.front_left_tyre_pressure)
self.add_optional_field_to_data(data, 'rearRightTyrePressure', self.rear_right_tyre_pressure)
self.add_optional_field_to_data(data, 'rearLeftTyrePressure', self.rear_left_tyre_pressure)
self.add_optional_field_to_data(data, 'wheelTyreMonitorStatus', self.wheel_tyre_monitor_status)
self.add_optional_field_to_data(data, 'vehicleAlarmStatus', self.vehicle_alarm_status)
self.add_optional_field_to_data(data, 'frontLeftSeatHeatLevel', self.front_left_seat_heat_level)
self.add_optional_field_to_data(data, 'frontRightSeatHeatLevel', self.front_right_seat_heat_level)
self.add_optional_field_to_data(data, 'fuelRangeElec', self.fuel_range_elec)
self.add_optional_field_to_data(data, 'extendedData1', self.extended_data1)
self.add_optional_field_to_data(data, 'extendedData2', self.extended_data2)
return data
def init_from_dict(self, data: dict):
self.driver_door = data.get('driverDoor')
self.passenger_door = data.get('passengerDoor')
self.rear_left_door = data.get('rearLeftDoor')
self.rear_right_door = data.get('rearRightDoor')
self.boot_status = data.get('bootStatus')
self.bonnet_status = data.get('bonnetStatus')
self.lock_status = data.get('lockStatus')
self.side_light_status = data.get('sideLightStatus')
self.dipped_beam_status = data.get('dippedBeamStatus')
self.main_beam_status = data.get('mainBeamStatus')
self.engine_status = data.get('engineStatus')
self.power_mode = data.get('powerMode')
self.last_key_seen = data.get('lastKeySeen')
self.current_journey_distance = data.get('currentjourneyDistance')
self.current_journey_id = data.get('currentJourneyID')
self.interior_temperature = data.get('interiorTemperature')
self.exterior_temperature = data.get('exteriorTemperature')
self.fuel_level_prc = data.get('fuelLevelPrc')
self.fuel_range = data.get('fuelRange')
self.remote_climate_status = data.get('remoteClimateStatus')
self.can_bus_active = data.get('canBusActive')
self.time_of_last_canbus_activity = data.get('timeOfLastCANBUSActivity')
self.clstr_dspd_fuel_lvl_sgmt = data.get('clstrDspdFuelLvlSgmt')
self.mileage = data.get('mileage')
self.battery_voltage = data.get('batteryVoltage')
self.hand_brake = data.get('handBrake')
self.veh_elec_rng_dsp = data.get('vehElecRngDsp')
self.rmt_htd_rr_wnd_st = data.get('rmtHtdRrWndSt')
self.driver_window = data.get('driverWindow')
self.passenger_window = data.get('passengerWindow')
self.rear_left_window = data.get('rearLeftWindow')
self.rear_right_window = data.get('rearRightWindow')
self.sun_roof_status = data.get('sunroofStatus')
self.front_right_tyre_pressure = data.get('frontRrightTyrePressure')
self.front_left_tyre_pressure = data.get('frontLeftTyrePressure')
self.rear_right_tyre_pressure = data.get('rearRightTyrePressure')
self.rear_left_tyre_pressure = data.get('rearLeftTyrePressure')
self.wheel_tyre_monitor_status = data.get('wheelTyreMonitorStatus')
self.vehicle_alarm_status = data.get('vehicleAlarmStatus')
self.front_left_seat_heat_level = data.get('frontLeftSeatHeatLevel')
self.front_right_seat_heat_level = data.get('frontRightSeatHeatLevel')
self.fuel_range_elec = data.get('fuelRangeElec')
self.extended_data1 = data.get('extendedData1')
self.extended_data2 = data.get('extendedData2')
def extended_data_2_present(self) -> bool:
return self.extended_data2 is not None
class RvsExtStatus(Asn1Type):
def __init__(self):
super().__init__('RvsExtStatus')
self.vehicle_alerts = []
def get_data(self) -> dict:
vehicle_alerts = []
for alert in self.vehicle_alerts:
vehicle_alerts.append(alert.get_data())
return {
FIELD_VEHICLE_ALERTS: vehicle_alerts
}
def init_from_dict(self, data: dict):
vehicle_alerts = data.get(FIELD_VEHICLE_ALERTS)
for alert in vehicle_alerts:
a = VehicleAlertInfo()
a.init_from_dict(alert)
self.vehicle_alerts.append(a)
class VehicleAlertInfo(Asn1Type):
def __init__(self):
super().__init__('VehicleAlertInfo')
self.id = None
self.value = None
def get_data(self) -> dict:
return {
FIELD_ID: self.id,
FIELD_VALUE: self.value
}
def init_from_dict(self, data: dict):
self.id = data.get(FIELD_ID)
self.value = data.get(FIELD_VALUE)
class OtaRvcReq(ApplicationData):
def __init__(self):
super().__init__('OTARVCReq')
self.rvc_req_type = None
self.rvc_params = []
def get_data(self) -> dict:
data = {
FIELD_RVC_REQ_TYPE: self.rvc_req_type
}
param_list = []
for param in self.rvc_params:
param_list.append(param.get_data())
data[FIELD_RVC_PARAMS] = param_list
return data
def init_from_dict(self, data: dict):
self.rvc_req_type = data.get(FIELD_RVC_REQ_TYPE)
if FIELD_RVC_PARAMS in data:
rvc_params_list = data.get(FIELD_RVC_PARAMS)
for item in rvc_params_list:
param = RvcReqParam()
param.init_from_dict(item)
self.rvc_params.append(param)
class RvcReqParam(Asn1Type):
def __init__(self):
super().__init__('RvcReqParam')
self.param_id = None
self.param_value = None
def get_data(self) -> dict:
return {
FIELD_PARAM_ID: self.param_id,
FIELD_PARAM_VALUE: self.param_value
}
def init_from_dict(self, data: dict):
self.param_id = data.get(FIELD_PARAM_ID)
self.param_value = data.get(FIELD_PARAM_VALUE)
class OtaRvmVehicleStatusResp25857(ApplicationData):
def __init__(self):
super().__init__('OTARVMVehicleStatusResp25857')
self.status_time = None
self.gps_position = None
self.basic_vehicle_status = None
self.extended_vehicle_status = None
def get_data(self) -> dict:
if (
self.status_time is not None
and self.gps_position is not None
and self.basic_vehicle_status is not None
):
data = {
FIELD_STATUS_TIME: self.status_time,
FIELD_GPS_POSITION: self.gps_position.get_data(),
FIELD_BASIC_VEHICLE_STATUS: self.basic_vehicle_status.get_data()
}
if FIELD_EXTENDED_VEHICLE_STATUS in data:
data[FIELD_EXTENDED_VEHICLE_STATUS] = self.extended_vehicle_status.get_data()
return data
else:
return {}
def init_from_dict(self, data: dict):
self.status_time = data.get(FIELD_STATUS_TIME)
self.gps_position = RvsPosition()
self.gps_position.init_from_dict(data.get(FIELD_GPS_POSITION))
self.basic_vehicle_status = RvsBasicStatus25857()
self.basic_vehicle_status.init_from_dict(data.get(FIELD_BASIC_VEHICLE_STATUS))
if FIELD_EXTENDED_VEHICLE_STATUS in data:
self.extended_vehicle_status = RvsExtStatus()
self.extended_vehicle_status.init_from_dict(data.get(FIELD_EXTENDED_VEHICLE_STATUS))
def get_basic_vehicle_status(self) -> RvsBasicStatus25857:
return cast(RvsBasicStatus25857, self.basic_vehicle_status)
def get_gps_position(self) -> RvsPosition:
return cast(RvsPosition, self.gps_position)
def is_charging(self) -> bool:
return (
self.get_basic_vehicle_status().extended_data_2_present()
and self.get_basic_vehicle_status().extended_data2 >= 1
)
def is_parked(self) -> bool:
return (
self.get_basic_vehicle_status().engine_status != 1
or self.get_basic_vehicle_status().hand_brake
)
def is_engine_running(self) -> bool:
return self.get_basic_vehicle_status().engine_status == 1
class OtaRvcStatus25857(ApplicationData):
def __init__(self):
super().__init__('OTARVCStatus25857')
self.rvcReqType = None # OCTET STRING(SIZE(1)),
self.rvcReqSts = None # OCTET STRING(SIZE(1)),
self.failureType = None # INTEGER(0..255) OPTIONAL,
self.gpsPosition = None # RvsPosition(1),
self.basicVehicleStatus = None # RvsBasicStatus25857(1)
def get_data(self) -> dict:
data = {
FIELD_RVC_REQ_TYPE: self.rvcReqType,
FIELD_RVC_REQ_STS: self.rvcReqSts,
FIELD_GPS_POSITION: self.gpsPosition.get_data(),
FIELD_BASIC_VEHICLE_STATUS: self.basicVehicleStatus.get_data()
}
self.add_optional_field_to_data(data, FIELD_FAILURE_TYPE, self.failureType)
return data
def init_from_dict(self, data: dict):
self.rvcReqType = data.get(FIELD_RVC_REQ_TYPE)
self.rvcReqSts = data.get(FIELD_RVC_REQ_STS)
self.gpsPosition = RvsPosition()
self.gpsPosition.init_from_dict(data.get(FIELD_GPS_POSITION))
self.basicVehicleStatus = RvsBasicStatus25857()
self.basicVehicleStatus.init_from_dict(data.get(FIELD_BASIC_VEHICLE_STATUS))
if FIELD_FAILURE_TYPE in data:
self.failureType = data.get(FIELD_FAILURE_TYPE) | /saic_ismart_client-1.6.0.tar.gz/saic_ismart_client-1.6.0/src/saic_ismart_client/ota_v2_1/data_model.py | 0.753467 | 0.157105 | data_model.py | pypi |
from saic_ismart_client.common_model import ApplicationData, MessageV2, MessageCoderV2, MessageBodyV2
class MessageBodyV30(MessageBodyV2):
def __init__(self):
super().__init__()
def ack_message_counter_present(self) -> bool:
return self.ack_message_counter is not None
def ack_required_present(self) -> bool:
return self.ack_required is not None
def application_data_encoding_present(self) -> bool:
return self.application_data_encoding is not None
def application_data_length_present(self) -> bool:
return self.application_data_length is not None
def application_data_protocol_version_present(self) -> bool:
return self.application_data_protocol_version is not None
def dl_message_counter_present(self) -> bool:
return self.dl_message_counter is not None
def ul_message_counter_present(self) -> bool:
return self.ul_message_counter is not None
def error_message_present(self) -> bool:
return self.error_message is not None
def event_id_present(self) -> bool:
return self.event_id is not None
def test_flag_present(self) -> bool:
return self.test_flag is not None
def token_present(self) -> bool:
return self.token is not None
def uid_present(self) -> bool:
return self.uid is not None
def vin_present(self) -> bool:
return self.vin is not None
class MessageV30(MessageV2):
def __init__(self, body: MessageBodyV30, application_data: ApplicationData = None,
reserved: bytes = None):
super().__init__(body, application_data, reserved)
class MessageCoderV30(MessageCoderV2):
def __init__(self):
super().__init__('ASN.1_schema/v3_0/')
def encode_request(self, message: MessageV30) -> str:
return super().encode_request(message)
def decode_response(self, message: str, decoded_message: MessageV30) -> None:
super().decode_response(message, decoded_message)
def initialize_message(self, uid: str, token: str, vin: str, application_id: str,
application_data_protocol_version: int, message_id: int, message: MessageV30) -> None:
return super().initialize_message(uid, token, vin, application_id, application_data_protocol_version,
message_id, message)
def get_protocol_version(self) -> int:
return 48 | /saic_ismart_client-1.6.0.tar.gz/saic_ismart_client-1.6.0/src/saic_ismart_client/ota_v3_0/Message.py | 0.691185 | 0.245514 | Message.py | pypi |
import base64
import hashlib
import json
from binascii import hexlify
try:
from hashlib import sha3_256
except ImportError:
from sha3 import sha3_256
def encode_transaction(value):
"""Encode a transaction (dict) to Base64."""
return base64.b64encode(json.dumps(value).encode('utf8')).decode('utf8')
def decode_transaction(raw):
"""Decode a transaction from bytes to a dict."""
return json.loads(raw.decode('utf8'))
def decode_transaction_base64(value):
"""Decode a transaction from Base64."""
return json.loads(base64.b64decode(value.encode('utf8')).decode('utf8'))
def calculate_hash(key_list):
if not key_list:
return ''
full_hash = sha3_256()
for key in key_list:
full_hash.update(key.encode('utf8'))
return full_hash.hexdigest()
def merkleroot(hashes):
"""Computes the merkle root for a given list.
Args:
hashes (:obj:`list` of :obj:`bytes`): The leaves of the tree.
Returns:
str: Merkle root in hexadecimal form.
"""
# XXX TEMPORARY -- MUST REVIEW and possibly CHANGE
# The idea here is that the UTXO SET would be empty and this function
# would be invoked to compute the merkle root, and since there is nothing,
# i.e. an empty list, then the hash of the empty string is returned.
# This seems too easy but maybe that is good enough? TO REVIEW!
if not hashes:
return sha3_256(b'').hexdigest()
# XXX END TEMPORARY -- MUST REVIEW ...
if len(hashes) == 1:
return hexlify(hashes[0]).decode()
if len(hashes) % 2 == 1:
hashes.append(hashes[-1])
parent_hashes = [
sha3_256(hashes[i] + hashes[i+1]).digest()
for i in range(0, len(hashes)-1, 2)
]
return merkleroot(parent_hashes)
def public_key64_to_address(base64_public_key):
"""Note this only compatible with Tendermint 0.19.x"""
ed25519_public_key = public_key_from_base64(base64_public_key)
encoded_public_key = amino_encoded_public_key(ed25519_public_key)
return hashlib.new('ripemd160', encoded_public_key).hexdigest().upper()
def public_key_from_base64(base64_public_key):
return key_from_base64(base64_public_key)
def key_from_base64(base64_key):
return base64.b64decode(base64_key).hex().upper()
def public_key_to_base64(ed25519_public_key):
return key_to_base64(ed25519_public_key)
def key_to_base64(ed25519_key):
ed25519_key = bytes.fromhex(ed25519_key)
return base64.b64encode(ed25519_key).decode('utf-8')
def amino_encoded_public_key(ed25519_public_key):
return bytes.fromhex('1624DE6220{}'.format(ed25519_public_key)) | /saiive.chain-2.3.1.0-py3-none-any.whl/bigchaindb/tendermint_utils.py | 0.833934 | 0.283999 | tendermint_utils.py | pypi |
import contextlib
import threading
import queue
import multiprocessing as mp
import json
import setproctitle
from packaging import version
from bigchaindb.version import __tm_supported_versions__
from bigchaindb.tendermint_utils import key_from_base64
from bigchaindb.common.crypto import key_pair_from_ed25519_key
class ProcessGroup(object):
def __init__(self, concurrency=None, group=None, target=None, name=None,
args=None, kwargs=None, daemon=None):
self.concurrency = concurrency or mp.cpu_count()
self.group = group
self.target = target
self.name = name
self.args = args or ()
self.kwargs = kwargs or {}
self.daemon = daemon
self.processes = []
def start(self):
for i in range(self.concurrency):
proc = mp.Process(group=self.group, target=self.target,
name=self.name, args=self.args,
kwargs=self.kwargs, daemon=self.daemon)
proc.start()
self.processes.append(proc)
class Process(mp.Process):
"""Wrapper around multiprocessing.Process that uses
setproctitle to set the name of the process when running
the target task.
"""
def run(self):
setproctitle.setproctitle(self.name)
super().run()
# Inspired by:
# - http://stackoverflow.com/a/24741694/597097
def pool(builder, size, timeout=None):
"""Create a pool that imposes a limit on the number of stored
instances.
Args:
builder: a function to build an instance.
size: the size of the pool.
timeout(Optional[float]): the seconds to wait before raising
a ``queue.Empty`` exception if no instances are available
within that time.
Raises:
If ``timeout`` is defined but the request is taking longer
than the specified time, the context manager will raise
a ``queue.Empty`` exception.
Returns:
A context manager that can be used with the ``with``
statement.
"""
lock = threading.Lock()
local_pool = queue.Queue()
current_size = 0
@contextlib.contextmanager
def pooled():
nonlocal current_size
instance = None
# If we still have free slots, then we have room to create new
# instances.
if current_size < size:
with lock:
# We need to check again if we have slots available, since
# the situation might be different after acquiring the lock
if current_size < size:
current_size += 1
instance = builder()
# Watchout: current_size can be equal to size if the previous part of
# the function has been executed, that's why we need to check if the
# instance is None.
if instance is None:
instance = local_pool.get(timeout=timeout)
yield instance
local_pool.put(instance)
return pooled
# TODO: Rename this function, it's handling fulfillments not conditions
def condition_details_has_owner(condition_details, owner):
"""Check if the public_key of owner is in the condition details
as an Ed25519Fulfillment.public_key
Args:
condition_details (dict): dict with condition details
owner (str): base58 public key of owner
Returns:
bool: True if the public key is found in the condition details, False otherwise
"""
if 'subconditions' in condition_details:
result = condition_details_has_owner(condition_details['subconditions'], owner)
if result:
return True
elif isinstance(condition_details, list):
for subcondition in condition_details:
result = condition_details_has_owner(subcondition, owner)
if result:
return True
else:
if 'public_key' in condition_details \
and owner == condition_details['public_key']:
return True
return False
class Lazy:
"""Lazy objects are useful to create chains of methods to
execute later.
A lazy object records the methods that has been called, and
replay them when the :py:meth:`run` method is called. Note that
:py:meth:`run` needs an object `instance` to replay all the
methods that have been recorded.
"""
def __init__(self):
"""Instantiate a new Lazy object."""
self.stack = []
def __getattr__(self, name):
self.stack.append(name)
return self
def __call__(self, *args, **kwargs):
self.stack.append((args, kwargs))
return self
def __getitem__(self, key):
self.stack.append('__getitem__')
self.stack.append(([key], {}))
return self
def run(self, instance):
"""Run the recorded chain of methods on `instance`.
Args:
instance: an object.
"""
last = instance
for item in self.stack:
if isinstance(item, str):
last = getattr(last, item)
else:
last = last(*item[0], **item[1])
self.stack = []
return last
# Load Tendermint's public and private key from the file path
def load_node_key(path):
with open(path) as json_data:
priv_validator = json.load(json_data)
priv_key = priv_validator['priv_key']['value']
hex_private_key = key_from_base64(priv_key)
return key_pair_from_ed25519_key(hex_private_key)
def tendermint_version_is_compatible(running_tm_ver):
"""
Check Tendermint compatability with BigchainDB server
:param running_tm_ver: Version number of the connected Tendermint instance
:type running_tm_ver: str
:return: True/False depending on the compatability with BigchainDB server
:rtype: bool
"""
# Splitting because version can look like this e.g. 0.22.8-40d6dc2e
tm_ver = running_tm_ver.split('-')
if not tm_ver:
return False
for ver in __tm_supported_versions__:
if version.parse(ver) == version.parse(tm_ver[0]):
return True
return False | /saiive.chain-2.3.1.0-py3-none-any.whl/bigchaindb/utils.py | 0.681409 | 0.154026 | utils.py | pypi |
from queue import Empty
from collections import defaultdict
from multiprocessing import Queue
POISON_PILL = 'POISON_PILL'
class EventTypes:
"""Container class that holds all the possible
events BigchainDB manages.
"""
# If you add a new Event Type, make sure to add it
# to the docs in docs/server/source/event-plugin-api.rst
ALL = ~0
BLOCK_VALID = 1
BLOCK_INVALID = 2
# NEW_EVENT = 4
# NEW_EVENT = 8
# NEW_EVENT = 16...
class Event:
"""An Event."""
def __init__(self, event_type, event_data):
"""Creates a new event.
Args:
event_type (int): the type of the event, see
:class:`~bigchaindb.events.EventTypes`
event_data (obj): the data of the event.
"""
self.type = event_type
self.data = event_data
class Exchange:
"""Dispatch events to subscribers."""
def __init__(self):
self.publisher_queue = Queue()
self.started_queue = Queue()
# Map <event_types -> queues>
self.queues = defaultdict(list)
def get_publisher_queue(self):
"""Get the queue used by the publisher.
Returns:
a :class:`multiprocessing.Queue`.
"""
return self.publisher_queue
def get_subscriber_queue(self, event_types=None):
"""Create a new queue for a specific combination of event types
and return it.
Returns:
a :class:`multiprocessing.Queue`.
Raises:
RuntimeError if called after `run`
"""
try:
self.started_queue.get(timeout=1)
raise RuntimeError('Cannot create a new subscriber queue while Exchange is running.')
except Empty:
pass
if event_types is None:
event_types = EventTypes.ALL
queue = Queue()
self.queues[event_types].append(queue)
return queue
def dispatch(self, event):
"""Given an event, send it to all the subscribers.
Args
event (:class:`~bigchaindb.events.EventTypes`): the event to
dispatch to all the subscribers.
"""
for event_types, queues in self.queues.items():
if event.type & event_types:
for queue in queues:
queue.put(event)
def run(self):
"""Start the exchange"""
self.started_queue.put('STARTED')
while True:
event = self.publisher_queue.get()
if event == POISON_PILL:
return
else:
self.dispatch(event) | /saiive.chain-2.3.1.0-py3-none-any.whl/bigchaindb/events.py | 0.840488 | 0.167866 | events.py | pypi |
from bigchaindb.backend.schema import validate_language_key
from bigchaindb.common.exceptions import (InvalidSignature,
DuplicateTransaction)
from bigchaindb.common.schema import validate_transaction_schema
from bigchaindb.common.transaction import Transaction
from bigchaindb.common.utils import (validate_txn_obj, validate_key)
class Transaction(Transaction):
ASSET = 'asset'
METADATA = 'metadata'
DATA = 'data'
def validate(self, bigchain, current_transactions=[]):
"""Validate transaction spend
Args:
bigchain (BigchainDB): an instantiated bigchaindb.BigchainDB object.
Returns:
The transaction (Transaction) if the transaction is valid else it
raises an exception describing the reason why the transaction is
invalid.
Raises:
ValidationError: If the transaction is invalid
"""
input_conditions = []
if self.operation == Transaction.CREATE:
duplicates = any(txn for txn in current_transactions if txn.id == self.id)
if bigchain.is_committed(self.id) or duplicates:
raise DuplicateTransaction('transaction `{}` already exists'
.format(self.id))
if not self.inputs_valid(input_conditions):
raise InvalidSignature('Transaction signature is invalid.')
elif self.operation == Transaction.TRANSFER:
self.validate_transfer_inputs(bigchain, current_transactions)
return self
@classmethod
def from_dict(cls, tx_body):
return super().from_dict(tx_body, False)
@classmethod
def validate_schema(cls, tx_body):
validate_transaction_schema(tx_body)
validate_txn_obj(cls.ASSET, tx_body[cls.ASSET], cls.DATA, validate_key)
validate_txn_obj(cls.METADATA, tx_body, cls.METADATA, validate_key)
validate_language_key(tx_body[cls.ASSET], cls.DATA)
validate_language_key(tx_body, cls.METADATA)
class FastTransaction:
"""A minimal wrapper around a transaction dictionary. This is useful for
when validation is not required but a routine expects something that looks
like a transaction, for example during block creation.
Note: immutability could also be provided
"""
def __init__(self, tx_dict):
self.data = tx_dict
@property
def id(self):
return self.data['id']
def to_dict(self):
return self.data | /saiive.chain-2.3.1.0-py3-none-any.whl/bigchaindb/models.py | 0.903093 | 0.186521 | models.py | pypi |
from collections import OrderedDict
import base58
from uuid import uuid4
from bigchaindb import backend
from bigchaindb.elections.vote import Vote
from bigchaindb.common.exceptions import (InvalidSignature,
MultipleInputsError,
InvalidProposer,
UnequalValidatorSet,
DuplicateTransaction)
from bigchaindb.tendermint_utils import key_from_base64, public_key_to_base64
from bigchaindb.common.crypto import (public_key_from_ed25519_key)
from bigchaindb.common.transaction import Transaction
from bigchaindb.common.schema import (_validate_schema,
TX_SCHEMA_COMMON,
TX_SCHEMA_CREATE)
class Election(Transaction):
"""Represents election transactions.
To implement a custom election, create a class deriving from this one
with OPERATION set to the election operation, ALLOWED_OPERATIONS
set to (OPERATION,), CREATE set to OPERATION.
"""
OPERATION = None
# Custom validation schema
TX_SCHEMA_CUSTOM = None
# Election Statuses:
ONGOING = 'ongoing'
CONCLUDED = 'concluded'
INCONCLUSIVE = 'inconclusive'
# Vote ratio to approve an election
ELECTION_THRESHOLD = 2 / 3
@classmethod
def get_validator_change(cls, bigchain):
"""Return the validator set from the most recent approved block
:return: {
'height': <block_height>,
'validators': <validator_set>
}
"""
latest_block = bigchain.get_latest_block()
if latest_block is None:
return None
return bigchain.get_validator_change(latest_block['height'])
@classmethod
def get_validators(cls, bigchain, height=None):
"""Return a dictionary of validators with key as `public_key` and
value as the `voting_power`
"""
validators = {}
for validator in bigchain.get_validators(height):
# NOTE: we assume that Tendermint encodes public key in base64
public_key = public_key_from_ed25519_key(key_from_base64(validator['public_key']['value']))
validators[public_key] = validator['voting_power']
return validators
@classmethod
def recipients(cls, bigchain):
"""Convert validator dictionary to a recipient list for `Transaction`"""
recipients = []
for public_key, voting_power in cls.get_validators(bigchain).items():
recipients.append(([public_key], voting_power))
return recipients
@classmethod
def is_same_topology(cls, current_topology, election_topology):
voters = {}
for voter in election_topology:
if len(voter.public_keys) > 1:
return False
[public_key] = voter.public_keys
voting_power = voter.amount
voters[public_key] = voting_power
# Check whether the voters and their votes is same to that of the
# validators and their voting power in the network
return current_topology == voters
def validate(self, bigchain, current_transactions=[]):
"""Validate election transaction
NOTE:
* A valid election is initiated by an existing validator.
* A valid election is one where voters are validators and votes are
allocated according to the voting power of each validator node.
Args:
:param bigchain: (BigchainDB) an instantiated bigchaindb.lib.BigchainDB object.
:param current_transactions: (list) A list of transactions to be validated along with the election
Returns:
Election: a Election object or an object of the derived Election subclass.
Raises:
ValidationError: If the election is invalid
"""
input_conditions = []
duplicates = any(txn for txn in current_transactions if txn.id == self.id)
if bigchain.is_committed(self.id) or duplicates:
raise DuplicateTransaction('transaction `{}` already exists'
.format(self.id))
if not self.inputs_valid(input_conditions):
raise InvalidSignature('Transaction signature is invalid.')
current_validators = self.get_validators(bigchain)
# NOTE: Proposer should be a single node
if len(self.inputs) != 1 or len(self.inputs[0].owners_before) != 1:
raise MultipleInputsError('`tx_signers` must be a list instance of length one')
# NOTE: Check if the proposer is a validator.
[election_initiator_node_pub_key] = self.inputs[0].owners_before
if election_initiator_node_pub_key not in current_validators.keys():
raise InvalidProposer('Public key is not a part of the validator set')
# NOTE: Check if all validators have been assigned votes equal to their voting power
if not self.is_same_topology(current_validators, self.outputs):
raise UnequalValidatorSet('Validator set much be exactly same to the outputs of election')
return self
@classmethod
def generate(cls, initiator, voters, election_data, metadata=None):
# Break symmetry in case we need to call an election with the same properties twice
uuid = uuid4()
election_data['seed'] = str(uuid)
(inputs, outputs) = cls.validate_create(initiator, voters, election_data, metadata)
election = cls(cls.OPERATION, {'data': election_data}, inputs, outputs, metadata)
cls.validate_schema(election.to_dict())
return election
@classmethod
def validate_schema(cls, tx):
"""Validate the election transaction. Since `ELECTION` extends `CREATE` transaction, all the validations for
`CREATE` transaction should be inherited
"""
_validate_schema(TX_SCHEMA_COMMON, tx)
_validate_schema(TX_SCHEMA_CREATE, tx)
if cls.TX_SCHEMA_CUSTOM:
_validate_schema(cls.TX_SCHEMA_CUSTOM, tx)
@classmethod
def create(cls, tx_signers, recipients, metadata=None, asset=None):
raise NotImplementedError
@classmethod
def transfer(cls, tx_signers, recipients, metadata=None, asset=None):
raise NotImplementedError
@classmethod
def to_public_key(cls, election_id):
return base58.b58encode(bytes.fromhex(election_id)).decode()
@classmethod
def count_votes(cls, election_pk, transactions, getter=getattr):
votes = 0
for txn in transactions:
if getter(txn, 'operation') == Vote.OPERATION:
for output in getter(txn, 'outputs'):
# NOTE: We enforce that a valid vote to election id will have only
# election_pk in the output public keys, including any other public key
# along with election_pk will lead to vote being not considered valid.
if len(getter(output, 'public_keys')) == 1 and [election_pk] == getter(output, 'public_keys'):
votes = votes + int(getter(output, 'amount'))
return votes
def get_commited_votes(self, bigchain, election_pk=None):
if election_pk is None:
election_pk = self.to_public_key(self.id)
txns = list(backend.query.get_asset_tokens_for_public_key(bigchain.connection,
self.id,
election_pk))
return self.count_votes(election_pk, txns, dict.get)
def has_concluded(self, bigchain, current_votes=[]):
"""Check if the election can be concluded or not.
* Elections can only be concluded if the validator set has not changed
since the election was initiated.
* Elections can be concluded only if the current votes form a supermajority.
Custom elections may override this function and introduce additional checks.
"""
if self.has_validator_set_changed(bigchain):
return False
election_pk = self.to_public_key(self.id)
votes_committed = self.get_commited_votes(bigchain, election_pk)
votes_current = self.count_votes(election_pk, current_votes)
total_votes = sum(output.amount for output in self.outputs)
if (votes_committed < (2/3) * total_votes) and \
(votes_committed + votes_current >= (2/3)*total_votes):
return True
return False
def get_status(self, bigchain):
election = self.get_election(self.id, bigchain)
if election and election['is_concluded']:
return self.CONCLUDED
return self.INCONCLUSIVE if self.has_validator_set_changed(bigchain) else self.ONGOING
def has_validator_set_changed(self, bigchain):
latest_change = self.get_validator_change(bigchain)
if latest_change is None:
return False
latest_change_height = latest_change['height']
election = self.get_election(self.id, bigchain)
return latest_change_height > election['height']
def get_election(self, election_id, bigchain):
return bigchain.get_election(election_id)
def store(self, bigchain, height, is_concluded):
bigchain.store_election(self.id, height, is_concluded)
def show_election(self, bigchain):
data = self.asset['data']
if 'public_key' in data.keys():
data['public_key'] = public_key_to_base64(data['public_key']['value'])
response = ''
for k, v in data.items():
if k != 'seed':
response += f'{k}={v}\n'
response += f'status={self.get_status(bigchain)}'
return response
@classmethod
def _get_initiated_elections(cls, height, txns):
elections = []
for tx in txns:
if not isinstance(tx, Election):
continue
elections.append({'election_id': tx.id, 'height': height,
'is_concluded': False})
return elections
@classmethod
def _get_votes(cls, txns):
elections = OrderedDict()
for tx in txns:
if not isinstance(tx, Vote):
continue
election_id = tx.asset['id']
if election_id not in elections:
elections[election_id] = []
elections[election_id].append(tx)
return elections
@classmethod
def process_block(cls, bigchain, new_height, txns):
"""Looks for election and vote transactions inside the block, records
and processes elections.
Every election is recorded in the database.
Every vote has a chance to conclude the corresponding election. When
an election is concluded, the corresponding database record is
marked as such.
Elections and votes are processed in the order in which they
appear in the block. Elections are concluded in the order of
appearance of their first votes in the block.
For every election concluded in the block, calls its `on_approval`
method. The returned value of the last `on_approval`, if any,
is a validator set update to be applied in one of the following blocks.
`on_approval` methods are implemented by elections of particular type.
The method may contain side effects but should be idempotent. To account
for other concluded elections, if it requires so, the method should
rely on the database state.
"""
# elections initiated in this block
initiated_elections = cls._get_initiated_elections(new_height, txns)
if initiated_elections:
bigchain.store_elections(initiated_elections)
# elections voted for in this block and their votes
elections = cls._get_votes(txns)
validator_update = None
for election_id, votes in elections.items():
election = bigchain.get_transaction(election_id)
if election is None:
continue
if not election.has_concluded(bigchain, votes):
continue
validator_update = election.on_approval(bigchain, new_height)
election.store(bigchain, new_height, is_concluded=True)
return [validator_update] if validator_update else []
@classmethod
def rollback(cls, bigchain, new_height, txn_ids):
"""Looks for election and vote transactions inside the block and
cleans up the database artifacts possibly created in `process_blocks`.
Part of the `end_block`/`commit` crash recovery.
"""
# delete election records for elections initiated at this height and
# elections concluded at this height
bigchain.delete_elections(new_height)
txns = [bigchain.get_transaction(tx_id) for tx_id in txn_ids]
elections = cls._get_votes(txns)
for election_id in elections:
election = bigchain.get_transaction(election_id)
election.on_rollback(bigchain, new_height)
def on_approval(self, bigchain, new_height):
"""Override to update the database state according to the
election rules. Consider the current database state to account for
other concluded elections, if required.
"""
raise NotImplementedError
def on_rollback(self, bigchain, new_height):
"""Override to clean up the database artifacts possibly created
in `on_approval`. Part of the `end_block`/`commit` crash recovery.
"""
raise NotImplementedError | /saiive.chain-2.3.1.0-py3-none-any.whl/bigchaindb/elections/election.py | 0.898109 | 0.26754 | election.py | pypi |
from bigchaindb.common.transaction import Transaction
from bigchaindb.common.schema import (_validate_schema,
TX_SCHEMA_COMMON,
TX_SCHEMA_TRANSFER,
TX_SCHEMA_VOTE)
class Vote(Transaction):
OPERATION = 'VOTE'
# NOTE: This class inherits TRANSFER txn type. The `TRANSFER` property is
# overriden to re-use methods from parent class
TRANSFER = OPERATION
ALLOWED_OPERATIONS = (OPERATION,)
# Custom validation schema
TX_SCHEMA_CUSTOM = TX_SCHEMA_VOTE
def validate(self, bigchain, current_transactions=[]):
"""Validate election vote transaction
NOTE: There are no additional validity conditions on casting votes i.e.
a vote is just a valid TRANFER transaction
For more details refer BEP-21: https://github.com/bigchaindb/BEPs/tree/master/21
Args:
bigchain (BigchainDB): an instantiated bigchaindb.lib.BigchainDB object.
Returns:
Vote: a Vote object
Raises:
ValidationError: If the election vote is invalid
"""
self.validate_transfer_inputs(bigchain, current_transactions)
return self
@classmethod
def generate(cls, inputs, recipients, election_id, metadata=None):
(inputs, outputs) = cls.validate_transfer(inputs, recipients, election_id, metadata)
election_vote = cls(cls.OPERATION, {'id': election_id}, inputs, outputs, metadata)
cls.validate_schema(election_vote.to_dict())
return election_vote
@classmethod
def validate_schema(cls, tx):
"""Validate the validator election vote transaction. Since `VOTE` extends `TRANSFER`
transaction, all the validations for `CREATE` transaction should be inherited
"""
_validate_schema(TX_SCHEMA_COMMON, tx)
_validate_schema(TX_SCHEMA_TRANSFER, tx)
_validate_schema(cls.TX_SCHEMA_CUSTOM, tx)
@classmethod
def create(cls, tx_signers, recipients, metadata=None, asset=None):
raise NotImplementedError
@classmethod
def transfer(cls, tx_signers, recipients, metadata=None, asset=None):
raise NotImplementedError | /saiive.chain-2.3.1.0-py3-none-any.whl/bigchaindb/elections/vote.py | 0.899787 | 0.154535 | vote.py | pypi |
from functools import singledispatch
import logging
import bigchaindb
from bigchaindb.backend.connection import connect
from bigchaindb.common.exceptions import ValidationError
from bigchaindb.common.utils import validate_all_values_for_key_in_obj, validate_all_values_for_key_in_list
logger = logging.getLogger(__name__)
# Tables/collections that every backend database must create
TABLES = ('transactions', 'blocks', 'assets', 'metadata',
'validators', 'elections', 'pre_commit', 'utxos', 'abci_chains')
VALID_LANGUAGES = ('danish', 'dutch', 'english', 'finnish', 'french', 'german',
'hungarian', 'italian', 'norwegian', 'portuguese', 'romanian',
'russian', 'spanish', 'swedish', 'turkish', 'none',
'da', 'nl', 'en', 'fi', 'fr', 'de', 'hu', 'it', 'nb', 'pt',
'ro', 'ru', 'es', 'sv', 'tr')
@singledispatch
def create_database(connection, dbname):
"""Create database to be used by BigchainDB.
Args:
dbname (str): the name of the database to create.
"""
raise NotImplementedError
@singledispatch
def create_tables(connection, dbname):
"""Create the tables to be used by BigchainDB.
Args:
dbname (str): the name of the database to create tables for.
"""
raise NotImplementedError
@singledispatch
def drop_database(connection, dbname):
"""Drop the database used by BigchainDB.
Args:
dbname (str): the name of the database to drop.
Raises:
:exc:`~DatabaseDoesNotExist`: If the given :attr:`dbname` does not
exist as a database.
"""
raise NotImplementedError
def init_database(connection=None, dbname=None):
"""Initialize the configured backend for use with BigchainDB.
Creates a database with :attr:`dbname` with any required tables
and supporting indexes.
Args:
connection (:class:`~bigchaindb.backend.connection.Connection`): an
existing connection to use to initialize the database.
Creates one if not given.
dbname (str): the name of the database to create.
Defaults to the database name given in the BigchainDB
configuration.
"""
connection = connection or connect()
dbname = dbname or bigchaindb.config['database']['name']
create_database(connection, dbname)
create_tables(connection, dbname)
def validate_language_key(obj, key):
"""Validate all nested "language" key in `obj`.
Args:
obj (dict): dictionary whose "language" key is to be validated.
Returns:
None: validation successful
Raises:
ValidationError: will raise exception in case language is not valid.
"""
backend = bigchaindb.config['database']['backend']
if backend == 'localmongodb':
data = obj.get(key, {})
if isinstance(data, dict):
validate_all_values_for_key_in_obj(data, 'language', validate_language)
elif isinstance(data, list):
validate_all_values_for_key_in_list(data, 'language', validate_language)
def validate_language(value):
"""Check if `value` is a valid language.
https://docs.mongodb.com/manual/reference/text-search-languages/
Args:
value (str): language to validated
Returns:
None: validation successful
Raises:
ValidationError: will raise exception in case language is not valid.
"""
if value not in VALID_LANGUAGES:
error_str = ('MongoDB does not support text search for the '
'language "{}". If you do not understand this error '
'message then please rename key/field "language" to '
'something else like "lang".').format(value)
raise ValidationError(error_str) | /saiive.chain-2.3.1.0-py3-none-any.whl/bigchaindb/backend/schema.py | 0.813387 | 0.171096 | schema.py | pypi |
from functools import singledispatch
from bigchaindb.backend.exceptions import OperationError
@singledispatch
def store_asset(connection, asset):
"""Write an asset to the asset table.
Args:
asset (dict): the asset.
Returns:
The result of the operation.
"""
raise NotImplementedError
@singledispatch
def store_assets(connection, assets):
"""Write a list of assets to the assets table.
Args:
assets (list): a list of assets to write.
Returns:
The database response.
"""
raise NotImplementedError
@singledispatch
def store_metadatas(connection, metadata):
"""Write a list of metadata to metadata table.
Args:
metadata (list): list of metadata.
Returns:
The result of the operation.
"""
raise NotImplementedError
@singledispatch
def store_transactions(connection, signed_transactions):
"""Store the list of transactions."""
raise NotImplementedError
@singledispatch
def get_transaction(connection, transaction_id):
"""Get a transaction from the transactions table.
Args:
transaction_id (str): the id of the transaction.
Returns:
The result of the operation.
"""
raise NotImplementedError
@singledispatch
def get_transactions(connection, transaction_ids):
"""Get transactions from the transactions table.
Args:
transaction_ids (list): list of transaction ids to fetch
Returns:
The result of the operation.
"""
raise NotImplementedError
@singledispatch
def get_asset(connection, asset_id):
"""Get a transaction from the transactions table.
Args:
asset_id (str): the id of the asset
Returns:
The result of the operation.
"""
raise NotImplementedError
@singledispatch
def get_spent(connection, transaction_id, condition_id):
"""Check if a `txid` was already used as an input.
A transaction can be used as an input for another transaction. Bigchain
needs to make sure that a given `txid` is only used once.
Args:
transaction_id (str): The id of the transaction.
condition_id (int): The index of the condition in the respective
transaction.
Returns:
The transaction that used the `txid` as an input else `None`
"""
raise NotImplementedError
@singledispatch
def get_spending_transactions(connection, inputs):
"""Return transactions which spend given inputs
Args:
inputs (list): list of {txid, output}
Returns:
Iterator of (block_ids, transaction) for transactions that
spend given inputs.
"""
raise NotImplementedError
@singledispatch
def get_owned_ids(connection, owner):
"""Retrieve a list of `txids` that can we used has inputs.
Args:
owner (str): base58 encoded public key.
Returns:
Iterator of (block_id, transaction) for transactions
that list given owner in conditions.
"""
raise NotImplementedError
@singledispatch
def get_block(connection, block_id):
"""Get a block from the bigchain table.
Args:
block_id (str): block id of the block to get
Returns:
block (dict): the block or `None`
"""
raise NotImplementedError
@singledispatch
def get_block_with_transaction(connection, txid):
"""Get a block containing transaction id `txid`
Args:
txid (str): id of transaction to be searched.
Returns:
block_id (int): the block id or `None`
"""
raise NotImplementedError
@singledispatch
def get_metadata(connection, transaction_ids):
"""Get a list of metadata from the metadata table.
Args:
transaction_ids (list): a list of ids for the metadata to be retrieved from
the database.
Returns:
metadata (list): the list of returned metadata.
"""
raise NotImplementedError
@singledispatch
def get_assets(connection, asset_ids):
"""Get a list of assets from the assets table.
Args:
asset_ids (list): a list of ids for the assets to be retrieved from
the database.
Returns:
assets (list): the list of returned assets.
"""
raise NotImplementedError
@singledispatch
def get_txids_filtered(connection, asset_id, operation=None):
"""Return all transactions for a particular asset id and optional operation.
Args:
asset_id (str): ID of transaction that defined the asset
operation (str) (optional): Operation to filter on
"""
raise NotImplementedError
@singledispatch
def text_search(conn, search, *, language='english', case_sensitive=False,
diacritic_sensitive=False, text_score=False, limit=0, table=None):
"""Return all the assets that match the text search.
The results are sorted by text score.
For more information about the behavior of text search on MongoDB see
https://docs.mongodb.com/manual/reference/operator/query/text/#behavior
Args:
search (str): Text search string to query the text index
language (str, optional): The language for the search and the rules for
stemmer and tokenizer. If the language is ``None`` text search uses
simple tokenization and no stemming.
case_sensitive (bool, optional): Enable or disable case sensitive
search.
diacritic_sensitive (bool, optional): Enable or disable case sensitive
diacritic search.
text_score (bool, optional): If ``True`` returns the text score with
each document.
limit (int, optional): Limit the number of returned documents.
Returns:
:obj:`list` of :obj:`dict`: a list of assets
Raises:
OperationError: If the backend does not support text search
"""
raise OperationError('This query is only supported when running '
'BigchainDB with MongoDB as the backend.')
@singledispatch
def get_latest_block(conn):
"""Get the latest commited block i.e. block with largest height"""
raise NotImplementedError
@singledispatch
def store_block(conn, block):
"""Write a new block to the `blocks` table
Args:
block (dict): block with current height and block hash.
Returns:
The result of the operation.
"""
raise NotImplementedError
@singledispatch
def store_unspent_outputs(connection, unspent_outputs):
"""Store unspent outputs in ``utxo_set`` table."""
raise NotImplementedError
@singledispatch
def delete_unspent_outputs(connection, unspent_outputs):
"""Delete unspent outputs in ``utxo_set`` table."""
raise NotImplementedError
@singledispatch
def delete_transactions(conn, txn_ids):
"""Delete transactions from database
Args:
txn_ids (list): list of transaction ids
Returns:
The result of the operation.
"""
raise NotImplementedError
@singledispatch
def get_unspent_outputs(connection, *, query=None):
"""Retrieves unspent outputs.
Args:
query (dict): An optional parameter to filter the result set.
Defaults to ``None``, which means that all UTXO records
will be returned.
Returns:
Generator yielding unspent outputs (UTXO set) according to the
given query.
"""
raise NotImplementedError
@singledispatch
def store_pre_commit_state(connection, state):
"""Store pre-commit state.
Args:
state (dict): pre-commit state.
Returns:
The result of the operation.
"""
raise NotImplementedError
@singledispatch
def get_pre_commit_state(connection):
"""Get pre-commit state.
Returns:
Document representing the pre-commit state.
"""
raise NotImplementedError
@singledispatch
def store_validator_set(conn, validator_update):
"""Store updated validator set"""
raise NotImplementedError
@singledispatch
def delete_validator_set(conn, height):
"""Delete the validator set at the given height."""
raise NotImplementedError
@singledispatch
def store_election(conn, election_id, height, is_concluded):
"""Store election record"""
raise NotImplementedError
@singledispatch
def store_elections(conn, elections):
"""Store election records in bulk"""
raise NotImplementedError
@singledispatch
def delete_elections(conn, height):
"""Delete all election records at the given height"""
raise NotImplementedError
@singledispatch
def get_validator_set(conn, height):
"""Get validator set for a given `height`, if `height` is not specified
then return the latest validator set
"""
raise NotImplementedError
@singledispatch
def get_election(conn, election_id):
"""Return the election record
"""
raise NotImplementedError
@singledispatch
def get_asset_tokens_for_public_key(connection, asset_id, public_key):
"""Retrieve a list of tokens of type `asset_id` that are owned by the `public_key`.
Args:
asset_id (str): Id of the token.
public_key (str): base58 encoded public key
Returns:
Iterator of transaction that list given owner in conditions.
"""
raise NotImplementedError
@singledispatch
def store_abci_chain(conn, height, chain_id, is_synced=True):
"""Create or update an ABCI chain at the given height.
Usually invoked in the beginning of the ABCI communications (height=0)
or when ABCI client (like Tendermint) is migrated (any height).
Args:
is_synced: True if the chain is known by both ABCI client and server
"""
raise NotImplementedError
@singledispatch
def delete_abci_chain(conn, height):
"""Delete the ABCI chain at the given height."""
raise NotImplementedError
@singledispatch
def get_latest_abci_chain(conn):
"""Returns the ABCI chain stored at the biggest height, if any,
None otherwise.
"""
raise NotImplementedError | /saiive.chain-2.3.1.0-py3-none-any.whl/bigchaindb/backend/query.py | 0.942994 | 0.507507 | query.py | pypi |
import base64
import binascii
import codecs
import bigchaindb
from abci import types_v0_22_8, types_v0_31_5, TmVersion
from bigchaindb.common.exceptions import InvalidPublicKey, BigchainDBError
def encode_validator(v):
ed25519_public_key = v['public_key']['value']
# NOTE: tendermint expects public to be encoded in go-amino format
try:
version = TmVersion(bigchaindb.config["tendermint"]["version"])
except ValueError:
raise BigchainDBError('Invalid tendermint version, '
'check BigchainDB configuration file')
validator_update_t, pubkey_t = {
TmVersion.v0_22_8: (types_v0_22_8.Validator, types_v0_22_8.PubKey),
TmVersion.v0_31_5: (types_v0_31_5.ValidatorUpdate, types_v0_31_5.PubKey)
}[version]
pub_key = pubkey_t(type='ed25519', data=bytes.fromhex(ed25519_public_key))
return validator_update_t(pub_key=pub_key, power=v['power'])
def decode_validator(v):
return {'public_key': {'type': 'ed25519-base64',
'value': codecs.encode(v.pub_key.data, 'base64').decode().rstrip('\n')},
'voting_power': v.power}
def new_validator_set(validators, updates):
validators_dict = {}
for v in validators:
validators_dict[v['public_key']['value']] = v
updates_dict = {}
for u in updates:
decoder = get_public_key_decoder(u['public_key'])
public_key64 = base64.b64encode(decoder(u['public_key']['value'])).decode('utf-8')
updates_dict[public_key64] = {'public_key': {'type': 'ed25519-base64',
'value': public_key64},
'voting_power': u['power']}
new_validators_dict = {**validators_dict, **updates_dict}
return list(new_validators_dict.values())
def encode_pk_to_base16(validator):
pk = validator['public_key']
decoder = get_public_key_decoder(pk)
public_key16 = base64.b16encode(decoder(pk['value'])).decode('utf-8')
validator['public_key']['value'] = public_key16
return validator
def validate_asset_public_key(pk):
pk_binary = pk['value'].encode('utf-8')
decoder = get_public_key_decoder(pk)
try:
pk_decoded = decoder(pk_binary)
if len(pk_decoded) != 32:
raise InvalidPublicKey('Public key should be of size 32 bytes')
except binascii.Error:
raise InvalidPublicKey('Invalid `type` specified for public key `value`')
def get_public_key_decoder(pk):
encoding = pk['type']
decoder = base64.b64decode
if encoding == 'ed25519-base16':
decoder = base64.b16decode
elif encoding == 'ed25519-base32':
decoder = base64.b32decode
elif encoding == 'ed25519-base64':
decoder = base64.b64decode
else:
raise InvalidPublicKey('Invalid `type` specified for public key `value`')
return decoder | /saiive.chain-2.3.1.0-py3-none-any.whl/bigchaindb/upsert_validator/validator_utils.py | 0.528777 | 0.185246 | validator_utils.py | pypi |
from bigchaindb.common.exceptions import InvalidPowerChange
from bigchaindb.elections.election import Election
from bigchaindb.common.schema import TX_SCHEMA_VALIDATOR_ELECTION
from .validator_utils import (new_validator_set, encode_validator, validate_asset_public_key)
class ValidatorElection(Election):
OPERATION = 'VALIDATOR_ELECTION'
# NOTE: this transaction class extends create so the operation inheritence is achieved
# by renaming CREATE to VALIDATOR_ELECTION
CREATE = OPERATION
ALLOWED_OPERATIONS = (OPERATION,)
TX_SCHEMA_CUSTOM = TX_SCHEMA_VALIDATOR_ELECTION
def validate(self, bigchain, current_transactions=[]):
"""For more details refer BEP-21: https://github.com/bigchaindb/BEPs/tree/master/21
"""
current_validators = self.get_validators(bigchain)
super(ValidatorElection, self).validate(bigchain, current_transactions=current_transactions)
# NOTE: change more than 1/3 of the current power is not allowed
if self.asset['data']['power'] >= (1/3)*sum(current_validators.values()):
raise InvalidPowerChange('`power` change must be less than 1/3 of total power')
return self
@classmethod
def validate_schema(cls, tx):
super(ValidatorElection, cls).validate_schema(tx)
validate_asset_public_key(tx['asset']['data']['public_key'])
def has_concluded(self, bigchain, *args, **kwargs):
latest_block = bigchain.get_latest_block()
if latest_block is not None:
latest_block_height = latest_block['height']
latest_validator_change = bigchain.get_validator_change()['height']
# TODO change to `latest_block_height + 3` when upgrading to Tendermint 0.24.0.
if latest_validator_change == latest_block_height + 2:
# do not conclude the election if there is a change assigned already
return False
return super().has_concluded(bigchain, *args, **kwargs)
def on_approval(self, bigchain, new_height):
validator_updates = [self.asset['data']]
curr_validator_set = bigchain.get_validators(new_height)
updated_validator_set = new_validator_set(curr_validator_set,
validator_updates)
updated_validator_set = [v for v in updated_validator_set
if v['voting_power'] > 0]
# TODO change to `new_height + 2` when upgrading to Tendermint 0.24.0.
bigchain.store_validator_set(new_height + 1, updated_validator_set)
return encode_validator(self.asset['data'])
def on_rollback(self, bigchaindb, new_height):
# TODO change to `new_height + 2` when upgrading to Tendermint 0.24.0.
bigchaindb.delete_validator_set(new_height + 1) | /saiive.chain-2.3.1.0-py3-none-any.whl/bigchaindb/upsert_validator/validator_election.py | 0.68342 | 0.193262 | validator_election.py | pypi |
import time
import re
import rapidjson
import bigchaindb
from bigchaindb.common.exceptions import ValidationError
def gen_timestamp():
"""The Unix time, rounded to the nearest second.
See https://en.wikipedia.org/wiki/Unix_time
Returns:
str: the Unix time
"""
return str(round(time.time()))
def serialize(data):
"""Serialize a dict into a JSON formatted string.
This function enforces rules like the separator and order of keys.
This ensures that all dicts are serialized in the same way.
This is specially important for hashing data. We need to make sure that
everyone serializes their data in the same way so that we do not have
hash mismatches for the same structure due to serialization
differences.
Args:
data (dict): dict to serialize
Returns:
str: JSON formatted string
"""
return rapidjson.dumps(data, skipkeys=False, ensure_ascii=False,
sort_keys=True)
def deserialize(data):
"""Deserialize a JSON formatted string into a dict.
Args:
data (str): JSON formatted string.
Returns:
dict: dict resulting from the serialization of a JSON formatted
string.
"""
return rapidjson.loads(data)
def validate_txn_obj(obj_name, obj, key, validation_fun):
"""Validate value of `key` in `obj` using `validation_fun`.
Args:
obj_name (str): name for `obj` being validated.
obj (dict): dictionary object.
key (str): key to be validated in `obj`.
validation_fun (function): function used to validate the value
of `key`.
Returns:
None: indicates validation successful
Raises:
ValidationError: `validation_fun` will raise exception on failure
"""
backend = bigchaindb.config['database']['backend']
if backend == 'localmongodb':
data = obj.get(key, {})
if isinstance(data, dict):
validate_all_keys_in_obj(obj_name, data, validation_fun)
elif isinstance(data, list):
validate_all_items_in_list(obj_name, data, validation_fun)
def validate_all_items_in_list(obj_name, data, validation_fun):
for item in data:
if isinstance(item, dict):
validate_all_keys_in_obj(obj_name, item, validation_fun)
elif isinstance(item, list):
validate_all_items_in_list(obj_name, item, validation_fun)
def validate_all_keys_in_obj(obj_name, obj, validation_fun):
"""Validate all (nested) keys in `obj` by using `validation_fun`.
Args:
obj_name (str): name for `obj` being validated.
obj (dict): dictionary object.
validation_fun (function): function used to validate the value
of `key`.
Returns:
None: indicates validation successful
Raises:
ValidationError: `validation_fun` will raise this error on failure
"""
for key, value in obj.items():
validation_fun(obj_name, key)
if isinstance(value, dict):
validate_all_keys_in_obj(obj_name, value, validation_fun)
elif isinstance(value, list):
validate_all_items_in_list(obj_name, value, validation_fun)
def validate_all_values_for_key_in_obj(obj, key, validation_fun):
"""Validate value for all (nested) occurrence of `key` in `obj`
using `validation_fun`.
Args:
obj (dict): dictionary object.
key (str): key whose value is to be validated.
validation_fun (function): function used to validate the value
of `key`.
Raises:
ValidationError: `validation_fun` will raise this error on failure
"""
for vkey, value in obj.items():
if vkey == key:
validation_fun(value)
elif isinstance(value, dict):
validate_all_values_for_key_in_obj(value, key, validation_fun)
elif isinstance(value, list):
validate_all_values_for_key_in_list(value, key, validation_fun)
def validate_all_values_for_key_in_list(input_list, key, validation_fun):
for item in input_list:
if isinstance(item, dict):
validate_all_values_for_key_in_obj(item, key, validation_fun)
elif isinstance(item, list):
validate_all_values_for_key_in_list(item, key, validation_fun)
def validate_key(obj_name, key):
"""Check if `key` contains ".", "$" or null characters.
https://docs.mongodb.com/manual/reference/limits/#Restrictions-on-Field-Names
Args:
obj_name (str): object name to use when raising exception
key (str): key to validated
Returns:
None: validation successful
Raises:
ValidationError: will raise exception in case of regex match.
"""
if re.search(r'^[$]|\.|\x00', key):
error_str = ('Invalid key name "{}" in {} object. The '
'key name cannot contain characters '
'".", "$" or null characters').format(key, obj_name)
raise ValidationError(error_str) | /saiive.chain-2.3.1.0-py3-none-any.whl/bigchaindb/common/utils.py | 0.852813 | 0.451931 | utils.py | pypi |
import logging
import torch
import os
import pickle as pkl
from torch import Tensor
from typing import Dict, Any
log = logging.getLogger(__name__)
class Checkpointer(object):
"""Checkpoint object to save and restore attributes."""
def __init__(self, toolset: Dict) -> None:
"""
Initialize.
Args:
toolset: Dictionary with parameter for the mixin
Returns:
None
"""
self.toolset = toolset
def _save_elementwise_attribute(
self, detector: Any, attribute: str, attribute_dict: Dict
) -> Dict:
"""
Private method to save attributes element wise.
Args:
detector: Instance of novelty detector
attribute: Name of the detector attribute that needs to be saved
attribute dict: A dictonary containing attribute value for other tests
Returns:
Update attribute dictionary
"""
attribute_val = getattr(detector, attribute)
test_id = self.toolset["test_id"]
if isinstance(attribute_val, dict):
if test_id in attribute_dict:
attribute_dict[test_id].update(attribute_val)
else:
attribute_dict[test_id] = attribute_val
elif isinstance(attribute_val, list):
if test_id in attribute_dict:
attribute_dict[test_id].extend(attribute_val)
else:
attribute_dict[test_id] = attribute_val
elif isinstance(attribute_val, tuple):
if test_id in attribute_dict:
old_attr_val = list(attribute_dict[test_id])
old_attr_val.extend(list(attribute_val))
attribute_dict[test_id] = tuple(old_attr_val)
else:
attribute_dict[test_id] = attribute_val
elif isinstance(attribute_val, Tensor):
if test_id in attribute_dict:
attribute_dict[test_id] = torch.cat(
[attribute_dict[test_id], attribute_val]
)
else:
attribute_dict[test_id] = attribute_val
else:
log.info(
"Treating attribute value as a single element rather than an iterable"
)
attribute_dict[test_id] = attribute_val
return attribute_dict
def save_attributes(self, step_descriptor: str) -> None:
"""
Save attribute for a detector.
Args:
step_descriptor: String describing steps for protocol
Returns
None
"""
if step_descriptor in self.toolset["saved_attributes"]:
attributes = self.toolset["saved_attributes"][step_descriptor]
else:
attributes = []
save_elementwise = self.toolset["save_elementwise"]
attribute_dict = self.toolset["attributes"]
self.detector: Any
if len(attributes) > 0:
for attribute in attributes:
if hasattr(self.detector, attribute) and save_elementwise:
if attribute not in attribute_dict:
attribute_dict[attribute] = {}
attribute_dict[attribute] = self._save_elementwise_attribute(
self.detector, attribute, attribute_dict[attribute]
)
elif hasattr(self.detector, attribute) and not save_elementwise:
raise NotImplementedError(
"Saving attributes for an entire round is not supported"
)
else:
log.warn(f"Detector does not have {attribute} attribute")
else:
log.info(f"No attributes found for {step_descriptor}")
self.toolset["attributes"] = attribute_dict
def _restore_elementwise_attribute(
self, detector: Any, attribute_name: str, attribute_val: Dict
) -> Any:
"""
Private method to restore attributes element wise.
Args:
detector: Instance of novelty detector
attribute_name: Name of the detector attribute that needs to be saved
attribute_val: A dictonary containing value for attributes
Returns
Detector with updated value for attributes
"""
dataset_ids = list(
map(lambda x: x.strip(), open(self.toolset["dataset"], "r").readlines())
)
round_id = self.toolset["round_id"]
round_len = len(dataset_ids)
if isinstance(attribute_val, dict):
round_attribute_val = {}
for dataset_id in dataset_ids:
round_attribute_val[dataset_id] = attribute_val[dataset_id]
elif (
isinstance(attribute_val, list)
or isinstance(attribute_val, tuple)
or isinstance(attribute_val, Tensor)
):
round_attribute_val = attribute_val[
round_id * round_len : (round_id + 1) * round_len
]
else:
log.info(
"Treating attribute value as a single element rather than an iterable."
)
round_attribute_val = attribute_val
setattr(detector, attribute_name, round_attribute_val)
return detector
def restore_attributes(self, step_descriptor: str) -> None:
"""
Restore attribute for a detector.
Args:
step_descriptor: String describing steps for protocol
Returns:
None
"""
if (
self.toolset["use_saved_attributes"]
and step_descriptor in self.toolset["saved_attributes"]
):
attributes = self.toolset["saved_attributes"][step_descriptor]
save_elementwise = self.toolset["save_elementwise"]
save_dir = self.toolset["save_dir"]
test_id = self.toolset["test_id"]
if os.path.isdir(save_dir):
attribute_file = os.path.join(save_dir, f"{test_id}_attribute.pkl")
attribute_val = pkl.load(open(attribute_file, "rb"))
else:
attribute_val = pkl.load(open(save_dir, "rb"))
for attribute in attributes:
if save_elementwise:
self.detector = self._restore_elementwise_attribute(
self.detector, attribute, attribute_val[attribute][test_id]
)
else:
raise NotImplementedError(
"Restoring attributes for an entire round is not supported."
)
else:
log.info(f"No attributes found for {step_descriptor}.") | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/checkpointer.py | 0.902692 | 0.151843 | checkpointer.py | pypi |
from sail_on_client.harness.local_harness import LocalHarness
from sail_on_client.harness.par_harness import ParHarness
from sail_on_client.feedback.feedback import Feedback
from typing import Union, Optional, Dict
import pandas as pd
SUPPORTED_FEEDBACK = [
"labels",
"classification",
"score",
"detection",
"detection_and_classification",
]
class ActivityRecognitionFeedback(Feedback):
"""Feedback for activity recognition."""
def __init__(
self,
first_budget: int,
income_per_batch: int,
maximum_budget: int,
interface: Union[LocalHarness, ParHarness],
session_id: str,
test_id: str,
feedback_type: str,
) -> None:
"""
Initialize activity recognition feedback object.
Args:
first_budget: Initial budget
income_per_batch: Additional labels added after every batch
maximum_budget: Max labels that can be requested
interface: An instance of evaluation interface
session_id: Session identifier
test_id: Test identifier
feedback_type: Type of feedback that can be requested
Returns:
None
"""
if feedback_type not in SUPPORTED_FEEDBACK:
raise ValueError(f"Unsupported feedback_type {feedback_type}")
super(ActivityRecognitionFeedback, self).__init__(
first_budget,
income_per_batch,
maximum_budget,
interface,
session_id,
test_id,
feedback_type,
)
self.current_round: int = -1
self.budget: int = first_budget
def get_classification_feedback(
self, round_id: int, images_id_list: list, image_names: list
) -> Union[pd.DataFrame, None]:
"""
Get labeled feedback for the round.
Args:
round_id: Round identifier
image_id_list: List if indices for images
image_names: List of image names for the round
Return:
A dictionary with the accuracy value or None if
feedback is requested for an older round
"""
if round_id > self.current_round:
self.deposit_income()
self.current_round = round_id
if len(images_id_list) <= self.budget:
self.budget = self.budget - len(images_id_list)
image_ids = [image_names[int(idx)] for idx in images_id_list]
feedback_file = self.interface.get_feedback_request(
image_ids,
self.feedback_type,
self.test_id,
round_id,
self.session_id,
)
df = pd.read_csv(
feedback_file,
delimiter=",",
header=None,
names=["id", "class1", "class2", "class3", "class4", "class5"],
)
else:
raise ValueError("the function should be added")
else:
df = None
return df
def get_detection_feedback(
self, round_id: int, images_id_list: list, image_names: list
) -> Optional[pd.DataFrame]:
"""
Get detection feedback for the round.
Args:
round_id: Round identifier
image_id_list: List of indices for images
image_names: List of image names for the round
Return:
A dataframe with id and novelty detection value as columns
"""
if round_id > self.current_round:
self.deposit_income()
self.current_round = round_id
if len(images_id_list) <= self.budget:
self.budget = self.budget - len(images_id_list)
image_ids = [image_names[int(idx)] for idx in images_id_list]
feedback_file = self.interface.get_feedback_request(
image_ids,
self.feedback_type,
self.test_id,
round_id,
self.session_id,
)
df = pd.read_csv(
feedback_file,
delimiter=",",
header=None,
names=["id", "detection"],
)
else:
raise ValueError("Requesting over budget")
else:
df = None
return df
def get_detection_and_classification_feedback(
self, round_id: int, images_id_list: list, image_names: list
) -> Optional[pd.DataFrame]:
"""
Get detection and classification feedback for the round.
Args:
round_id: Round identifier
image_id_list: List of indices for images
image_names: List of image names for the round
Return:
A dataframe with id and novelty detection value as columns
"""
if round_id > self.current_round:
self.deposit_income()
self.current_round = round_id
if len(images_id_list) <= self.budget:
self.budget = self.budget - len(images_id_list)
image_ids = [image_names[int(idx)] for idx in images_id_list]
detection_feedback_file = self.interface.get_feedback_request(
image_ids,
"detection",
self.test_id,
round_id,
self.session_id,
)
detection_df = pd.read_csv(
detection_feedback_file,
delimiter=",",
header=None,
names=["id", "detection"],
)
classification_feedback_file = self.interface.get_feedback_request(
image_ids,
"classification",
self.test_id,
round_id,
self.session_id,
)
classification_df = pd.read_csv(
classification_feedback_file,
delimiter=",",
header=None,
names=["id", "class1", "class2", "class3", "class4", "class5"],
)
df = pd.merge(detection_df, classification_df, on="id")
else:
raise ValueError("Requesting over budget")
else:
df = None
return df
def get_feedback(
self, round_id: int, images_id_list: list, image_names: list
) -> Union[pd.DataFrame, Dict, None]:
"""
Get feedback for the round.
Args:
round_id: Round identifier
image_id_list: List if indices for images
image_names: List of image names for the round
Return:
Either a dataframe or dictionary with score if the request is valid
for the current round.
"""
if self.feedback_type == "classification":
return self.get_classification_feedback(
round_id, images_id_list, image_names
)
elif self.feedback_type == "labels":
return self.get_labeled_feedback(round_id, images_id_list, image_names)
elif self.feedback_type == "score":
return super().get_feedback(round_id, images_id_list, image_names)
elif self.feedback_type == "detection":
return self.get_detection_feedback(round_id, images_id_list, image_names)
elif self.feedback_type == "detection_and_classification":
return self.get_detection_and_classification_feedback(
round_id, images_id_list, image_names
)
else:
raise ValueError("Unsupported feedback type {self.feedback_type} specified") | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/feedback/activity_recognition_feedback.py | 0.904776 | 0.251343 | activity_recognition_feedback.py | pypi |
import pandas as pd
from sail_on_client.harness.par_harness import ParHarness
from sail_on_client.harness.local_harness import LocalHarness
from typing import Union, Dict
class Feedback:
"""Base class for Feedback."""
def __init__(
self,
first_budget: int,
income_per_batch: int,
maximum_budget: int,
interface: Union[LocalHarness, ParHarness],
session_id: str,
test_id: str,
feedback_type: str,
) -> None:
"""
Initialize.
Args:
first_budget: Initial budget
income_per_batch: Additional labels added after every batch
maximum_budget: Max labels that can be requested
interface: An instance of evaluation interface
session_id: Session identifier
test_id: Test identifier
feedback_type: Type of feedback that can be requested
Returns:
None
"""
self.budget = first_budget
self.income_per_batch = income_per_batch
self.maximum_budget = maximum_budget
self.current_round = -1
self.interface = interface
self.session_id = session_id
self.test_id = test_id
self.feedback_type = feedback_type
def get_labeled_feedback(
self, round_id: int, images_id_list: list, image_names: list
) -> Union[pd.DataFrame, None]:
"""
Get labeled feedback for the round.
Args:
round_id: Round identifier
image_id_list: List if indices for images
image_names: List of image names for the round
Return:
A dictionary with the accuracy value or None if
feedback is requested for an older round
"""
if round_id > self.current_round:
self.deposit_income()
self.current_round = round_id
if len(images_id_list) <= self.budget:
self.budget = self.budget - len(images_id_list)
image_ids = [image_names[int(idx)] for idx in images_id_list]
feedback_file = self.interface.get_feedback_request(
image_ids,
self.feedback_type,
self.test_id,
round_id,
self.session_id,
)
df = pd.read_csv(
feedback_file, delimiter=",", header=None, names=["id", "labels"]
)
else:
raise ValueError("the function should be added")
else:
df = None
return df
def get_score_feedback(
self, round_id: int, images_id_list: list, image_names: list
) -> Union[Dict, None]:
"""
Get accuracy value for the round. Note: this is not budgeted.
Args:
round_id: Round identifier
image_id_list: List if indices for images
image_names: List of image names for the round
Return:
A dictionary with the accuracy value or None if
feedback is requested for an older round
"""
if round_id > self.current_round:
self.deposit_income()
self.current_round = round_id
image_ids = [image_names[int(idx)] for idx in images_id_list]
feedback_file = self.interface.get_feedback_request(
image_ids,
self.feedback_type,
self.test_id,
round_id,
self.session_id,
)
df = pd.read_csv(feedback_file, delimiter=",", header=None)
return df
else:
return None
def get_feedback(
self, round_id: int, images_id_list: list, image_names: list
) -> Union[pd.DataFrame, Dict, None]:
"""
Get feedback for the round.
Args:
round_id: Round identifier
image_id_list: List if indices for images
image_names: List of image names for the round
Return:
Either a dataframe or dictionary with score if the request is valid
for the current round.
"""
if self.feedback_type == "classification":
feedback_fn = self.get_labeled_feedback
elif self.feedback_type == "score":
feedback_fn = self.get_score_feedback
else:
raise ValueError("Unsupported feedback type {self.feedback_type} specified")
return feedback_fn(round_id, images_id_list, image_names)
def deposit_income(self) -> None:
"""Get income for a round."""
self.budget = min(self.maximum_budget, (self.budget + self.income_per_batch))
def get_budget(self) -> int:
"""Get current budget."""
return self.budget | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/feedback/feedback.py | 0.933355 | 0.222204 | feedback.py | pypi |
import pandas as pd
from sail_on_client.harness.local_harness import LocalHarness
from sail_on_client.harness.par_harness import ParHarness
from sail_on_client.feedback.feedback import Feedback
from typing import Union, Dict
SUPPORTED_FEEDBACK = ["classification", "score", "transcription"]
class DocumentTranscriptionFeedback(Feedback):
"""Feedback for document transcription."""
def __init__(
self,
first_budget: int,
income_per_batch: int,
maximum_budget: int,
interface: Union[LocalHarness, ParHarness],
session_id: str,
test_id: str,
feedback_type: str,
) -> None:
"""
Initialize document transcription feedback object.
Args:
first_budget: Initial budget
income_per_batch: Additional labels added after every batch
maximum_budget: Max labels that can be requested
interface: An instance of evaluation interface
session_id: Session identifier
test_id: Test identifier
feedback_type: Type of feedback that can be requested
Returns:
None
"""
if feedback_type not in SUPPORTED_FEEDBACK:
raise ValueError(f"Unsupported feedback_type {feedback_type}")
super(DocumentTranscriptionFeedback, self).__init__(
first_budget,
income_per_batch,
maximum_budget,
interface,
session_id,
test_id,
feedback_type,
)
self.current_round: int = -1
self.budget: int = first_budget
def get_levenshtein_feedback(
self, round_id: int, images_id_list: list, image_names: list
) -> Union[Dict, None]:
"""
Get levenshtein feedback for the round.
Args:
round_id: Round identifier
image_id_list: List if indices for images
image_names: List of image names for the round
Return:
A dictionary containing levenshtein score or None if
feedback is requested for an older round
"""
if round_id > self.current_round:
self.deposit_income()
self.current_round = round_id
if len(images_id_list) <= self.budget:
self.budget = self.budget - len(images_id_list)
image_ids = [image_names[int(idx)] for idx in images_id_list]
feedback_file = self.interface.get_feedback_request(
image_ids,
self.feedback_type,
self.test_id,
round_id,
self.session_id,
)
df = pd.read_csv(feedback_file, delimiter=",", header=None)
return df
else:
raise ValueError("the function should be added")
else:
return None
def get_feedback(
self, round_id: int, images_id_list: list, image_names: list
) -> Union[pd.DataFrame, Dict, None]:
"""
Get feedback for the round.
Args:
round_id: Round identifier
image_id_list: List if indices for images
image_names: List of image names for the round
Return:
Either a dataframe or dictionary with score if the request is valid
for the current round.
"""
if self.feedback_type == "classification":
feedback_fn = self.get_labeled_feedback
elif self.feedback_type == "score":
feedback_fn = self.get_score_feedback
elif self.feedback_type == "transcription":
feedback_fn = self.get_levenshtein_feedback
else:
raise ValueError("Unsupported feedback type {self.feedback_type} specified")
return feedback_fn(round_id, images_id_list, image_names) | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/feedback/document_transcription_feedback.py | 0.931408 | 0.189296 | document_transcription_feedback.py | pypi |
import warnings
import numpy as np
from sail_on_client.evaluate.utils import (
check_novel_validity,
check_class_validity,
get_first_detect_novelty,
top1_accuracy,
top3_accuracy,
get_rolling_stats,
topk_accuracy,
)
from typing import Dict
DETECT_THRESH_ = [0.175, 0.225, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
def _get_threshold(p_novel: np.ndarray) -> np.ndarray:
return np.min(p_novel) + ((np.max(p_novel) - np.min(p_novel)) / 2.0)
def m_num(p_novel: np.ndarray, gt_novel: np.ndarray) -> Dict:
"""
Program Metric: Number of samples needed for detecting novelty.
The method computes number of GT novel samples needed to predict the first true positive.
Args:
p_novel: NX1 vector with each element corresponding to probability of novelty
gt_novel: NX1 vector with each element 0 (not novel) or 1 (novel)
Returns:
single scalar for number of GT novel samples
"""
res = {}
check_novel_validity(p_novel, gt_novel)
if np.sum(gt_novel) < 1:
for thresh in DETECT_THRESH_:
res[f"{thresh}"] = -1
else:
for thresh in DETECT_THRESH_:
res[f"{thresh}"] = ((p_novel[gt_novel == 1] >= thresh).argmax(axis=0)) + 1
return res
def m_num_stats(p_novel: np.ndarray, gt_novel: np.ndarray) -> Dict:
"""
Program Metric: Number of samples needed for detecting novelty.
The method computes number of GT novel samples needed to predict the first true positive.
Args:
p_novel: NX1 vector with each element corresponding to probability of novelty
gt_novel: NX1 vector with each element 0 (not novel) or 1 (novel)
Returns:
single scalar for number of GT novel samples
"""
check_novel_validity(p_novel, gt_novel)
res = {}
if np.sum(gt_novel) < 1:
# only print warning first time.
first_novel_indx = len(gt_novel) + 1
else:
first_novel_indx = np.where(gt_novel == 1)[0][0] + 1
res["GT_indx"] = first_novel_indx
for thresh in DETECT_THRESH_:
res[f"P_indx_{thresh}"] = get_first_detect_novelty(p_novel, thresh)
return res
def m_ndp(p_novel: np.ndarray, gt_novel: np.ndarray, mode: str = "full_test") -> Dict:
"""
Program Metric: Novelty detection performance.
The method computes per-sample novelty detection performance
Args:
p_novel: NX1 vector with each element corresponding to probability of it being novel
gt_novel: NX1 vector with each element 0 (not novel) or 1 (novel)
mode: if 'full_test' computes on all test samples, if 'post_novelty' computes from first GT novel sample
Returns:
Dictionary of various metrics: Accuracy, Precision, Recall, F1_score and Confusion matrix
"""
check_novel_validity(p_novel, gt_novel)
if mode not in ["full_test", "pre_novelty", "post_novelty"]:
raise Exception(
"Mode should be one of ['full_test','pre_novelty', 'post_novelty']"
)
def get_all_scores_ndp(thresh: float) -> Dict:
preds: np.ndarray = p_novel > thresh
gt_novel_ = gt_novel
if mode == "post_novelty":
if any(gt_novel != 0):
post_novel_idx = (gt_novel != 0).argmax(axis=0)
preds = preds[post_novel_idx:]
gt_novel_ = gt_novel[post_novel_idx:]
else:
return {
f"accuracy_{thresh}": -1,
f"precision_{thresh}": -1,
f"recall_{thresh}": -1,
f"f1_score_{thresh}": -1,
f"TP_{thresh}": -1,
f"FP_{thresh}": -1,
f"TN_{thresh}": -1,
f"FN_{thresh}": -1,
}
elif mode == "pre_novelty":
if any(gt_novel != 0) and not all(gt_novel != 0):
post_novel_idx = (gt_novel != 0).argmax(axis=0)
preds = preds[:post_novel_idx]
gt_novel_ = gt_novel[:post_novel_idx]
tp = np.sum(np.logical_and(preds == 1, gt_novel_ == 1))
fp = np.sum(np.logical_and(preds == 1, gt_novel_ == 0))
tn = np.sum(np.logical_and(preds == 0, gt_novel_ == 0))
fn = np.sum(np.logical_and(preds == 0, gt_novel_ == 1))
acc = (tp + tn) / (tp + tn + fp + fn)
if tp + fp == 0.0:
precision = 0.0
else:
precision = tp / (tp + fp)
if tp + fn == 0.0:
recall = 0.0
else:
recall = tp / (tp + fn)
if precision == 0.0 and recall == 0.0:
f1_score = 0.0
else:
f1_score = 2 * precision * recall / (precision + recall)
return {
f"accuracy_{thresh}": round(acc, 5),
f"precision_{thresh}": round(precision, 5),
f"recall_{thresh}": round(recall, 5),
f"f1_score_{thresh}": round(f1_score, 5),
f"TP_{thresh}": tp,
f"FP_{thresh}": fp,
f"TN_{thresh}": tn,
f"FN_{thresh}": fn,
}
res = {}
for thresh in DETECT_THRESH_:
res.update(get_all_scores_ndp(thresh))
return res
def m_acc(
gt_novel: np.ndarray,
p_class: np.ndarray,
gt_class: np.ndarray,
round_size: int,
asymptotic_start_round: int,
) -> Dict:
"""
Compute top1 and top3 accuracy.
Args:
p_novel: NX1 vector with each element corresponding to probability of novelty
p_class : Nx(K+1) matrix with each row corresponding to K+1 class probabilities for each sample
gt_class : Nx1 vector with ground-truth class for each sample
round_size: Number of samples in a single round of the test
asymptotic_start_round: Round id where metric computation starts
Returns:
Dictionary with results
"""
# full test
batch_size = round_size
results = {}
try:
results["full_top1"] = top1_accuracy(p_class, gt_class, txt="full_top1")
results["full_top3"] = top3_accuracy(p_class, gt_class, txt="full_top3")
# red button push:
if np.sum(gt_novel) < 1:
# only print warning first time.
first_novel_indx = len(gt_novel) + 1
else:
first_novel_indx = np.where(gt_novel == 1)[0][0] + 1
if first_novel_indx == len(gt_novel) + 1:
results["pre_top1"] = top1_accuracy(p_class, gt_class, txt="pre_top1")
results["pre_top3"] = top3_accuracy(p_class, gt_class, txt="pre_top3")
results["post_top1"] = -1
results["post_top3"] = -1
results["post_mean_top1"] = -1
results["post_mean_top3"] = -1
results["post_std_top1"] = -1
results["post_std_top3"] = -1
else:
# pre_novelty
if first_novel_indx == 0:
results["pre_top1"] = -1
results["pre_top3"] = -1
results["pre_mean_top1"] = -1
results["pre_mean_top3"] = -1
results["pre_std_top1"] = -1
results["pre_std_top3"] = -1
else:
p_class_pre = p_class[:first_novel_indx]
gt_class_pre = gt_class[:first_novel_indx]
results["pre_top1"] = top1_accuracy(
p_class_pre, gt_class_pre, txt="pre_top1"
)
results["pre_top3"] = top3_accuracy(
p_class_pre, gt_class_pre, txt="pre_top3"
)
[results["pre_mean_top1"], results["pre_std_top1"]] = get_rolling_stats(
p_class_pre, gt_class_pre, k=1, window_size=batch_size
)
[results["pre_mean_top3"], results["pre_std_top3"]] = get_rolling_stats(
p_class_pre, gt_class_pre, k=3, window_size=batch_size
)
# post_novelty
p_class_post = p_class[first_novel_indx:]
gt_class_post = gt_class[first_novel_indx:]
results["post_top1"] = top1_accuracy(
p_class_post, gt_class_post, txt="post_top1"
)
results["post_top3"] = top3_accuracy(
p_class_post, gt_class_post, txt="post_top3"
)
[results["post_mean_top1"], results["post_std_top1"]] = get_rolling_stats(
p_class_post, gt_class_post, k=1, window_size=batch_size
)
[results["post_mean_top3"], results["post_std_top3"]] = get_rolling_stats(
p_class_post, gt_class_post, k=3, window_size=batch_size
)
# asymptotic performance
for last_i in np.arange(
int(asymptotic_start_round) * batch_size, gt_novel.shape[0], round_size
):
if len(gt_novel) > last_i:
p_class_asym = p_class[-last_i:]
gt_class_asym = gt_class[-last_i:]
results[f"asymptotic_{last_i}_top1"] = top1_accuracy(
p_class_asym, gt_class_asym, txt=f"asymptotic_{last_i}_top1"
)
results[f"asymptotic_{last_i}_top3"] = top3_accuracy(
p_class_asym, gt_class_asym, txt=f"asymptotic_{last_i}_top3"
)
[
results[f"asymptotic_{last_i}_mean_top1"],
results[f"asymptotic_{last_i}_std_top1"],
] = get_rolling_stats(
p_class_asym, gt_class_asym, k=1, window_size=batch_size
)
[
results[f"asymptotic_{last_i}_mean_top3"],
results[f"asymptotic_{last_i}_std_top3"],
] = get_rolling_stats(
p_class_asym, gt_class_asym, k=3, window_size=batch_size
)
else:
results[f"asymptotic_{last_i}_top1"] = -1
results[f"asymptotic_{last_i}_top3"] = -1
results[f"asymptotic_{last_i}_mean_top1"] = -1
results[f"asymptotic_{last_i}_mean_top3"] = -1
results[f"asymptotic_{last_i}_std_top1"] = -1
results[f"asymptotic_{last_i}_std_top3"] = -1
except Exception:
import code
import traceback as tb
tb.print_stack()
namespace = globals().copy()
namespace.update(locals())
code.interact(local=namespace)
return results
def m_ndp_pre(p_novel: np.ndarray, gt_novel: np.ndarray) -> Dict:
"""
Additional Metric: Novelty detection performance before novelty is introduced.
Args:
p_novel: NX1 vector with each element corresponding to probability of novelty
gt_novel: NX1 vector with each element 0 (not novel) or 1 (novel)
Returns:
Dictionary of following metrics values: Accuracy, Precision, Recall, F1_score and Confusion matrix
"""
return m_ndp(p_novel, gt_novel, mode="pre_novelty")
def m_ndp_post(p_novel: np.ndarray, gt_novel: np.ndarray) -> Dict:
"""
Additional Metric: Novelty detection performance after novelty is introduced.
Args:
p_novel: NX1 vector with each element corresponding to probability of novelty
gt_novel: NX1 vector with each element 0 (not novel) or 1 (novel)
Returns:
Dictionary of following metrics values: Accuracy, Precision, Recall, F1_score and Confusion matrix
"""
return m_ndp(p_novel, gt_novel, mode="post_novelty")
def m_ndp_failed_reaction(
p_novel: np.ndarray,
gt_novel: np.ndarray,
p_class: np.ndarray,
gt_class: np.ndarray,
mode: str = "full_test",
) -> Dict:
"""
Additional Metric: Novelty detection when reaction fails.
The method computes novelty detection performance for only on samples with incorrect k-class predictions
Args:
p_novel: NX1 vector with each element corresponding to probability of novelty
gt_novel: NX1 vector with each element 0 (not novel) or 1 (novel)
p_class : Nx(K+1) matrix with each row corresponding to K+1 class probabilities for each sample
gt_class : Nx1 vector with ground-truth class for each sample
mode: if 'full_test' computes on all test samples, if 'post_novelty' computes from the first GT novel sample
k: 'k' used in top-K accuracy
Returns:
Dictionary of various metrics: Accuracy, Precision, Recall, F1_score and Confusion matrix
"""
check_class_validity(p_class, gt_class)
results = {}
for k in [1, 3]:
p_class_k = np.argsort(-p_class, axis=1)[:, :k]
gt_class_k = gt_class[:, np.newaxis]
check_zero = p_class_k - gt_class_k
incorrect_mask = ~np.any(check_zero == 0, axis=1)
if np.sum(incorrect_mask) == 0:
warnings.warn(
"WARNING! No incorrect predictions found. Returning empty dictionary"
)
for metric in {
"accuracy",
"precision",
"recall",
"f1_score",
"FN",
"TP",
"FP",
"TN",
}:
results[f"top{k}_{metric}"] = -1
continue
p_novel_k = p_novel[incorrect_mask]
gt_novel_k = gt_novel[incorrect_mask]
res = m_ndp(p_novel_k, gt_novel_k, mode)
for metric in res:
results[f"top{k}_{metric}"] = res[metric]
return results
def m_accuracy_on_novel(
p_class: np.ndarray, gt_class: np.ndarray, gt_novel: np.ndarray
) -> Dict:
"""
Additional Metric: Novelty robustness.
The method computes top-K accuracy for only the novel samples
Args:
p_class : Nx(K+1) matrix with each row corresponding to K+1 class probabilities for each sample
gt_class : Nx1 vector with ground-truth class for each sample
gt_novel : Nx1 binary vector corresponding to the ground truth novel{1}/seen{0} labels
k : K value to compute accuracy at
Returns:
Accuracy at rank-k
"""
check_class_validity(p_class, gt_class)
if np.sum(gt_novel) < 1:
return {"top3_acc_novel_only": -1, "top1_acc_novel_only": -1}
p_class = p_class[gt_novel == 1]
gt_class = gt_class[gt_novel == 1]
return {
"top3_acc_novel_only": topk_accuracy(p_class, gt_class, k=3),
"top1_acc_novel_only": topk_accuracy(p_class, gt_class, k=1),
} | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/evaluate/metrics.py | 0.861188 | 0.444083 | metrics.py | pypi |
from sail_on_client.evaluate.program_metrics import ProgramMetrics
from sail_on_client.evaluate.metrics import m_acc, m_num, m_ndp, m_num_stats
from sail_on_client.evaluate.metrics import m_ndp_failed_reaction
from sail_on_client.evaluate.metrics import m_accuracy_on_novel
from sail_on_client.evaluate.utils import topk_accuracy
import numpy as np
from pandas import DataFrame
from typing import Dict
class DocumentTranscriptionMetrics(ProgramMetrics):
"""Document transcription program metric class."""
def __init__(
self,
protocol: str,
image_id: int,
text: int,
novel: int,
representation: int,
detection: int,
classification: int,
pen_pressure: int,
letter_size: int,
word_spacing: int,
slant_angle: int,
attribute: int,
) -> None:
"""
Initialize.
Args:
protocol: Name of the protocol.
image_id: Column id for image
text: Transcription associated with the image
novel: Column id for predicting if change was detected
representation: Column id with representation novelty label
detection: Column id with sample wise novelty
classification: Column id with writer id
pen_pressure: Column id with pen pressure values
letter_size: Column id with letter size values
word_spacing: Column id with word spacing values
slant_angle: Column id with slant angle values
attribute: Column id with attribute level novelty label
Returns:
None
"""
super().__init__(protocol)
self.image_id = image_id
self.text_id = text
self.novel_id = novel
self.representation_id = representation
self.detection_id = detection
self.classification_id = classification
self.pen_pressure_id = pen_pressure
self.letter_size_id = letter_size
self.word_spacing_id = word_spacing
self.slant_angle_id = slant_angle
self.attribute_id = attribute
def m_acc(
self,
gt_novel: DataFrame,
p_class: DataFrame,
gt_class: DataFrame,
round_size: int,
asymptotic_start_round: int,
) -> Dict:
"""
m_acc helper function used for computing novelty reaction performance.
Args:
gt_novel: ground truth detections (Dimension: [img X detection])
p_class: class predictions (Dimension: [img X prob that sample is novel, prob of known classes])
gt_class: ground truth classes (Dimension: [img X class idx])
round_size: size of the round
asymptotic_start_round: asymptotic samples considered for computing metrics
Returns:
Dictionary containing top1, top3 accuracy over the test, pre and post novelty.
"""
class_prob = p_class.iloc[:, range(1, p_class.shape[1])].to_numpy()
gt_class_idx = gt_class.to_numpy()
return m_acc(
gt_novel, class_prob, gt_class_idx, round_size, asymptotic_start_round
)
def m_acc_round_wise(
self, p_class: DataFrame, gt_class: DataFrame, round_id: int
) -> Dict:
"""
m_acc_round_wise function.
Args:
p_class: class predictions
gt_class: ground truth classes
round_id: round identifier
Returns:
Dictionary containing top1, top3 accuracy for a round
"""
class_prob = p_class.iloc[:, range(1, p_class.shape[1])].to_numpy()
gt_class_idx = gt_class.to_numpy()
top1_acc = topk_accuracy(class_prob, gt_class_idx, k=1)
top3_acc = topk_accuracy(class_prob, gt_class_idx, k=3)
return {
f"top1_accuracy_round_{round_id}": top1_acc,
f"top3_accuracy_round_{round_id}": top3_acc,
}
def m_num(self, p_novel: DataFrame, gt_novel: DataFrame) -> Dict:
"""
m_num function.
A Program Metric where the number of samples needed for detecting novelty.
The method computes the number of GT novel samples needed to predict the
first true positive.
Args:
p_novel: detection predictions (Dimension: [img X novel])
gt_novel: ground truth detections (Dimension: [img X detection])
Returns:
Difference between the novelty introduction and predicting change in world.
"""
return m_num(p_novel, gt_novel)
def m_num_stats(self, p_novel: np.ndarray, gt_novel: np.ndarray) -> Dict:
"""
m_num_stats function.
Number of samples needed for detecting novelty. The method computes
number of GT novel samples needed to predict the first true positive.
Args:
p_novel: detection predictions (Dimension: [img X novel])
gt_novel: ground truth detections (Dimension: [img X detection])
Returns:
Dictionary containing indices for novelty introduction and change in world prediction.
"""
return m_num_stats(p_novel, gt_novel)
def m_ndp(self, p_novel: np.ndarray, gt_novel: np.ndarray) -> Dict:
"""
m_ndp function.
Novelty detection performance. The method computes per-sample novelty
detection performance over the entire test.
Args:
p_novel: detection predictions (Dimension: [img X novel])
gt_novel: ground truth detections (Dimension: [img X detection])
Returns:
Dictionary containing novelty detection performance over the test.
"""
return m_ndp(p_novel, gt_novel)
def m_ndp_pre(self, p_novel: np.ndarray, gt_novel: np.ndarray) -> Dict:
"""
m_ndp_pre function.
See :func:`~sail-on-client.evaluate.transcription.DocumentTranscriptionMetrics.m_ndp`
with post_novelty. This computes to the first GT novel sample. It really isn't useful
and is just added for completion. Should always be 0 since no possible TP.
Args:
p_novel: detection predictions (Dimension: [img X novel])
gt_novel: ground truth detections (Dimension: [img X detection])
Returns:
Dictionary containing detection performance pre novelty.
"""
return m_ndp(p_novel, gt_novel, mode="pre_novelty")
def m_ndp_post(self, p_novel: np.ndarray, gt_novel: np.ndarray) -> Dict:
"""
m_ndp_post function.
See :func:`~sail-on-client.evaluate.transcription.DocumentTranscriptionMetrics.m_ndp`
with post_novelty. This computes from the first GT novel sample.
Args:
p_novel: detection predictions (Dimension: [img X novel])
gt_novel: ground truth detections (Dimension: [img X detection])
Returns:
Dictionary containing detection performance post novelty.
"""
return m_ndp(p_novel, gt_novel, mode="post_novelty")
def m_ndp_failed_reaction(
self,
p_novel: DataFrame,
gt_novel: DataFrame,
p_class: DataFrame,
gt_class: DataFrame,
) -> Dict:
"""
m_ndp_failed_reaction function.
Not Implemented since no gt_class info for novel samples. The method
computes novelty detection performance for only on samples with
incorrect k-class predictions
Args:
p_novel: detection predictions (Dimension: [img X novel])
gt_novel: ground truth detections (Dimension: [img X detection])
p_class: detection predictions (Dimension: [img X prob that sample is novel, prob of known classes])
gt_class: ground truth classes (Dimension: [img X class idx])
Returns:
Dictionary containing TP, FP, TN, FN, top1, top3 accuracy over the test.
"""
class_prob = p_class.iloc[:, range(1, p_class.shape[1])].to_numpy()
gt_class_idx = gt_class.to_numpy()
return m_ndp_failed_reaction(p_novel, gt_novel, class_prob, gt_class_idx)
def m_accuracy_on_novel(
self, p_class: DataFrame, gt_class: DataFrame, gt_novel: DataFrame
) -> Dict:
"""
Additional Metric: Novelty robustness.
Not Implemented since no gt_class info for novel samples. The method
computes top-K accuracy for only the novel samples
Args:
p_class: detection predictions (Dimension: [img X prob that sample is novel, prob of known classes])
gt_class: ground truth classes (Dimension: [img X class idx])
gt_novel: ground truth detections (Dimension: [img X detection])
Returns:
Accuracy on novely samples
"""
class_prob = p_class.iloc[:, range(1, p_class.shape[1])].to_numpy()
gt_class_idx = gt_class.to_numpy()
return m_accuracy_on_novel(class_prob, gt_class_idx, gt_novel)
def m_is_cdt_and_is_early(self, gt_idx: int, ta2_idx: int, test_len: int) -> Dict:
"""
Is change detection and is change detection early (m_is_cdt_and_is_early) function.
Args:
gt_idx: Index when novelty is introduced
ta2_idx: Index when change is detected
test_len: Length of test
Returns
Dictionary containing boolean showing if change was was detected and if it was detected early
"""
is_cdt = (ta2_idx >= gt_idx) & (ta2_idx < test_len)
is_early = ta2_idx < gt_idx
return {"Is CDT": is_cdt, "Is Early": is_early}
def m_nrp(self, ta2_acc: Dict, baseline_acc: Dict) -> Dict:
"""
m_nrp function.
Args:
ta2_acc: Accuracy scores for the agent
baseline_acc: Accuracy scores for baseline
Returns:
Reaction performance for the agent
"""
nrp = {}
nrp["M_nrp_post_top3"] = 100 * (ta2_acc["post_top3"] / baseline_acc["pre_top3"])
nrp["M_nrp_post_top1"] = 100 * (ta2_acc["post_top1"] / baseline_acc["pre_top1"])
return nrp | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/evaluate/document_transcription.py | 0.924849 | 0.445771 | document_transcription.py | pypi |
from sail_on_client.evaluate.program_metrics import ProgramMetrics
from sail_on_client.evaluate.metrics import m_acc, m_num, m_ndp, m_num_stats
from sail_on_client.evaluate.metrics import m_ndp_failed_reaction
from sail_on_client.evaluate.metrics import m_accuracy_on_novel
from sail_on_client.evaluate.utils import topk_accuracy
import numpy as np
from pandas import DataFrame
from typing import Dict
class ActivityRecognitionMetrics(ProgramMetrics):
"""Activity Recognition program metric class."""
def __init__(
self,
protocol: str,
video_id: int,
novel: int,
detection: int,
classification: int,
spatial: int,
temporal: int,
) -> None:
"""
Initialize.
Args:
protocol: Name of the protocol.
video_id: Column id for video
novel: Column id for predicting if change was detected
detection: Column id for predicting sample wise novelty
classification: Column id for predicting sample wise classes
spatial: Column id for predicting spatial attribute
temporal: Column id for predicting temporal attribute
Returns:
None
"""
super().__init__(protocol)
self.activity_id = video_id
self.novel_id = novel
self.detection_id = detection
self.classification_id = classification
self.spatial_id = spatial
self.temporal_id = temporal
def m_acc(
self,
gt_novel: DataFrame,
p_class: DataFrame,
gt_class: DataFrame,
round_size: int,
asymptotic_start_round: int,
) -> Dict:
"""
m_acc function.
Args:
gt_novel: ground truth detections for N videos (Dimension: N X 1)
p_class: class predictions with video id for N videos (Dimension: N X 90 [vid,novel_class,88 known class])
gt_class: ground truth classes for N videos (Dimension: N X 1)
round_size: size of the round
asymptotic_start_round: asymptotic samples considered for computing metrics
Returns:
Dictionary containing top1, top3 accuracy over the test, pre and post novelty.
"""
class_prob = p_class.iloc[:, range(1, p_class.shape[1])].to_numpy()
gt_class_idx = gt_class.to_numpy()
return m_acc(
gt_novel, class_prob, gt_class_idx, round_size, asymptotic_start_round
)
def m_acc_round_wise(
self, p_class: DataFrame, gt_class: DataFrame, round_id: int
) -> Dict:
"""
m_acc_round_wise function.
Args:
p_class: detection predictions
gt_class: ground truth classes
round_id: round identifier
Returns:
Dictionary containing top1, top3 accuracy for a round
"""
class_prob = p_class.iloc[:, range(1, p_class.shape[1])].to_numpy()
gt_class_idx = gt_class.to_numpy()
top1_acc = topk_accuracy(class_prob, gt_class_idx, k=1)
top3_acc = topk_accuracy(class_prob, gt_class_idx, k=3)
return {
f"top1_accuracy_round_{round_id}": top1_acc,
f"top3_accuracy_round_{round_id}": top3_acc,
}
def m_num(self, p_novel: DataFrame, gt_novel: DataFrame) -> Dict:
"""
m_num function.
Args:
p_novel: detection predictions for N videos (Dimension: N X 1)
gt_novel: ground truth detections for N videos (Dimension: N X 1)
Returns:
Difference between the novelty introduction and predicting change in world.
"""
return m_num(p_novel, gt_novel)
def m_num_stats(self, p_novel: np.ndarray, gt_novel: np.ndarray) -> Dict:
"""
m_num_stats function.
Args:
p_novel: detection predictions for N videos (Dimension: N X 1)
gt_novel: ground truth detections for N videos (Dimension: N X 1)
Returns:
Dictionary containing indices for novelty introduction and change in world prediction.
"""
return m_num_stats(p_novel, gt_novel)
def m_ndp(self, p_novel: np.ndarray, gt_novel: np.ndarray) -> Dict:
"""
m_ndp function.
Args:
p_novel: detection predictions for N videos (Dimension: N X 1)
gt_novel: ground truth detections for N videos (Dimension: N X 1)
Returns:
Dictionary containing novelty detection performance over the test.
"""
return m_ndp(p_novel, gt_novel, mode="full_test")
def m_ndp_pre(self, p_novel: np.ndarray, gt_novel: np.ndarray) -> Dict:
"""
m_ndp_pre function.
Args:
p_novel: detection predictions for N videos (Dimension: N X 1)
gt_novel: ground truth detections for N videos (Dimension: N X 1)
Returns:
Dictionary containing detection performance pre novelty.
"""
return m_ndp(p_novel, gt_novel, mode="pre_novelty")
def m_ndp_post(self, p_novel: np.ndarray, gt_novel: np.ndarray) -> Dict:
"""
m_ndp_post function.
Args:
p_novel: detection predictions for N videos (Dimension: N X 1)
gt_novel: ground truth detections for N videos (Dimension: N X 1)
Returns:
Dictionary containing detection performance post novelty.
"""
return m_ndp(p_novel, gt_novel, mode="post_novelty")
def m_ndp_failed_reaction(
self,
p_novel: DataFrame,
gt_novel: DataFrame,
p_class: DataFrame,
gt_class: DataFrame,
) -> Dict:
"""
m_ndp_failed_reaction function.
Args:
p_novel: detection predictions for N videos (Dimension: N X 1)
gt_novel: ground truth detections for N videos (Dimension: N X 1)
p_class: class predictions with video id for N videos (Dimension: N X 90 [vid,novel_class,88 known class])
gt_class: ground truth classes for N videos (Dimension: N X 1)
Returns:
Dictionary containing TP, FP, TN, FN, top1, top3 accuracy over the test.
"""
class_prob = p_class.iloc[:, range(1, p_class.shape[1])].to_numpy()
gt_class_idx = gt_class.to_numpy()
return m_ndp_failed_reaction(p_novel, gt_novel, class_prob, gt_class_idx)
def m_accuracy_on_novel(
self, p_class: DataFrame, gt_class: DataFrame, gt_novel: DataFrame
) -> Dict:
"""
m_accuracy_on_novel function.
Args:
p_class: class predictions with video id for N videos (Dimension: N X 90 [vid,novel_class,88 known class])
gt_class: ground truth classes for N videos (Dimension: N X 1)
gt_novel: ground truth detections for N videos (Dimension: N X 1)
Returns:
Accuracy on novely samples
"""
class_prob = p_class.iloc[:, range(1, p_class.shape[1])].to_numpy()
gt_class_idx = gt_class.to_numpy()
return m_accuracy_on_novel(class_prob, gt_class_idx, gt_novel)
def m_is_cdt_and_is_early(self, gt_idx: int, ta2_idx: int, test_len: int) -> Dict:
"""
m_is_cdt_and_is_early function.
Args:
gt_idx: Index when novelty is introduced
ta2_idx: Index when change is detected
test_len: Length of test
Returns
Dictionary containing boolean showing if change was was detected and if it was detected early
"""
is_cdt = (ta2_idx >= gt_idx) & (ta2_idx < test_len)
is_early = ta2_idx < gt_idx
return {"Is CDT": is_cdt, "Is Early": is_early}
def m_nrp(self, ta2_acc: Dict, baseline_acc: Dict) -> Dict:
"""
m_nrp function.
Args:
ta2_acc: Accuracy scores for the agent
baseline_acc: Accuracy scores for baseline
Returns:
Reaction performance for the agent
"""
nrp = {}
nrp["M_nrp_post_top3"] = 100 * (ta2_acc["post_top3"] / baseline_acc["pre_top3"])
nrp["M_nrp_post_top1"] = 100 * (ta2_acc["post_top1"] / baseline_acc["pre_top1"])
return nrp | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/evaluate/activity_recognition.py | 0.956836 | 0.453322 | activity_recognition.py | pypi |
import numpy as np
from abc import ABC, abstractmethod
from typing import Dict
class ProgramMetrics(ABC):
"""Abstract program metric class."""
def __init__(self, protocol: str) -> None:
"""
Initialize.
Args:
protocol: Name of the protocol.
Returns:
None
"""
self.protocol = protocol
@abstractmethod
def m_acc(
self,
gt_novel: np.ndarray,
p_class: np.ndarray,
gt_class: np.ndarray,
round_size: int,
asymptotic_start_round: int,
) -> Dict:
"""
m_acc abstract function.
Args:
gt_novel: ground truth detections
p_class: class predictions
gt_class: ground truth classes
round_size: size of the round
asymptotic_start_round: asymptotic samples considered for computing metrics
Returns:
Dictionary containing top1, top3 accuracy over the test, pre and post novelty.
"""
@abstractmethod
def m_acc_round_wise(
self, p_class: np.ndarray, gt_class: np.ndarray, round_id: int
) -> Dict:
"""
m_acc_round_wise abstract function.
Args:
p_class: class predictions
gt_class: ground truth classes
Returns:
Dictionary containing top1, top3 accuracy for a round
"""
@abstractmethod
def m_num(self, p_novel: np.ndarray, gt_novel: np.ndarray) -> Dict:
"""
m_num abstract function.
Args:
p_novel: detection predictions
gt_novel: ground truth detections
Returns:
Difference between the novelty introduction and predicting change in world.
"""
@abstractmethod
def m_num_stats(self, p_novel: np.ndarray, gt_novel: np.ndarray) -> Dict:
"""
m_num_stats abstract function.
Args:
p_novel: detection predictions
gt_novel: ground truth detections
Returns:
Dictionary containing indices for novelty introduction and change in world prediction.
"""
@abstractmethod
def m_ndp(self, p_novel: np.ndarray, gt_novel: np.ndarray) -> Dict:
"""
m_ndp abstract function.
Args:
p_novel: detection predictions
gt_novel: ground truth detections
Returns:
Dictionary containing novelty detection performance over the test.
"""
@abstractmethod
def m_ndp_pre(self, p_novel: np.ndarray, gt_novel: np.ndarray) -> Dict:
"""
m_ndp_pre abstract function.
Args:
p_novel: detection predictions
gt_novel: ground truth detections
Returns:
Dictionary containing detection performance pre novelty.
"""
@abstractmethod
def m_ndp_post(self, p_novel: np.ndarray, gt_novel: np.ndarray) -> Dict:
"""
m_ndp_post abstract function.
Args:
p_novel: detection predictions
gt_novel: ground truth detections
Returns:
Dictionary containing detection performance post novelty.
"""
@abstractmethod
def m_ndp_failed_reaction(
self,
p_novel: np.ndarray,
gt_novel: np.ndarray,
p_class: np.ndarray,
gt_class: np.ndarray,
) -> Dict:
"""
m_ndp_failed_reaction abstract function.
Args:
p_novel: detection predictions
gt_novel: ground truth detections
p_class: class predictions
gt_class: ground truth classes
Returns:
Dictionary containing TP, FP, TN, FN, top1, top3 accuracy over the test.
"""
@abstractmethod
def m_accuracy_on_novel(
self, p_novel: np.ndarray, gt_class: np.ndarray, gt_novel: np.ndarray
) -> Dict:
"""
m_accuracy_on_novel abstract function.
Args:
p_novel: detection predictions
gt_class: ground truth classes
gt_novel: ground truth detections
Returns:
Accuracy on novely samples
"""
@abstractmethod
def m_is_cdt_and_is_early(self, gt_idx: int, ta2_idx: int, test_len: int) -> Dict:
"""
m_is_cdt_and_is_early abstract function.
Args:
gt_idx: Index when novelty is introduced
ta2_idx: Index when change is detected
test_len: Length of test
Returns
Dictionary containing boolean showing if change was was detected and if it was detected early
""" | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/evaluate/program_metrics.py | 0.963652 | 0.582847 | program_metrics.py | pypi |
import numpy as np
import pandas as pd
from typing import List
def check_novel_validity(p_novel: np.ndarray, gt_novel: np.ndarray) -> None:
"""
Check the validity of the inputs for per-sample novelty detection.
Args:
p_novel: NX1 vector with each element corresponding to probability of novelty
gt_novel: NX1 vector with each element 0 (not novel) or 1 (novel)
Returns:
None
"""
if p_novel.shape[0] != gt_novel.shape[0]:
raise Exception(
"Number of predicted samples not equal to number of groundtruth samples!"
)
if p_novel.ndim != 1:
raise Exception(
"Predicted probabilities must be a vector but is an array of dimension {}!".format(
p_novel.ndim
)
)
if np.any(p_novel < 0) or np.any(p_novel > 1):
raise Exception("Predicted novel probabilities should be between 0 and 1!")
if np.any(np.logical_and(gt_novel != 0, gt_novel != 1)):
raise Exception(
"Groundtruth array should only consist of 0s (non-novel) or 1s(novel)!"
)
return
def check_class_validity(p_class: np.ndarray, gt_class: np.ndarray) -> None:
"""
Check the validity of the inputs for image classification.
Inputs:
p_class: Nx(K+1) matrix with each row corresponding to K+1 class probabilities for each sample
gt_class: Nx1 vector with ground-truth class for each sample
"""
if p_class.shape[0] != gt_class.shape[0]:
raise Exception(
"Number of predicted samples not equal to number of groundtruth samples!"
)
if np.any(p_class < 0) or np.any(p_class > 1):
raise Exception("Predicted class probabilities should be between 0 and 1!")
if p_class.ndim != 2:
raise Exception(
"Predicted probabilities must be a 2D matrix but is an array of dimension {}!".format(
p_class.ndim
)
)
if np.max(gt_class) >= p_class.shape[1] or np.min(gt_class < 0):
raise Exception(
"Groundtruth class labels must lie in the range [0-{}]!".format(
p_class.shape[1]
)
)
return
def topk_accuracy(
p_class: np.ndarray, gt_class: np.ndarray, k: int, txt: str = ""
) -> float:
"""
Compute top-K accuracy.
Args:
p_class: Nx(K+1) matrix with each row corresponding to K+1 class probabilities for each sample
gt_class: Nx1 computevector with ground-truth class for each sample
k: 'k' used in top-K accuracy
txt: Text associated with accuracy
Returns:
top-K accuracy
"""
check_class_validity(p_class, gt_class)
p_class = np.argsort(-p_class)[:, :k]
gt_class = gt_class[:, np.newaxis]
check_zero: np.ndarray = p_class - gt_class
correct = np.sum(np.any(check_zero == 0, axis=1).astype(int))
return round(float(correct) / p_class.shape[0], 5)
def top3_accuracy(p_class: np.ndarray, gt_class: np.ndarray, txt: str = "") -> float:
"""
Compute top-3 accuracy. (see topk_accuracy() for details).
Args:
p_class: Nx(K+1) matrix with each row corresponding to K+1 class probabilities for each sample
gt_class: Nx1 computevector with ground-truth class for each sample
txt: Text associated with accuracy
Returns:
top-3 accuracy
"""
return topk_accuracy(p_class, gt_class, k=3, txt=txt)
def top1_accuracy(p_class: np.ndarray, gt_class: np.ndarray, txt: str = "") -> float:
"""
Compute top-1 accuracy. (see topk_accuracy() for details).
Args:
p_class: Nx(K+1) matrix with each row corresponding to K+1 class probabilities for each sample
gt_class: Nx1 computevector with ground-truth class for each sample
txt: Text associated with accuracy
Returns:
top-1 accuracy
"""
return topk_accuracy(p_class, gt_class, k=1, txt=txt)
# compute information for the robustness measures
def get_rolling_stats(
p_class: np.ndarray, gt_class: np.ndarray, k: int = 1, window_size: int = 50
) -> List:
"""
Compute rolling statistics which are used for robustness measures.
Args:
p_class: Nx(K+1) matrix with each row corresponding to K+1 class probabilities for each sample
gt_class: Nx1 compute vector with ground-truth class for each sample
k: 'k' used for selecting top k values
window_size: Window size for running stats
Returns:
List with mean and standard deviation
"""
p_cls_topk = np.argsort(-p_class)[:, :k]
gt_cls_indx = gt_class[:, np.newaxis]
check_zero_topk = p_cls_topk - gt_cls_indx
topk_correct = 1 * (np.any(check_zero_topk == 0, axis=1))
acc_mean = pd.Series(topk_correct).rolling(window=window_size).mean().mean()
acc_std = pd.Series(topk_correct).rolling(window=window_size).mean().std()
return [acc_mean, acc_std]
def get_first_detect_novelty(p_novel: np.ndarray, thresh: float) -> int:
"""
Find the first index where novelty is detected.
Args:
p_novel: NX1 vector with each element corresponding to probability of novelty
thresh: Score threshold for detecting when a sample is novel
Returns:
Index where an agent reports that a sample is novel
"""
if np.sum(p_novel >= thresh) < 1:
first_detect_novelty = len(p_novel) + 1
else:
first_detect_novelty = np.where(p_novel >= thresh)[0][0] + 1
return first_detect_novelty | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/evaluate/utils.py | 0.948751 | 0.755907 | utils.py | pypi |
from sail_on_client.evaluate.program_metrics import ProgramMetrics
from sail_on_client.evaluate.metrics import m_acc, m_num, m_ndp, m_num_stats
from sail_on_client.evaluate.metrics import m_ndp_failed_reaction
from sail_on_client.evaluate.metrics import m_accuracy_on_novel
from sail_on_client.evaluate.utils import topk_accuracy
import numpy as np
from pandas import DataFrame
import pandas as pd
from typing import Dict
class ImageClassificationMetrics(ProgramMetrics):
"""Image Classification program metric class."""
def __init__(
self, protocol: str, image_id: int, detection: int, classification: int
) -> None:
"""
Initialize.
Args:
protocol: Name of the protocol.
image_id: Column id for image
detection: Column id for predicting sample wise world detection
classification: Column id for predicting sample wise classes
Returns:
None
"""
super().__init__(protocol)
self.image_id = image_id
self.detection_id = detection
self.classification_id = classification
self.novel_id = -1 # Added only for fixing typechecking problems
def m_acc(
self,
gt_novel: DataFrame,
p_class: DataFrame,
gt_class: DataFrame,
round_size: int,
asymptotic_start_round: int,
) -> Dict:
"""
m_acc function.
Args:
gt_novel: ground truth detections (Dimension: [img X detection])
p_class: class predictions (Dimension: [img X prob that sample is novel, prob of 88 known classes])
gt_class: ground truth classes (Dimension: [img X detection, classification])
round_size: size of the round
asymptotic_start_round: asymptotic samples considered for computing metrics
Returns:
Dictionary containing top1, top3 accuracy over the test, pre and post novelty.
"""
class_prob = p_class.iloc[:, range(1, p_class.shape[1])].to_numpy()
gt_class_idx = gt_class.to_numpy()
return m_acc(
gt_novel, class_prob, gt_class_idx, round_size, asymptotic_start_round
)
def m_acc_round_wise(
self, p_class: DataFrame, gt_class: DataFrame, round_id: int
) -> Dict:
"""
m_acc_round_wise function.
Args:
p_class: class predictions
gt_class: ground truth classes
round_id: round identifier
Returns:
Dictionary containing top1, top3 accuracy for a round
"""
class_prob = p_class.iloc[:, range(1, p_class.shape[1])].to_numpy()
gt_class_idx = gt_class.to_numpy()
top1_acc = topk_accuracy(class_prob, gt_class_idx, k=1)
top3_acc = topk_accuracy(class_prob, gt_class_idx, k=3)
return {
f"top1_accuracy_round_{round_id}": top1_acc,
f"top3_accuracy_round_{round_id}": top3_acc,
}
def m_num(self, p_novel: DataFrame, gt_novel: DataFrame) -> Dict:
"""
m_num function.
A Program Metric where the number of samples needed for detecting novelty.
The method computes the number of GT novel samples needed to predict the first true positive.
Args:
p_novel: detection predictions (Dimension: [img X novel])
Nx1 vector with each element corresponding to probability of novelty
gt_novel: ground truth detections (Dimension: [img X detection])
Nx1 vector with each element 0 (not novel) or 1 (novel)
Returns:
Difference between the novelty introduction and predicting change in world.
"""
return m_num(p_novel, gt_novel)
def m_num_stats(self, p_novel: np.ndarray, gt_novel: np.ndarray) -> Dict:
"""
Program Metric.
Number of samples needed for detecting novelty. The method computes number of GT novel
samples needed to predict the first true positive.
Args:
p_novel: detection predictions (Dimension: [img X novel])
Nx1 vector with each element corresponding to probability of novelty
gt_novel: ground truth detections (Dimension: [img X detection])
Nx1 vector with each element 0 (not novel) or 1 (novel)
Returns:
Dictionary containing indices for novelty introduction and change in world prediction.
"""
return m_num_stats(p_novel, gt_novel)
def m_ndp(
self, p_novel: np.ndarray, gt_novel: np.ndarray, mode: str = "full_test"
) -> Dict:
"""
Novelty Detection Performance: Program Metric.
Novelty detection performance. The method computes per-sample novelty detection performance.
Args:
p_novel: detection predictions (Dimension: [img X novel])
Nx1 vector with each element corresponding to probability of it being novel
gt_novel: ground truth detections (Dimension: [img X detection])
Nx1 vector with each element 0 (not novel) or 1 (novel)
mode: the mode to compute the test. if 'full_test' computes on all test samples,
if 'post_novelty' computes from first GT novel sample. If 'pre_novelty', only calculate
before first novel sample.
Returns:
Dictionary containing novelty detection performance over the test.
"""
return m_ndp(p_novel, gt_novel, mode="full_test")
def m_ndp_pre(self, p_novel: np.ndarray, gt_novel: np.ndarray) -> Dict:
"""
Novelty Detection Performance Pre Red Light. m_ndp_pre function.
See :func:`~sail-on-client.evaluation.ImageClassificationMetrics.m_ndp` with
post_novelty. This computes to the first GT novel sample. It really isn't useful
and is just added for completion. Should always be 0 since no possible TP.
Args:
p_novel: detection predictions (Dimension: [img X novel])
gt_novel: ground truth detections (Dimension: [img X detection])
Returns:
Dictionary containing detection performance pre novelty.
"""
return m_ndp(p_novel, gt_novel, mode="pre_novelty")
def m_ndp_post(self, p_novel: np.ndarray, gt_novel: np.ndarray) -> Dict:
"""
Novelty Detection Performance Post Red Light. m_ndp_post function.
See :func:`~sail-on-client.evaluation.ImageClassificationMetrics.m_ndp` with
post_novelty. This computes from the first GT novel sample
Args:
p_novel: detection predictions (Dimension: [img X novel])
gt_novel: ground truth detections (Dimension: [img X detection])
Returns:
Dictionary containing detection performance post novelty.
"""
return m_ndp(p_novel, gt_novel, mode="post_novelty")
def m_ndp_failed_reaction(
self,
p_novel: DataFrame,
gt_novel: DataFrame,
p_class: DataFrame,
gt_class: DataFrame,
mode: str = "full_test",
) -> Dict:
"""
Additional Metric: Novelty detection when reaction fails.
Not Implemented since no gt_class info for novel samples
The method computes novelty detection performance for only on samples with incorrect k-class predictions
Args:
p_novel: detection predictions (Dimension: [img X novel])
Nx1 vector with each element corresponding to probability of novelty
gt_novel: ground truth detections (Dimension: [img X detection])
Nx1 vector with each element 0 (not novel) or 1 (novel)
p_class: detection predictions (Dimension: [img X prob that sample is novel, prob of 88 known classes])
Nx(K+1) matrix with each row corresponding to K+1 class probabilities for each sample
gt_class: ground truth classes (Dimension: [img X classification])
Nx1 vector with ground-truth class for each sample
mode: if 'full_test' computes on all test samples, if 'post_novelty' computes from the first GT
novel sample. If 'pre_novelty', than everything before novelty introduced.
Returns:
Dictionary containing TP, FP, TN, FN, top1, top3 accuracy over the test.
"""
class_prob = p_class.iloc[:, range(1, p_class.shape[1])].to_numpy()
gt_class_idx = gt_class.to_numpy()
return m_ndp_failed_reaction(p_novel, gt_novel, class_prob, gt_class_idx)
def m_accuracy_on_novel(
self, p_class: DataFrame, gt_class: DataFrame, gt_novel: DataFrame
) -> Dict:
"""
Additional Metric: Novelty robustness.
The method computes top-K accuracy for only the novel samples
Args:
p_class: detection predictions (Dimension: [img X prob that sample is novel, prob of known classes])
Nx(K+1) matrix with each row corresponding to K+1 class probabilities for each sample
gt_class: ground truth classes (Dimension: [img X classification])
Nx1 vector with ground-truth class for each sample
gt_novel: ground truth detections (Dimension: N X [img, classification])
Nx1 binary vector corresponding to the ground truth novel{1}/seen{0} labels
Returns:
Accuracy on novely samples
"""
class_prob = p_class.iloc[:, range(1, p_class.shape[1])].to_numpy()
gt_class_idx = gt_class.to_numpy()
return m_accuracy_on_novel(class_prob, gt_class_idx, gt_novel)
def m_is_cdt_and_is_early(self, gt_idx: int, ta2_idx: int, test_len: int) -> Dict:
"""
Is change detection and is change detection early (m_is_cdt_and_is_early) function.
Args:
gt_idx: Index when novelty is introduced
ta2_idx: Index when change is detected
test_len: Length of test
Returns
Dictionary containing boolean showing if change was was detected and if it was detected early
"""
is_cdt = (ta2_idx >= gt_idx) & (ta2_idx < test_len)
is_early = ta2_idx < gt_idx
return {"Is CDT": is_cdt, "Is Early": is_early}
def m_nrp(self, ta2_acc: Dict, baseline_acc: Dict) -> Dict:
"""
m_nrp function.
Args:
ta2_acc: Accuracy scores for the agent
baseline_acc: Accuracy scores for baseline
Returns:
Reaction performance for the agent
"""
nrp = {}
nrp["M_nrp_post_top3"] = 100 * (ta2_acc["post_top3"] / baseline_acc["pre_top3"])
nrp["M_nrp_post_top1"] = 100 * (ta2_acc["post_top1"] / baseline_acc["pre_top1"])
return nrp
def convert_df(old_filepath: str, new_filepath: str) -> None:
"""
Convert from the old df to the new df.
Args:
old_filepath: the filepath the the old *_single_df.csv file
new_filepath: the filepath the the old *_single_df.csv file
Return:
None
"""
df = pd.read_csv(old_filepath)
df["id"] = df.current_path
df["detection"] = df.cls_novelty.cummax()
df["classification"] = df.class_id
# Retain the class num for novel classes but as negative numbers
mask = df.classification == -1
df.loc[mask, "classification"] = df.loc[mask, "current_path"].map(
lambda x: -int(x.split("/")[-2])
)
df[["id", "detection", "classification"]].to_csv(new_filepath, index=False) | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/evaluate/image_classification.py | 0.938646 | 0.538134 | image_classification.py | pypi |
from sail_on_client.checkpointer import Checkpointer
from sail_on_client.agent.condda_agent import CONDDAAgent
from typing import Dict, Any, Tuple, Callable
import logging
import os
import shutil
import torch
log = logging.getLogger(__name__)
class MockCONDDAAgent(CONDDAAgent):
"""Mock Detector for CONDDA Protocol."""
def __init__(self) -> None:
"""Construct Mock CONDDA Detector."""
super().__init__()
self.step_dict: Dict[str, Callable] = {
"Initialize": self.initialize,
"FeatureExtraction": self.feature_extraction,
"WorldDetection": self.world_detection,
"NoveltyCharacterization": self.novelty_characterization,
}
def initialize(self, toolset: Dict) -> None:
"""
Algorithm Initialization.
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
None
"""
pass
def get_config(self) -> Dict:
"""
Get config for the plugin.
Returns:
Parameters for the agent
"""
return {}
def feature_extraction(
self, toolset: Dict
) -> Tuple[Dict[str, Any], Dict[str, Any]]:
"""
Feature extraction step for the algorithm.
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
Tuple of dictionary
"""
self.dataset = toolset["dataset"]
return {}, {}
def world_detection(self, toolset: Dict) -> str:
"""
Detect change in world ( Novelty has been introduced ).
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
path to csv file containing the results for change in world
"""
dataset_dir = os.path.dirname(self.dataset)
dst_file = os.path.join(dataset_dir, "wc.csv")
shutil.copyfile(self.dataset, dst_file)
return dst_file
def novelty_characterization(self, toolset: Dict) -> str:
"""
Characterize novelty by clustering different novel samples.
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
path to csv file containing the results for novelty characterization step
"""
dataset_dir = os.path.dirname(self.dataset)
dst_file = os.path.join(dataset_dir, "nc.csv")
shutil.copyfile(self.dataset, dst_file)
return dst_file
def execute(self, toolset: Dict, step_descriptor: str) -> Any:
"""
Execute method used by the protocol to run different steps.
Args:
toolset (dict): Dictionary containing parameters for different steps
step_descriptor (str): Name of the step
"""
log.info(f"Executing {step_descriptor}")
return self.step_dict[step_descriptor](toolset)
class MockCONDDAAgentWithAttributes(MockCONDDAAgent):
"""Mock Detector for testing checkpointing."""
def __init__(self) -> None:
"""
Detector constructor.
Args:
toolset (dict): Dictionary containing parameters for the constructor
"""
MockCONDDAAgent.__init__(self)
def feature_extraction(
self, toolset: Dict
) -> Tuple[Dict[str, Any], Dict[str, Any]]:
"""
Feature extraction step for the algorithm.
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
Tuple of dictionary
"""
self.dummy_dict = toolset["dummy_dict"]
self.dummy_list = toolset["dummy_list"]
self.dummy_tuple = toolset["dummy_tuple"]
self.dummy_tensor = toolset["dummy_tensor"]
self.dummy_val = toolset["dummy_val"]
return {}, {}
class MockCONDDAAdapterWithCheckpoint(MockCONDDAAgent, Checkpointer):
"""Mock Adapter for testing checkpointing."""
def __init__(self, toolset: Dict) -> None:
"""
Detector constructor.
Args:
toolset (dict): Dictionary containing parameters for the constructor
"""
MockCONDDAAgent.__init__(self)
Checkpointer.__init__(self, toolset)
self.detector = MockCONDDAAgentWithAttributes()
def get_config(self) -> Dict:
"""
Get config for the plugin.
Returns:
Parameters for the agent
"""
config = super().get_config()
config.update(self.toolset)
return config
def execute(self, toolset: Dict, step_descriptor: str) -> Any:
"""
Execute method used by the protocol to run different steps.
Args:
toolset (dict): Dictionary containing parameters for different steps
step_descriptor (str): Name of the step
"""
log.info(f"Executing {step_descriptor}")
return self.detector.step_dict[step_descriptor](toolset)
def __eq__(self, other: object) -> bool:
"""
Overriden method to compare two mock adapters.
Args:
other (MockCONDDAAdapterWithCheckpoint): Another instance of mock adapter
Return:
True if both instances have same attributes
"""
if not isinstance(other, MockCONDDAAdapterWithCheckpoint):
return NotImplemented
return (
self.detector.dummy_dict == other.detector.dummy_dict
and self.detector.dummy_list == other.detector.dummy_list
and self.detector.dummy_tuple == other.detector.dummy_tuple
and bool(
torch.all(
torch.eq(self.detector.dummy_tensor, other.detector.dummy_tensor)
)
)
and self.detector.dummy_val == other.detector.dummy_val
) | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/agent/mock_condda_agents.py | 0.936343 | 0.268276 | mock_condda_agents.py | pypi |
from sail_on_client.checkpointer import Checkpointer
from sail_on_client.agent.ond_agent import ONDAgent
from typing import Dict, Any, Tuple, Callable
import logging
import os
import shutil
import torch
log = logging.getLogger(__name__)
class MockONDAgent(ONDAgent):
"""Mock Detector for OND Protocol."""
def __init__(self) -> None:
"""Construct Mock OND Detector."""
super().__init__()
self.step_dict: Dict[str, Callable] = {
"Initialize": self.initialize,
"FeatureExtraction": self.feature_extraction,
"WorldDetection": self.world_detection,
"NoveltyClassification": self.novelty_classification,
"NoveltyAdaption": self.novelty_adaptation,
"NoveltyCharacterization": self.novelty_characterization,
}
def initialize(self, toolset: Dict) -> None:
"""
Algorithm Initialization.
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
None
"""
pass
def feature_extraction(
self, toolset: Dict
) -> Tuple[Dict[str, Any], Dict[str, Any]]:
"""
Feature extraction step for the algorithm.
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
Tuple of dictionary
"""
self.dataset = toolset["dataset"]
return {}, {}
def world_detection(self, toolset: Dict) -> str:
"""
Detect change in world ( Novelty has been introduced ).
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
path to csv file containing the results for change in world
"""
dataset_dir = os.path.dirname(self.dataset)
dst_file = os.path.join(dataset_dir, "wc.csv")
shutil.copyfile(self.dataset, dst_file)
return dst_file
def novelty_classification(self, toolset: Dict) -> str:
"""
Classify data provided in known classes and unknown class.
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
path to csv file containing the results for novelty classification step
"""
dataset_dir = os.path.dirname(self.dataset)
dst_file = os.path.join(dataset_dir, "ncl.csv")
shutil.copyfile(self.dataset, dst_file)
return dst_file
def novelty_adaptation(self, toolset: Dict) -> None:
"""
Update models based on novelty classification and characterization.
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
None
"""
pass
def novelty_characterization(self, toolset: Dict) -> str:
"""
Characterize novelty by clustering different novel samples.
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
path to csv file containing the results for novelty characterization step
"""
dataset_dir = os.path.dirname(self.dataset)
dst_file = os.path.join(dataset_dir, "nc.csv")
shutil.copyfile(self.dataset, dst_file)
return dst_file
def execute(self, toolset: Dict, step_descriptor: str) -> Any:
"""
Execute method used by the protocol to run different steps.
Args:
toolset (dict): Dictionary containing parameters for different steps
step_descriptor (str): Name of the step
"""
log.info(f"Executing {step_descriptor}")
return self.step_dict[step_descriptor](toolset)
class MockONDAgentWithAttributes(MockONDAgent):
"""Mock Detector for testing checkpointing."""
def __init__(self) -> None:
"""
Detector constructor.
Args:
toolset (dict): Dictionary containing parameters for the constructor
"""
MockONDAgent.__init__(self)
def feature_extraction(
self, toolset: Dict
) -> Tuple[Dict[str, Any], Dict[str, Any]]:
"""
Feature extraction step for the algorithm.
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
Tuple of dictionary
"""
self.dummy_dict = toolset["dummy_dict"]
self.dummy_list = toolset["dummy_list"]
self.dummy_tuple = toolset["dummy_tuple"]
self.dummy_tensor = toolset["dummy_tensor"]
self.dummy_val = toolset["dummy_val"]
return {}, {}
class MockONDAdapterWithCheckpoint(Checkpointer, MockONDAgent):
"""Mock Adapter for testing checkpointing."""
def __init__(self, toolset: Dict) -> None:
"""
Detector constructor.
Args:
toolset (dict): Dictionary containing parameters for the constructor
"""
MockONDAgent.__init__(self)
Checkpointer.__init__(self, toolset)
self.detector = MockONDAgentWithAttributes()
def get_config(self) -> Dict:
"""
Get config for the plugin.
Returns:
Parameters for the agent
"""
config = super().get_config()
config.update(self.toolset)
return config
def execute(self, toolset: Dict, step_descriptor: str) -> Any:
"""
Execute method used by the protocol to run different steps.
Args:
toolset (dict): Dictionary containing parameters for different steps
step_descriptor (str): Name of the step
"""
log.info(f"Executing {step_descriptor}")
return self.detector.step_dict[step_descriptor](toolset)
def __eq__(self, other: object) -> bool:
"""
Overriden method to compare two mock adapters.
Args:
other (MockONDAdapterWithCheckpoint): Another instance of mock adapter
Return:
True if both instances have same attributes
"""
if not isinstance(other, MockONDAdapterWithCheckpoint):
return NotImplemented
return (
self.detector.dummy_dict == other.detector.dummy_dict
and self.detector.dummy_list == other.detector.dummy_list
and self.detector.dummy_tuple == other.detector.dummy_tuple
and bool(
torch.all(
torch.eq(self.detector.dummy_tensor, other.detector.dummy_tensor)
)
)
and self.detector.dummy_val == other.detector.dummy_val
) | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/agent/mock_ond_agents.py | 0.933862 | 0.264531 | mock_ond_agents.py | pypi |
from sail_on_client.agent.ond_reaction_agent import ONDReactionAgent
from sail_on_client.agent.pre_computed_detector import PreComputedONDAgent
import logging
from typing import Dict, Any, Tuple
log = logging.getLogger(__name__)
class PreComputedONDReactionAgent(ONDReactionAgent):
"""Detector for submitting precomputed results for computing reaction performance."""
def __init__(
self,
algorithm_name: str,
cache_dir: str,
has_roundwise_file: bool,
round_size: int,
) -> None:
"""
Construct agent with precomputed results.
Args:
algorithm_name: Name of the algorithm
cache_dir: Path to cache directory
has_roundwise_file: Flag to determine if the cache has files for rounds
round_size: Size of a round
"""
self.detector = PreComputedONDAgent(
algorithm_name, cache_dir, has_roundwise_file, round_size
)
def get_config(self) -> Dict:
"""Return a default configuration dictionary."""
return {
"algorithm_name": self.detector.algorithm_name,
"cache_dir": self.detector.cache_dir,
"has_roundwise_file": self.detector.has_roundwise_file,
"round_size": self.detector.round_size,
}
def execute(self, toolset: Dict, step_descriptor: str) -> Any:
"""
Execute method used by the protocol to run different steps associated with the algorithm.
Args:
toolset (dict): Dictionary containing parameters for different steps
step_descriptor (str): Name of the step
"""
log.info(f"Executing {step_descriptor}")
return self.detector.step_dict[step_descriptor](toolset)
def initialize(self, toolset: Dict) -> None:
"""
Algorithm Initialization.
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
None
"""
self.detector.initialize(toolset)
def feature_extraction(
self, toolset: Dict
) -> Tuple[Dict[str, Any], Dict[str, Any]]:
"""
Feature extraction step for the algorithm.
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
Tuple of dictionary
"""
return self.detector.feature_extraction(toolset)
def novelty_classification(self, toolset: Dict) -> str:
"""
Classify data provided in known classes and unknown class.
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
path to csv file containing the results for novelty classification step
"""
return self.detector.novelty_classification(toolset) | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/agent/pre_computed_reaction_agent.py | 0.950983 | 0.254683 | pre_computed_reaction_agent.py | pypi |
from sail_on_client.agent.visual_agent import VisualAgent
from sail_on_client.agent.ond_agent import ONDAgent
from sail_on_client.agent.condda_agent import CONDDAAgent
from typing import Dict, Any, Tuple, Callable
import logging
import os
import pandas as pd
log = logging.getLogger(__name__)
class PreComputedAgent(VisualAgent):
"""Detector for submitting precomputed results."""
def __init__(
self,
algorithm_name: str,
cache_dir: str,
has_roundwise_file: bool,
round_size: int,
) -> None:
"""
Construct agent with precomputed results.
Args:
algorithm_name: Name of the algorithm
cache_dir: Path to cache directory
has_roundwise_file: Flag to determine if the cache has files for rounds
round_size: Size of a round
"""
ONDAgent.__init__(self)
self.algorithm_name = algorithm_name
self.cache_dir = cache_dir
self.has_roundwise_file = has_roundwise_file
self.round_size = round_size
self.step_dict: Dict[str, Callable] = {
"Initialize": self.initialize,
"FeatureExtraction": self.feature_extraction,
"WorldDetection": self.world_detection,
}
def get_config(self) -> Dict:
"""Return a default configuration dictionary."""
return {
"algorithm_name": self.algorithm_name,
"cache_dir": self.cache_dir,
"has_roundwise_file": self.has_roundwise_file,
"round_size": self.round_size,
}
def execute(self, toolset: Dict, step_descriptor: str) -> Any:
"""
Execute method used by the protocol to run different steps associated with the algorithm.
Args:
toolset (dict): Dictionary containing parameters for different steps
step_descriptor (str): Name of the step
"""
log.info(f"Executing {step_descriptor}")
return self.step_dict[step_descriptor](toolset)
def initialize(self, toolset: Dict) -> None:
"""
Algorithm Initialization.
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
None
"""
self.round_idx = {"detection": 0, "classification": 0}
self.test_id = toolset["test_id"]
def _get_test_info_from_toolset(self, toolset: Dict) -> Tuple:
"""
Private function for getting test id and round id (optionally) from toolset.
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
tuple containing test id and round id (optionally)
"""
if self.has_roundwise_file:
return (self.test_id, toolset["round_id"])
else:
return self.test_id
def _get_result_path(self, toolset: Dict, step_descriptor: str) -> str:
"""
Private function for getting path to results.
Args:
toolset (dict): Dictionary containing parameters for different steps
step_descriptor (str): Name of the step
Return:
Path to the result file
"""
if self.has_roundwise_file:
test_id, round_id = self._get_test_info_from_toolset(toolset)
return os.path.join(
self.cache_dir,
f"{test_id}.{round_id}_{self.algorithm_name}_{step_descriptor}.csv",
)
else:
test_id = self._get_test_info_from_toolset(toolset)
return os.path.join(
self.cache_dir, f"{test_id}_{self.algorithm_name}_{step_descriptor}.csv"
)
def _generate_step_result(self, toolset: Dict, step_descriptor: str) -> str:
result_path = self._get_result_path(toolset, step_descriptor)
if self.has_roundwise_file:
return result_path
else:
round_file_path = os.path.join(
self.cache_dir, f"{self.algorithm_name}_{step_descriptor}.csv"
)
round_idx = self.round_idx[step_descriptor]
test_df = pd.read_csv(result_path, header=None)
round_df = test_df.iloc[round_idx : round_idx + self.round_size]
self.round_idx[step_descriptor] += self.round_size
round_df.to_csv(round_file_path, index=False, header=False)
return round_file_path
def feature_extraction(
self, toolset: Dict
) -> Tuple[Dict[str, Any], Dict[str, Any]]:
"""
Feature extraction step for the algorithm.
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
Tuple of dictionary
"""
self.dataset = toolset["dataset"]
pd.read_csv(self.dataset, header=None).shape[0]
return {}, {}
def world_detection(self, toolset: Dict) -> str:
"""
Detect change in world ( Novelty has been introduced ).
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
path to csv file containing the results for change in world
"""
return self._generate_step_result(toolset, "detection")
class PreComputedONDAgent(PreComputedAgent, ONDAgent):
"""Detector for submitting precomputed results in OND."""
def __init__(
self,
algorithm_name: str,
cache_dir: str,
has_roundwise_file: bool,
round_size: int,
) -> None:
"""
Construct agent with precomputed results for OND.
Args:
algorithm_name: Name of the algorithm
cache_dir: Path to cache directory
has_roundwise_file: Flag to determine if the cache has files for rounds
round_size: Size of a round
"""
PreComputedAgent.__init__(
self, algorithm_name, cache_dir, has_roundwise_file, round_size
)
ONDAgent.__init__(self)
self.step_dict.update(
{
"NoveltyClassification": self.novelty_classification,
"NoveltyAdaptation": self.novelty_adaptation,
"NoveltyCharacterization": self.novelty_characterization,
}
)
def novelty_classification(self, toolset: Dict) -> str:
"""
Classify data provided in known classes and unknown class.
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
path to csv file containing the results for novelty classification step
"""
return self._generate_step_result(toolset, "classification")
def novelty_adaptation(self, toolset: Dict) -> None:
"""
Update models based on novelty classification and characterization.
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
None
"""
pass
def novelty_characterization(self, toolset: Dict) -> str:
"""
Characterize novelty by clustering different novel samples.
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
path to csv file containing the results for novelty characterization step
"""
return self._get_result_path(toolset, "characterization")
class PreComputedCONDDAAgent(PreComputedAgent, CONDDAAgent):
"""Detector for submitting precomputed results in CONDDA."""
def __init__(
self,
algorithm_name: str,
cache_dir: str,
has_roundwise_file: bool,
round_size: int,
) -> None:
"""
Construct agent with precomputed results for CONDDA.
Args:
algorithm_name: Name of the algorithm
cache_dir: Path to cache directory
has_roundwise_file: Flag to determine if the cache has files for rounds
round_size: Size of a round
"""
PreComputedAgent.__init__(
self, algorithm_name, cache_dir, has_roundwise_file, round_size
)
ONDAgent.__init__(self)
self.step_dict.update(
{"NoveltyCharacterization": self.novelty_characterization}
)
def novelty_characterization(self, toolset: Dict) -> str:
"""
Characterize novelty by clustering different novel samples.
Args:
toolset (dict): Dictionary containing parameters for different steps
Return:
path to csv file containing the results for novelty characterization step
"""
return self._get_result_path(toolset, "characterization") | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/agent/pre_computed_detector.py | 0.926694 | 0.226955 | pre_computed_detector.py | pypi |
from sail_on_client.agent.ond_agent import ONDAgent
from sail_on_client.harness.test_and_evaluation_harness import (
TestAndEvaluationHarnessType,
)
from sail_on_client.protocol.visual_protocol import VisualProtocol
from sail_on_client.utils.numpy_encoder import NumpyEncoder
from sail_on_client.protocol.ond_dataclasses import AlgorithmAttributes
from sail_on_client.protocol.ond_test import ONDTest
from sail_on_client.utils.decorators import skip_stage
import os
import json
import logging
from typing import Dict, List, Optional
log = logging.getLogger(__name__)
class ONDProtocol(VisualProtocol):
"""OND protocol."""
def __init__(
self,
algorithms: Dict[str, ONDAgent],
dataset_root: str,
domain: str,
harness: TestAndEvaluationHarnessType,
save_dir: str,
seed: str,
test_ids: List[str],
baseline_class: str = "",
feature_extraction_only: bool = False,
has_baseline: bool = False,
has_reaction_baseline: bool = False,
hints: List = None,
is_eval_enabled: bool = False,
is_eval_roundwise_enabled: bool = False,
resume_session: bool = False,
resume_session_ids: Dict = None,
save_attributes: bool = False,
saved_attributes: Dict = None,
save_elementwise: bool = False,
save_features: bool = False,
feature_dir: str = "",
skip_stages: List = None,
use_feedback: bool = False,
feedback_type: str = "classification",
use_consolidated_features: bool = False,
use_saved_attributes: bool = False,
use_saved_features: bool = False,
) -> None:
"""
Construct OND protocol.
Args:
algorithms: Dictionary of algorithms that are used run based on the protocol
baseline_class: Name of the baseline class
dataset_root: Root directory of the dataset
domain: Domain of the problem
save_dir: Directory where results are saved
seed: Seed for the experiments
feedback_type: Type of feedback
test_ids: List of tests
feature_extraction_only: Flag to only run feature extraction
has_baseline: Flag to check if the session has baseline
has_reaction_baseline: Flag to check if the session has reaction baseline
hints: List of hint provided in the session
harness: A harness for test and evaluation
is_eval_enabled: Flag to check if evaluation is enabled in session
is_eval_roundwise_enabled: Flag to check if evaluation is enabled for rounds
resume_session: Flag to resume session
resume_session_ids: Dictionary for resuming sessions
save_attributes: Flag to save attributes
saved_attributes: Dictionary for attributes
save_elementwise: Flag to save features elementwise
save_features: Flag to save features
feature_dir: Directory to save features
skip_stages: List of stages that are skipped
use_feedback: Flag to use feedback
use_saved_attributes: Flag to use saved attributes
use_saved_features: Flag to use saved features
Returns:
None
"""
super().__init__(algorithms, harness)
self.baseline_class = baseline_class
self.dataset_root = dataset_root
self.domain = domain
self.feature_extraction_only = feature_extraction_only
self.feature_dir = feature_dir
self.feedback_type = feedback_type
self.has_baseline = has_baseline
self.has_reaction_baseline = has_reaction_baseline
if hints is None:
self.hints = []
else:
self.hints = hints
self.is_eval_enabled = is_eval_enabled
self.is_eval_roundwise_enabled = is_eval_roundwise_enabled
self.resume_session = resume_session
if resume_session_ids is None:
self.resume_session_ids = {}
else:
self.resume_session_ids = resume_session_ids
self.save_attributes = save_attributes
if saved_attributes is None:
self.saved_attributes = {}
else:
self.saved_attributes = saved_attributes
self.save_dir = save_dir
self.save_elementwise = save_elementwise
self.save_features = save_features
if skip_stages is None:
self.skip_stages = []
else:
self.skip_stages = skip_stages
self.seed = seed
self.test_ids = test_ids
self.use_consolidated_features = use_consolidated_features
self.use_feedback = use_feedback
self.use_saved_attributes = use_saved_attributes
self.use_saved_features = use_saved_features
def get_config(self) -> Dict:
"""Get dictionary representation of the object."""
config = super().get_config()
config.update(
{
"baseline_class": self.baseline_class,
"dataset_root": self.dataset_root,
"domain": self.domain,
"feature_extraction_only": self.feature_extraction_only,
"feature_dir": self.feature_dir,
"feedback_type": self.feedback_type,
"has_baseline": self.has_baseline,
"has_reaction_baseline": self.has_reaction_baseline,
"hints": self.hints,
"is_eval_enabled": self.is_eval_enabled,
"is_eval_roundwise_enabled": self.is_eval_roundwise_enabled,
"resume_session": self.resume_session,
"resume_session_ids": self.resume_session_ids,
"save_attributes": self.save_attributes,
"saved_attributes": self.saved_attributes,
"save_dir": self.save_dir,
"save_elementwise": self.save_elementwise,
"save_features": self.save_features,
"skip_stages": self.skip_stages,
"seed": self.seed,
"test_ids": self.test_ids,
"use_feedback": self.use_feedback,
"use_saved_attributes": self.use_saved_attributes,
"use_saved_features": self.use_saved_features,
}
)
return config
def create_algorithm_attributes(
self,
algorithm_name: str,
algorithm_param: Dict,
baseline_algorithm_name: str,
has_baseline: bool,
has_reaction_baseline: bool,
test_ids: List[str],
) -> AlgorithmAttributes:
"""
Create an instance of algorithm attributes.
Args:
algorithm_name: Name of the algorithm
algorithm_param: Parameters for the algorithm
baseline_algorithm_name: Name of the baseline algorithm
has_baseline: Flag to check if a baseline is present in the config
has_reaction_baseline: Flag to check if a reaction baseline is present in the config
test_ids: List of test
Returns:
An instance of AlgorithmAttributes
"""
algorithm_instance = self.algorithms[algorithm_name]
is_baseline = algorithm_name == baseline_algorithm_name
session_id = self.resume_session_ids.get(algorithm_name, "")
return AlgorithmAttributes(
algorithm_name,
algorithm_param.get("detection_threshold", 0.5),
algorithm_instance,
has_baseline and is_baseline,
has_reaction_baseline and is_baseline,
algorithm_param.get("package_name", None),
algorithm_param,
session_id,
test_ids,
)
def create_algorithm_session(
self,
algorithm_attributes: AlgorithmAttributes,
domain: str,
hints: List[str],
has_a_session: bool,
protocol_name: str,
) -> AlgorithmAttributes:
"""
Create/resume session for an algorithm.
Args:
algorithm_attributes: An instance of AlgorithmAttributes
domain: Domain for the algorithm
hints: List of hints used in the session
has_a_session: Already has a session and we want to resume it
protocol_name: Name of the algorithm
Returns:
An AlgorithmAttributes object with updated session id or test id
"""
test_ids = algorithm_attributes.test_ids
named_version = algorithm_attributes.named_version()
detection_threshold = algorithm_attributes.detection_threshold
if has_a_session:
session_id = algorithm_attributes.session_id
finished_test = self.harness.resume_session(session_id)
algorithm_attributes.remove_completed_tests(finished_test)
log.info(f"Resumed session {session_id} for {algorithm_attributes.name}")
else:
session_id = self.harness.session_request(
test_ids,
protocol_name,
domain,
named_version,
hints,
detection_threshold,
)
algorithm_attributes.session_id = session_id
log.info(f"Created session {session_id} for {algorithm_attributes.name}")
return algorithm_attributes
def _find_baseline_session_id(
self, algorithms_attributes: List[AlgorithmAttributes]
) -> str:
"""
Find baseline session id based on the attributes of algorithms.
Args:
algorithms_attributes: List of algorithm attributes
Returns:
Baseline session id
"""
for algorithm_attributes in algorithms_attributes:
if (
algorithm_attributes.is_baseline
or algorithm_attributes.is_reaction_baseline
):
return algorithm_attributes.session_id
raise Exception(
"Failed to find baseline, this is required to compute reaction perfomance"
)
@skip_stage("EvaluateAlgorithms")
def _evaluate_algorithms(
self,
algorithms_attributes: List[AlgorithmAttributes],
algorithm_scores: Dict,
save_dir: str,
) -> None:
"""
Evaluate algorithms after all tests have been submitted.
Args:
algorithms_attributes: All algorithms present in the config
algorithm_scores: Scores for round wise evaluation
save_dir: Directory where the scores are stored
Returns:
None
"""
if self.has_baseline or self.has_reaction_baseline:
baseline_session_id: Optional[str] = self._find_baseline_session_id(
algorithms_attributes
)
else:
baseline_session_id = None
for algorithm_attributes in algorithms_attributes:
if (
algorithm_attributes.is_baseline
or algorithm_attributes.is_reaction_baseline
):
continue
session_id = algorithm_attributes.session_id
test_ids = algorithm_attributes.test_ids
algorithm_name = algorithm_attributes.name
test_scores = algorithm_scores[algorithm_name]
log.info(f"Started evaluating {algorithm_name}")
for test_id in test_ids:
score = self.harness.evaluate(
test_id, 0, session_id, baseline_session_id
)
score.update(test_scores[test_id])
with open(
os.path.join(save_dir, f"{test_id}_{algorithm_name}.json"), "w"
) as f: # type: ignore
log.info(f"Saving results in {save_dir}")
json.dump(score, f, indent=4, cls=NumpyEncoder) # type: ignore
log.info(f"Finished evaluating {algorithm_name}")
def update_skip_stages(
self,
skip_stages: List[str],
is_eval_enabled: bool,
is_eval_roundwise_enabled: bool,
use_feedback: bool,
save_features: bool,
feature_extraction_only: bool,
) -> List[str]:
"""
Update skip stages based on the boolean values in config.
Args:
skip_stages: List of skip stages specified in the config
is_eval_enabled: Flag to enable evaluation
is_eval_roundwise_enabled: Flag to enable evaluation in every round
use_feedback: Flag to enable using feedback
save_features: Flag to enable saving features
feature_extraction_only: Flag to only run feature extraction
Returns:
Update list of skip stages
"""
if not is_eval_enabled:
skip_stages.append("EvaluateAlgorithms")
skip_stages.append("EvaluateRoundwise")
if not is_eval_roundwise_enabled:
skip_stages.append("EvaluateRoundwise")
if not use_feedback:
skip_stages.append("CreateFeedbackInstance")
skip_stages.append("NoveltyAdaptation")
if not save_features:
skip_stages.append("SaveFeatures")
if feature_extraction_only:
skip_stages.append("CreateFeedbackInstance")
skip_stages.append("WorldDetection")
skip_stages.append("NoveltyClassification")
skip_stages.append("NoveltyAdaptation")
skip_stages.append("NoveltyCharacterization")
return skip_stages
def run_protocol(self, config: Dict) -> None:
"""
Run the protocol.
Args:
config: Parameters provided in the config
Returns:
None
"""
log.info("Starting OND")
self.skip_stages = self.update_skip_stages(
self.skip_stages,
self.is_eval_enabled,
self.is_eval_roundwise_enabled,
self.use_feedback,
self.save_features,
self.feature_extraction_only,
)
algorithms_attributes = []
# Populate most of the attributes for the algorithm
for algorithm_name in self.algorithms.keys():
algorithm_param = self.algorithms[algorithm_name].get_config()
algorithm_attributes = self.create_algorithm_attributes(
algorithm_name,
algorithm_param,
self.baseline_class,
self.has_baseline,
self.has_reaction_baseline,
self.test_ids,
)
log.info(f"Consolidating attributes for {algorithm_name}")
algorithms_attributes.append(algorithm_attributes)
# Create sessions an instances of all the algorithms and populate
# session_id for algorithm attributes
for idx, algorithm_attributes in enumerate(algorithms_attributes):
algorithms_attributes[idx] = self.create_algorithm_session(
algorithm_attributes,
self.domain,
self.hints,
self.resume_session,
"OND",
)
# Run tests for all the algorithms
algorithm_scores = {}
for algorithm_attributes in algorithms_attributes:
algorithm_name = algorithm_attributes.name
session_id = algorithm_attributes.session_id
test_ids = algorithm_attributes.test_ids
log.info(f"Starting session: {session_id} for algorithm: {algorithm_name}")
skip_stages = self.skip_stages.copy()
if algorithm_attributes.is_reaction_baseline:
skip_stages.append("WorldDetection")
skip_stages.append("NoveltyCharacterization")
ond_test = ONDTest(
algorithm_attributes,
self.dataset_root,
self.domain,
self.feedback_type,
self.feature_dir,
self.harness,
self.save_dir,
session_id,
skip_stages,
self.use_consolidated_features,
self.use_saved_features,
)
test_scores = {}
for test_id in test_ids:
log.info(f"Start test: {test_id}")
test_score = ond_test(test_id)
test_scores[test_id] = test_score
log.info(f"Test complete: {test_id}")
algorithm_scores[algorithm_name] = test_scores
# Evaluate algorithms
self._evaluate_algorithms(
algorithms_attributes, algorithm_scores, self.save_dir
)
# Terminate algorithms
for algorithm_attributes in algorithms_attributes:
algorithm_name = algorithm_attributes.name
session_id = algorithm_attributes.session_id
self.harness.terminate_session(session_id)
log.info(f"Session ended for {algorithm_name}: {session_id}") | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/protocol/ond_protocol.py | 0.89303 | 0.202838 | ond_protocol.py | pypi |
import logging
from typing import List, Any, Tuple, Dict
from sail_on_client.protocol.visual_dataclasses import (
FeatureExtractionParams,
WorldChangeDetectionParams,
)
from sail_on_client.harness.test_and_evaluation_harness import (
TestAndEvaluationHarnessType,
)
from sail_on_client.utils.utils import safe_remove
from sail_on_client.utils.decorators import skip_stage
log = logging.getLogger(__name__)
class VisualRound:
"""Class with common elements for visual protocols."""
def __init__(
self,
algorithm: Any,
data_root: str,
features_dict: Dict,
harness: TestAndEvaluationHarnessType,
logit_dict: Dict,
redlight_instance: str,
session_id: str,
skip_stages: List[str],
test_id: str,
) -> None:
"""
Construct VisualRound.
Args:
algorithm: An instance of algorithm
data_root: Root directory of the data
features_dict: Dictionary with features for the entire dataset
harness: An instance of the harness used for T&E
logit_dict: Dictionary with logits for the entire dataset
redlight_instance: The instance when the world changes
session_id: Session id associated with the algorithm
skip_stages: List of stages that are skipped
test_id: Test id associated with the round
Returns:
None
"""
self.algorithm = algorithm
self.data_root = data_root
self.features_dict = features_dict
self.harness = harness
self.logit_dict = logit_dict
self.redlight_instance = redlight_instance
self.session_id = session_id
self.skip_stages = skip_stages
self.test_id = test_id
@staticmethod
def get_instance_ids(dataset_path: str) -> List[str]:
"""
Get instance ids from the dataset.
Args:
dataset_path: Path to text file with instances used in a round
Returns:
List of instance ids from the dataset
"""
with open(dataset_path, "r") as dataset:
instance_ids = dataset.readlines()
instance_ids = [instance_id.strip() for instance_id in instance_ids]
return instance_ids
@skip_stage("FeatureExtraction", ({}, {}))
def _run_feature_extraction(
self, fe_params: FeatureExtractionParams, instance_ids: List[str]
) -> Tuple[Dict, Dict]:
"""
Private helper function for running feature extraction.
Args:
fe_params: An instance of dataclass with parameters for feature extraction
instance_ids: Identifiers associated with data for a round
Returns:
Tuple for feature and logit dictionary for a round
"""
rfeature_dict, rlogit_dict = {}, {}
if len(self.features_dict) > 0 and len(self.logit_dict) > 0:
for instance_id in instance_ids:
rfeature_dict[instance_id] = self.features_dict[instance_id]
rlogit_dict[instance_id] = self.logit_dict[instance_id]
else:
fe_toolset = fe_params.get_toolset()
rfeature_dict, rlogit_dict = self.algorithm.execute(
fe_toolset, "FeatureExtraction"
)
self.rfeature_dict, self.rlogit_dict = rfeature_dict, rlogit_dict
return rfeature_dict, rlogit_dict
@skip_stage("WorldDetection")
def _run_world_change_detection(
self,
wcd_params: WorldChangeDetectionParams,
round_id: int,
) -> None:
"""
Private helper function for detecting that the world has changed.
Args:
wcd_params: An instance of dataclass with parameters for world change detection
round_id: Identifier for a round
Returns:
None
"""
wd_result = self.algorithm.execute(wcd_params.get_toolset(), "WorldDetection")
self.harness.post_results(
{"detection": wd_result}, self.test_id, round_id, self.session_id
)
safe_remove(wd_result) | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/protocol/visual_round.py | 0.92215 | 0.390708 | visual_round.py | pypi |
from sail_on_client.agent.condda_agent import CONDDAAgent
from sail_on_client.harness.test_and_evaluation_harness import (
TestAndEvaluationHarnessType,
)
from sail_on_client.protocol.visual_protocol import VisualProtocol
from sail_on_client.protocol.condda_dataclasses import AlgorithmAttributes
from sail_on_client.protocol.condda_test import CONDDATest
import logging
from typing import Dict, List
log = logging.getLogger(__name__)
class Condda(VisualProtocol):
"""CONDDA protocol."""
def __init__(
self,
algorithms: Dict[str, CONDDAAgent],
dataset_root: str,
domain: str,
harness: TestAndEvaluationHarnessType,
save_dir: str,
seed: str,
test_ids: List[str],
feature_extraction_only: bool = False,
hints: List = None,
is_eval_enabled: bool = False,
is_eval_roundwise_enabled: bool = False,
resume_session: bool = False,
resume_session_ids: Dict = None,
save_attributes: bool = False,
saved_attributes: Dict = None,
save_elementwise: bool = False,
save_features: bool = False,
feature_dir: str = "",
skip_stages: List = None,
use_consolidated_features: bool = False,
use_saved_attributes: bool = False,
use_saved_features: bool = False,
) -> None:
"""
Initialize CONDDA protocol object.
Args:
algorithms: Dictionary of algorithms that are used run based on the protocol
dataset_root: Root directory of the dataset
domain: Domain of the problem
save_dir: Directory where results are saved
seed: Seed for the experiments
test_ids: List of tests
feature_extraction_only: Flag to only run feature extraction
hints: List of hint provided in the session
harness: A harness for test and evaluation
is_eval_enabled: Flag to check if evaluation is enabled in session
is_eval_roundwise_enabled: Flag to check if evaluation is enabled for rounds
resume_session: Flag to resume session
resume_session_ids: Dictionary for resuming sessions
save_attributes: Flag to save attributes
saved_attributes: Dictionary for attributes
save_elementwise: Flag to save features elementwise
save_features: Flag to save features
feature_dir: Directory to save features
skip_stages: List of stages that are skipped
use_consolidated_features: Flag to use consolidated features
use_saved_attributes: Flag to use saved attributes
use_saved_features: Flag to use saved features
Returns:
None
"""
super().__init__(algorithms, harness)
self.dataset_root = dataset_root
self.domain = domain
self.feature_extraction_only = feature_extraction_only
self.feature_dir = feature_dir
if hints is None:
self.hints = []
else:
self.hints = hints
self.is_eval_enabled = is_eval_enabled
self.is_eval_roundwise_enabled = is_eval_roundwise_enabled
self.resume_session = resume_session
if resume_session_ids is None:
self.resume_session_ids = {}
else:
self.resume_session_ids = resume_session_ids
self.save_attributes = save_attributes
if saved_attributes is None:
self.saved_attributes = {}
else:
self.saved_attributes = saved_attributes
self.save_dir = save_dir
self.save_elementwise = save_elementwise
self.save_features = save_features
if skip_stages is None:
self.skip_stages = []
else:
self.skip_stages = skip_stages
self.seed = seed
self.test_ids = test_ids
self.use_consolidated_features = use_consolidated_features
self.use_saved_attributes = use_saved_attributes
self.use_saved_features = use_saved_features
def create_algorithm_attributes(
self, algorithm_name: str, algorithm_param: Dict, test_ids: List[str]
) -> AlgorithmAttributes:
"""
Create an instance of algorithm attributes.
Args:
algorithm_name: Name of the algorithm
algorithm_param: Parameters for the algorithm
baseline_algorithm_name: Name of the baseline algorithm
has_baseline: Flag to check if a baseline is present in the config
has_reaction_baseline: Flag to check if a reaction baseline is present in the config
test_ids: List of test
Returns:
An instance of AlgorithmAttributes
"""
algorithm_instance = self.algorithms[algorithm_name]
session_id = self.resume_session_ids.get(algorithm_name, "")
return AlgorithmAttributes(
algorithm_name,
algorithm_param.get("detection_threshold", 0.5),
algorithm_instance,
algorithm_param.get("package_name", None),
algorithm_param,
session_id,
test_ids,
)
def create_algorithm_session(
self,
algorithm_attributes: AlgorithmAttributes,
domain: str,
hints: List[str],
has_a_session: bool,
protocol_name: str,
) -> AlgorithmAttributes:
"""
Create/resume session for an algorithm.
Args:
algorithm_attributes: An instance of AlgorithmAttributes
domain: Domain for the algorithm
hints: List of hints used in the session
has_a_session: Already has a session and we want to resume it
protocol_name: Name of the algorithm
Returns:
An AlgorithmAttributes object with updated session id or test id
"""
test_ids = algorithm_attributes.test_ids
named_version = algorithm_attributes.named_version()
detection_threshold = algorithm_attributes.detection_threshold
if has_a_session:
session_id = algorithm_attributes.session_id
finished_test = self.harness.resume_session(session_id)
algorithm_attributes.remove_completed_tests(finished_test)
log.info(f"Resumed session {session_id} for {algorithm_attributes.name}")
else:
session_id = self.harness.session_request(
test_ids,
protocol_name,
domain,
named_version,
hints,
detection_threshold,
)
algorithm_attributes.session_id = session_id
log.info(f"Created session {session_id} for {algorithm_attributes.name}")
return algorithm_attributes
def update_skip_stages(
self, skip_stages: List[str], save_features: bool, feature_extraction_only: bool
) -> List[str]:
"""
Update skip stages based on the boolean values in config.
Args:
skip_stages: List of skip stages specified in the config
is_eval_enabled: Flag to enable evaluation
is_eval_roundwise_enabled: Flag to enable evaluation in every round
use_feedback: Flag to enable using feedback
save_features: Flag to enable saving features
feature_extraction_only: Flag to only run feature extraction
Returns:
Update list of skip stages
"""
if not save_features:
skip_stages.append("SaveFeatures")
if feature_extraction_only:
skip_stages.append("WorldDetection")
skip_stages.append("NoveltyCharacterization")
return skip_stages
def run_protocol(self, config: Dict) -> None:
"""
Run protocol.
Args:
config: Parameters provided in the config
Returns:
None
"""
log.info("Starting CONDDA")
self.skip_stages = self.update_skip_stages(
self.skip_stages, self.save_features, self.feature_extraction_only
)
algorithms_attributes = []
# Populate most of the attributes for the algorithm
for algorithm_name in self.algorithms.keys():
algorithm_param = self.algorithms[algorithm_name].get_config()
algorithm_attributes = self.create_algorithm_attributes(
algorithm_name, algorithm_param, self.test_ids
)
log.info(f"Consolidating attributes for {algorithm_name}")
algorithms_attributes.append(algorithm_attributes)
# Create sessions an instances of all the algorithms and populate
# session_id for algorithm attributes
for idx, algorithm_attributes in enumerate(algorithms_attributes):
algorithms_attributes[idx] = self.create_algorithm_session(
algorithm_attributes,
self.domain,
self.hints,
self.resume_session,
"CONDDA",
)
# Run tests for all the algorithms
for algorithm_attributes in algorithms_attributes:
algorithm_name = algorithm_attributes.name
session_id = algorithm_attributes.session_id
test_ids = algorithm_attributes.test_ids
log.info(f"Starting session: {session_id} for algorithm: {algorithm_name}")
skip_stages = self.skip_stages.copy()
condda_test = CONDDATest(
algorithm_attributes,
self.dataset_root,
self.domain,
"",
self.harness,
self.save_dir,
session_id,
skip_stages,
self.use_consolidated_features,
self.use_saved_features,
)
for test_id in test_ids:
log.info(f"Start test: {test_id}")
condda_test(test_id)
log.info(f"Test complete: {test_id}")
# Terminate algorithms
for algorithm_attributes in algorithms_attributes:
algorithm_name = algorithm_attributes.name
session_id = algorithm_attributes.session_id
self.harness.terminate_session(session_id)
log.info(f"Session ended for {algorithm_name}: {session_id}") | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/protocol/condda_protocol.py | 0.890732 | 0.265098 | condda_protocol.py | pypi |
from dataclasses import dataclass
import logging
from typing import Dict, List, Any, Union
from sail_on_client.utils.utils import merge_dictionaries
from sail_on_client.feedback.image_classification_feedback import (
ImageClassificationFeedback,
)
from sail_on_client.feedback.document_transcription_feedback import (
DocumentTranscriptionFeedback,
)
from sail_on_client.feedback.activity_recognition_feedback import (
ActivityRecognitionFeedback,
)
try:
from importlib.metadata import version, PackageNotFoundError # type:ignore
except ModuleNotFoundError:
from importlib_metadata import version, PackageNotFoundError # type: ignore
log = logging.getLogger(__name__)
@dataclass
class AlgorithmAttributes:
"""Class for storing attributes of algorithm present in the protocol."""
name: str
detection_threshold: float
instance: Any
is_baseline: bool
is_reaction_baseline: bool
package_name: str
parameters: Dict
session_id: str
test_ids: List[str]
def named_version(self) -> str:
"""
Compute version of an algorithm.
Returns:
A string containing name and the version number
"""
try:
if self.package_name:
version_number = version(self.package_name)
else:
log.warn("No package_name provided. Using 0.0.1 as stand in.")
version_number = "0.0.1"
except PackageNotFoundError:
log.warn(
"Failed to detect the version of the algorithm. Using 0.0.1 as stand in."
)
version_number = "0.0.1"
return f"{self.name}-{version_number}"
def remove_completed_tests(self, finished_tests: List[str]) -> None:
"""
Remove finished tests from test_ids.
Args:
finished_tests: List of tests that are complete
Returns:
None
"""
test_set = set(self.test_ids)
ftest_set = set(finished_tests)
self.test_ids = list(test_set ^ ftest_set)
def merge_detector_params(
self, detector_params: Dict, exclude_keys: List = None
) -> None:
"""
Merge common parameters with algorithm specific parameters with exclusions.
Args:
detector_params: Dictionary of common parameters
exclude_keys: List of keys that should be excluded in the merge
Returns:
None
"""
if not exclude_keys:
exclude_keys = []
self.parameters = merge_dictionaries(
self.parameters, detector_params, exclude_keys
)
@dataclass
class InitializeParams:
"""Class for storing parameters that are used to initialize the algorithm."""
parameters: Dict
session_id: str
test_id: str
pre_novelty_batches: int
feedback_instance: Union[
ImageClassificationFeedback,
DocumentTranscriptionFeedback,
ActivityRecognitionFeedback,
None,
]
def get_toolset(self) -> Dict:
"""
Convert the data present in the class into a dictionary.
Returns
A dictionary with data associated with the class
"""
algorithm_toolset = self.parameters.copy()
algorithm_toolset["session_id"] = self.session_id
algorithm_toolset["test_id"] = self.test_id
algorithm_toolset["test_type"] = ""
algorithm_toolset["pre_novelty_batches"] = self.pre_novelty_batches
if self.feedback_instance:
algorithm_toolset["FeedbackInstance"] = self.feedback_instance
return algorithm_toolset
@dataclass
class NoveltyClassificationParams:
"""Class for storing parameters associated novelty classification in an algorithm."""
features_dict: Dict
logit_dict: Dict
round_id: int
def get_toolset(self) -> Dict:
"""
Convert the data present in the class into a dictionary.
Returns
A dictionary with data associated with the class
"""
return {
"features_dict": self.features_dict,
"logit_dict": self.logit_dict,
"round_id": self.round_id,
}
@dataclass
class NoveltyAdaptationParams:
"""Class for storing parameters associated novelty adaptation with an algorithm."""
round_id: int
def get_toolset(self) -> Dict:
"""
Convert the data present in the class into a dictionary.
Returns
A dictionary with data associated with the class
"""
return {
"round_id": self.round_id,
}
@dataclass
class NoveltyCharacterizationParams:
"""Class for storing parameters associated novelty characterization with an algorithm."""
dataset_ids: List[str]
def get_toolset(self) -> Dict:
"""
Convert the data present in the class into a dictionary.
Returns
A dictionary with data associated with the class
"""
return {"dataset_ids": self.dataset_ids} | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/protocol/ond_dataclasses.py | 0.932837 | 0.278824 | ond_dataclasses.py | pypi |
import logging
from typing import List, Dict, Any
from sail_on_client.harness.test_and_evaluation_harness import (
TestAndEvaluationHarnessType,
)
from sail_on_client.utils.decorators import skip_stage
from sail_on_client.protocol.visual_round import VisualRound
from sail_on_client.protocol.condda_dataclasses import NoveltyCharacterizationParams
from sail_on_client.protocol.visual_dataclasses import (
FeatureExtractionParams,
WorldChangeDetectionParams,
)
log = logging.getLogger(__name__)
class CONDDARound(VisualRound):
"""Class Representing a round for CONDDA."""
def __init__(
self,
algorithm: Any,
data_root: str,
features_dict: Dict,
harness: TestAndEvaluationHarnessType,
logit_dict: Dict,
redlight_instance: str,
session_id: str,
skip_stages: List[str],
test_id: str,
) -> None:
"""
Construct CONDDARound.
Args:
algorithm: An instance of algorithm
data_root: Root directory of the data
features_dict: Dictionary with features for the entire dataset
harness: An instance of the harness used for T&E
logit_dict: Dictionary with logits for the entire dataset
redlight_instance: The instance when the world changes
session_id: Session id associated with the algorithm
skip_stages: List of stages that are skipped
test_id: Test id associated with the round
Returns:
None
"""
super().__init__(
algorithm,
data_root,
features_dict,
harness,
logit_dict,
redlight_instance,
session_id,
skip_stages,
test_id,
)
@skip_stage("NoveltyCharacterization")
def _run_novelty_characterization(
self, nc_params: NoveltyCharacterizationParams, round_id: int
) -> None:
characterization_results = self.algorithm.execute(
nc_params.get_toolset(), "NoveltyCharacterization"
)
if characterization_results:
if isinstance(characterization_results, dict):
self.harness.post_results(
characterization_results, self.test_id, round_id, self.session_id
)
else:
results = {"characterization": characterization_results}
self.harness.post_results(
results, self.test_id, round_id, self.session_id
)
else:
log.warn("No characterization result provided by the algorithm")
def __call__(self, dataset: str, round_id: int) -> None:
"""
Core logic for running round in CONDDA.
Args:
dataset: Path to a file with the dataset for the round
round_id: An Identifier for a round
Returns:
None
"""
# Run feature extraction
fe_params = FeatureExtractionParams(dataset, self.data_root, round_id)
instance_ids = CONDDARound.get_instance_ids(dataset)
rfeature_dict, rlogit_dict = self._run_feature_extraction(
fe_params, instance_ids
)
# Run World Change Detection
wc_params = WorldChangeDetectionParams(
rfeature_dict, rlogit_dict, round_id, self.redlight_instance
)
self._run_world_change_detection(wc_params, round_id)
# Run Novelty Classification
nc_params = NoveltyCharacterizationParams(rfeature_dict, rlogit_dict, round_id)
self._run_novelty_characterization(nc_params, round_id) | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/protocol/condda_round.py | 0.909196 | 0.262795 | condda_round.py | pypi |
import logging
from typing import List, Any, Dict, Union
from sail_on_client.protocol.ond_dataclasses import (
NoveltyClassificationParams,
NoveltyAdaptationParams,
)
from sail_on_client.protocol.visual_dataclasses import (
FeatureExtractionParams,
WorldChangeDetectionParams,
)
from sail_on_client.protocol.visual_round import VisualRound
from sail_on_client.harness.test_and_evaluation_harness import (
TestAndEvaluationHarnessType,
)
from sail_on_client.utils.utils import safe_remove
from sail_on_client.utils.decorators import skip_stage
log = logging.getLogger(__name__)
class ONDRound(VisualRound):
"""Class Representing a round in OND."""
def __init__(
self,
algorithm: Any,
data_root: str,
features_dict: Dict,
harness: TestAndEvaluationHarnessType,
logit_dict: Dict,
redlight_instance: str,
session_id: str,
skip_stages: List[str],
test_id: str,
) -> None:
"""
Construct round for OND.
Args:
algorithm: An instance of algorithm
data_root: Root directory of the data
features_dict: Dictionary with features for the entire dataset
harness: An instance of the harness used for T&E
logit_dict: Dictionary with logits for the entire dataset
redlight_instance: The instance when the world changes
session_id: Session id associated with the algorithm
skip_stages: List of stages that are skipped
test_id: Test id associated with the round
Returns:
None
"""
super().__init__(
algorithm,
data_root,
features_dict,
harness,
logit_dict,
redlight_instance,
session_id,
skip_stages,
test_id,
)
@skip_stage("NoveltyClassification")
def _run_novelty_classification(
self, nc_params: NoveltyClassificationParams, round_id: int
) -> None:
"""
Private helper function for novelty classification.
Args:
nc_params: An instance of dataclass with parameters for novelty classification
round_id: Identifier for a round
Returns:
None
"""
ncl_result = self.algorithm.execute(
nc_params.get_toolset(), "NoveltyClassification"
)
self.harness.post_results(
{"classification": ncl_result}, self.test_id, round_id, self.session_id
)
safe_remove(ncl_result)
@skip_stage("EvaluateRoundwise")
def _evaluate_roundwise(self, round_id: int) -> Dict:
"""
Compute roundwise accuracy.
Args:
round_id: Identifier for a round
Returns:
Dictionary with accuracy metrics for round
"""
return self.harness.evaluate_round_wise(self.test_id, round_id, self.session_id)
@skip_stage("NoveltyAdaptation")
def _run_novelty_adaptation(self, na_params: NoveltyAdaptationParams) -> None:
"""
Private helper function for adaptation.
Args:
na_params: An instance of dataclass with parameters for adaptation
Returns:
None
"""
return self.algorithm.execute(na_params.get_toolset(), "NoveltyAdaptation")
def __call__(self, dataset: str, round_id: int) -> Union[Dict, None]:
"""
Core logic for running round in OND.
Args:
algorithm: An instance of the algorithm
dataset: Path to a file with the dataset for the round
round_id: An Identifier for a round
Returns:
Score for the round
"""
# Run feature extraction
fe_params = FeatureExtractionParams(dataset, self.data_root, round_id)
instance_ids = ONDRound.get_instance_ids(dataset)
rfeature_dict, rlogit_dict = self._run_feature_extraction(
fe_params, instance_ids
)
# Run World Change Detection
wc_params = WorldChangeDetectionParams(
rfeature_dict, rlogit_dict, round_id, self.redlight_instance
)
self._run_world_change_detection(wc_params, round_id)
# Run Novelty Classification
nc_params = NoveltyClassificationParams(rfeature_dict, rlogit_dict, round_id)
self._run_novelty_classification(nc_params, round_id)
# Compute metrics for the round
round_score = self._evaluate_roundwise(round_id)
na_params = NoveltyAdaptationParams(round_id)
self._run_novelty_adaptation(na_params)
return round_score | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/protocol/ond_round.py | 0.942837 | 0.324115 | ond_round.py | pypi |
import logging
from typing import Dict, TypeVar, Type, Any
from sail_on_client.harness.test_and_evaluation_harness import (
TestAndEvaluationHarnessType,
)
from sail_on_client.agent.visual_agent import VisualAgentType
from tinker.protocol import Protocol
from tinker.configuration import process_config
log = logging.getLogger(__name__)
VisualProtocolType = TypeVar("VisualProtocolType", bound="VisualProtocol")
class VisualProtocol(Protocol):
"""Protocol for visual tasks."""
def __init__(
self,
algorithms: Dict[str, VisualAgentType],
harness: TestAndEvaluationHarnessType,
) -> None:
"""
Construct visual protocol.
Args:
algorithms: Dictionary of algorithms that are used run based on the protocol
harness: A harness for test and evaluation
Returns:
None
"""
super().__init__()
self.algorithms = algorithms
self.harness = harness
@classmethod
def from_config(
cls: Type[VisualProtocolType], config_dict: Dict, merge_default: bool = True
) -> VisualProtocolType:
"""
Construct protocol from config.
Args:
config_dict: dictionary with parameters
merge_default: Merge dictionary with default values
Returns:
An instance of visual protocol
"""
config_dict = dict(config_dict)
algorithm_configs = config_dict.get("algorithms", None)
if not algorithm_configs:
raise ValueError("No algorithms provided in the config.")
for algorithm_name, algorithm_config in algorithm_configs.items():
config_dict["algorithms"][algorithm_name] = process_config(algorithm_config)
harness_config = config_dict.get("harness", None)
if not harness_config:
raise ValueError("Harness parameters not provided in the config.")
config_dict["harness"] = process_config(harness_config)
return super().from_config(config_dict, merge_default=merge_default)
def get_config(self) -> Dict:
"""
Get json compliant representation of the protocol.
Returns:
Dictionary with json compliant representation of the protocol
"""
cfg: Dict[str, Any] = {"algorithms": {}}
for algorithm_name, algorithm in self.algorithms.items():
cfg["algorithms"][algorithm_name] = {}
cfg["algorithms"][algorithm_name]["config"] = algorithm.get_config()
cfg["algorithms"][algorithm_name]["class"] = algorithm.__class__.__name__
cfg["harness"] = {}
cfg["harness"]["config"] = self.harness.get_config()
cfg["harness"]["class"] = self.harness.__class__.__name__
return cfg | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/protocol/visual_protocol.py | 0.92258 | 0.270339 | visual_protocol.py | pypi |
from dataclasses import dataclass
import logging
from typing import Dict, List, Any
from sail_on_client.utils.utils import merge_dictionaries
try:
from importlib.metadata import version, PackageNotFoundError # type:ignore
except ModuleNotFoundError:
from importlib_metadata import version, PackageNotFoundError # type: ignore
log = logging.getLogger(__name__)
@dataclass
class AlgorithmAttributes:
"""Class for storing attributes of algorithm present in the protocol."""
name: str
detection_threshold: float
instance: Any
package_name: str
parameters: Dict
session_id: str
test_ids: List[str]
def named_version(self) -> str:
"""
Compute version of an algorithm.
Returns:
A string containing name and the version number
"""
try:
if self.package_name:
version_number = version(self.package_name)
else:
log.warn("No package_name provided. Using 0.0.1 as stand in.")
version_number = "0.0.1"
except PackageNotFoundError:
log.warn(
"Failed to detect the version of the algorithm. Using 0.0.1 as stand in."
)
version_number = "0.0.1"
return f"{self.name}-{version_number}"
def remove_completed_tests(self, finished_tests: List[str]) -> None:
"""
Remove finished tests from test_ids.
Args:
finished_tests: List of tests that are complete
Returns:
None
"""
test_set = set(self.test_ids)
ftest_set = set(finished_tests)
self.test_ids = list(test_set ^ ftest_set)
def merge_detector_params(
self, detector_params: Dict, exclude_keys: List = None
) -> None:
"""
Merge common parameters with algorithm specific parameters with exclusions.
Args:
detector_params: Dictionary of common parameters
exclude_keys: List of keys that should be excluded in the merge
Returns:
None
"""
if not exclude_keys:
exclude_keys = []
self.parameters = merge_dictionaries(
self.parameters, detector_params, exclude_keys
)
@dataclass
class InitializeParams:
"""Class for storing parameters that are used to initialize the algorithm."""
parameters: Dict
session_id: str
test_id: str
def get_toolset(self) -> Dict:
"""
Convert the data present in the class into a dictionary.
Returns
A dictionary with data associated with the class
"""
algorithm_toolset = self.parameters.copy()
algorithm_toolset["session_id"] = self.session_id
algorithm_toolset["test_id"] = self.test_id
algorithm_toolset["test_type"] = ""
return algorithm_toolset
@dataclass
class NoveltyCharacterizationParams:
"""Class for storing parameters associated novelty characterization with an algorithm."""
features_dict: Dict
logit_dict: Dict
round_id: int
def get_toolset(self) -> Dict:
"""
Convert the data present in the class into a dictionary.
Returns
A dictionary with data associated with the class
"""
return {
"features_dict": self.features_dict,
"logit_dict": self.logit_dict,
"round_id": self.round_id,
} | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/protocol/condda_dataclasses.py | 0.922822 | 0.30905 | condda_dataclasses.py | pypi |
import requests
import json
import io
import os
import traceback
import logging
from sail_on_client.harness.test_and_evaluation_harness import TestAndEvaluationHarness
from typing import Any, Dict, Union, List
from requests import Response
from sail_on_client.errors import ApiError, RoundError
from tenacity import (
retry,
stop_after_attempt,
wait_fixed,
before_sleep_log,
)
from json import JSONDecodeError
log = logging.getLogger(__name__)
class ParHarness(TestAndEvaluationHarness):
"""Harness for PAR server."""
def __init__(self, url: str, save_directory: str) -> None:
"""
Initialize a client connection object.
Args:
url: URL for the server
save_directory: A directory to save files
Returns:
None
"""
TestAndEvaluationHarness.__init__(self)
self.url = url
self.save_directory = save_directory
def get_config(self) -> Dict:
"""JSON Compliant representation of the object."""
return {"url": self.url, "save_directory": self.save_directory}
def _check_response(self, response: Response) -> None:
"""
Parse errors that present in the server response.
Args:
response: The response object obtained from the server
Returns:
None
"""
if response.status_code != 200:
try:
response_json = response.json()
# Find the appropriate error class based on error code.
for subclass in ApiError.error_classes():
if subclass.error_code == response.status_code:
raise subclass(
response_json["reason"],
response_json["message"],
response_json["stack_trace"],
)
except JSONDecodeError:
log.exception(f"Server Error: {traceback.format_exc()}")
exit(1)
@retry(
stop=stop_after_attempt(5),
wait=wait_fixed(2),
reraise=True,
before_sleep=before_sleep_log(log, logging.INFO),
)
def test_ids_request(
self,
protocol: str,
domain: str,
detector_seed: str,
test_assumptions: str = "{}",
) -> str:
"""
Request Test Identifiers as part of a series of individual tests.
Args:
protocol : string indicating which protocol is being evaluated
domain : problem domain for the tests
detector_seed : A seed provided by the novelty detector
test_assumptions : Assumptions used by the detector
Returns:
Filename of file containing test ids
"""
payload = {
"protocol": protocol,
"domain": domain,
"detector_seed": detector_seed,
}
with open(test_assumptions, "r") as f:
contents = f.read()
response = requests.get(
f"{self.url}/test/ids",
files={ # type: ignore
"test_requirements": io.StringIO(json.dumps(payload)),
"test_assumptions": io.StringIO(contents),
},
)
self._check_response(response)
filename = os.path.abspath(
os.path.join(
self.save_directory, f"{protocol}.{domain}.{detector_seed}.csv"
)
)
with open(filename, "w") as f:
f.write(response.content.decode("utf-8"))
return filename
@retry(
stop=stop_after_attempt(5),
wait=wait_fixed(2),
reraise=True,
before_sleep=before_sleep_log(log, logging.INFO),
)
def session_request(
self,
test_ids: list,
protocol: str,
domain: str,
novelty_detector_version: str,
hints: list,
detection_threshold: float,
) -> str:
"""
Create a new session to evaluate the detector using an empirical protocol.
Args:
test_ids: List of tests being evaluated in this session
protocol: String indicating which protocol is being evaluated
domain: String indicating which domain is being evaluated
novelty_detector_version: The novelty detector being evaluated
hints: Hints used for the session
detection_threshold: Detection threshold for the session
Returns:
A session identifier provided by the server
"""
payload = {
"protocol": protocol,
"novelty_detector_version": novelty_detector_version,
"domain": domain,
"hints": hints,
"detection_threshold": detection_threshold,
}
ids = "\n".join(test_ids) + "\n"
response = requests.post(
f"{self.url}/session",
files={"test_ids": ids, "configuration": io.StringIO(json.dumps(payload))}, # type: ignore
)
self._check_response(response)
return response.json()["session_id"]
@retry(
stop=stop_after_attempt(5),
wait=wait_fixed(2),
reraise=True,
before_sleep=before_sleep_log(log, logging.INFO),
)
def resume_session(self, session_id: str) -> List[str]:
"""
Get finished test from an existing session.
Args:
session id : Session id that was started but not terminated
Returns:
List of tests finished in the session
"""
params: Dict[str, str] = {"session_id": session_id}
response = requests.get(f"{self.url}/session/latest", params=params)
self._check_response(response)
return response.json()["finished_tests"]
@retry(
stop=stop_after_attempt(5),
wait=wait_fixed(2),
reraise=True,
before_sleep=before_sleep_log(log, logging.INFO),
)
def dataset_request(self, test_id: str, round_id: int, session_id: str) -> str:
"""
Request data for evaluation.
Args:
test_id: The test being evaluated at this moment.
round_id: The sequential number of the round being evaluated
session_id: The identifier provided by the server for a single experiment
Returns:
Filename of a file containing a list of image files (including full path for each)
"""
params: Dict[str, Union[str, int]] = {
"session_id": session_id,
"test_id": test_id,
"round_id": round_id,
}
response = requests.get(
f"{self.url}/session/dataset",
params=params,
)
if response.status_code == 204:
raise RoundError("End of Dataset", "The entire dataset has been requested")
self._check_response(response)
filename = os.path.abspath(
os.path.join(self.save_directory, f"{session_id}.{test_id}.{round_id}.csv")
)
with open(filename, "wb") as f:
f.write(response.content)
return filename
@retry(
stop=stop_after_attempt(5),
wait=wait_fixed(2),
reraise=True,
before_sleep=before_sleep_log(log, logging.INFO),
)
def get_feedback_request(
self,
feedback_ids: list,
feedback_type: str,
test_id: str,
round_id: int,
session_id: str,
) -> str:
"""
Get Labels from the server based provided one or more example ids.
Args:
feedback_ids: List of media ids for which feedback is required
feedback_type: Protocols constants with the values: label, detection, characterization
test_id: The id of the test currently being evaluated
round_id: The sequential number of the round being evaluated
session_id: The id provided by a server denoting a session
Returns:
Path to a file containing containing requested feedback
"""
params: Dict[str, Union[str, int]] = {
"feedback_ids": "|".join(feedback_ids),
"session_id": session_id,
"test_id": test_id,
"feedback_type": feedback_type,
}
response = requests.get(
f"{self.url}/session/feedback",
params=params,
)
self._check_response(response)
filename = os.path.abspath(
os.path.join(
self.save_directory,
f"{session_id}.{test_id}.{round_id}_{feedback_type}.csv",
)
)
with open(filename, "wb") as f:
f.write(response.content)
return filename
@retry(
stop=stop_after_attempt(5),
wait=wait_fixed(2),
reraise=True,
before_sleep=before_sleep_log(log, logging.INFO),
)
def post_results(
self, result_files: Dict[str, str], test_id: str, round_id: int, session_id: str
) -> None:
"""
Post client detector predictions for the dataset.
Args:
result_files: A dictionary of results with protocol constant as key and file path as value
test_id: The id of the test currently being evaluated
round_id: The sequential number of the round being evaluated
session_id: The id provided by a server denoting a session
Returns:
None
"""
payload = {
"session_id": session_id,
"test_id": test_id,
"round_id": round_id,
"result_types": "|".join(result_files.keys()),
}
files = {"test_identification": io.StringIO(json.dumps(payload))}
if len(result_files.keys()) == 0:
raise Exception("Must provide at least one result file")
for r_type in result_files:
with open(result_files[r_type], "r") as f:
contents = f.read()
files[f"{r_type}_file"] = io.StringIO(contents)
response = requests.post(f"{self.url}/session/results", files=files) # type: ignore
self._check_response(response)
@retry(
stop=stop_after_attempt(5),
wait=wait_fixed(2),
reraise=True,
before_sleep=before_sleep_log(log, logging.INFO),
)
def evaluate_round_wise(
self,
test_id: str,
round_id: int,
session_id: str,
) -> Dict[str, Any]:
"""
Get results for round(s).
Args:
test_id: The id of the test currently being evaluated
round_id: The sequential number of the round being evaluated
session_id: The id provided by a server denoting a session
Returns:
Path to a file with the results
"""
raise NotImplementedError("Round wise accuracy computation is not supported")
@retry(
stop=stop_after_attempt(5),
wait=wait_fixed(2),
reraise=True,
before_sleep=before_sleep_log(log, logging.INFO),
)
def evaluate(
self,
test_id: str,
round_id: int,
session_id: str,
baseline_session_id: str = None,
) -> Dict:
"""
Get results for test(s).
Args:
test_id: The id of the test currently being evaluated
round_id: The sequential number of the round being evaluated
session_id: The id provided by a server denoting a session
Returns:
Path to a file with the results
"""
params: Dict[str, Union[str, int]] = {
"session_id": session_id,
"test_id": test_id,
"round_id": round_id,
}
response = requests.get(
f"{self.url}/session/evaluations",
params=params,
)
self._check_response(response)
return json.loads(response.text)
@retry(
stop=stop_after_attempt(5),
wait=wait_fixed(2),
reraise=True,
before_sleep=before_sleep_log(log, logging.INFO),
)
def get_test_metadata(self, session_id: str, test_id: str) -> Dict[str, Any]:
"""
Retrieve the metadata json for the specified test.
Args:
session_id: The id of the session currently being evaluated
test_id: The id of the test currently being evaluated
Returns:
A dictionary containing metadata
"""
response = requests.get(
f"{self.url}/test/metadata",
params={"test_id": test_id, "session_id": session_id},
)
self._check_response(response)
return response.json()
@retry(
stop=stop_after_attempt(5),
wait=wait_fixed(2),
reraise=True,
before_sleep=before_sleep_log(log, logging.INFO),
)
def complete_test(self, session_id: str, test_id: str) -> None:
"""
Mark test as completed.
Args:
session_id: The id of the session currently being evaluated
test_id: The id of the test currently being evaluated
Returns:
None
"""
requests.delete(
f"{self.url}/test",
params={"test_id": test_id, "session_id": session_id},
)
@retry(
stop=stop_after_attempt(5),
wait=wait_fixed(2),
reraise=True,
before_sleep=before_sleep_log(log, logging.INFO),
)
def terminate_session(self, session_id: str) -> None:
"""
Terminate the session after the evaluation for the protocol is complete.
Args:
session_id: The id provided by a server denoting a session
Returns: None
"""
response = requests.delete(
f"{self.url}/session", params={"session_id": session_id}
)
self._check_response(response) | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/harness/par_harness.py | 0.903752 | 0.192312 | par_harness.py | pypi |
from typing import Any, List, Tuple, Dict
def _get_all_subclasses(cls: Any) -> List[Any]:
from itertools import chain
return list(
chain.from_iterable(
[
list(chain.from_iterable([[x], _get_all_subclasses(x)]))
for x in cls.__subclasses__()
]
)
)
class ApiError(Exception):
"""Base class for all server side error conditions."""
reason = "Unknown"
msg = ""
stack_trace = "stack trace unavailable"
error_code = 500
def __init__(
self, reason: str, msg: str, stack_trace: str = "stack trace unavailable"
):
"""
Initialize the api error object.
Args:
reason: Cause for the error
msg: Additional message associated with the error
stack_trace: Stack trace associated with the error
Returns:
None
"""
self.reason = reason
self.msg = msg
self.stack_trace = stack_trace
@staticmethod
def error_classes() -> List[Any]:
"""
Return all error classes in the system.
Returns:
List of subclasses of server error
"""
return _get_all_subclasses(ApiError)
def flask_response(self) -> Tuple[Dict[str, str], int]:
"""
Convert the object to a Flask response.
Returns:
Tuple of response obtained from server and error code
"""
response = {
"reason": self.reason,
"message": self.msg,
"stack_trace": self.stack_trace,
}
return response, self.error_code
class ServerError(ApiError):
"""500-series error indicating general problem on the serverside."""
error_code = 500
def __init__(
self, reason: str, msg: str, stack_trace: str = "stack trace unavailable"
):
"""
Initialize the server error object.
Args:
reason: Cause for the error
msg: Additional message associated with the error
stack_trace: Stack trace associated with the error
Returns:
None
"""
super().__init__(reason, msg, stack_trace)
class RoundError(ServerError):
"""Error indicating problem with rounds."""
error_code = 204
def __init__(
self, reason: str, msg: str, stack_trace: str = "stack trace unavailable"
):
"""
Initialize the round error object.
Args:
reason: Cause for the error
msg: Additional message associated with the error
stack_trace: Stack trace associated with the error
Returns:
None
"""
super().__init__(reason, msg, stack_trace)
class ProtocolError(ApiError):
"""400-series error indicating caller caused a problem engaging a protocol."""
error_code = 400
def __init__(
self, reason: str, msg: str, stack_trace: str = "stack trace unavailable"
):
"""
Initialize the Protocol error object.
Args:
reason: Cause for the error
msg: Additional message associated with the error
stack_trace: Stack trace associated with the error
Returns:
None
"""
super().__init__(reason, msg, stack_trace) | /sail_on_client-0.30.0-py3-none-any.whl/sail_on_client/errors/errors.py | 0.959068 | 0.253243 | errors.py | pypi |
import wave
import numpy as np
import pandas as pd
class FreqAnalysis:
"""
spectrum analysis class
"""
def __init__(self, file_name: str):
wav = wave.open(file_name, 'rb')
n_frames = wav.getnframes()
self._frame_rate = wav.getframerate()
self._duration = n_frames / self._frame_rate
str_data = wav.readframes(n_frames)
wave_data = np.frombuffer(str_data, dtype=np.short)
wave_data.shape = -1, 1
self._wave_data = wave_data.T
wav.close()
def spectrum(self, start_offset: int, window: int, cutoff=5000) -> tuple:
"""
spectrum of the targeted audio segment
:param start_offset:
:param window:
:param cutoff:
:return:
"""
total_samples = self._frame_rate * window
start = start_offset * self._frame_rate
data_freq = self._frame_rate / total_samples
spec = np.fft.fft(self._wave_data[0][start:start + total_samples])
max_idx = min(int(cutoff / data_freq), int(len(spec) / 2))
freq = np.arange(0, max_idx) * data_freq
spec = np.abs(spec[:max_idx])
spec[0] /= total_samples
spec[1:] /= total_samples / 2
return freq, spec
def freq_feature(self, buckets: list, start_offset: int, window: int, normalized: bool = False,
cutoff=5000) -> np.array:
"""
get the aggregated frequency features from spectrum
:param buckets: the buckets should not overlap
:param start_offset:
:param normalized:
:param window:
:param cutoff:
:return:
"""
freq, spec = self.spectrum(start_offset, window, cutoff)
freq_series = pd.Series(data=np.abs(spec), index=freq)
features = []
for bucket in buckets:
width = bucket[1] - bucket[0]
# the interval's both ends are closed
selected_freq = freq_series[bucket[0]:bucket[1]]
features.append(np.sum(selected_freq) / width)
features = np.array(features)
if normalized:
features = features / features.max()
return features
def __str__(self):
return f"frame_rate: {self._frame_rate}\n" \
f"duration: {self._duration}" | /sail-utils-0.2.24.tar.gz/sail-utils-0.2.24/sail_utils/audio/spectrum.py | 0.81721 | 0.300104 | spectrum.py | pypi |
from abc import (
ABC,
abstractmethod,
)
import cv2
from sail_utils import LOGGER
class _Streamer(ABC):
def __init__(self, source: str, rate: float):
self._source = source
self._rate = rate
self._stream = None
@property
def source(self) -> str:
"""
get the source
:return:
"""
return self._source
@property
def rate(self) -> float:
"""
get the sampling rate
:return:
"""
return self._rate
@property
def stream(self):
"""
get the internal stream
:return:
"""
return self._stream
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self._stream.release()
class _Detector(ABC):
def __init__(self,
server: str,
src_size: int,
dst_size: int,
threshold: float,
timeout: float):
self._server = server
self._threshold = threshold
self._mapper = _Mapper(src_size, dst_size)
self._timeout = timeout
LOGGER.info(f"detector at: <{self._server}> with threshold <{self._threshold:.2f}>")
@abstractmethod
def detect(self, img, epoch) -> list:
"""
method to detect a image
:param img:
:param epoch:
:return:
"""
def __str__(self):
return f"mapper: {self._mapper}\nserver: {self._server}"
class _Mapper:
def __init__(self, src: int, dst: int):
self._src = src
self._dst = dst
LOGGER.info(f"mapper from <{self._src}> to <{self._dst}>")
def resize(self, img):
"""
resize pic to destination size
:param img:
:return:
"""
return cv2.resize(img, (self._dst, self._dst), interpolation=cv2.INTER_AREA)
def __call__(self, bbox):
scale = self._src / self._dst
return [
int(bbox[0] * scale),
int(bbox[1] * scale),
int(bbox[2] * scale),
int(bbox[3] * scale),
]
def __str__(self):
return f"source: <{self._src} - destination: <{self._dst}>" | /sail-utils-0.2.24.tar.gz/sail-utils-0.2.24/sail_utils/cv/base.py | 0.904894 | 0.275909 | base.py | pypi |
import cv2
import numpy as np
from sail_utils import LOGGER
def _run_in_batches(func, data_dict, out, batch):
data_len = len(out)
num_batches = int(data_len / batch)
start, end = 0, 0
for i in range(num_batches):
start, end = i * batch, (i + 1) * batch
batch_data_dict = {k: v[start:end] for k, v in data_dict.items()}
out[start:end] = func(batch_data_dict)
if end < len(out):
batch_data_dict = {k: v[end:] for k, v in data_dict.items()}
out[end:] = func(batch_data_dict)
class ImageEncoder:
"""
image encoding class
"""
def __init__(self,
checkpoint: str,
input_name: str = "images",
output_name: str = "features"):
import tensorflow as tf
self._session = tf.Session()
with tf.gfile.GFile(checkpoint, 'rb') as f_handle:
graph = tf.GraphDef()
graph.ParseFromString(f_handle.read())
tf.import_graph_def(graph, name='net')
self._input = tf.get_default_graph().get_tensor_by_name("net/%s:0" % input_name)
self._output = tf.get_default_graph().get_tensor_by_name("net/%s:0" % output_name)
self._feature_dim = self._output.get_shape().as_list()[-1]
self._image_shape = self._input.get_shape().as_list()[1:]
@property
def image_shape(self):
"""
get image shape required for the net
:return:
"""
return self._image_shape
def encode(self, data_x, batch=32):
"""
encode detection results
:param data_x:
:param batch:
:return:
"""
out = np.zeros((len(data_x), self._feature_dim), np.float32)
_run_in_batches(
lambda x: self._session.run(self._output, feed_dict=x),
{self._input: data_x}, out, batch)
return out
def _extract_image_patch(image, bbox, patch_shape):
"""Extract image patch from bounding box.
Parameters
----------
image : ndarray
The full image.
bbox : array_like
The bounding box in format (x, y, width, height).
patch_shape : Optional[array_like]
This parameter can be used to enforce a desired patch shape
(height, width). First, the `bbox` is adapted to the aspect ratio
of the patch shape, then it is clipped at the image boundaries.
If None, the shape is computed from :arg:`bbox`.
Returns
-------
ndarray | NoneType
An image patch showing the :arg:`bbox`, optionally reshaped to
:arg:`patch_shape`.
Returns None if the bounding box is empty or fully outside of the image
boundaries.
"""
bbox = np.array(bbox)
if patch_shape is not None:
# correct aspect ratio to patch shape
target_aspect = float(patch_shape[1]) / patch_shape[0]
new_width = target_aspect * bbox[3]
bbox[0] -= (new_width - bbox[2]) / 2
bbox[2] = new_width
# convert to top left, bottom right
bbox[2:] += bbox[:2]
bbox = bbox.astype(np.int)
# clip at image boundaries
bbox[:2] = np.maximum(0, bbox[:2])
bbox[2:] = np.minimum(np.asarray(image.shape[:2][::-1]) - 1, bbox[2:])
if np.any(bbox[:2] >= bbox[2:]):
return None
s_x, s_y, e_x, e_y = bbox
image = image[s_y:e_y, s_x:e_x]
image = cv2.resize(image, tuple(patch_shape[::-1]))
return image
def create_box_encoder(model_filename, input_name="images",
output_name="features", batch_size=32):
"""
wrapper to create bounding box encoder
:param model_filename:
:param input_name:
:param output_name:
:param batch_size:
:return:
"""
image_encoder = ImageEncoder(model_filename, input_name, output_name)
image_shape = image_encoder.image_shape
def encoder(image, boxes):
image_patches = []
for box in boxes:
patch = _extract_image_patch(image, box, image_shape[:2])
if patch is None:
LOGGER.warning("WARNING: Failed to extract image patch: %s." % str(box))
patch = np.random.uniform(
0., 255., image_shape).astype(np.uint8)
image_patches.append(patch)
image_patches = np.asarray(image_patches)
return image_encoder.encode(image_patches, batch_size)
return encoder | /sail-utils-0.2.24.tar.gz/sail-utils-0.2.24/sail_utils/cv/encode.py | 0.798344 | 0.432423 | encode.py | pypi |
from dataclasses import dataclass
import glob
from pathlib import Path
import subprocess as sp
import time
import cv2
import numpy as np
from sail_utils.cv.base import _Streamer
class LiveStreamer(_Streamer):
"""
class for read from a live feed
"""
def __init__(self, source: str, rate: float, max_errors: int = 3600):
super().__init__(source, rate)
self._stream = cv2.VideoCapture(self.source)
self._fps = self._stream.get(cv2.CAP_PROP_FPS)
self._need_to_wait = 1. / rate
self._last_time = - 1. / rate
self._error_frames = 0
self._max_errors = max_errors
@property
def max_errors_allowed(self) -> int:
"""
get number of max errors allowed
:return:
"""
return self._max_errors
@property
def fps(self) -> int:
"""
get stream fps
:return:
"""
return self._fps
def __iter__(self):
return self
def __next__(self):
while self._stream.isOpened():
ret, frame = self._stream.read()
if ret:
current_time = time.time()
need_to_wait = self._last_time + self._need_to_wait - current_time
self._error_frames = 0
if need_to_wait < 0:
self._last_time = current_time
return frame, current_time
time.sleep(need_to_wait * 0.30)
else:
self._error_frames += 1
if self._error_frames >= self._max_errors:
self._error_frames = 0
raise StopIteration(f"# of error {self._error_frames} "
f"is greater than allowed. stop stream")
raise ValueError(f"<{self._stream}> is closed. please reconnect")
def __del__(self):
self._stream.release()
class VideoFileStreamer(_Streamer):
"""
class for read from a video file
"""
def __init__(self, source, rate: float = 1):
super().__init__(source, rate)
self._stream = cv2.VideoCapture(self.source)
self._fps = self._stream.get(cv2.CAP_PROP_FPS)
self._gap = int(self._fps / rate)
self._count = 0
self._index = 0
@property
def fps(self) -> int:
"""
get stream fps
:return:
"""
return self._fps
def __iter__(self):
return self
def __next__(self):
while True:
ret, frame = self._stream.read()
if ret:
self._count += 1
if self._count >= self._gap:
self._count = 0
self._index += 1
return frame, self._index
else:
raise StopIteration
def __del__(self):
self._stream.release()
class ImageFileStreamer(_Streamer):
"""
class for read from a folders file
"""
def __init__(self, source, suffix: str = 'jpg', rate: int = 1):
super().__init__(source, rate)
self._stream = glob.glob((Path(self.source) / ("**" + suffix)).as_posix(), recursive=True)
self._stream = sorted(self._stream, key=lambda x: (len(x), x))
self._rate = rate
self._start = 0
def __iter__(self):
return self
def __next__(self):
if self._start >= len(self._stream):
raise StopIteration()
file_loc = self._stream[self._start]
self._start += self._rate
img = cv2.imread(file_loc, cv2.IMREAD_COLOR)
return img, file_loc
class LivePusher:
"""
class for live stream writer
"""
def __init__(self, url: str, width: int, height: int, fps: int):
"""
use subprocess pipe to interact with ffmpeg to send video frame
:param url: video server url
:param width: video width
:param height: video height
:param fps: video fps
"""
self._fps = fps
self._command = ['ffmpeg',
'-y',
'-f', 'rawvideo',
'-pix_fmt', 'bgr24',
'-s', "{}x{}".format(width, height),
'-r', str(self._fps),
'-i', '-',
'-c:v', 'libx264',
'-pix_fmt', 'yuv420p',
'-g', '10',
'-preset', 'ultrafast',
'-tune', 'zerolatency',
'-f', 'flv',
url]
self._process = sp.Popen(self._command, bufsize=0, stdin=sp.PIPE)
def write(self, frame: np.ndarray):
"""
send out one frame to video stream server
:param frame: frame to send
:return:
"""
self._process.stdin.write(frame.tostring())
@property
def fps(self) -> int:
"""
get fps setting
:return:
"""
return self._fps
def __del__(self):
"""
close the subprocess pipe
:return:
"""
self._process.kill()
@dataclass
class VideoSetting:
"""
conf for video base settings
"""
fourcc = cv2.VideoWriter_fourcc(*"XVID")
font = cv2.FONT_HERSHEY_SIMPLEX
class VideoRecorder:
"""
class to record imaga into a .avi video file
"""
def __init__(self, source: str, width: int, height: int, fps: int):
self._writer = cv2.VideoWriter(source,
VideoSetting.fourcc,
fps,
(width, height))
def write(self, frame: np.ndarray):
"""
write one image into video
:param frame:
:return:
"""
self._writer.write(frame)
def __del__(self):
self._writer.release()
class Annotator:
"""
class to annotate a specific image
"""
def __init__(self, style_map: dict):
self._style_map = style_map
@property
def style_map(self) -> dict:
"""
get the style map data
:return:
"""
return self._style_map
def annotate(self,
category: str,
frame: np.ndarray,
detection: dict,
caption: str = None):
"""
annotate one image with a specific object detection
:param category:
:param frame:
:param detection:
:param caption:
:return:
"""
location = detection['location']
cv2.rectangle(frame,
tuple(location[:2]),
tuple(location[2:]),
color=self._style_map[category],
thickness=2)
if caption:
cv2.putText(frame,
caption,
(location[0], location[1] - 5),
VideoSetting.font,
0.5,
color=self._style_map[category],
thickness=2) | /sail-utils-0.2.24.tar.gz/sail-utils-0.2.24/sail_utils/cv/frame.py | 0.835551 | 0.186484 | frame.py | pypi |
from pathlib import Path
from simpleutils.time import unix2dt
from sail_utils.oss.utilities import OSSUtility
from sail_utils.utilities import _merge
class Merger:
"""
class for merger
"""
def __init__(self, company_id: int,
shop_id: int,
ipc_id: int,
oss_utils: OSSUtility):
self._root = Path(f"data/{company_id}/{shop_id}/{ipc_id}")
self._company_id = company_id
self._shop_id = shop_id
self._ipc_id = ipc_id
self._oss_utils = oss_utils
@property
def company_id(self) -> int:
"""
get company id
:return:
"""
return self._company_id
@property
def shop_id(self) -> int:
"""
get shop id
:return:
"""
return self._shop_id
@property
def ipc_id(self) -> int:
"""
get ipc id
:return:
"""
return self._ipc_id
@property
def oss_utils(self) -> OSSUtility:
"""
get internal oss state
:return:
"""
return self._oss_utils
def download_files(self, start_epoch, end_epoch) -> list:
"""
download files between start epoch and end epoch
:param start_epoch:
:param end_epoch:
:return:
"""
# TODO: should include 2 dates in case
target_date = unix2dt(start_epoch)[:10].replace('-', '')
file_folder = self._root / target_date
download_folder = Path('tmp/')
download_folder.mkdir(exist_ok=True)
used_files = []
for file in self.oss_utils.list(file_folder.as_posix()):
if file.endswith('flv'):
file_name = Path(file).name
file_start_epoch, file_end_epoch = file_name[:-4].split('_')
file_start_epoch = int(file_start_epoch)
file_end_epoch = int(file_end_epoch)
if start_epoch <= file_start_epoch <= end_epoch \
or start_epoch <= file_end_epoch <= end_epoch \
or (file_start_epoch <= start_epoch and end_epoch <= file_end_epoch):
download_file = download_folder / file_name
self.oss_utils.download(file, download_file)
used_files.append(download_file)
return used_files
def merge(self,
start_epoch: int,
end_epoch: int,
merged_file: str,
used_files: list = None) -> str:
"""
merge video files between start epoch and end epoch
:param start_epoch:
:param end_epoch:
:param merged_file:
:param used_files:
:return:
"""
if not used_files:
used_files = self.download_files(start_epoch, end_epoch)
if used_files:
# merge
_merge(start_epoch, end_epoch, merged_file, used_files)
return merged_file | /sail-utils-0.2.24.tar.gz/sail-utils-0.2.24/sail_utils/cv/merge.py | 0.614625 | 0.172764 | merge.py | pypi |
import uuid
import numpy as np
from sail_utils.cv.head.deep_sort import iou_matching
from sail_utils.cv.head.deep_sort import kalman_filter
from sail_utils.cv.head.deep_sort import linear_assignment
from sail_utils.cv.head.deep_sort.config import (
MAX_AGE,
MAX_IOU_DISTANCE,
N_INIT
)
from sail_utils.cv.head.deep_sort.detection import Detection
from sail_utils.cv.head.deep_sort.track import Track
def _convert_detection_struct(from_struct: list) -> list:
"""
convert detection format to deep sort compatible format
:param from_struct:
:return:
"""
to_struct = []
for each in from_struct:
xmin = each['location'][0]
ymin = each['location'][1]
xmax = each['location'][2]
ymax = each['location'][3]
confidence = each['score']
feature = each['feature'] if 'feature' in each else np.zeros(5, dtype=np.float64) + 1.0
to_struct.append(
Detection(
np.array([xmin, ymin, xmax - xmin, ymax - ymin],
dtype=np.float64),
confidence,
feature=feature))
return to_struct
class Tracker:
"""
This is the multi-target tracker.
Parameters
----------
metric : nn_matching.NearestNeighborDistanceMetric
A distance metric for measurement-to-track association.
max_age : int
Maximum number of missed misses before a track is deleted.
n_init : int
Number of consecutive detections before the track is confirmed. The
track state is set to `Deleted` if a miss occurs within the first
`n_init` frames.
Attributes
----------
metric : nn_matching.NearestNeighborDistanceMetric
The distance metric used for measurement to track association.
max_age : int
Maximum number of missed misses before a track is deleted.
n_init : int
Number of frames that a track remains in initialization phase.
kf : kalman_filter.KalmanFilter
A Kalman filter to filter target trajectories in image space.
tracks : List[Track]
The list of active tracks at the current time step.
"""
def __init__(self,
metric,
max_iou_distance=MAX_IOU_DISTANCE,
max_age=MAX_AGE,
n_init=N_INIT):
self.metric = metric
self.max_iou_distance = max_iou_distance
self.max_age = max_age
self.n_init = n_init
self.kf = kalman_filter.KalmanFilter()
self.tracks = []
self._next_id = uuid.uuid1()
def predict(self):
"""Propagate track state distributions one time step forward.
This function should be called once every time step, before `update`.
"""
for track in self.tracks:
track.predict(self.kf)
def result(self, time_stamp):
track_result = []
for track in self.tracks:
if track.is_confirmed():
track_bbox = track.to_tlwh()
track_id = track.track_id
track_x0 = int(track_bbox[0])
track_x1 = int(track_bbox[0] + track_bbox[2])
track_y0 = int(track_bbox[1])
track_y1 = int(track_bbox[1] + track_bbox[3])
track_result.append(dict(
id=track_id,
location=[track_x0, track_y0, track_x1, track_y1],
time_stamp=time_stamp
))
return sorted(track_result, key=lambda x: (x['time_stamp'], x['id']))
def update(self, detections):
"""
Perform measurement update and track management.
Parameters
----------
detections : List[dict]
A list of detections at the current time step.
"""
# Run matching cascade.
detections = _convert_detection_struct(detections)
matches, unmatched_tracks, unmatched_detections = \
self._match(detections)
# Update track set.
for track_idx, detection_idx in matches:
self.tracks[track_idx].update(
self.kf, detections[detection_idx])
for track_idx in unmatched_tracks:
self.tracks[track_idx].mark_missed()
for detection_idx in unmatched_detections:
self._initiate_track(detections[detection_idx])
self.tracks = [t for t in self.tracks if not t.is_deleted()]
# Update distance metric.
active_targets = [t.track_id for t in self.tracks if t.is_confirmed()]
features, targets = [], []
for track in self.tracks:
if not track.is_confirmed():
continue
features += track.features
targets += [track.track_id for _ in track.features]
track.features = []
self.metric.partial_fit(
np.asarray(features), np.asarray(targets), active_targets)
def _match(self, detections):
def gated_metric(tracks, dets, track_indices, detection_indices):
features = np.array([dets[i].feature for i in detection_indices])
targets = np.array([tracks[i].track_id for i in track_indices])
cost_matrix = self.metric.distance(features, targets)
cost_matrix = linear_assignment.gate_cost_matrix(
self.kf, cost_matrix, tracks, dets, track_indices,
detection_indices)
return cost_matrix
# Split track set into confirmed and unconfirmed tracks.
confirmed_tracks = [
i for i, t in enumerate(self.tracks) if t.is_confirmed()]
unconfirmed_tracks = [
i for i, t in enumerate(self.tracks) if not t.is_confirmed()]
# Associate confirmed tracks using appearance features.
matches_a, unmatched_tracks_a, unmatched_detections = \
linear_assignment.matching_cascade(
gated_metric, self.metric.matching_threshold, self.max_age,
self.tracks, detections, confirmed_tracks)
# Associate remaining tracks together with unconfirmed tracks using IOU.
iou_track_candidates = unconfirmed_tracks + [
k for k in unmatched_tracks_a if
self.tracks[k].time_since_update <= self.max_age]
unmatched_tracks_a = [
k for k in unmatched_tracks_a if
self.tracks[k].time_since_update > self.max_age]
matches_b, unmatched_tracks_b, unmatched_detections = \
linear_assignment.min_cost_matching(
iou_matching.iou_cost, self.max_iou_distance, self.tracks,
detections, iou_track_candidates, unmatched_detections)
matches = matches_a + matches_b
unmatched_tracks = list(set(unmatched_tracks_a + unmatched_tracks_b))
return matches, unmatched_tracks, unmatched_detections
def _initiate_track(self, detection):
mean, covariance = self.kf.initiate(detection.to_xyah())
self.tracks.append(Track(
mean, covariance, self._next_id, self.n_init, self.max_age,
detection.feature))
self._next_id = uuid.uuid1() | /sail-utils-0.2.24.tar.gz/sail-utils-0.2.24/sail_utils/cv/head/deep_sort/tracker.py | 0.877437 | 0.457197 | tracker.py | pypi |
import numpy as np
from sail_utils.cv.head.deep_sort.config import (
MAX_COSINE_DISTANCE,
NN_BUDGET
)
def _pdist(a, b):
"""Compute pair-wise squared distance between points in `a` and `b`.
Parameters
----------
a : array_like
An NxM matrix of N samples of dimensionality M.
b : array_like
An LxM matrix of L samples of dimensionality M.
Returns
-------
ndarray
Returns a matrix of size len(a), len(b) such that eleement (i, j)
contains the squared distance between `a[i]` and `b[j]`.
"""
a, b = np.asarray(a), np.asarray(b)
if len(a) == 0 or len(b) == 0:
return np.zeros((len(a), len(b)))
a2, b2 = np.square(a).sum(axis=1), np.square(b).sum(axis=1)
r2 = -2. * np.dot(a, b.T) + a2[:, None] + b2[None, :]
r2 = np.clip(r2, 0., float(np.inf))
return r2
def _cosine_distance(a, b, data_is_normalized=False):
"""Compute pair-wise cosine distance between points in `a` and `b`.
Parameters
----------
a : array_like
An NxM matrix of N samples of dimensionality M.
b : array_like
An LxM matrix of L samples of dimensionality M.
data_is_normalized : Optional[bool]
If True, assumes rows in a and b are unit length vectors.
Otherwise, a and b are explicitly normalized to lenght 1.
Returns
-------
ndarray
Returns a matrix of size len(a), len(b) such that eleement (i, j)
contains the squared distance between `a[i]` and `b[j]`.
"""
if not data_is_normalized:
a = np.asarray(a) / np.linalg.norm(a, axis=1, keepdims=True)
b = np.asarray(b) / np.linalg.norm(b, axis=1, keepdims=True)
return 1. - np.dot(a, b.T)
def _nn_euclidean_distance(x, y):
""" Helper function for nearest neighbor distance metric (Euclidean).
Parameters
----------
x : ndarray
A matrix of N row-vectors (sample points).
y : ndarray
A matrix of M row-vectors (query points).
Returns
-------
ndarray
A vector of length M that contains for each entry in `y` the
smallest Euclidean distance to a sample in `x`.
"""
distances = _pdist(x, y)
return np.maximum(0.0, distances.min(axis=0))
def _nn_cosine_distance(x, y):
""" Helper function for nearest neighbor distance metric (cosine).
Parameters
----------
x : ndarray
A matrix of N row-vectors (sample points).
y : ndarray
A matrix of M row-vectors (query points).
Returns
-------
ndarray
A vector of length M that contains for each entry in `y` the
smallest cosine distance to a sample in `x`.
"""
distances = _cosine_distance(x, y)
return distances.min(axis=0)
class NearestNeighborDistanceMetric(object):
"""
A nearest neighbor distance metric that, for each target, returns
the closest distance to any sample that has been observed so far.
Parameters
----------
metric : str
Either "euclidean" or "cosine".
matching_threshold: float
The matching threshold. Samples with larger distance are considered an
invalid match.
budget : Optional[int]
If not None, fix samples per class to at most this number. Removes
the oldest samples when the budget is reached.
Attributes
----------
samples : Dict[int -> List[ndarray]]
A dictionary that maps from target identities to the list of samples
that have been observed so far.
"""
def __init__(self, metric, matching_threshold=MAX_COSINE_DISTANCE, budget=NN_BUDGET):
if metric == "euclidean":
self._metric = _nn_euclidean_distance
elif metric == "cosine":
self._metric = _nn_cosine_distance
else:
raise ValueError(
"Invalid metric; must be either 'euclidean' or 'cosine'")
self.matching_threshold = matching_threshold
self.budget = budget
self.samples = {}
def partial_fit(self, features, targets, active_targets):
"""
Update the distance metric with new data.
Parameters
----------
features : ndarray
An NxM matrix of N features of dimensionality M.
targets : ndarray
An integer array of associated target identities.
active_targets : List[int]
A list of targets that are currently present in the scene.
"""
for feature, target in zip(features, targets):
self.samples.setdefault(target, []).append(feature)
if self.budget is not None:
self.samples[target] = self.samples[target][-self.budget:]
self.samples = {k: self.samples[k] for k in active_targets}
def distance(self, features, targets):
"""
Compute distance between features and targets.
Parameters
----------
features : ndarray
An NxM matrix of N features of dimensionality M.
targets : List[int]
A list of targets to match the given `features` against.
Returns
-------
ndarray
Returns a cost matrix of shape len(targets), len(features), where
element (i, j) contains the closest squared distance between
`targets[i]` and `features[j]`.
"""
cost_matrix = np.zeros((len(targets), len(features)))
for i, target in enumerate(targets):
cost_matrix[i, :] = self._metric(self.samples[target], features)
return cost_matrix | /sail-utils-0.2.24.tar.gz/sail-utils-0.2.24/sail_utils/cv/head/deep_sort/nn_matching.py | 0.958866 | 0.901834 | nn_matching.py | pypi |
import numpy as np
import scipy.linalg
"""
Table for the 0.95 quantile of the chi-square distribution with N degrees of
freedom (contains values for N=1, ..., 9). Taken from MATLAB/Octave's chi2inv
function and used as Mahalanobis gating threshold.
"""
chi2inv95 = {
1: 3.8415,
2: 5.9915,
3: 7.8147,
4: 9.4877,
5: 11.070,
6: 12.592,
7: 14.067,
8: 15.507,
9: 16.919}
class KalmanFilter:
"""
A simple Kalman filter for tracking bounding boxes in image space.
The 8-dimensional state space
x, y, a, h, vx, vy, va, vh
contains the bounding box center position (x, y), aspect ratio a, height h,
and their respective velocities.
Object motion follows a constant velocity model. The bounding box location
(x, y, a, h) is taken as direct observation of the state space (linear
observation model).
"""
def __init__(self):
ndim, dt = 4, 1.
# Create Kalman filter model matrices.
self._motion_mat = np.eye(2 * ndim, 2 * ndim)
for i in range(ndim):
self._motion_mat[i, ndim + i] = dt
self._update_mat = np.eye(ndim, 2 * ndim)
# Motion and observation uncertainty are chosen relative to the current
# state estimate. These weights control the amount of uncertainty in
# the model. This is a bit hacky.
self._std_weight_position = 1. / 20
self._std_weight_velocity = 1. / 160
def initiate(self, measurement):
"""
Create track from unassociated measurement.
Parameters
----------
measurement : ndarray
Bounding box coordinates (x, y, a, h) with center position (x, y),
aspect ratio a, and height h.
Returns
-------
(ndarray, ndarray)
Returns the mean vector (8 dimensional) and covariance matrix (8x8
dimensional) of the new track. Unobserved velocities are initialized
to 0 mean.
"""
mean_pos = measurement
mean_vel = np.zeros_like(mean_pos)
mean = np.r_[mean_pos, mean_vel]
std = [
2 * self._std_weight_position * measurement[3],
2 * self._std_weight_position * measurement[3],
1e-2,
2 * self._std_weight_position * measurement[3],
10 * self._std_weight_velocity * measurement[3],
10 * self._std_weight_velocity * measurement[3],
1e-5,
10 * self._std_weight_velocity * measurement[3]]
covariance = np.diag(np.square(std))
return mean, covariance
def predict(self, mean, covariance):
"""
Run Kalman filter prediction step.
Parameters
----------
mean : ndarray
The 8 dimensional mean vector of the object state at the previous
time step.
covariance : ndarray
The 8x8 dimensional covariance matrix of the object state at the
previous time step.
Returns
-------
(ndarray, ndarray)
Returns the mean vector and covariance matrix of the predicted
state. Unobserved velocities are initialized to 0 mean.
"""
std_pos = [
self._std_weight_position * mean[3],
self._std_weight_position * mean[3],
1e-2,
self._std_weight_position * mean[3]]
std_vel = [
self._std_weight_velocity * mean[3],
self._std_weight_velocity * mean[3],
1e-5,
self._std_weight_velocity * mean[3]]
motion_cov = np.diag(np.square(np.r_[std_pos, std_vel]))
mean = np.dot(self._motion_mat, mean)
covariance = np.linalg.multi_dot((
self._motion_mat, covariance, self._motion_mat.T)) + motion_cov
return mean, covariance
def project(self, mean, covariance):
"""
Project state distribution to measurement space.
Parameters
----------
mean : ndarray
The state's mean vector (8 dimensional array).
covariance : ndarray
The state's covariance matrix (8x8 dimensional).
Returns
-------
(ndarray, ndarray)
Returns the projected mean and covariance matrix of the given state
estimate.
"""
std = [
self._std_weight_position * mean[3],
self._std_weight_position * mean[3],
1e-1,
self._std_weight_position * mean[3]]
innovation_cov = np.diag(np.square(std))
mean = np.dot(self._update_mat, mean)
covariance = np.linalg.multi_dot((
self._update_mat, covariance, self._update_mat.T))
return mean, covariance + innovation_cov
def update(self, mean, covariance, measurement):
"""
Run Kalman filter correction step.
Parameters
----------
mean : ndarray
The predicted state's mean vector (8 dimensional).
covariance : ndarray
The state's covariance matrix (8x8 dimensional).
measurement : ndarray
The 4 dimensional measurement vector (x, y, a, h), where (x, y)
is the center position, a the aspect ratio, and h the height of the
bounding box.
Returns
-------
(ndarray, ndarray)
Returns the measurement-corrected state distribution.
"""
projected_mean, projected_cov = self.project(mean, covariance)
chol_factor, lower = scipy.linalg.cho_factor(
projected_cov, lower=True, check_finite=False)
kalman_gain = scipy.linalg.cho_solve(
(chol_factor, lower), np.dot(covariance, self._update_mat.T).T,
check_finite=False).T
innovation = measurement - projected_mean
new_mean = mean + np.dot(innovation, kalman_gain.T)
new_covariance = covariance - np.linalg.multi_dot((
kalman_gain, projected_cov, kalman_gain.T))
return new_mean, new_covariance
def gating_distance(self, mean, covariance, measurements,
only_position=False):
"""
Compute gating distance between state distribution and measurements.
A suitable distance threshold can be obtained from `chi2inv95`. If
`only_position` is False, the chi-square distribution has 4 degrees of
freedom, otherwise 2.
Parameters
----------
mean : ndarray
Mean vector over the state distribution (8 dimensional).
covariance : ndarray
Covariance of the state distribution (8x8 dimensional).
measurements : ndarray
An Nx4 dimensional matrix of N measurements, each in
format (x, y, a, h) where (x, y) is the bounding box center
position, a the aspect ratio, and h the height.
only_position : Optional[bool]
If True, distance computation is done with respect to the bounding
box center position only.
Returns
-------
ndarray
Returns an array of length N, where the i-th element contains the
squared Mahalanobis distance between (mean, covariance) and
`measurements[i]`.
"""
mean, covariance = self.project(mean, covariance)
if only_position:
mean, covariance = mean[:2], covariance[:2, :2]
measurements = measurements[:, :2]
cholesky_factor = np.linalg.cholesky(covariance)
d = measurements - mean
z = scipy.linalg.solve_triangular(
cholesky_factor, d.T, lower=True, check_finite=False,
overwrite_b=True)
squared_maha = np.sum(z * z, axis=0)
return squared_maha | /sail-utils-0.2.24.tar.gz/sail-utils-0.2.24/sail_utils/cv/head/deep_sort/kalman_filter.py | 0.950824 | 0.819965 | kalman_filter.py | pypi |
import numpy as np
from scipy.optimize import linear_sum_assignment
from sail_utils.cv.head.deep_sort import kalman_filter
INFTY_COST = 1e+5
def min_cost_matching(
distance_metric, max_distance, tracks, detections, track_indices=None,
detection_indices=None):
"""
Solve linear assignment problem.
Parameters
----------
distance_metric : Callable[List[Track], List[Detection], List[int], List[int]) -> ndarray
The distance metric is given a list of tracks and detections as well as
a list of N track indices and M detection indices. The metric should
return the NxM dimensional cost matrix, where element (i, j) is the
association cost between the i-th track in the given track indices and
the j-th detection in the given detection_indices.
max_distance : float
Gating threshold. Associations with cost larger than this value are
disregarded.
tracks : List[track.Track]
A list of predicted tracks at the current time step.
detections : List[detection.Detection]
A list of detections at the current time step.
track_indices : List[int]
List of track indices that maps rows in `cost_matrix` to tracks in
`tracks` (see description above).
detection_indices : List[int]
List of detection indices that maps columns in `cost_matrix` to
detections in `detections` (see description above).
Returns
-------
(List[(int, int)], List[int], List[int])
Returns a tuple with the following three entries:
* A list of matched track and detection indices.
* A list of unmatched track indices.
* A list of unmatched detection indices.
"""
if track_indices is None:
track_indices = np.arange(len(tracks))
if detection_indices is None:
detection_indices = np.arange(len(detections))
if len(detection_indices) == 0 or len(track_indices) == 0:
return [], track_indices, detection_indices # Nothing to match.
cost_matrix = distance_metric(
tracks, detections, track_indices, detection_indices)
cost_matrix[cost_matrix > max_distance] = max_distance + 1e-5
indices = linear_sum_assignment(cost_matrix)
indices = np.asarray(indices)
indices = np.transpose(indices)
matches, unmatched_tracks, unmatched_detections = [], [], []
for col, detection_idx in enumerate(detection_indices):
if col not in indices[:, 1]:
unmatched_detections.append(detection_idx)
for row, track_idx in enumerate(track_indices):
if row not in indices[:, 0]:
unmatched_tracks.append(track_idx)
for row, col in indices:
track_idx = track_indices[row]
detection_idx = detection_indices[col]
if cost_matrix[row, col] > max_distance:
unmatched_tracks.append(track_idx)
unmatched_detections.append(detection_idx)
else:
matches.append((track_idx, detection_idx))
return matches, unmatched_tracks, unmatched_detections
def matching_cascade(
distance_metric, max_distance, cascade_depth, tracks, detections,
track_indices=None, detection_indices=None):
"""
Run matching cascade.
Parameters
----------
distance_metric : Callable[List[Track], List[Detection], List[int], List[int]) -> ndarray
The distance metric is given a list of tracks and detections as well as
a list of N track indices and M detection indices. The metric should
return the NxM dimensional cost matrix, where element (i, j) is the
association cost between the i-th track in the given track indices and
the j-th detection in the given detection indices.
max_distance : float
Gating threshold. Associations with cost larger than this value are
disregarded.
cascade_depth: int
The cascade depth, should be se to the maximum track age.
tracks : List[track.Track]
A list of predicted tracks at the current time step.
detections : List[detection.Detection]
A list of detections at the current time step.
track_indices : Optional[List[int]]
List of track indices that maps rows in `cost_matrix` to tracks in
`tracks` (see description above). Defaults to all tracks.
detection_indices : Optional[List[int]]
List of detection indices that maps columns in `cost_matrix` to
detections in `detections` (see description above). Defaults to all
detections.
Returns
-------
(List[(int, int)], List[int], List[int])
Returns a tuple with the following three entries:
* A list of matched track and detection indices.
* A list of unmatched track indices.
* A list of unmatched detection indices.
"""
if track_indices is None:
track_indices = list(range(len(tracks)))
if detection_indices is None:
detection_indices = list(range(len(detections)))
unmatched_detections = detection_indices
matches = []
for level in range(cascade_depth):
if len(unmatched_detections) == 0: # No detections left
break
track_indices_l = [
k for k in track_indices
if tracks[k].time_since_update == 1 + level
]
if len(track_indices_l) == 0: # Nothing to match at this level
continue
matches_l, _, unmatched_detections = \
min_cost_matching(
distance_metric, max_distance, tracks, detections,
track_indices_l, unmatched_detections)
matches += matches_l
unmatched_tracks = list(set(track_indices) - set(k for k, _ in matches))
return matches, unmatched_tracks, unmatched_detections
def gate_cost_matrix(
kf, cost_matrix, tracks, detections, track_indices, detection_indices,
gated_cost=INFTY_COST, only_position=False):
"""
Invalidate infeasible entries in cost matrix based on the state
distributions obtained by Kalman filtering.
Parameters
----------
kf : The Kalman filter.
cost_matrix : ndarray
The NxM dimensional cost matrix, where N is the number of track indices
and M is the number of detection indices, such that entry (i, j) is the
association cost between `tracks[track_indices[i]]` and
`detections[detection_indices[j]]`.
tracks : List[track.Track]
A list of predicted tracks at the current time step.
detections : List[detection.Detection]
A list of detections at the current time step.
track_indices : List[int]
List of track indices that maps rows in `cost_matrix` to tracks in
`tracks` (see description above).
detection_indices : List[int]
List of detection indices that maps columns in `cost_matrix` to
detections in `detections` (see description above).
gated_cost : Optional[float]
Entries in the cost matrix corresponding to infeasible associations are
set this value. Defaults to a very large value.
only_position : Optional[bool]
If True, only the x, y position of the state distribution is considered
during gating. Defaults to False.
Returns
-------
ndarray
Returns the modified cost matrix.
"""
gating_dim = 2 if only_position else 4
gating_threshold = kalman_filter.chi2inv95[gating_dim]
measurements = np.asarray(
[detections[i].to_xyah() for i in detection_indices])
for row, track_idx in enumerate(track_indices):
track = tracks[track_idx]
gating_distance = kf.gating_distance(
track.mean, track.covariance, measurements, only_position)
cost_matrix[row, gating_distance > gating_threshold] = gated_cost
return cost_matrix | /sail-utils-0.2.24.tar.gz/sail-utils-0.2.24/sail_utils/cv/head/deep_sort/linear_assignment.py | 0.949949 | 0.764232 | linear_assignment.py | pypi |
class TrackState:
"""
Enumeration type for the single target track state. Newly created tracks are
classified as `tentative` until enough evidence has been collected. Then,
the track state is changed to `confirmed`. Tracks that are no longer alive
are classified as `deleted` to mark them for removal from the set of active
tracks.
"""
Tentative = 1
Confirmed = 2
Deleted = 3
class Track:
"""
A single target track with state space `(x, y, a, h)` and associated
velocities, where `(x, y)` is the center of the bounding box, `a` is the
aspect ratio and `h` is the height.
Parameters
----------
mean : ndarray
Mean vector of the initial state distribution.
covariance : ndarray
Covariance matrix of the initial state distribution.
track_id : UUID
A unique track identifier.
n_init : int
Number of consecutive detections before the track is confirmed. The
track state is set to `Deleted` if a miss occurs within the first
`n_init` frames.
max_age : int
The maximum number of consecutive misses before the track state is
set to `Deleted`.
feature : Optional[ndarray]
Feature vector of the detection this track originates from. If not None,
this feature is added to the `features` cache.
Attributes
----------
mean : ndarray
Mean vector of the initial state distribution.
covariance : ndarray
Covariance matrix of the initial state distribution.
track_id : UUID
A unique track identifier.
hits : int
Total number of measurement updates.
age : int
Total number of frames since first occurance.
time_since_update : int
Total number of frames since last measurement update.
state : TrackState
The current track state.
features : List[ndarray]
A cache of features. On each measurement update, the associated feature
vector is added to this list.
"""
def __init__(self, mean, covariance, track_id, n_init, max_age,
feature=None):
self.mean = mean
self.covariance = covariance
self.track_id = track_id
self.hits = 1
self.age = 1
self.time_since_update = 0
self.state = TrackState.Tentative
self.features = []
if feature is not None:
self.features.append(feature)
self._n_init = n_init
self._max_age = max_age
def to_tlwh(self):
"""
Get current position in bounding box format `(top left x, top left y,
width, height)`.
Returns
-------
ndarray
The bounding box.
"""
ret = self.mean[:4].copy()
ret[2] *= ret[3]
ret[:2] -= ret[2:] / 2
return ret
def to_tlbr(self):
"""
Get current position in bounding box format `(min x, miny, max x,
max y)`.
Returns
-------
ndarray
The bounding box.
"""
ret = self.to_tlwh()
ret[2:] = ret[:2] + ret[2:]
return ret
def predict(self, kalman_filter):
"""
Propagate the state distribution to the current time step using a
Kalman filter prediction step.
Parameters
----------
kalman_filter : KalmanFilter
The Kalman filter.
"""
self.mean, self.covariance = kalman_filter.predict(self.mean, self.covariance)
self.age += 1
self.time_since_update += 1
def update(self, kalman_filter, detection):
"""
Perform Kalman filter measurement update step and update the feature
cache.
Parameters
----------
kalman_filter : KalmanFilter
The Kalman filter.
detection : Detection
The associated detection.
"""
self.mean, self.covariance = kalman_filter.update(
self.mean, self.covariance, detection.to_xyah())
self.features.append(detection.feature)
self.hits += 1
self.time_since_update = 0
if self.state == TrackState.Tentative and self.hits >= self._n_init:
self.state = TrackState.Confirmed
def mark_missed(self):
"""
Mark this track as missed (no association at the current time step).
"""
if self.state == TrackState.Confirmed:
self.state = TrackState.Tentative
if self.state == TrackState.Tentative and self.time_since_update >= 3:
self.state = TrackState.Deleted
elif self.time_since_update > self._max_age:
self.state = TrackState.Deleted
def is_tentative(self):
"""
Returns True if this track is tentative (unconfirmed).
"""
return self.state == TrackState.Tentative
def is_confirmed(self):
"""
Returns True if this track is confirmed.
"""
return self.state == TrackState.Confirmed
def is_deleted(self):
"""
Returns True if this track is dead and should be deleted.
"""
return self.state == TrackState.Deleted | /sail-utils-0.2.24.tar.gz/sail-utils-0.2.24/sail_utils/cv/head/deep_sort/track.py | 0.965332 | 0.8586 | track.py | pypi |
# Sailboat Gym ⛵
Welcome to Sailboat Gym! This repository provides a dynamic simulation environment specifically designed for sailboats. With Sailboat Gym, you can explore and experiment with different control algorithms and strategies in a realistic virtual sailing environment.
## Table of Contents
- [Installation (Docker Needed)](#installation-docker-needed)
- [Usage](#usage)
- [Environment](#environment)
- [Description](#description)
- [Limitations](#limitations)
- [Observation Space](#observation-space)
- [Action Space](#action-space)
- [Reward Function](#reward-function)
- [Rendering](#rendering)
- [Documentation](#documentation)
- [Contributing](#contributing)
- [License](#license)
## Installation (Docker Needed)
**Pre-requirement: Please make sure you have [Docker](https://www.docker.com/) installed and running on your machine.**
To install and set up Sailboat Gym, follow these steps:
1. Clone the repository:
```bash
git clone https://github.com/lucasmrdt/sailboat-gym.git
cd sailboat-gym
```
2. Install the required dependencies:
```bash
pip install -r requirements.txt
```
## Usage
To run a simple example in Sailboat Gym, use the following command:
```bash
python3 example.py
```
Alternatively, you can use the following code snippet in your Python script:
```python
import gymnasium as gym
from gymnasium.wrappers.record_video import RecordVideo
import sailboat_gym
env = gym.make('SailboatLSAEnv-v0', renderer=sailboat_gym.CV2DRenderer())
env = RecordVideo(env, video_folder='./output/videos/')
env.reset(seed=10)
while True:
act = env.action_space.sample()
obs, reward, terminated, truncated, info = env.step(act)
if truncated:
break
env.render()
env.close()
```
This example demonstrates how to create an instance of the `SailboatLSAEnv` environment and record a video of the simulation.
## Environment
### Description
The Sailboat Gym simulation is conducted using the [Gazebo](http://gazebosim.org/) simulator and implemented through the [usv_sim_lsa project](https://github.com/disaster-robotics-proalertas/usv_sim_lsa), encapsulated inside a Docker. The Docker images/containers are handled automatically by the environment, so you don't have to worry about them.
The simulation incorporates various forces, such as hydrodynamic, hydrostatic, wind, wave, and thruster forces, using an enhanced version of the [Free-Floating Plugin](https://github.com/disaster-robotics-proalertas/freefloating_gazebo/tree/713bb6ab69d8d748906ea8eabb21da56b7db5562). Additionally, it incorporates lift and drag forces acting on the boat's rudder, keel, and/or sail through the Foil Dynamics Plugin. For more detailed information about the simulation, please consult the [original paper](https://www.mdpi.com/1424-8220/19/5/1117).
### Limitations
The current Docker version of the simulation does not include wave simulations. The calculation of waves relies on the [UWSim Plugin](https://github.com/uji-ros-pkg/underwater_simulation), which heavily depends on [OpenSceneGraph](http://www.openscenegraph.com/). By default, OpenSceneGraph requires creating a window and rendering the scene, making it challenging to run within a Docker container. Nevertheless, we are actively working on finding a solution to this issue.
### Observation Space
The sailboat's state is described by the following variables:
- `p_boat` / $\mathbf{p}_{\text{boat}}$ (position of the boat in the world frame, 3D vector)
- `dt_p_boat` / $\dot{\mathbf{p}}_{\text{boat}}$ (velocity of the boat in the world frame, 3D vector)
- `theta_boat` / $\boldsymbol{\theta}_{\text{boat}}$ (orientation of the boat in the world frame - roll, pitch, and yaw)
- `dt_theta_boat` / $\dot{\boldsymbol{\theta}}_{\text{boat}}$ (relative angular velocity of the boat)
- `theta_rudder` / $\theta_{\text{rudder}}$ (relative orientation of the rudder)
- `dt_theta_rudder` / $\dot{\theta}_{\text{rudder}}$ (relative angular velocity of the rudder)
- `theta_sail` / $\theta_{\text{sail}}$ (relative orientation of the sail)
- `dt_theta_sail` / $\dot{\theta}_{\text{sail}}$ (relative angular velocity of the sail)
- `wind` / $\mathbf{wind}$ (wind velocity in the world frame - x and y components)
### Action Space
The sailboat's action is described by the following variables:
- `theta_rudder` / $\theta_{\text{rudder}}$ (relative orientation of the rudder)
- `theta_sail` / $\theta_{\text{sail}}$ (relative orientation of the sail)
### Reward Function
You are responsible for defining the reward function based on the specific task you aim to accomplish. The reward function takes the current state and the action taken by the agent as input and returns a scalar value. For example, the following reward function returns the negative distance between the boat and the goal:
```python
goal = np.array([0, 0, 0])
def reward_fn(state, action):
return -np.linalg.norm(state['p_boat'] - goal)
```
### Rendering
Currently, Sailboat Gym provides 2D rendering of the simulation. The rendering is done using the [CV2DRenderer](./sailboat_gym/envs/renderers/cv2d_renderer.py) class, which utilizes the [OpenCV](https://opencv.org/) library to render the simulation based on the observation. It may be possible to implement 3D rendering using libraries such as [Open3D](http://www.open3d.org/), but this feature has not been implemented yet.
## Documentation
For detailed information on the API, usage examples, and customization options, please refer to our [documentation](./DOCUMENTATION.md).
## Contributing
We welcome contributions to Sailboat Gym. Please refer to our [contributing guidelines](./CONTRIBUTING.md) for more information.
## License
Sailboat Gym is released under the [MIT License](./LICENSE). You are free to use, modify, and distribute this software for both commercial and non-commercial purposes. | /sailboat-gym-1.0.40.tar.gz/sailboat-gym-1.0.40/README.md | 0.919195 | 0.993455 | README.md | pypi |
import os.path as osp
import re
import pickle
import pandas as pd
import numpy as np
from glob import glob
from functools import lru_cache
from ..envs import env_by_name
current_dir = osp.dirname(osp.abspath(__file__))
pkl_dir = osp.join(current_dir, '..', 'pkl')
def extract_index(filepath):
matchs = re.findall(r'(\d+)', filepath)
return int(matchs[-1])
def dict_to_df(d):
dd = {(k1, k2): v2 for k1, v1 in d.items() for k2, v2 in v1.items()}
df = pd.DataFrame.from_dict(dd, orient='index')
df.index.names = ['theta_wind', 'theta_sail']
for col in df.columns:
if col == 'index':
continue
for i, new_col in enumerate(['min', 'max']):
df[f'{col}_{new_col}'] = df[col].apply(lambda x: x[i])
df = df.drop(col, axis=1)
return df
def extract_vmc(df):
df = df.copy()
df.index = df.index.get_level_values('theta_wind')
v_max = df['vmc_max'].groupby('theta_wind').max()
v_max = np.maximum(0, v_max)
return v_max
def extract_best_sail(df):
df = df.copy()
df = df.reset_index()
df['vmc_max'] = np.maximum(0, df['vmc_max'])
# we encourage to take the closest sail to 0
df['abs_diff'] = np.abs(df['theta_sail'] - 0)
df = df.sort_values('abs_diff')
max_index = df.groupby('theta_wind')['vmc_max'].idxmax()
df_max_vmc = df.loc[max_index]
theta_wind = df_max_vmc['theta_wind'].values
best_sail = df_max_vmc['theta_sail'].values
return theta_wind, best_sail
@lru_cache()
def load_best_sail_dict(env_name, wind_velocity=1):
assert env_name in list(env_by_name.keys()), f'Env {env_name} not found.'
pathname = osp.join(
pkl_dir, f'{env_name}_bounds_v_wind_{wind_velocity}.pkl')
filepaths = sorted(glob(pathname), key=extract_index, reverse=True)
assert filepaths, f'Error: Please run `python3 scripts/extract_sim_bounds.py --env-name={env_name} --wind-velocity={wind_velocity}` to extract the velocity bounds first.'
filepath = filepaths[0]
d = pickle.load(open(filepath, 'rb'))
df = dict_to_df(d)
theta_wind, best_sail = extract_best_sail(df)
theta_wind, best_sail = np.deg2rad(theta_wind), np.deg2rad(best_sail) # noqa
best_sail_dict = dict(zip(theta_wind, best_sail))
return best_sail_dict
def get_best_sail(env_name, theta_wind, wind_velocity=1):
theta_wind = theta_wind % (2 * np.pi)
best_sail_dict = load_best_sail_dict(env_name, wind_velocity)
best_sail = np.interp(theta_wind,
xp=list(best_sail_dict.keys()),
fp=list(best_sail_dict.values()))
return best_sail | /sailboat-gym-1.0.40.tar.gz/sailboat-gym-1.0.40/sailboat_gym/helpers/get_best_sail.py | 0.512937 | 0.321267 | get_best_sail.py | pypi |
import click
import os.path as osp
import re
import pickle
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from functools import lru_cache
from glob import glob
from ..envs import env_by_name
current_dir = osp.dirname(osp.abspath(__file__))
pkl_dir = osp.join(current_dir, '..', 'pkl')
def extract_index(filepath):
matchs = re.findall(r'(\d+)', filepath)
return int(matchs[-1])
def dict_to_df(d):
dd = {(k1, k2): v2 for k1, v1 in d.items() for k2, v2 in v1.items()}
df = pd.DataFrame.from_dict(dd, orient='index')
df.index.names = ['theta_wind', 'theta_sail']
for col in df.columns:
if col == 'index':
continue
for i, new_col in enumerate(['min', 'max']):
df[f'{col}_{new_col}'] = df[col].apply(lambda x: x[i])
df = df.drop(col, axis=1)
return df
def extract_vmc_from_df(df):
df = df.copy()
df.index = df.index.get_level_values('theta_wind')
v_max = df['vmc_max'].groupby('theta_wind').max()
v_max = np.maximum(0, v_max)
return v_max.index, v_max.values
# @lru_cache()
def load_vmc_dict(env_name, wind_velocity=1):
assert env_name in list(env_by_name.keys()), f'Env {env_name} not found.'
pathname = osp.join(
pkl_dir, f'{env_name}_bounds_v_wind_{wind_velocity}.pkl')
filepaths = sorted(glob(pathname), key=extract_index, reverse=True)
assert filepaths, f'Error: Please run `python3 scripts/extract_sim_bounds.py --env-name={env_name} --wind-velocity={wind_velocity}` to extract the velocity bounds first.'
filepath = filepaths[0]
d = pickle.load(open(filepath, 'rb'))
df = dict_to_df(d)
thetas, vmc = extract_vmc_from_df(df)
thetas = np.deg2rad(thetas)
vmc_dict = dict(zip(thetas, vmc))
return vmc_dict
def get_vmc(env_name, theta_wind, wind_velocity=1):
vmc_dict = load_vmc_dict(env_name, wind_velocity)
vmc = np.interp(theta_wind,
xp=list(vmc_dict.keys()),
fp=list(vmc_dict.values()))
return vmc | /sailboat-gym-1.0.40.tar.gz/sailboat-gym-1.0.40/sailboat_gym/helpers/get_vmc.py | 0.438304 | 0.260331 | get_vmc.py | pypi |
import numpy as np
from typing import Callable, Union
from ...abstracts import AbcRender
from ...types import Observation, Action
from ...utils import is_debugging_all
from ..env import SailboatEnv
from .lsa_sim import LSASim
class SailboatLSAEnv(SailboatEnv):
NB_STEPS_PER_SECONDS = 10 # Hz
def __init__(self, reward_fn: Callable[[Observation, Action, Observation], float] = lambda *_: 0, renderer: Union[AbcRender, None] = None, wind_generator_fn: Union[Callable[[int], np.ndarray], None] = None, water_generator_fn: Union[Callable[[int], np.ndarray], None] = None, video_speed: float = 1, keep_sim_alive: bool = False, container_tag: str = 'mss1-ode', name='default', map_scale=1, stop_condition_fn: Callable[[Observation, Action, Observation], bool] = lambda *_: False):
"""Sailboat LSA environment
Args:
reward_fn (Callable[[Observation, Action], float], optional): Use a custom reward function depending of your task. Defaults to lambda *_: 0.
renderer (AbcRender, optional): Renderer instance to be used for rendering the environment, look at sailboat_gym/renderers folder for more information. Defaults to None.
wind_generator_fn (Callable[[int], np.ndarray], optional): Function that returns a 2D vector representing the global wind during the simulation. Defaults to None.
water_generator_fn (Callable[[int], np.ndarray], optional): Function that returns a 2D vector representing the global water current during the simulation. Defaults to None.
video_speed (float, optional): Speed of the video recording. Defaults to 1.
keep_sim_alive (bool, optional): Keep the simulation running even after the program exits. Defaults to False.
container_tag (str, optional): Docker tag to be used for the simulation, see the documentation for more information. Defaults to 'mss1-ode'.
name ([type], optional): Name of the simulation, required to run multiples environment on same machine.. Defaults to 'default'.
map_scale (int, optional): Scale of the map, used to scale the map in the renderer. Defaults to 1.
"""
super().__init__()
# IMPORTANT: The following variables are required by the gymnasium API
self.render_mode = renderer.get_render_mode() if renderer else None
self.metadata = {
'render_modes': renderer.get_render_modes() if renderer else [],
'render_fps': float(video_speed * self.NB_STEPS_PER_SECONDS),
}
def direction_generator(std=1.):
direction = np.random.normal(0, std, 2)
def generate_direction(step_idx):
return direction
return generate_direction
self.name = name
self.container_tag = container_tag
self.reward_fn = reward_fn
self.stop_condition_fn = stop_condition_fn
self.renderer = renderer
self.obs = None
self.wind_generator_fn = wind_generator_fn if wind_generator_fn \
else direction_generator()
self.water_generator_fn = water_generator_fn if water_generator_fn \
else direction_generator(0.01)
self.map_scale = map_scale
self.keep_sim_alive = keep_sim_alive
self.step_idx = 0
self.sim = LSASim(self.container_tag, self.name)
def reset(self, seed=None, **kwargs):
super().reset(seed=seed, **kwargs)
if seed is not None:
np.random.seed(seed)
self.step_idx = 0
wind = self.wind_generator_fn(self.step_idx)
water = self.water_generator_fn(self.step_idx)
self.obs, info = self.sim.reset(wind, water, self.NB_STEPS_PER_SECONDS)
# setup the renderer, its needed to know the min/max position of the boat
if self.renderer:
self.renderer.setup(info['map_bounds'] * self.map_scale)
if is_debugging_all():
print('\nResetting environment:')
print(f' -> Wind: {wind}')
print(f' -> Water: {water}')
print(f' -> frequency: {self.NB_STEPS_PER_SECONDS} Hz')
print(f' <- Obs: {self.obs}')
print(f' <- Info: {info}')
return self.obs, info
def step(self, action: Action):
assert self.obs is not None, 'Please call reset before step'
self.step_idx += 1
wind = self.wind_generator_fn(self.step_idx)
water = self.water_generator_fn(self.step_idx)
next_obs, terminated, info = self.sim.step(wind, water, action)
reward = self.reward_fn(self.obs, action, next_obs)
truncated = self.stop_condition_fn(self.obs, action, next_obs)
self.obs = next_obs
if is_debugging_all():
print('\nStepping environment:')
print(f' -> Wind: {wind}')
print(f' -> Water: {water}')
print(f' -> Action: {action}')
print(f' <- Obs: {self.obs}')
print(f' <- Reward: {reward}')
print(f' <- Terminated: {terminated}')
print(f' <- Info: {info}')
return self.obs, reward, terminated, truncated, info
def render(self):
assert self.renderer, 'No renderer'
assert self.obs is not None, 'Please call reset before render'
return self.renderer.render(self.obs)
def close(self):
self.sim.close()
self.obs = None
def __del__(self):
if not self.keep_sim_alive:
self.sim.stop() | /sailboat-gym-1.0.40.tar.gz/sailboat-gym-1.0.40/sailboat_gym/envs/sailboat_lsa/lsa_env.py | 0.85564 | 0.504455 | lsa_env.py | pypi |
__all__ = ["Environment"]
import json
import random
import numpy as np
from sailboat_playground.constants import constants
class Environment:
def __init__(self, config_file: str):
try:
with open(config_file, "r") as f:
self._config = json.loads(f.read())
f.close()
except Exception as e:
raise Exception(f"Failed to load configuration file: {e}")
self._currentWindSpeed = (
self.config["wind_min_speed"] + self.config["wind_max_speed"])/2
self._isWindGust = False
self._currentWindGustStart = 0
self._currentWindGustDuration = 0
self._currentTime = 0
@property
def config(self):
return self._config
@property
def wind_direction_rad(self):
return self.config["wind_direction"] * np.pi / 180
@property
def current_direction_rad(self):
return self.config["current_direction"] * np.pi / 180
@property
def wind_speed(self):
return np.array([np.cos(self.wind_direction_rad), np.sin(self.wind_direction_rad)]) * self._currentWindSpeed
@property
def water_speed(self):
return np.array([np.cos(self.current_direction_rad), np.sin(self.current_direction_rad)]) * self.config["current_speed"]
@classmethod
def get_delta_range(cls, current_speed, min_speed, max_speed, max_delta):
delta_range = np.arange(
min_speed, max_speed, 0.1)
return list(delta_range[(delta_range > current_speed * (1 - max_delta / 100))
& (delta_range < current_speed * (1 + max_delta / 100))])
def execute(self):
self._currentTime += constants.time_delta
self.change_wind_speed()
def change_wind_speed(self):
if self._isWindGust:
delta_range = self.get_delta_range(
self._currentWindSpeed, self.config["wind_gust_min_speed"], self.config["wind_gust_max_speed"], self.config["wind_gust_max_delta_percent"])
try:
self._currentWindSpeed = random.choice(delta_range)
except IndexError:
pass
except Exception as e:
raise e
self._isWindGust = (
self._currentTime - self._currentWindGustStart) < self._currentWindGustDuration
else:
delta_range = self.get_delta_range(
self._currentWindSpeed, self.config["wind_min_speed"], self.config["wind_max_speed"], self.config["wind_max_delta_percent"])
try:
self._currentWindSpeed = random.choice(delta_range)
except IndexError:
pass
except Exception as e:
raise e
self._isWindGust = random.random(
) < self.config["wind_gust_probability"]
if self._isWindGust:
self._currentWindGustDuration = random.choice(np.arange(
self.config["wind_gust_min_duration"], self.config["wind_gust_max_duration"], constants.time_delta)) | /sailboat_playground-0.1.1.tar.gz/sailboat_playground-0.1.1/sailboat_playground/engine/Environment.py | 0.625209 | 0.150528 | Environment.py | pypi |
__all__ = ["Manager"]
import numpy as np
from numpy.linalg.linalg import norm
from sailboat_playground.engine.utils import *
from sailboat_playground.engine.Boat import Boat
from sailboat_playground.constants import constants
from sailboat_playground.engine.Environment import Environment
class Manager:
def __init__(self, boat_config: str, env_config: str, foils_dir: str = "foils/", debug: bool = False, boat_heading: float = 90, boat_position: np.ndarray = np.array([0, 0])):
self._boat = Boat(boat_config, foils_dir)
self._boat.set_heading(boat_heading)
self._boat.set_position(boat_position)
self._env = Environment(env_config)
self._apparent_wind_speed = 0
self._apparent_wind_direction = 0
self._debug = debug
def log(self, *args, **kwargs):
if self._debug:
print(*args, **kwargs)
@property
def boat(self):
return self._boat
@property
def environment(self):
return self._env
@property
def state(self):
return {
"wind_speed": self._env.wind_speed,
"water_speed": self._env.water_speed,
"boat_heading": self._boat.heading,
"boat_speed": self._boat.speed,
"boat_speed_direction": compute_angle(self._boat.speed),
"boat_position": self._boat.position,
"sail_angle": self._boat.alpha,
"rudder_angle": self._boat.rudder_angle
}
@property
def agent_state(self):
return {
"heading": self._boat.heading,
"wind_speed": self._apparent_wind_speed,
"wind_direction": self._apparent_wind_direction,
"position": self._boat.position,
}
@classmethod
def compute_force(cls, rho, velocity, area, coeff):
return 1 / 2 * rho * (velocity ** 2) * area * coeff
def print_current_state(self):
self.log("*" * 15)
self.log("*** Current Manager state:")
self.log("True wind speed: {}".format(self._env.wind_speed))
self.log("True water speed: {}".format(self._env.water_speed))
self.log("Boat heading: {}".format(self._boat.heading))
self.log("Boat speed: {}".format(self._boat.speed))
self.log("Boat speed direction: {}".format(
compute_angle(self._boat.speed) * 180 / np.pi))
self.log("Boat position: {}".format(self._boat.position))
self.log("Sail angle of attack: {}".format(self._boat.alpha))
self.log("Rudder angle of attack: {}".format(self._boat.rudder_angle))
self.log("*" * 15)
def step(self, ans: list):
if type(ans) != list or len(ans) != 2:
raise Exception(
"Argument \"ans\" for Manager.step() must be a list with two values: [alpha, rudder_angle]")
self.apply_agent(ans[0], ans[1])
self.print_current_state()
total_force = np.array([0., 0.])
# 1 - Wind forces on sail
# 1.1 - Compute apparent wind
self.log("----------- Wind forces on sail")
Va = self._env.wind_speed - self._boat.speed
self.log(f"Va={Va}")
Va_angle = compute_angle(Va) * 180 / np.pi
self._apparent_wind_direction = Va_angle - self._boat.heading
global_sail_angle = self._boat.heading + self._boat.alpha
while global_sail_angle < 0:
global_sail_angle += 360
while global_sail_angle > 360:
global_sail_angle -= 360
self.log(f"global_sail_angle={global_sail_angle}")
alpha = Va_angle - global_sail_angle + 180
while alpha < -180:
alpha += 360
while alpha > 180:
alpha -= 360
self.log(f"Va_angle={Va_angle}")
self.log(f"alpha={alpha}")
Va_norm = np.linalg.norm(Va)
self._apparent_wind_speed = Va_norm
self.log(f"Va_norm={Va_norm}")
# 1.2 - Compute total force (in order to check driving force direction)
D_norm = abs(self.compute_force(
constants.wind_rho, Va_norm, self._boat.config["sail_area"], self._boat.sail_df[self._boat.sail_df["alpha"] == round(alpha)]["cd"].values[0]))
self.log(f"D_norm={D_norm}")
D_angle = Va_angle
self.log(f"D_angle={D_angle}")
D = norm_to_vector(D_norm, D_angle * np.pi / 180)
self.log(f"D={D}")
L_norm = abs(self.compute_force(
constants.wind_rho, Va_norm, self._boat.config["sail_area"], self._boat.sail_df[self._boat.sail_df["alpha"] == round(alpha)]["cl"].values[0]))
self.log(f"L_norm={L_norm}")
if self._boat.alpha > 0:
L_angle = D_angle + 90
else:
L_angle = D_angle - 90
while L_angle > 360:
L_angle -= 360
while L_angle < 0:
L_angle += 360
self.log(f"L_angle={L_angle}")
L = norm_to_vector(L_norm, L_angle * np.pi / 180)
self.log(f"L={L}")
F_T = L + D
self.log(f"F_T={F_T}")
# 1.3 - Compute driving force (project total force into unit vector on boat heading)
unit_vector = norm_to_vector(1, self._boat.heading * np.pi / 180)
F_R = np.dot(F_T, unit_vector) * unit_vector
self.log(f"F_R={F_R}")
self.log(f"* Adding {F_R}")
total_force += F_R
# # 2 - Water forces on hull
# # 2.1 - Compute apparent water current
self.log("----------- Water forces on hull")
Wa = self._env.water_speed - self._boat.speed
self.log(f"Wa={Wa}")
Wa_angle = compute_angle(Wa) * 180 / np.pi
while Wa_angle < 0:
Wa_angle += 360
while Wa_angle > 360:
Wa_angle -= 360
self.log(f"Wa_angle={Wa_angle}")
Wa_norm = np.linalg.norm(Wa)
self.log(f"Wa_norm={Wa_norm}")
# 2.2 - Compute water resistance on hull
F_WR_norm = abs(self.compute_force(
constants.sea_water_rho, Wa_norm, self._boat.config["hull_area"], self._boat.config["hull_friction_coefficient"]))
self.log(f"F_WR_norm={F_WR_norm}")
F_WR = norm_to_vector(F_WR_norm, Wa_angle * np.pi / 180)
self.log(f"F_WR={F_WR}")
self.log(f"* Adding {F_WR}")
# 2.3 - Apply forces
total_force += F_WR
# 3 - Water forces on rudder
# 3.1 - Compute water force on rudder
self.log("----------- Water forces on rudder")
global_rudder_angle = self._boat.heading + self._boat.rudder_angle
while global_rudder_angle < 0:
global_rudder_angle += 360
while global_rudder_angle > 360:
global_rudder_angle -= 360
rudder_angle = Wa_angle - global_rudder_angle + 180
while rudder_angle < -180:
rudder_angle += 360
while rudder_angle > 180:
rudder_angle -= 360
D_norm = abs(self.compute_force(
constants.sea_water_rho, Wa_norm, self._boat.config["rudder_area"], self._boat.rudder_df[self._boat.rudder_df["alpha"] == round(rudder_angle)]["cd"].values[0]))
self.log(f"D_norm={D_norm}")
D_angle = Va_angle
self.log(f"D_angle={D_angle}")
D = norm_to_vector(D_norm, D_angle * np.pi / 180)
self.log(f"D={D}")
L_norm = abs(self.compute_force(
constants.sea_water_rho, Wa_norm, self._boat.config["rudder_area"], self._boat.rudder_df[self._boat.rudder_df["alpha"] == round(rudder_angle)]["cl"].values[0]))
self.log(f"L_norm={L_norm}")
if self._boat.rudder_angle > 0:
L_angle = D_angle - 90
else:
L_angle = D_angle + 90
while L_angle > 360:
L_angle -= 360
while L_angle < 0:
L_angle += 360
self.log(f"L_angle={L_angle}")
L = norm_to_vector(L_norm, L_angle * np.pi / 180)
self.log(f"L={L}")
F_T = L + D
self.log(f"F_T={F_T}")
F_T_norm = np.linalg.norm(F_T)
self.log(f"F_T_norm={F_T_norm}")
# 3.2 - Compute hull rotation resistance
F_WR_norm = abs(self.compute_force(
constants.sea_water_rho, self._boat.angular_speed, self._boat.config["hull_area"], self._boat.config["hull_rotation_resistance"]))
self.log(f"F_WR_norm={F_WR_norm}")
# 3.3 - Compute torque and angular acceleration
angular_acceleration_signal = 1 if self._boat.rudder_angle < 0 else -1
self.log(f"angular_acceleration_signal={angular_acceleration_signal}")
torque = (F_T_norm - F_WR_norm) * \
(self._boat.config["length"] - self._boat.config["com_length"])
self.log(f"torque={torque}")
angular_acceleration = torque / \
self._boat.config["moment_of_inertia"] * \
angular_acceleration_signal
self.log(f"angular_acceleration={angular_acceleration}")
# 3.4 - Apply angular acceleration
self._boat.apply_angular_acceleration(angular_acceleration)
# 4 - Apply all forces
self.log(f"--> Applying total_force={total_force}")
self._boat.apply_force(total_force)
# 4 - Execute boat and environment
self._boat.execute()
self._env.execute()
def apply_agent(self, alpha: int, rudder_angle: int):
self._boat.set_alpha(alpha)
self._boat.set_rudder_angle(rudder_angle) | /sailboat_playground-0.1.1.tar.gz/sailboat_playground-0.1.1/sailboat_playground/engine/Manager.py | 0.762866 | 0.313945 | Manager.py | pypi |
__all__ = ["Boat"]
import json
import numpy as np
from os import path
import pandas as pd
from sailboat_playground.constants import constants
class Boat:
def __init__(self, config_file: str, foils_dir: str = "foils/"):
try:
with open(config_file, "r") as f:
self._config = json.loads(f.read())
f.close()
except Exception as e:
raise Exception(f"Failed to load configuration file: {e}")
self._sail_foil_df = pd.read_csv(
path.join(foils_dir, f"{self._config['sail_foil']}.csv"))
self._rudder_foil_df = pd.read_csv(
path.join(foils_dir, f"{self._config['rudder_foil']}.csv"))
self._sail_foil_df["alpha_rad"] = self._sail_foil_df["alpha"] * np.pi / 180
self._sail_foil_df["cr"] = np.sin(self._sail_foil_df["alpha_rad"]) * self._sail_foil_df["cl"] - np.cos(
self._sail_foil_df["alpha_rad"]) * self._sail_foil_df["cd"]
self._sail_foil_df["clat"] = np.cos(self._sail_foil_df["alpha_rad"]) * self._sail_foil_df["cl"] + np.cos(
self._sail_foil_df["alpha_rad"]) * self._sail_foil_df["cd"]
self._rudder_foil_df["alpha_rad"] = self._rudder_foil_df["alpha"] * np.pi / 180
self._rudder_foil_df["cr"] = np.sin(self._rudder_foil_df["alpha_rad"]) * self._rudder_foil_df["cl"] - np.cos(
self._rudder_foil_df["alpha_rad"]) * self._rudder_foil_df["cd"]
self._rudder_foil_df["clat"] = np.cos(self._rudder_foil_df["alpha_rad"]) * self._rudder_foil_df["cl"] + np.cos(
self._rudder_foil_df["alpha_rad"]) * self._rudder_foil_df["cd"]
self._speed = np.array([0, 0])
self._angular_speed = 0
self._position = np.array([0, 0])
self._currentTime = 0
self._alpha = 0
self._rudder_angle = 0
self._heading = 270
@property
def alpha(self):
return self._alpha
@property
def rudder_angle(self):
return self._rudder_angle
@property
def heading(self):
return self._heading
@property
def sail_df(self):
return self._sail_foil_df
@property
def rudder_df(self):
return self._rudder_foil_df
@property
def config(self):
return self._config
@property
def mass(self):
return self._config["mass"]
@property
def speed(self):
return self._speed
@property
def angular_speed(self):
return self._angular_speed
@property
def position(self):
return self._position
def apply_force(self, force: np.ndarray):
self._speed = self._speed + (force / self.mass * constants.time_delta)
def apply_angular_acceleration(self, accel: float):
self._angular_speed += accel * constants.time_delta
if self._angular_speed > 360 / constants.time_delta:
self._angular_speed = 360 / constants.time_delta
if self._angular_speed < -360 / constants.time_delta:
self._angular_speed = -360 / constants.time_delta
def execute(self):
self._currentTime += constants.time_delta
self._position = self._position + (self._speed * constants.time_delta)
self._heading += self._angular_speed * constants.time_delta
while self._heading >= 360:
self._heading -= 360
def set_alpha(self, alpha):
self._alpha = alpha
def set_rudder_angle(self, rudder_angle):
self._rudder_angle = rudder_angle
def set_heading(self, heading):
self._heading = heading
def set_position(self, position):
self._position = position | /sailboat_playground-0.1.1.tar.gz/sailboat_playground-0.1.1/sailboat_playground/engine/Boat.py | 0.6488 | 0.161585 | Boat.py | pypi |
import pyglet
import numpy as np
from sailboat_playground.engine.utils import compute_angle
from sailboat_playground.visualization.Sailboat import Sailboat
from sailboat_playground.visualization.utils import map_position
from sailboat_playground.visualization.resources.resources import wind_image, speed_image, buoy_image
class Viewer ():
def __init__(self, map_size: int = 800, buoy_list: list = None):
self._map_size = map_size
self._buoy_list = buoy_list if buoy_list is not None else []
self._window = pyglet.window.Window(800, 800)
self._window.event(self.on_draw)
pyglet.gl.glClearColor(0.1, 0.4, 0.8, 0.4)
self._step = 0
self._main_batch = pyglet.graphics.Batch()
self._end_label = pyglet.text.Label(text="End of simulation", x=400,
y=-400, anchor_x="center", batch=self._main_batch, font_size=48)
WIND_X = 40
self._wind_arrow = pyglet.sprite.Sprite(
img=wind_image, x=WIND_X, y=40, batch=self._main_batch)
self._wind_text = pyglet.text.Label(
text="N/A m/s", x=WIND_X, y=10, anchor_x="center", anchor_y="center", batch=self._main_batch, font_size=15)
SPEED_X = 140
self._speed_icon = pyglet.sprite.Sprite(
img=speed_image, x=SPEED_X, y=40, batch=self._main_batch)
self._speed_text = pyglet.text.Label(
text="N/A m/s", x=SPEED_X, y=10, anchor_x="center", anchor_y="center", batch=self._main_batch, font_size=15)
POSITION_X = 700
self._position_text = pyglet.text.Label(
text="(nan, nan)", x=POSITION_X, y=10, anchor_x="center", anchor_y="center", batch=self._main_batch, font_size=15)
self._sailboat = None
self._objects = []
def init(self):
self._sailboat = Sailboat(
x=400, y=400, batch=self._main_batch, map_size=self._map_size)
self._objects = [self._sailboat]
for obj in self._objects:
for handler in obj.event_handlers:
self._window.push_handlers(handler)
for (x, y) in self._buoy_list:
pos = map_position(np.array([x, y]), self._map_size)
x_map = pos[0]
y_map = pos[1]
self._objects.append(pyglet.sprite.Sprite(
img=buoy_image, x=x_map, y=y_map, batch=self._main_batch))
def on_draw(self):
self._window.clear()
self._main_batch.draw()
def update(self, dt, state_list=None):
if self._step >= len(state_list):
self._end_label.y = 400
else:
state = state_list[self._step]
self._wind_arrow.rotation = 90 - \
compute_angle(state["wind_speed"]) * 180 / np.pi
self._sailboat.set_position(map_position(
state["boat_position"], self._map_size))
self._sailboat.set_rotation(state["boat_heading"])
self._sailboat.set_alpha(state["sail_angle"])
self._sailboat.set_rudder_angle(state["rudder_angle"])
self._sailboat.update(dt)
self._wind_text.text = "{:.1f}m/s".format(
np.linalg.norm(state["wind_speed"]))
self._speed_text.text = "{:.1f}m/s".format(
np.linalg.norm(state["boat_speed"]))
self._position_text.text = "Pos: ({:.2f}, {:.2f})".format(
state["boat_position"][0], state["boat_position"][1])
self._step += 1
def run(self, state_list, simulation_speed=100):
# Init
self.init()
# Set update interval
pyglet.clock.schedule_interval(
self.update, 1 / simulation_speed, state_list=state_list)
# Run
pyglet.app.run() | /sailboat_playground-0.1.1.tar.gz/sailboat_playground-0.1.1/sailboat_playground/visualization/Viewer.py | 0.653569 | 0.298146 | Viewer.py | pypi |
<h1 align="center"><img src="https://www.pinclipart.com/picdir/big/383-3832964_im-on-a-boat-stamp-sailboat-stencil-clipart.png" width="70px">
<br>
sailboat
<br>
<a href="https://github.com/cole-wilson/sailboat"><img alt="GitHub Repo stars" src="https://img.shields.io/github/stars/cole-wilson/sailboat?style=social"></a>
<a href="https://twitter.com/intent/tweet?text=Wow:&url=https%3A%2F%2Fgithub.com%2Fsole-wilson%2Fsailboat"><img alt="Twitter" src="https://img.shields.io/twitter/url?style=social&url=https%3A%2F%2Fgithub.com%2Fsole-wilson%2Fsailboat"></a>
<br>
<img alt="GitHub commit activity" src="https://img.shields.io/github/commit-activity/m/cole-wilson/sailboat">
<img alt="GitHub Release Date" src="https://img.shields.io/github/release-date/cole-wilson/sailboat?label=latest%20release">
<img alt="GitHub Workflow Status" src="https://img.shields.io/github/workflow/status/cole-wilson/sailboat/Publish%20release%20files%20for%20Sailboat.">
<img alt="GitHub code size in bytes" src="https://img.shields.io/github/languages/code-size/cole-wilson/sailboat">
<img alt="GitHub release (latest SemVer including pre-releases)" src="https://img.shields.io/github/v/release/cole-wilson/sailboat?include_prereleases">
<img alt="GitHub" src="https://img.shields.io/github/license/cole-wilson/sailboat">
<img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/sailboat">
</h1>
<a style="display:inline-block;" align="center" href="//sailboat.colewilson.xyz">View Documentation Site</a>
## About
Sailboat is a Python developer's best friend. It's a Python build tool that can do anything you need it to! It suports a countless number of plugins — you can even [make your own](#plugins). Sailboat is made for anyone, whether you are a beginner on your very first project, or a senior software engineer with years of experience.
Let's say that that you have created a basic game, **Guess My Number**, and you want to send it to all of your friends. There are a lot of different ways you can do this, but using Sailboat is the easiest. All you have to do is type three commands: `sail quickstart`, `sail build`, and `sail release`, and you can have a Homebrew file, a `pip` installable package, and a [PyInstaller](https://www.pyinstaller.org/) desktop app. So easy!
Sailboat also supports custom subcommands. These don't build your project, but they can add features such as a todo list that help speed up your development process.
## Installation
### Pip:
```bash
pip3 install sailboat
```
### Binary:
Download from [latest release](https://github.com/cole-wilson/sailboat/releases/latest).
### Homebrew:
```bash
brew install cole-wilson/taps/Sailboat
```
### Build From Source:
```bash
git clone https://github.com/cole-wilson/sailboat
cd sailboat
python3 setup.py install
```
## Usage:
Sailboat is intended to be used from the command line/terminal.
It is suggested to run `sail quickstart` to get started. Then, use `sail build` to build your project, and `sail release` to release it! Be sure to to look at the subcommand docs for more detail.
*(look in table below)*
There are two base commands that can be used: `sail` and `sailboat`. These both do exactly the same thing, there is no difference. `sail` will be used in the documentation, as it's shorter easier to type, but you can do whatever.
To get a list of the availible subcommands type `sail help`.
To refresh the plugin list, type `sail -r`.
There are countless subcommands, but these are the core ones:
|subcommand|description|
|----------|-----------|
| add | Add a plugin to your project. |
| build | Build your project for release. |
| dev | Run your project without building it. |
| git | Manage git for your project. |
| github | Manage git for your project. |
| plugins | Plugin manager. |
| quickstart | Get your project up and running. |
| release | Release your project. |
| remove | Remove a plugin from you project. |
| wizard | Configure you project or a plugin. |
| workflow | Generate a GitHub actions workflow file. |
| help | Display this message. |
## Plugins:
Sailboat uses a plugin based architecture. Every single command or subcommand is a plugin, even the core features. Plugins are registered using the [Python entry points system](https://amir.rachum.com/blog/2017/07/28/python-entry-points/), using the group name `sailboat_plugins`. There are four types of plugins:
### `core`
This type of plugin is reserved for 1st party plugins - plugins that are part of the actual Sailboat source. They have unreserved access to all project data, and therefore this type should not be used in custom plugins.
### `command`
`command` plugins are most basic form of a plugin. They are called by typing `sail <name of plugin>`. They are standalone python scripts that add to the project, like a task list manager.
### `build`
This is perhaps the most common type of plugin, they are run with the `build` core plugin, and are used to generate or edit project files. An example would be the PyInstaller plugin, which generates frozen binaries of the project. These should store output in the top level `dist` folder, in a subfolder with the name of the project. For example: the PyInstaller plugin saves output in `./dist/pyinstaller`. Build plugins can also contain `release` plugins within them.
### `release`
This group of plugins is used by the `release` core plugin. They are used to distribute files. For example: the `homebrew` release plugin uploads the Homebrew formula to a GitHub repo.
All plugins should be a subclass of `sailboat.plugins.Plugin`, a basic class that provide the neccesary functions and registration features. An example `command` plugin might look like this:
```python
from sailboat.plugins import Plugin
class Echo(Plugin):
description = "A basic command plugin that echos it's input."
_type = 'command'
setup = {"string_to_echo":"What string should I echo? "} # Used by wizard
def run(self):
string = self.getData('string_to_echo') # Get string to echo.
print(string)
return
```
Plugins store their data in the `sailboat.toml` file, under their type namespace. For example, the above example will store it's data like so:
```toml
...
[command.echo]
string_to_echo = "Testing..."
...
```
A plugin should ***NEVER*** edit the `sailboat.toml` file on it's own. Instead plugins should use the provided functions OR edit `self.data`, a dictionary of the file. Only data stored in the plugins namespace will be preserved. However, a plugin can read from the top level data.
Plugins can get very complex, and therefore useful, but it is too long to put here. Please look at the [`sailboat.colewilson.xyz/plugins.html`](//sailboat.colewilson.xyz/plugins.html) file for details.
## Acknowledgements:
Thanks to all the people at PyInstaller, dmgbuild, twine, and GitHub actions who provided ways for me to create this.
## Stargazers
[](https://github.com/cole-wilson/sailboat/stargazers)
## Contributors
- Cole Wilson
## Contact
Please submit an issue if you have any questions or need help or find a bug. I'm happy to help!
<cole@colewilson.xyz>
| /sailboat-0.26.1.tar.gz/sailboat-0.26.1/README.md | 0.49048 | 0.938067 | README.md | pypi |
References
==========
.. rubric: References
.. [Baccala2001] Baccala L.A. and Sameshima K. Partial directed coherence: a new concept in neural structure determination. Biological Cybernetics. 84. 463-474. https://doi.org/10.1007/PL00007990
.. [Barrett2010] Barrett A.B., Barnett L. and Seth A.K. Multivariate Granger causality and generalized variance. Physical Review E. E81, 041907. http://dx.doi.org/10.1103/PhysRevE.81.041907
.. [Burnham2002] Burnham K.P. and Anderson D.R. Model Selection and Multimodel Inference: A Practical Information-Theoretic Approach. Springer. ISBN: 9780387224565
.. [Chatfield2003] Chatfield C. The Analysis of Time Series: An Introduction. Chapman and Hall. ISBN: 9780429208706
.. [Colclough2015] Colclough G.L., Brookes M.J., Smith S.M., Woolrich M.W. A symmetric multivariate leakage correction for MEG connectomes. NeuroImage. 117. 439-448. http://dx.doi.org/10.1016/j.neuroimage.2015.03.071
.. [Ding2000] Ding M., Bressler S.L., Weiming Y. and Liang H. Short-window spectral analysis of cortical event-related potentials by adaptive multivariate autoregressive modeling: data preprocessing, model validation, and variability assessment. Biological Cybernetics. 83(1) 35-45. https://doi.org/10.1007/s004229900137
.. [Durbin1950] Durbin, J., & Watson, G. S. (1950). Testing For Serial Correlation In Least Squares Regression. I. Biometrika, 37(3–4), 409–428. https://doi.org/10.1093/biomet/37.3-4.409
.. [Durbin1951] Durbin, J., & Watson, G. S. (1951). Testing For Serial Correlation In Least Squares Regression. II. Biometrika, 38(1–2), 159–178. https://doi.org/10.1093/biomet/38.1-2.159
.. [Fasoula2013] Fasoula A, Attal Y and Schwartz D. Comparative performance evaluation of data-driven causality measures applied to brain networks. Journal of Neuroscience Methods. 215(2). 170-189. https://doi.org/10.1016/j.jneumeth.2013.02.021
.. [Kaminski1991] Kaminski M.J. and Blinowska K.J. A new method of the description of the information flow in the brain structures. Biological Cybernetics. 65(3) 203-210. http://dx.doi.org/10.1007/BF00198091
.. [Kasdin1995] Kasdin, N.J. Discrete Simulation of Colored Noise and Stochastic Processes and 1/f^\alpha Power Law Noise Generation, Proceedings of the IEEE, Vol. 83, No. 5, 1995, pp. 802-827.
.. [Korzeniewska2003] Korzeniewska A, Mańczakb M, Kamiński M, Blinowska K.J. and Kasicki S. Determination of information flow direction among brain structures by a modified directed transfer function (dDTF) method. Journal of Neuroscience Methods. 125(1-2). 195-207. https://doi.org/10.1016/S0165-0270(03)00052-9
.. [Krzywinski2009] Krzywinski M, Schein J, Birol I, Connors J, Gascoyne R, Horsman D, Jones S.J. and Marra M.A. Circos: an Information Aesthetic for Comparative Genomics. Genome Res. 19(9). 1639-1645. http://dx.doi.org/10.1101/gr.092759.109
.. [Lutkephol2006] Lutkepohl H. New Introduction to Multiple Time Series Analysis. Springer. ISBN: 9783540262398
.. [Marple1987] Marple Jr, L.S. Digital Spectral Analysis: With Applications. Prentice-Hall. ISBN: 9780132141499
.. [Neumaier2001] Neumaier A. and Schneider T. Estimation of parameters and eigenmodes of multivariate autoregressive models. ACM Transactions on Mathematical Software. 27(1). 27-57. http://dx.doi.org/10.1145/382043.382304
.. [Pascual-Marqui2014] Pascual-Marqui R.D., Biscay R.J., Bosch-Bayard J., Lehmann D., Kochi K., Kinoshita T., Yamada N. and Sadato N. Assessing direct paths of intracortical causal information flow of oscillatory activity with the isolated effective coherence (iCOH). Frontiers in Human Neuroscience. 8. 448. http://dx.doi.org/10.3389/fnhum.2014.00448
.. [Pascual-Marqui2017] Pascual-Marqui R.D., Biscay R.J., Bosch-Bayard J., Faber P., Kinoshita T., Kochi K., Milz P., Nishida K. and Yoshimura M. Innovations orthogonalization: a solution to the major pitfalls of EEG/MEG "leakage correction". Biorxiv. https://doi.org/10.1101/178657
.. [Penny2009] Penny W.D. Signal Processing Course. https://www.fil.ion.ucl.ac.uk/~wpenny/course/course.html
.. [Quinn2020] Quinn A.J. and Hymers M. SAILS: Spectral Analysis In Linear Systems. Journal of Open Source Software, 5(47), 1982. https://doi.org/10.21105/joss.01982
.. [Quinn2021] Quinn A.J., Green G.G.R. and Hymers, M. Delineating between-subject heterogeneity in alpha networks with Spatio-Spectral Eigenmodes. NeuroImage, 118330. https://doi.org/10.1016/j.neuroimage.2021.118330
.. [Schelter2006] Schelter B, Winterhalder M, Eichler M, Peifer M, Hellwig B, Guschlbauer B, Hermann-Lucking C, Dahlhaus R and Timmer J. Testing for directed influences among neural signals using partial directed coherence. Journal of Neuroscience Methods. 152(1-2). 210-219. https://doi.org/10.1016/j.jneumeth.2005.09.001
.. [Quirk1983] Quirk M. and Liu B. Improving resolution for autoregressive spectral estimation by decimation. IEEE Transactions on Acoustics, Speech and Signal Processing. 31(3) 630-637. http://dx.doi.org/10.1109/TASSP.1983.1164124
.. [Zhu2006] Zhu M and Ghodsi A. Automatic dimensionality selection from the scree plot via the use of profile likelihood. Computational Statistics & Data Analysis. 51(2) 918-930. https://doi.org/10.1016/j.csda.2005.09.010
| /sails-1.4.0.tar.gz/sails-1.4.0/doc/source/references.rst | 0.894732 | 0.815233 | references.rst | pypi |
Tutorial 9 - Modal decomposition of a simulated system
======================================================
One of the main features of SAILS is the ability to perform a modal
decomposition on fitted MVAR models. This tutorial will outline the use of
modal decomposition on some simulated data. This example is included
as part of an upcoming paper from the authors of SAILS.
The system which is being simulated consists of 10 "nodes". Each node is made
up of a mixture of two components, each of which is distributed differently
amongst the nodes. We start by simulating the data for a single realisation:
.. code-block:: python
import numpy as np
import scipy.signal as signal
import matplotlib.pyplot as plt
import sails
plt.style.use('ggplot')
# General configuration for the generation and analysis
sample_rate = 128
num_samples = sample_rate*50
f1 = 10
f2 = 0
siggen = sails.simulate.SailsTutorialExample()
num_sources = siggen.get_num_sources()
weight1, weight2 = siggen.get_connection_weights()
# Calculate the base signals for reference later on
sig1 = siggen.generate_basesignal(f1, .8+.05, sample_rate, num_samples)
sig2 = siggen.generate_basesignal(f2, .61, sample_rate, num_samples)
sig1 = (sig1 - sig1.mean(axis=0)) / sig1.std(axis=0)
sig2 = (sig2 - sig2.mean(axis=0)) / sig2.std(axis=0)
# Generate a network realisation
X = siggen.generate_signal(f1, f2, sample_rate, num_samples)
At this point the variable `X` contains the simulated data. We start by
visualising this data. `sig1` and `sig2` contain the base signals which are
used for visualistion purposes only. Finally, `weight1` and `weight2` contain
the connection weights (the amount to which each signal is spread across the
nodes).
Next we visualise the system before fitting our model. This section of
the code is for plotting purposes only and can be skipped if you are happy
to just examine the plot following it.
.. code-block:: python
# Calculate the Welch PSD of the signals
f, pxx1 = signal.welch(sig1.T, fs=sample_rate, nperseg=128, nfft=512)
f, pxx2 = signal.welch(sig2.T, fs=sample_rate, nperseg=128, nfft=512)
# Visualise the signal and the mixing of it
x_label_pos = -2.25
x_min = -1.75
plot_seconds = 5
plot_samples = int(plot_seconds * sample_rate)
# Plot the two base signals
plt.figure(figsize=(7.5, 2.5))
plt.axes([.15, .8, .65, .15], frameon=False)
plt.plot(sig1[:plot_samples], 'r')
plt.plot(sig2[:plot_samples] + 7.5, 'b')
plt.xlim(-10, plot_samples)
yl = plt.ylim()
plt.xticks([])
plt.yticks([])
# Add labelling to the base signals
plt.axes([.05, .8, .1, .15], frameon=False)
plt.text(x_label_pos, 7.5, 'Mode 1', verticalalignment='center', color='b')
plt.text(x_label_pos, 0, 'Mode 2', verticalalignment='center', color='r')
plt.xlim(x_label_pos, 1)
plt.ylim(*yl)
plt.xticks([])
plt.yticks([])
# Add a diagram of the Welch PSD to each signal
plt.fill_between(np.linspace(0, 2, 257), np.zeros((257)), 20 * pxx1[0, :], color='r')
plt.fill_between(np.linspace(0, 2, 257), np.zeros((257)) + 7.5, 20 * pxx2[0, :]+7.5, color='b')
plt.xlim(x_min, 1)
# Plot the mixed signals in the network
plt.axes([.15, .1, .65, .7], frameon=False)
plt.plot(X[:, :plot_samples, 0].T + np.arange(num_sources) * 7.5, color='k', linewidth=.5)
plt.hlines(np.arange(num_sources)*7.5, -num_sources, plot_samples, linewidth=.2)
plt.xlim(-num_sources, plot_samples)
plt.xticks([])
plt.yticks([])
yl = plt.ylim()
# Add labelling and the weighting information
plt.axes([.05, .1, .1, .7], frameon=False)
plt.barh(np.arange(num_sources)*7.5+1, weight1, color='r', height=2)
plt.barh(np.arange(num_sources)*7.5-1, weight2, color='b', height=2)
plt.xlim(x_min, 1)
plt.ylim(*yl)
for ii in range(num_sources):
plt.text(x_label_pos, 7.5 * ii, 'Node {0}'.format(ii+1), verticalalignment='center')
plt.xticks([])
plt.yticks([])
# Plot the mixing matrices
wmat1, wmat2 = siggen.get_connection_weights('matrix')
plt.axes [.85, .6, .13, .34])
plt.pcolormesh(wmat2, cmap='Blues')
plt.xticks(np.arange(num_sources, 0, -1) - .5, [''] * num_sources, fontsize=6)
plt.yticks(np.arange(num_sources, 0, -1) - .5, np.arange(num_sources, 0, -1), fontsize=6)
plt.axis('scaled')
plt.axes([.85, .2, .13, .34])
plt.pcolormesh(wmat1, cmap='Reds')
plt.xticks(np.arange(num_sources, 0, -1)-.5, np.arange(num_sources, 0, -1), fontsize=6)
plt.yticks(np.arange(num_sources, 0, -1)-.5, np.arange(num_sources, 0, -1), fontsize=6)
plt.axis('scaled')
.. image:: tutorial9_1.png
Next we fit an MVAR model and examine the Modal decomposition:
.. code-block:: python
model_order = 5
delay_vect = np.arange(model_order + 1)
freq_vect = np.linspace(0, sample_rate/2, 512)
# Fit our MVAR model and perform the modal decomposition
m = sails.VieiraMorfLinearModel.fit_model(X, delay_vect)
modes = sails.MvarModalDecomposition.initialise(m, sample_rate)
# Now extract the metrics for the modal model
M = sails.ModalMvarMetrics.initialise(m, sample_rate,
freq_vect, sum_modes=False)
Each mode in the decomposition consists of either a single pole
(where it is a DC component) or a pair of poles (where it is
an oscillator). We can extract the indicies of the pole pairs
using the ```mode_indices``` property. Given the nature of
our simulation, we would expect to find one DC pole and one
pole at 10Hz with a stronger effect than all other poles.
For the purposes of this tutorial, we are going to set an arbitrary
threshold on the modes; in reality a permutation testing scheme
can be used to determine this threshold (which will be the
subject of a future tutorial).
.. code-block:: python
# For real data and simulations this can be estimated using
# a permutation scheme
pole_threshold = 2.3
# Extract the pairs of mode indices
pole_idx = modes.mode_indices
# Find which modes pass threshold
surviving_modes = []
for idx, poles in enumerate(pole_idx):
# The DTs of a pair of poles will be identical
# so we can just check the first one
if modes.dampening_time[poles[0]] > pole_threshold:
surviving_modes.append(idx)
# Use root plot to plot all modes and then replot
# the surviving modes on top of them
ax = sails.plotting.root_plot(modes.evals)
low_mode = None
high_mode = None
for mode in surviving_modes:
# Pick the colour based on the peak frequency
if modes.peak_frequency[pole_idx[mode][0]] < 0.001:
color = 'b'
low_mode = mode
else:
color = 'r'
high_mode = mode
for poleidx in pole_idx[mode]:
ax.plot(modes.evals[poleidx].real, modes.evals[poleidx].imag,
marker='+', color=color)
.. image:: tutorial9_2.png
From this, we can see that the modal decomposition has clearly extracted a set
of poles of importance. We can now visualise the connectivity patterns
for these modes as well as their spectra:
.. code-block:: python
# The frequency location simply acts as a scaling factor at this
# point, but we pick the closest bin in freq_vect to the
# peak frequency of the mode
low_freq_idx = np.argmin(np.abs(freq_vect - modes.peak_frequency[pole_idx[low_mode][0]]))
high_freq_idx = np.argmin(np.abs(freq_vect - modes.peak_frequency[pole_idx[high_mode][0]]))
# We can now plot the two graph
plt.figure()
low_psd = np.sum(M.PSD[:, :, :, pole_idx[low_mode]], axis=3)
high_psd = np.sum(M.PSD[:, :, :, pole_idx[high_mode]], axis=3)
# Plot the connectivity patterns as well as the spectra
plt.subplot(2, 2, 1)
plt.pcolormesh(low_psd[:, :, low_freq_idx], cmap='Blues')
plt.xticks(np.arange(num_sources, 0, -1)-.5, np.arange(num_sources, 0, -1), fontsize=6)
plt.yticks(np.arange(num_sources, 0, -1)-.5, np.arange(num_sources, 0, -1), fontsize=6)
plt.subplot(2, 2, 2)
for k in range(num_sources):
plt.plot(freq_vect, low_psd[k, k, :])
plt.subplot(2, 2, 3)
plt.pcolormesh(high_psd[:, :, high_freq_idx], cmap='Reds')
plt.xticks(np.arange(num_sources, 0, -1)-.5, np.arange(num_sources, 0, -1), fontsize=6)
plt.yticks(np.arange(num_sources, 0, -1)-.5, np.arange(num_sources, 0, -1), fontsize=6)
plt.subplot(2, 2, 4)
for k in range(num_sources):
plt.plot(freq_vect, high_psd[k, k, :])
plt.xlabel('Frequency (Hz)')
.. image:: tutorial9_3.png
In this tutorial we have demonstrated how to use the modal decomposition
functionality in SAILS to decompose the parameters of an MVAR model and then to
extract spectral and connectivity patterns from just the modes of significance.
This approach can be extended across participants and, with the additional use
of PCA, used to simultaneously estimate spatial and spectral patterns in data.
More details of this approach will be available in an upcoming paper from
the authors of SAILS.
| /sails-1.4.0.tar.gz/sails-1.4.0/doc/source/tutorials/tutorial9.rst | 0.963317 | 0.914749 | tutorial9.rst | pypi |
Tutorial 6 - Sliding window univariate model estimation
=======================================================
In this tutorial, we will examine fitting multiple models using a sliding window approach.
For this tutorial, we will use the same MEG example data which we have used in previous
tutorials.
We start by importing our modules and finding and loading the example data.
.. code-block:: python
import os
from os.path import join
import h5py
import numpy as np
import matplotlib.pyplot as plt
import sails
plt.style.use('ggplot')
SAILS will automatically detect the example data if downloaded into your home
directory. If you've used a different location, you can specify this in an
environment variable named ``SAILS_EXAMPLE_DATA``.
.. code-block:: python
# Specify environment variable with example data location
# This is only necessary if you have not checked out the
# example data into $HOME/sails-example-data
os.environ['SAILS_EXAMPLE_DATA'] = '/path/to/sails-example-data'
# Locate and validate example data directory
example_path = sails.find_example_path()
# Load data using h5py
data_path = os.path.join(sails.find_example_path(), 'meg_occipital_ve.hdf5')
X = h5py.File(data_path, 'r')['X'][:, 122500:130000, :]
X = sails.utils.fast_resample(X, 5/2)
sample_rate = 250 / (5/2)
nyq = sample_rate / 2.
time_vect = np.linspace(0, X.shape[1] // sample_rate, X.shape[1])
freq_vect = np.linspace(0, nyq, 64)
As a reminder, our data is (nsignals, nsamples, ntrials):
.. code-block:: python
print(X.shape)
.. code-block:: console
(1, 3000, 1)
The idea behind a sliding window analysis is to fit a separate MVAR model
to short windows of the data. For the purposes of this example, we will
fit consecutive windows which are 200 samples long. We can do this
by simply extracting the relevant data and fitting the model in the
same way that we have done so before. We are using 10 delays in each
of our models. After computing the model, we can then calculate
some of our diagnostics and examine, for example, the :math:`R^2` value.
We could also choose to examine our Fourier MVAR metrics.
.. code-block:: python
from sails import VieiraMorfLinearModel, FourierMvarMetrics
delay_vect = np.arange(10)
m1 = VieiraMorfLinearModel.fit_model(X[:, 0:200, :], delay_vect)
d1 = m1.compute_diagnostics(X[:, 0:200, :])
print(d1.R_square)
.. code-block:: console
0.6695709340724934
We can then repeat this procedure for the next, overlapping, window:
.. code-block:: python
delay_vect = np.arange(10)
m2 = VieiraMorfLinearModel.fit_model(X[:, 1:201, :], delay_vect)
d2 = m1.compute_diagnostics(X[:, 1:201, :])
print(d2.R_square)
.. code-block:: python
0.6567768337622513
This is obviously a time-consuming task, so we provide a helper function
which will take a set of time-series data and compute a model and
diagnostic information for each window. The
:func:`sails.modelfit.sliding_window_fit`
function takes at least five parameters:
1. the class to use for fitting (here, we use :class:`sails.modelfit.VieiraMorfLinearModel`)
2. the data to which the models are being fitted
3. the delay vector to use for each model
4. the `length` of each window in samples
5. the `step` between windows. For example, if this is set to 1 sample, consecutive overlapping windows will be used. If this is set to 10, each consecutive window will start 10 samples apart. If this is equal to the `length` of the window or greater, the windows will not overlap.
The sliding_window_fit routine returns specially constructed model in which the
parameters matrix is set up as `(nsources, nsources, ndelays, nwindows)`. In
other words, there is a model (indexed on the final dimension) for each of the
windows. A :class:`~sails.diags.ModelDiagnostics` class is also returned
which contains the diagnostic information for all of the windows. Use of the
:func:`~sails.modelfit.sliding_window_fit` routine is straightforward:
.. code-block:: python
from sails import sliding_window_fit
M, D = sliding_window_fit(VieiraMorfLinearModel, X, delay_vect, 100, 1)
model_time_vect = time_vect[M.time_vect.astype(int)]
Once we have constructed our models, we can go ahead and construct our
:class:`~sails.mvar_metrics.FourierMvarMetrics` class which will allow us to,
for example, extract the transfer function for each window:
.. code-block:: python
F = FourierMvarMetrics.initialise(M, sample_rate, freq_vect)
We will now produce a composite plot which illustrates how the behaviour
of the system evolves over time. We are going to limit ourselves to the
first 10000 data points and windows.
.. code-block:: python
f1, axes = plt.subplots(nrows=5, ncols=1, figsize=(12, 8))
On the top row, we plot our data.
.. code-block:: python
plt.subplot(5, 1, 1)
plt.plot(time_vect, X[0, :, 0])
plt.xlim(0, 30)
plt.grid(True)
plt.ylabel('Amplitude')
On the next two rows, we plot our transfer function for the first 10000
windows:
.. code-block:: python
plt.subplot(5, 1, (2, 3))
plt.contourf(model_time_vect, F.freq_vect[3:], np.sqrt(np.abs(F.PSD[0, 0, 3:, :])))
plt.xlim(0, 30)
plt.grid(True)
plt.ylabel('Frequency (Hz)')
Underneath the transfer function, we examine the stability index
(in red) and the :math:`R^2` value (in blue):
.. code-block:: python
plt.subplot(5, 1, 4)
plt.plot(model_time_vect, D.SI)
plt.plot(model_time_vect, D.R_square)
plt.xlim(0, 30)
plt.grid(True)
plt.ylabel('SI / $R^2$')
On the bottom row, we plot the AIC value for each of the models:
.. code-block:: python
plt.subplot(5, 1, 5)
plt.plot(model_time_vect, D.AIC)
plt.xlim(0, 30)
plt.grid(True)
plt.xlabel('Time (samples)')
plt.ylabel('AIC')
Finally, we can look at our overall figure:
.. code-block:: python
f1.tight_layout()
f1.show()
.. image:: tutorial6_1.png
| /sails-1.4.0.tar.gz/sails-1.4.0/doc/source/tutorials/tutorial6.rst | 0.938695 | 0.864654 | tutorial6.rst | pypi |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.