prompt
stringlengths 19
1.03M
| completion
stringlengths 4
2.12k
| api
stringlengths 8
90
|
|---|---|---|
from django.db import models
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from django.contrib.staticfiles import finders
from covision.local_settings import BASE_DIR
import os
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score
import datetime
import plotly.graph_objects as go
from plotly.offline import download_plotlyjs,init_notebook_mode,plot,iplot
from tweepy.streaming import StreamListener
from tweepy import OAuthHandler
from tweepy import Stream
import neattext.functions as nf
from textblob import TextBlob
import plotly.express as px
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.svm import SVC
from sklearn.metrics import confusion_matrix,accuracy_score
import pickle
import spacy
from spacy.lang.en.stop_words import STOP_WORDS
from string import punctuation
from heapq import nlargest
import re
from dotenv import load_dotenv, find_dotenv
load_dotenv(find_dotenv())
# Create your models here.
class Predictor():
def load_data(self):
csv_path = os.path.join(BASE_DIR,'base','datasets','covid_cases.csv')
dataset = pd.read_csv(csv_path)
dataset = dataset[['Date_reported','New_cases']]
return dataset
def predict(self,dataset):
X_dataset_train = dataset[0:int(len(dataset)*0.75)]
X_dataset_test = dataset[int(len(dataset)*0.75):]
training=pd.DataFrame(X_dataset_train['New_cases'])
testing=pd.DataFrame(X_dataset_test['New_cases'])
sc = StandardScaler()
training = sc.fit_transform(training)
testing = sc.transform(testing)
window=30
x_train=[]
y_train=[]
for i in range(window,len(training)):
x_train.append(training[i-window:i,0])
y_train.append(training[i,0])
x_train,y_train=np.array(x_train),np.array(y_train)
regressor = LinearRegression()
regressor.fit(x_train, y_train)
x_test=[]
for i in range(window,len(testing)):
x_test.append(testing[i-window:i,0])
x_test=np.array(x_test)
y_pred = sc.inverse_transform(regressor.predict(x_test))
Final = X_dataset_test[window:]
Final['Predicted'] = y_pred
X_dataset_test['Date_reported']=pd.to_datetime(X_dataset_test['Date_reported'],format="%Y-%m-%d")
for i in range (window):
x_test=[]
x_test.append(testing[-window:,0])
x_test=np.array(x_test)
pred=sc.inverse_transform(regressor.predict(x_test))
new_date=X_dataset_test['Date_reported'][-1:] + datetime.timedelta(days=1)
data = {'Date_reported':new_date.values[0],'New_cases':pred[0]}
X_dataset_test = X_dataset_test.append(data,ignore_index=True)
testing = np.reshape(np.append(testing,regressor.predict(x_test)),(-1,1))
X_dataset_test['New_cases'][-window:] = X_dataset_test['New_cases'][-window:].apply(lambda x: int(round(x)))
return Final,X_dataset_test[-window:]
def get_accuracy(self,result):
return round(r2_score(result['New_cases'], result['Predicted'])*100,2)
def visualize_test(self,Final):
fig = go.Figure()
fig.add_trace(go.Scatter(x=Final['Date_reported'],y=Final['New_cases'],name='Actual'))
fig.add_trace(go.Scatter(x=Final['Date_reported'],y=Final['Predicted'],name='Predicted'))
fig.update_layout(title='Daily Cases VS Date',xaxis_title='Date',yaxis_title='Number of Daily Cases')
plot_div=plot(fig, output_type='div',include_plotlyjs=False)
return plot_div
def visualize_forecast(self,dataset,result):
fig = go.Figure()
fig.add_trace(go.Scatter(x=dataset['Date_reported'],y=dataset['New_cases'],name='Prehistoric Data'))
fig.add_trace(go.Scatter(x=result['Date_reported'],y=result['New_cases'],name='Forecasted Data'))
fig.update_layout(title='Daily Cases VS Date',xaxis_title='Date',yaxis_title='Number of Daily Cases')
plot_div=plot(fig, output_type='div',include_plotlyjs=False)
return plot_div
tweet_dataset = | pd.DataFrame() | pandas.DataFrame |
import re
from unittest.mock import Mock, patch
import numpy as np
import pandas as pd
import pytest
from rdt.transformers import (
CategoricalTransformer, LabelEncodingTransformer, OneHotEncodingTransformer)
RE_SSN = re.compile(r'\d\d\d-\d\d-\d\d\d\d')
class TestCategoricalTransformer:
def test___init__(self):
"""Passed arguments must be stored as attributes."""
# Run
transformer = CategoricalTransformer(
fuzzy='fuzzy_value',
clip='clip_value',
)
# Asserts
assert transformer.fuzzy == 'fuzzy_value'
assert transformer.clip == 'clip_value'
def test__get_intervals(self):
# Run
data = pd.Series(['foo', 'bar', 'bar', 'foo', 'foo', 'tar'])
result = CategoricalTransformer._get_intervals(data)
# Asserts
expected_intervals = {
'foo': (0, 0.5, 0.25, 0.5 / 6),
'bar': (0.5, 0.8333333333333333, 0.6666666666666666, 0.05555555555555555),
'tar': (0.8333333333333333, 0.9999999999999999, 0.9166666666666666,
0.027777777777777776)
}
assert result[0] == expected_intervals
def test_fit(self):
# Setup
transformer = CategoricalTransformer()
# Run
data = np.array(['foo', 'bar', 'bar', 'foo', 'foo', 'tar'])
transformer.fit(data)
# Asserts
expected_intervals = {
'foo': (0, 0.5, 0.25, 0.5 / 6),
'bar': (0.5, 0.8333333333333333, 0.6666666666666666, 0.05555555555555555),
'tar': (0.8333333333333333, 0.9999999999999999, 0.9166666666666666,
0.027777777777777776)
}
assert transformer.intervals == expected_intervals
def test__get_value_no_fuzzy(self):
# Setup
transformer = CategoricalTransformer(fuzzy=False)
transformer.fuzzy = False
transformer.intervals = {
'foo': (0, 0.5, 0.25, 0.5 / 6),
}
# Run
result = transformer._get_value('foo')
# Asserts
assert result == 0.25
@patch('scipy.stats.norm.rvs')
def test__get_value_fuzzy(self, rvs_mock):
# setup
rvs_mock.return_value = 0.2745
transformer = CategoricalTransformer(fuzzy=True)
transformer.intervals = {
'foo': (0, 0.5, 0.25, 0.5 / 6),
}
# Run
result = transformer._get_value('foo')
# Asserts
assert result == 0.2745
def test__normalize_no_clip(self):
"""Test normalize data"""
# Setup
transformer = CategoricalTransformer(clip=False)
# Run
data = pd.Series([-0.43, 0.1234, 1.5, -1.31])
result = transformer._normalize(data)
# Asserts
expect = pd.Series([0.57, 0.1234, 0.5, 0.69], dtype=float)
pd.testing.assert_series_equal(result, expect)
def test__normalize_clip(self):
"""Test normalize data with clip=True"""
# Setup
transformer = CategoricalTransformer(clip=True)
# Run
data = pd.Series([-0.43, 0.1234, 1.5, -1.31])
result = transformer._normalize(data)
# Asserts
expect = pd.Series([0.0, 0.1234, 1.0, 0.0], dtype=float)
pd.testing.assert_series_equal(result, expect)
def test_reverse_transform_array(self):
"""Test reverse_transform a numpy.array"""
# Setup
data = np.array(['foo', 'bar', 'bar', 'foo', 'foo', 'tar'])
rt_data = np.array([-0.6, 0.5, 0.6, 0.2, 0.1, -0.2])
transformer = CategoricalTransformer()
# Run
transformer.fit(data)
result = transformer.reverse_transform(rt_data)
# Asserts
expected_intervals = {
'foo': (0, 0.5, 0.25, 0.5 / 6),
'bar': (0.5, 0.8333333333333333, 0.6666666666666666, 0.05555555555555555),
'tar': (0.8333333333333333, 0.9999999999999999, 0.9166666666666666,
0.027777777777777776)
}
assert transformer.intervals == expected_intervals
expect = pd.Series(data)
pd.testing.assert_series_equal(result, expect)
def test__transform_by_category_called(self):
"""Test that the `_transform_by_category` method is called.
When the number of rows is greater than the number of categories, expect
that the `_transform_by_category` method is called.
Setup:
The categorical transformer is instantiated with 4 categories.
Input:
- data with 5 rows
Output:
- the output of `_transform_by_category`
Side effects:
- `_transform_by_category` will be called once
"""
# Setup
data = pd.Series([1, 3, 3, 2, 1])
categorical_transformer_mock = Mock()
categorical_transformer_mock.means = pd.Series([0.125, 0.375, 0.625, 0.875])
# Run
transformed = CategoricalTransformer.transform(categorical_transformer_mock, data)
# Asserts
categorical_transformer_mock._transform_by_category.assert_called_once_with(data)
assert transformed == categorical_transformer_mock._transform_by_category.return_value
def test__transform_by_category(self):
"""Test the `_transform_by_category` method with numerical data.
Expect that the correct transformed data is returned.
Setup:
The categorical transformer is instantiated with 4 categories and intervals.
Input:
- data with 5 rows
Ouptut:
- the transformed data
"""
# Setup
data = pd.Series([1, 3, 3, 2, 1])
transformer = CategoricalTransformer()
transformer.intervals = {
4: (0, 0.25, 0.125, 0.041666666666666664),
3: (0.25, 0.5, 0.375, 0.041666666666666664),
2: (0.5, 0.75, 0.625, 0.041666666666666664),
1: (0.75, 1.0, 0.875, 0.041666666666666664),
}
# Run
transformed = transformer._transform_by_category(data)
# Asserts
expected = np.array([0.875, 0.375, 0.375, 0.625, 0.875])
assert (transformed == expected).all()
def test__transform_by_row_called(self):
"""Test that the `_transform_by_row` method is called.
When the number of rows is less than or equal to the number of categories,
expect that the `_transform_by_row` method is called.
Setup:
The categorical transformer is instantiated with 4 categories.
Input:
- data with 4 rows
Output:
- the output of `_transform_by_row`
Side effects:
- `_transform_by_row` will be called once
"""
# Setup
data = pd.Series([1, 2, 3, 4])
categorical_transformer_mock = Mock()
categorical_transformer_mock.means = pd.Series([0.125, 0.375, 0.625, 0.875])
# Run
transformed = CategoricalTransformer.transform(categorical_transformer_mock, data)
# Asserts
categorical_transformer_mock._transform_by_row.assert_called_once_with(data)
assert transformed == categorical_transformer_mock._transform_by_row.return_value
def test__transform_by_row(self):
"""Test the `_transform_by_row` method with numerical data.
Expect that the correct transformed data is returned.
Setup:
The categorical transformer is instantiated with 4 categories and intervals.
Input:
- data with 4 rows
Ouptut:
- the transformed data
"""
# Setup
data = pd.Series([1, 2, 3, 4])
transformer = CategoricalTransformer()
transformer.intervals = {
4: (0, 0.25, 0.125, 0.041666666666666664),
3: (0.25, 0.5, 0.375, 0.041666666666666664),
2: (0.5, 0.75, 0.625, 0.041666666666666664),
1: (0.75, 1.0, 0.875, 0.041666666666666664),
}
# Run
transformed = transformer._transform_by_row(data)
# Asserts
expected = np.array([0.875, 0.625, 0.375, 0.125])
assert (transformed == expected).all()
@patch('psutil.virtual_memory')
def test__reverse_transfrom_by_matrix_called(self, psutil_mock):
"""Test that the `_reverse_transform_by_matrix` method is called.
When there is enough virtual memory, expect that the
`_reverse_transform_by_matrix` method is called.
Setup:
The categorical transformer is instantiated with 4 categories. Also patch the
`psutil.virtual_memory` function to return a large enough `available_memory`.
Input:
- numerical data with 4 rows
Output:
- the output of `_reverse_transform_by_matrix`
Side effects:
- `_reverse_transform_by_matrix` will be called once
"""
# Setup
data = pd.Series([1, 2, 3, 4])
categorical_transformer_mock = Mock()
categorical_transformer_mock.means = pd.Series([0.125, 0.375, 0.625, 0.875])
categorical_transformer_mock._normalize.return_value = data
virtual_memory = Mock()
virtual_memory.available = 4 * 4 * 8 * 3 + 1
psutil_mock.return_value = virtual_memory
# Run
reverse = CategoricalTransformer.reverse_transform(categorical_transformer_mock, data)
# Asserts
categorical_transformer_mock._reverse_transform_by_matrix.assert_called_once_with(data)
assert reverse == categorical_transformer_mock._reverse_transform_by_matrix.return_value
@patch('psutil.virtual_memory')
def test__reverse_transfrom_by_matrix(self, psutil_mock):
"""Test the _reverse_transform_by_matrix method with numerical data
Expect that the transformed data is correctly reverse transformed.
Setup:
The categorical transformer is instantiated with 4 categories and means. Also patch
the `psutil.virtual_memory` function to return a large enough `available_memory`.
Input:
- transformed data with 4 rows
Ouptut:
- the original data
"""
# Setup
data = pd.Series([1, 2, 3, 4])
transformed = pd.Series([0.875, 0.625, 0.375, 0.125])
transformer = CategoricalTransformer()
transformer.means = pd.Series([0.125, 0.375, 0.625, 0.875], index=[4, 3, 2, 1])
transformer.dtype = data.dtype
virtual_memory = Mock()
virtual_memory.available = 4 * 4 * 8 * 3 + 1
psutil_mock.return_value = virtual_memory
# Run
reverse = transformer._reverse_transform_by_matrix(transformed)
# Assert
pd.testing.assert_series_equal(data, reverse)
@patch('psutil.virtual_memory')
def test__reverse_transform_by_category_called(self, psutil_mock):
"""Test that the `_reverse_transform_by_category` method is called.
When there is not enough virtual memory and the number of rows is greater than the
number of categories, expect that the `_reverse_transform_by_category` method is called.
Setup:
The categorical transformer is instantiated with 4 categories. Also patch the
`psutil.virtual_memory` function to return an `available_memory` of 1.
Input:
- numerical data with 5 rows
Output:
- the output of `_reverse_transform_by_category`
Side effects:
- `_reverse_transform_by_category` will be called once
"""
# Setup
transform_data = pd.Series([1, 3, 3, 2, 1])
categorical_transformer_mock = Mock()
categorical_transformer_mock.means = pd.Series([0.125, 0.375, 0.625, 0.875])
categorical_transformer_mock._normalize.return_value = transform_data
virtual_memory = Mock()
virtual_memory.available = 1
psutil_mock.return_value = virtual_memory
# Run
reverse = CategoricalTransformer.reverse_transform(
categorical_transformer_mock, transform_data)
# Asserts
categorical_transformer_mock._reverse_transform_by_category.assert_called_once_with(
transform_data)
assert reverse == categorical_transformer_mock._reverse_transform_by_category.return_value
@patch('psutil.virtual_memory')
def test__reverse_transform_by_category(self, psutil_mock):
"""Test the _reverse_transform_by_category method with numerical data.
Expect that the transformed data is correctly reverse transformed.
Setup:
The categorical transformer is instantiated with 4 categories, and the means
and intervals are set for those categories. Also patch the `psutil.virtual_memory`
function to return an `available_memory` of 1.
Input:
- transformed data with 5 rows
Ouptut:
- the original data
"""
data = pd.Series([1, 3, 3, 2, 1])
transformed = pd.Series([0.875, 0.375, 0.375, 0.625, 0.875])
transformer = CategoricalTransformer()
transformer.means = pd.Series([0.125, 0.375, 0.625, 0.875], index=[4, 3, 2, 1])
transformer.intervals = {
4: (0, 0.25, 0.125, 0.041666666666666664),
3: (0.25, 0.5, 0.375, 0.041666666666666664),
2: (0.5, 0.75, 0.625, 0.041666666666666664),
1: (0.75, 1.0, 0.875, 0.041666666666666664),
}
transformer.dtype = data.dtype
virtual_memory = Mock()
virtual_memory.available = 1
psutil_mock.return_value = virtual_memory
reverse = transformer._reverse_transform_by_category(transformed)
pd.testing.assert_series_equal(data, reverse)
@patch('psutil.virtual_memory')
def test__reverse_transform_by_row_called(self, psutil_mock):
"""Test that the `_reverse_transform_by_row` method is called.
When there is not enough virtual memory and the number of rows is less than or equal
to the number of categories, expect that the `_reverse_transform_by_row` method
is called.
Setup:
The categorical transformer is instantiated with 4 categories. Also patch the
`psutil.virtual_memory` function to return an `available_memory` of 1.
Input:
- numerical data with 4 rows
Output:
- the output of `_reverse_transform_by_row`
Side effects:
- `_reverse_transform_by_row` will be called once
"""
# Setup
data = pd.Series([1, 2, 3, 4])
categorical_transformer_mock = Mock()
categorical_transformer_mock.means = pd.Series([0.125, 0.375, 0.625, 0.875])
categorical_transformer_mock.starts = pd.DataFrame(
[0., 0.25, 0.5, 0.75], index=[4, 3, 2, 1], columns=['category'])
categorical_transformer_mock._normalize.return_value = data
virtual_memory = Mock()
virtual_memory.available = 1
psutil_mock.return_value = virtual_memory
# Run
reverse = CategoricalTransformer.reverse_transform(categorical_transformer_mock, data)
# Asserts
categorical_transformer_mock._reverse_transform_by_row.assert_called_once_with(data)
assert reverse == categorical_transformer_mock._reverse_transform_by_row.return_value
@patch('psutil.virtual_memory')
def test__reverse_transform_by_row(self, psutil_mock):
"""Test the _reverse_transform_by_row method with numerical data.
Expect that the transformed data is correctly reverse transformed.
Setup:
The categorical transformer is instantiated with 4 categories, and the means, starts,
and intervals are set for those categories. Also patch the `psutil.virtual_memory`
function to return an `available_memory` of 1.
Input:
- transformed data with 4 rows
Ouptut:
- the original data
"""
# Setup
data = pd.Series([1, 2, 3, 4])
transformed = pd.Series([0.875, 0.625, 0.375, 0.125])
transformer = CategoricalTransformer()
transformer.means = pd.Series([0.125, 0.375, 0.625, 0.875], index=[4, 3, 2, 1])
transformer.starts = pd.DataFrame(
[4, 3, 2, 1], index=[0., 0.25, 0.5, 0.75], columns=['category'])
transformer.intervals = {
4: (0, 0.25, 0.125, 0.041666666666666664),
3: (0.25, 0.5, 0.375, 0.041666666666666664),
2: (0.5, 0.75, 0.625, 0.041666666666666664),
1: (0.75, 1.0, 0.875, 0.041666666666666664),
}
transformer.dtype = data.dtype
virtual_memory = Mock()
virtual_memory.available = 1
psutil_mock.return_value = virtual_memory
# Run
reverse = transformer.reverse_transform(transformed)
# Assert
pd.testing.assert_series_equal(data, reverse)
class TestOneHotEncodingTransformer:
def test__prepare_data_empty_lists(self):
# Setup
ohet = OneHotEncodingTransformer()
data = [[], [], []]
# Assert
with pytest.raises(ValueError):
ohet._prepare_data(data)
def test__prepare_data_nested_lists(self):
# Setup
ohet = OneHotEncodingTransformer()
data = [[[]]]
# Assert
with pytest.raises(ValueError):
ohet._prepare_data(data)
def test__prepare_data_list_of_lists(self):
# Setup
ohet = OneHotEncodingTransformer()
# Run
data = [['a'], ['b'], ['c']]
out = ohet._prepare_data(data)
# Assert
expected = np.array(['a', 'b', 'c'])
np.testing.assert_array_equal(out, expected)
def test__prepare_data_pandas_series(self):
# Setup
ohet = OneHotEncodingTransformer()
# Run
data = pd.Series(['a', 'b', 'c'])
out = ohet._prepare_data(data)
# Assert
expected = pd.Series(['a', 'b', 'c'])
np.testing.assert_array_equal(out, expected)
def test_fit_no_nans(self):
"""Test the ``fit`` method without nans.
Check that the settings of the transformer
are properly set based on the input. Encoding
should be activated
Input:
- Series with values
"""
# Setup
ohet = OneHotEncodingTransformer()
# Run
data = pd.Series(['a', 'b', 'c'])
ohet.fit(data)
# Assert
np.testing.assert_array_equal(ohet.dummies, ['a', 'b', 'c'])
np.testing.assert_array_equal(ohet.decoder, ['a', 'b', 'c'])
assert ohet.dummy_encoded
assert not ohet.dummy_na
def test_fit_no_nans_numeric(self):
"""Test the ``fit`` method without nans.
Check that the settings of the transformer
are properly set based on the input. Encoding
should be deactivated
Input:
- Series with values
"""
# Setup
ohet = OneHotEncodingTransformer()
# Run
data = pd.Series([1, 2, 3])
ohet.fit(data)
# Assert
np.testing.assert_array_equal(ohet.dummies, [1, 2, 3])
np.testing.assert_array_equal(ohet.decoder, [1, 2, 3])
assert not ohet.dummy_encoded
assert not ohet.dummy_na
def test_fit_nans(self):
"""Test the ``fit`` method with nans.
Check that the settings of the transformer
are properly set based on the input. Encoding
and NA should be activated.
Input:
- Series with containing nan values
"""
# Setup
ohet = OneHotEncodingTransformer()
# Run
data = pd.Series(['a', 'b', None])
ohet.fit(data)
# Assert
np.testing.assert_array_equal(ohet.dummies, ['a', 'b'])
np.testing.assert_array_equal(ohet.decoder, ['a', 'b', np.nan])
assert ohet.dummy_encoded
assert ohet.dummy_na
def test_fit_nans_numeric(self):
"""Test the ``fit`` method with nans.
Check that the settings of the transformer
are properly set based on the input. Encoding
should be deactivated and NA activated.
Input:
- Series with containing nan values
"""
# Setup
ohet = OneHotEncodingTransformer()
# Run
data = pd.Series([1, 2, np.nan])
ohet.fit(data)
# Assert
np.testing.assert_array_equal(ohet.dummies, [1, 2])
np.testing.assert_array_equal(ohet.decoder, [1, 2, np.nan])
assert not ohet.dummy_encoded
assert ohet.dummy_na
def test_fit_single(self):
# Setup
ohet = OneHotEncodingTransformer()
# Run
data = pd.Series(['a', 'a', 'a'])
ohet.fit(data)
# Assert
np.testing.assert_array_equal(ohet.dummies, ['a'])
def test__transform_no_nan(self):
"""Test the ``_transform`` method without nans.
The values passed to ``_transform`` should be
returned in a one-hot encoding representation.
Input:
- Series with values
Output:
- one-hot encoding of the input
"""
# Setup
ohet = OneHotEncodingTransformer()
data = pd.Series(['a', 'b', 'c'])
ohet.dummies = ['a', 'b', 'c']
ohet.num_dummies = 3
# Run
out = ohet._transform(data)
# Assert
expected = np.array([
[1, 0, 0],
[0, 1, 0],
[0, 0, 1]
])
np.testing.assert_array_equal(out, expected)
def test__transform_no_nan_categorical(self):
"""Test the ``_transform`` method without nans.
The values passed to ``_transform`` should be
returned in a one-hot encoding representation
using the categorical branch.
Input:
- Series with categorical values
Output:
- one-hot encoding of the input
"""
# Setup
ohet = OneHotEncodingTransformer()
data = pd.Series(['a', 'b', 'c'])
ohet.dummies = ['a', 'b', 'c']
ohet.indexer = [0, 1, 2]
ohet.num_dummies = 3
ohet.dummy_encoded = True
# Run
out = ohet._transform(data)
# Assert
expected = np.array([
[1, 0, 0],
[0, 1, 0],
[0, 0, 1]
])
np.testing.assert_array_equal(out, expected)
def test__transform_nans(self):
"""Test the ``_transform`` method with nans.
The values passed to ``_transform`` should be
returned in a one-hot encoding representation. Null
values should be represented by the same encoding.
Input:
- Series with values containing nans
Output:
- one-hot encoding of the input
"""
# Setup
ohet = OneHotEncodingTransformer()
data = pd.Series([np.nan, None, 'a', 'b'])
ohet.dummies = ['a', 'b']
ohet.dummy_na = True
ohet.num_dummies = 2
# Run
out = ohet._transform(data)
# Assert
expected = np.array([
[0, 0, 1],
[0, 0, 1],
[1, 0, 0],
[0, 1, 0]
])
np.testing.assert_array_equal(out, expected)
def test__transform_nans_categorical(self):
"""Test the ``_transform`` method with nans.
The values passed to ``_transform`` should be
returned in a one-hot encoding representation using
the categorical branch. Null values should be
represented by the same encoding.
Input:
- Series with categorical values containing nans
Output:
- one-hot encoding of the input
"""
# Setup
ohet = OneHotEncodingTransformer()
data = pd.Series([np.nan, None, 'a', 'b'])
ohet.dummies = ['a', 'b']
ohet.indexer = [0, 1]
ohet.dummy_na = True
ohet.num_dummies = 2
ohet.dummy_encoded = True
# Run
out = ohet._transform(data)
# Assert
expected = np.array([
[0, 0, 1],
[0, 0, 1],
[1, 0, 0],
[0, 1, 0]
])
np.testing.assert_array_equal(out, expected)
def test__transform_single(self):
"""Test the ``_transform`` with one category.
The values passed to ``_transform`` should be
returned in a one-hot encoding representation
where it should be a single column.
Input:
- Series with a single category
Output:
- one-hot encoding of the input
"""
# Setup
ohet = OneHotEncodingTransformer()
data = pd.Series(['a', 'a', 'a'])
ohet.dummies = ['a']
ohet.num_dummies = 1
# Run
out = ohet._transform(data)
# Assert
expected = np.array([
[1],
[1],
[1]
])
np.testing.assert_array_equal(out, expected)
def test__transform_single_categorical(self):
"""Test the ``_transform`` with one category.
The values passed to ``_transform`` should be
returned in a one-hot encoding representation
using the categorical branch where it should
be a single column.
Input:
- Series with a single category
Output:
- one-hot encoding of the input
"""
# Setup
ohet = OneHotEncodingTransformer()
data = pd.Series(['a', 'a', 'a'])
ohet.dummies = ['a']
ohet.indexer = [0]
ohet.num_dummies = 1
ohet.dummy_encoded = True
# Run
out = ohet._transform(data)
# Assert
expected = np.array([
[1],
[1],
[1]
])
np.testing.assert_array_equal(out, expected)
def test__transform_zeros(self):
"""Test the ``_transform`` with unknown category.
The values passed to ``_transform`` should be
returned in a one-hot encoding representation
where it should be a column of zeros.
Input:
- Series with unknown values
Output:
- one-hot encoding of the input
"""
# Setup
ohet = OneHotEncodingTransformer()
pd.Series(['a'])
ohet.dummies = ['a']
ohet.num_dummies = 1
# Run
out = ohet._transform(pd.Series(['b', 'b', 'b']))
# Assert
expected = np.array([
[0],
[0],
[0]
])
np.testing.assert_array_equal(out, expected)
def test__transform_zeros_categorical(self):
"""Test the ``_transform`` with unknown category.
The values passed to ``_transform`` should be
returned in a one-hot encoding representation
using the categorical branch where it should
be a column of zeros.
Input:
- Series with categorical and unknown values
Output:
- one-hot encoding of the input
"""
# Setup
ohet = OneHotEncodingTransformer()
pd.Series(['a'])
ohet.dummies = ['a']
ohet.indexer = [0]
ohet.num_dummies = 1
ohet.dummy_encoded = True
# Run
out = ohet._transform(pd.Series(['b', 'b', 'b']))
# Assert
expected = np.array([
[0],
[0],
[0]
])
np.testing.assert_array_equal(out, expected)
def test__transform_unknown_nan(self):
"""Test the ``_transform`` with unknown and nans.
This is an edge case for ``_transform`` where
unknowns should be zeros and nans should be
the last entry in the column.
Input:
- Series with unknown and nans
Output:
- one-hot encoding of the input
"""
# Setup
ohet = OneHotEncodingTransformer()
pd.Series(['a'])
ohet.dummies = ['a']
ohet.dummy_na = True
ohet.num_dummies = 1
# Run
out = ohet._transform(pd.Series(['b', 'b', np.nan]))
# Assert
expected = np.array([
[0, 0],
[0, 0],
[0, 1]
])
np.testing.assert_array_equal(out, expected)
def test_transform_no_nans(self):
"""Test the ``transform`` without nans.
In this test ``transform`` should return an identity
matrix representing each item in the input.
Input:
- Series with categorical values
Output:
- one-hot encoding of the input
"""
# Setup
ohet = OneHotEncodingTransformer()
data = pd.Series(['a', 'b', 'c'])
ohet.fit(data)
# Run
out = ohet.transform(data)
# Assert
expected = np.array([
[1, 0, 0],
[0, 1, 0],
[0, 0, 1]
])
np.testing.assert_array_equal(out, expected)
def test_transform_nans(self):
"""Test the ``transform`` with nans.
In this test ``transform`` should return an identity matrix
representing each item in the input as well as nans.
Input:
- Series with categorical values and nans
Output:
- one-hot encoding of the input
"""
# Setup
ohet = OneHotEncodingTransformer()
data = pd.Series(['a', 'b', None])
ohet.fit(data)
# Run
out = ohet.transform(data)
# Assert
expected = np.array([
[1, 0, 0],
[0, 1, 0],
[0, 0, 1]
])
np.testing.assert_array_equal(out, expected)
def test_transform_single(self):
"""Test the ``transform`` on a single category.
In this test ``transform`` should return a column
filled with ones.
Input:
- Series with a single categorical value
Output:
- one-hot encoding of the input
"""
# Setup
ohet = OneHotEncodingTransformer()
data = pd.Series(['a', 'a', 'a'])
ohet.fit(data)
# Run
out = ohet.transform(data)
# Assert
expected = np.array([
[1],
[1],
[1]
])
np.testing.assert_array_equal(out, expected)
def test_transform_unknown(self):
"""Test the ``transform`` with unknown data.
In this test ``transform`` should raise an error
due to the attempt of transforming data with previously
unseen categories.
Input:
- Series with unknown categorical values
"""
# Setup
ohet = OneHotEncodingTransformer()
data = pd.Series(['a'])
ohet.fit(data)
# Assert
with np.testing.assert_raises(ValueError):
ohet.transform(['b'])
def test_transform_numeric(self):
"""Test the ``transform`` on numeric input.
In this test ``transform`` should return a matrix
representing each item in the input as one-hot encodings.
Input:
- Series with numeric input
Output:
- one-hot encoding of the input
"""
# Setup
ohet = OneHotEncodingTransformer()
data = pd.Series([1, 2])
ohet.fit(data)
expected = np.array([
[1, 0],
[0, 1],
])
# Run
out = ohet.transform(data)
# Assert
assert not ohet.dummy_encoded
np.testing.assert_array_equal(out, expected)
def test_reverse_transform_no_nans(self):
# Setup
ohet = OneHotEncodingTransformer()
data = pd.Series(['a', 'b', 'c'])
ohet.fit(data)
# Run
transformed = np.array([
[1, 0, 0],
[0, 1, 0],
[0, 0, 1]
])
out = ohet.reverse_transform(transformed)
# Assert
expected = pd.Series(['a', 'b', 'c'])
pd.testing.assert_series_equal(out, expected)
def test_reverse_transform_nans(self):
# Setup
ohet = OneHotEncodingTransformer()
data = pd.Series(['a', 'b', None])
ohet.fit(data)
# Run
transformed = np.array([
[1, 0, 0],
[0, 1, 0],
[0, 0, 1]
])
out = ohet.reverse_transform(transformed)
# Assert
expected = pd.Series(['a', 'b', None])
pd.testing.assert_series_equal(out, expected)
def test_reverse_transform_single(self):
# Setup
ohet = OneHotEncodingTransformer()
data = pd.Series(['a', 'a', 'a'])
ohet.fit(data)
# Run
transformed = np.array([
[1],
[1],
[1]
])
out = ohet.reverse_transform(transformed)
# Assert
expected = pd.Series(['a', 'a', 'a'])
pd.testing.assert_series_equal(out, expected)
def test_reverse_transform_1d(self):
# Setup
ohet = OneHotEncodingTransformer()
data = pd.Series(['a', 'a', 'a'])
ohet.fit(data)
# Run
transformed = np.array([1, 1, 1])
out = ohet.reverse_transform(transformed)
# Assert
expected = pd.Series(['a', 'a', 'a'])
pd.testing.assert_series_equal(out, expected)
class TestLabelEncodingTransformer:
def test_reverse_transform_clips_values(self):
"""Test the ``reverse_transform`` method with values not in map.
If a value that is not in ``values_to_categories`` is passed
to ``reverse_transform``, then the value should be clipped to
the range of the dict's keys.
Input:
- array with values outside of dict
Output:
- categories corresponding to closest key in the dict
"""
# Setup
transformer = LabelEncodingTransformer()
transformer.values_to_categories = {0: 'a', 1: 'b', 2: 'c'}
data = | pd.Series([0, 1, 10]) | pandas.Series |
'''
Buffered data loading
'''
import logging
import os
import pickle
from functools import lru_cache
from itertools import chain
import pandas as pd
# import torch
from gtfparse import read_gtf_as_dataframe
from intervaltree import IntervalTree
from sklearn.externals import joblib
import azimuth
from pavooc.config import (APPRIS_FILE, BASEDIR, CHROMOSOME_RAW_FILE,
CHROMOSOMES, CNS_FILE, DATADIR, GENCODE_HG19_FILE,
GENCODE_HG38_FILE, GENCODE_MM10_FILE, GENOME,
MUTATIONS_FILE, PDB_LIST_FILE,
PROTEIN_ID_MAPPING_FILE, SCALER_FILE)
# from pavooc.scoring.models import CNN38
from pavooc.util import buffer_return_value
logging.basicConfig(level=logging.INFO)
# TODO 'ENSG00000101464.6' for example has a CDS-feature with a protein_id
# but its exon-feature has no protein_id assigned. Is it good to filter it
# out though?
def _filter_best_transcript(gene):
appris_values = set(chain.from_iterable(gene.tag.apply(
lambda v: [x for x in v.split(',') if 'appris' in x]).values))
for appris_type in ['appris_principal',
'appris_candidate_longest',
'appris_candidate']:
if appris_type in appris_values:
transcript_id = gene[gene.tag.str.contains(
appris_type)].iloc[0].transcript_id
break
else:
transcript_id = gene[gene.feature == 'transcript'].transcript_id
# if len(transcript_id) > 1:
# print(gene.gene_id.iloc[0])
transcript_id = transcript_id.iloc[0]
return gene[(gene.feature == 'gene') |
(gene.transcript_id == transcript_id)]
@buffer_return_value
def pfam_mapping():
df = pd.read_csv(os.path.join(DATADIR, 'pdb_pfam_mapping.txt'), sep='\t')
df = df[['PFAM_ACC', 'PFAM_Name']].drop_duplicates()
df.index = df['PFAM_ACC'].apply(lambda row: row[:7])
return df
@buffer_return_value
def pfam_pdb_mapping():
df = pd.read_csv(os.path.join(DATADIR, 'pdb_pfam_mapping.txt'), sep='\t')
return df
@lru_cache()
def read_gencode(genome=GENOME):
'''
Buffered gencode read with HAVANA/ENSEMBL merged
Swissprot IDs are merged and start-end indexing is adjusted
Returns relevant columns only
Returns the gencode dataframe but with havana and ensembl merged
'''
if genome == 'hg19':
df = read_gtf_as_dataframe(GENCODE_HG19_FILE)
elif genome == 'hg38':
df = read_gtf_as_dataframe(GENCODE_HG38_FILE)
elif genome == 'mm10':
df = read_gtf_as_dataframe(GENCODE_MM10_FILE)
df.exon_number = df.exon_number.apply(pd.to_numeric, errors='coerce')
df.protein_id = df.protein_id.map(lambda v: v[:v.find('.')])
df.exon_id = df.exon_id.map(lambda v: v[:v.find('.')])
df.gene_id = df.gene_id.map(lambda v: v[:v.find('.')])
df.transcript_id = df.transcript_id.map(lambda v: v[:v.find('.')])
# only take protein_coding genes/transcripts/exons
df = df[
(df['gene_type'] == 'protein_coding') &
(df['feature'].isin(['gene', 'transcript', 'exon', 'UTR'])) &
(df['seqname'].isin(CHROMOSOMES))]
# drop all transcripts and exons that have no protein_id
df.drop(df.index[(df.protein_id == '') & (
df.feature.isin(['exon', 'transcript', 'UTR']))], inplace=True)
# only take exons and transcripts which contain a basic-tag
non_basic_transcripts = (df['feature'].isin(['transcript', 'exon', 'UTR'])) & \
~(df['tag'].str.contains('basic'))
df.drop(df.index[non_basic_transcripts], inplace=True)
# add swissprot id mappings
protein_id_mapping = load_protein_mapping()
protein_id_mapping = protein_id_mapping[
protein_id_mapping.ID_NAME == 'Ensembl_PRO'][
['swissprot_id', 'protein_id']]
df = df.merge(protein_id_mapping, how='left', on='protein_id')
# delete ENSEMBL entries which come from both, HAVANA and ENSEMBL
mixed_ids = df[['gene_id', 'source']].drop_duplicates()
counts = mixed_ids.gene_id.value_counts()
duplicate_ids = counts.index[counts == 2]
df.drop(df.index[
df.gene_id.isin(duplicate_ids) &
(df.source == 'ENSEMBL')], inplace=True)
# fix indexing
df.start -= 1
# drop alternative_3or5_UTR transcripts
# df = df.drop(df.index[df.tag.str.contains('alternative_')])
# drop all genes which have no transcripts
valid_genes = df[df['feature'] == 'transcript'].gene_id.drop_duplicates()
# double check, there are no orphan-exons or so
assert set(valid_genes) == \
set(df[df['feature'] == 'exon'].gene_id.drop_duplicates())
df.drop(df.index[~df.gene_id.isin(valid_genes)], inplace=True)
# select best transcript
df = df.groupby('gene_id').apply(_filter_best_transcript)
df.reset_index(level=0, drop=True, inplace=True)
return df[[
'feature', 'gene_id', 'transcript_id',
'start', 'end', 'exon_id', 'exon_number',
'gene_name', 'transcript_type', 'strand',
'gene_type', 'tag', 'protein_id', 'swissprot_id',
'score', 'seqname', 'source']]
@buffer_return_value
def celllines():
with open(os.path.join(BASEDIR, 'pavooc/server/celllines.txt')) as f:
return [line.strip() for line in f.readlines()]
def load_protein_mapping():
# TODO "P63104-1 Ensembl_PRO ENSP00000309503"
# is not recognized for example (due to the '-1')
return pd.read_csv(
PROTEIN_ID_MAPPING_FILE,
sep='\t',
header=None,
names=['swissprot_id', 'ID_NAME', 'protein_id'],
dtype={'swissprot_id': str, 'ID_NAME': str, 'protein_id': str},
index_col=False)
def compute_canonical_exons(gene):
exons = gene[gene.feature == 'exon']
utrs = []
for index, row in gene[gene.feature == 'UTR'].iterrows():
utrs.extend(list(range(row.start, row.end)))
utrs = set(utrs)
sorted_exons = exons.sort_values('exon_number')
result_exons = []
for index, exon in sorted_exons.iterrows():
exon_positions = set(range(exon.start, exon.end))
filtered = (exon_positions - utrs)
try:
end = max(filtered) + 1
start = min(filtered)
except ValueError:
continue
else:
new_exon = exon.copy()
new_exon.start = start
new_exon.end = end
result_exons.append(new_exon)
df = pd.DataFrame(result_exons)
# df.index.name = 'exon_id'
try:
return df.reset_index()[[
'seqname', 'start', 'end', 'strand', 'transcript_id',
'swissprot_id', 'gene_id', 'gene_name', 'exon_id', 'exon_number']]
except KeyError:
logging.error(
f'fixme at data.py canonical_exons: {gene.iloc[0].gene_id}')
return
@buffer_return_value
def gencode_exons(genome=GENOME):
'''
Return the protein-coding exons from gencode, indexed by exon_id
Deletes UTR (untranslated region)
:returns: DataFrame with unique exons
'''
gencode = read_gencode(genome)
prepared = gencode.groupby('gene_id').apply(compute_canonical_exons)
return prepared.set_index('exon_id')
# OLD: (we now use simply appris principal)
# # Use longest transcript only
# prepared['length'] = prepared['end'] - prepared['start']
# transcripts_lengths = prepared.groupby(
# ['gene_id', 'transcript_id']).sum().length
# longest_transcripts = transcripts_lengths[
# transcripts_lengths ==
# transcripts_lengths.groupby(level=0).transform('max')]
#
# prepared = prepared[prepared.transcript_id.isin(
# longest_transcripts.index.get_level_values(1))]
@buffer_return_value
def cns_trees():
trees = {chromosome: IntervalTree() for chromosome in CHROMOSOMES}
df = pd.read_csv(CNS_FILE, sep='\t')
df.Chromosome = df.Chromosome.map(lambda c: f'chr{c}')
for _, cns in df.iterrows():
try:
trees[cns.Chromosome][cns.Start - 1:
cns.End] = \
{'type': 2 * (2 ** cns.Segment_Mean),
'cellline': cns.CCLE_name}
except KeyError:
pass
return trees
@buffer_return_value
def cellline_mutation_trees():
trees = {chromosome: IntervalTree() for chromosome in CHROMOSOMES}
df = pd.read_csv(MUTATIONS_FILE, sep='\t')
df.Chromosome = df.Chromosome.map(lambda c: f'chr{c}')
for _, mutation in df.iterrows():
try:
trees[mutation.Chromosome][mutation.Start_position - 1:
mutation.End_position] = \
{'type': mutation.Variant_Type,
'cellline': mutation.Tumor_Sample_Barcode}
except KeyError:
pass
return trees
@buffer_return_value
def exon_interval_trees():
'''
Generate an exon interval tree
'''
logging.info('Building exon tree')
trees = {chromosome: IntervalTree() for chromosome in CHROMOSOMES}
relevant_exons = gencode_exons()
for _, row in relevant_exons.iterrows():
if row['end'] > row['start']:
# end is included, start count at 0 instead of 1
trees[row['seqname']][row['start'] - 1:row['end']
] = (row['gene_id'], row['exon_number'])
logging.info('Built exon tree with {} nodes'
.format(sum([len(tree) for tree in trees.values()])))
return trees
@buffer_return_value
def pdb_list():
df = | pd.read_csv(PDB_LIST_FILE, sep=',', skiprows=1, index_col=False) | pandas.read_csv |
import builtins
from io import StringIO
import numpy as np
import pytest
from pandas.errors import UnsupportedFunctionCall
import pandas as pd
from pandas import DataFrame, Index, MultiIndex, Series, Timestamp, date_range, isna
import pandas._testing as tm
import pandas.core.nanops as nanops
from pandas.util import _test_decorators as td
@pytest.fixture(
params=[np.int32, np.int64, np.float32, np.float64],
ids=["np.int32", "np.int64", "np.float32", "np.float64"],
)
def numpy_dtypes_for_minmax(request):
"""
Fixture of numpy dtypes with min and max values used for testing
cummin and cummax
"""
dtype = request.param
min_val = (
np.iinfo(dtype).min if np.dtype(dtype).kind == "i" else np.finfo(dtype).min
)
max_val = (
np.iinfo(dtype).max if np.dtype(dtype).kind == "i" else np.finfo(dtype).max
)
return (dtype, min_val, max_val)
@pytest.mark.parametrize("agg_func", ["any", "all"])
@pytest.mark.parametrize("skipna", [True, False])
@pytest.mark.parametrize(
"vals",
[
["foo", "bar", "baz"],
["foo", "", ""],
["", "", ""],
[1, 2, 3],
[1, 0, 0],
[0, 0, 0],
[1.0, 2.0, 3.0],
[1.0, 0.0, 0.0],
[0.0, 0.0, 0.0],
[True, True, True],
[True, False, False],
[False, False, False],
[np.nan, np.nan, np.nan],
],
)
def test_groupby_bool_aggs(agg_func, skipna, vals):
df = DataFrame({"key": ["a"] * 3 + ["b"] * 3, "val": vals * 2})
# Figure out expectation using Python builtin
exp = getattr(builtins, agg_func)(vals)
# edge case for missing data with skipna and 'any'
if skipna and all(isna(vals)) and agg_func == "any":
exp = False
exp_df = DataFrame([exp] * 2, columns=["val"], index=Index(["a", "b"], name="key"))
result = getattr(df.groupby("key"), agg_func)(skipna=skipna)
tm.assert_frame_equal(result, exp_df)
def test_max_min_non_numeric():
# #2700
aa = DataFrame({"nn": [11, 11, 22, 22], "ii": [1, 2, 3, 4], "ss": 4 * ["mama"]})
result = aa.groupby("nn").max()
assert "ss" in result
result = aa.groupby("nn").max(numeric_only=False)
assert "ss" in result
result = aa.groupby("nn").min()
assert "ss" in result
result = aa.groupby("nn").min(numeric_only=False)
assert "ss" in result
def test_min_date_with_nans():
# GH26321
dates = pd.to_datetime(
pd.Series(["2019-05-09", "2019-05-09", "2019-05-09"]), format="%Y-%m-%d"
).dt.date
df = pd.DataFrame({"a": [np.nan, "1", np.nan], "b": [0, 1, 1], "c": dates})
result = df.groupby("b", as_index=False)["c"].min()["c"]
expected = pd.to_datetime(
pd.Series(["2019-05-09", "2019-05-09"], name="c"), format="%Y-%m-%d"
).dt.date
| tm.assert_series_equal(result, expected) | pandas._testing.assert_series_equal |
""" ecospold2matrix - Class for recasting ecospold2 dataset in matrix form.
The module provides function to parse ecospold2 data, notably ecoinvent 3, as
Leontief A-matrix and extensions, or alternatively as supply and use tables for
the unallocated version of ecoinvent.
:PythonVersion: 3
:Dependencies: pandas 0.14.1 or more recent, scipy, numpy, lxml and xml
License: BDS
Authors:
<NAME>
<NAME>
<NAME>
<NAME>
Credits:
This module re-uses/adapts code from brightway2data, more specifically the
Ecospold2DataExtractor class in import_ecospold2.py, changeset:
271:7e67a75ed791; Wed Sep 10; published under BDS-license:
Copyright (c) 2014, <NAME> and ETH Zürich
Neither the name of ETH Zürich nor the names of its contributors may be
used to endorse or promote products derived from this software without
specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE
COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
"""
import pdb
import os
import glob
import io
import pkgutil
import subprocess
from lxml import objectify
import xml.etree.ElementTree as ET
from lxml import etree
import pandas as pd
_df = pd.DataFrame
import numpy as np
import scipy.sparse
import scipy.io
import logging
import pickle
import gzip
import csv
import shelve
import hashlib
import sqlite3
try:
import IPython
except:
pass
import re
import xlrd
import xlwt
import copy
# pylint: disable-msg=C0103
class Ecospold2Matrix(object):
"""
Defines a parser object that holds all project parameters and processes the
ecospold-formatted data into matrices of choice.
The two main functions of this class are ecospold_to_Leontief() and
ecospold_to_sut()
"""
# Some hardcoded stuff
__PRE = '{http://www.EcoInvent.org/EcoSpold02}'
__ELEXCHANGE = 'ElementaryExchanges.xml'
__INTERMEXCHANGE = 'IntermediateExchanges.xml'
__ACTIVITYINDEX = 'ActivityIndex.xml'
__DB_CHARACTERISATION = 'characterisation.db'
rtolmin = 1e-16 # 16 significant digits being roughly the limit of float64
__TechnologyLevels = pd.Series(
['Undefined', 'New', 'Modern', 'Current', 'Old', 'Outdated'],
index=[0, 1, 2, 3, 4, 5])
def __init__(self, sys_dir, project_name, out_dir='.', lci_dir=None,
positive_waste=False, prefer_pickles=False, nan2null=False,
save_interm=True, PRO_order=['ISIC', 'activityName'],
STR_order=['comp', 'name', 'subcomp'],
verbose=True, version_name='ecoinvent31',
unlinked = True, remove_markets=True):
""" Defining an ecospold2matrix object, with key parameters that
determine how the data will be processes.
Args:
-----
* sys_dir: directory containing the system description,i.e., ecospold
dataset and master XML files
* project_name: Name used to log progress and save results
* out_dir: Directory where to save result matrices and logs
* lci_dir: Directory where official cummulative LCI ecospold files are
* positive_waste: Whether or not to change sign convention and make
waste flows positive
[default false]
* prefer_pickles: If sys_dir contains pre-processed data in form of
pickle-files, whether or not to use those
[Default: False, don't use]
* nan2null: Whether or not to replace Not-a-Number by 0.0
[Default: False, don't replace anything]
* save_interm: Whether or not to save intermediate results as pickle
files for potential re-use
[Default: True, do it]
* PRO_order: List of meta-data used for sorting processes in the
different matrices.
[Default: first sort by order of ISIC code, then, within
each code, by order of activity name]
* PRO_order: List of meta-data used for sorting stressors (elementary
flows) in the different matrices.
[Default: first sort by order of compartment,
subcompartment and then by name]
* unlinked: Whether or not the datasets are linked/allocated.
[Default: True, the data are unlinked]
Main functions and worflow:
---------------------------
self.ecospold_to_Leontief(): Turn ecospold files into Leontief matrix
representation
* Parse ecospold files, get products, activities, flows, emissions
* If need be, correct inconsistencies in system description
* After corrections, create "final" labels for matrices
* Generate symmetric, normalized system description (A-matrix,
extension F-matrix)
* Save to file (many different formats)
* Optionally, read cummulative lifecycle inventories (slow) and
compare to calculated LCI for sanity testing
self.ecospold_to_sut(): Turn unallocated ecospold into Suppy and Use
Tables
* Parse ecospold files, get products, activities, flows, emissions
* Organize in supply and use
* optionally, aggregate sources to generate a fully untraceable SUT
* Save to file
"""
# INTERMEDIATE DATA/RESULTS, TO BE GENERATED BY OBJECT METHODS
self.products = None # products, with IDs and descriptions
self.activities = None # activities, w IDs and description
self.inflows = None # intermediate-exchange input flows
self.outflows = None # intermediate-exchange output flows
self.prices = None
self.elementary_flows = None # elementary flows
self.q = None # total supply of each product
self.PRO_old=None
self.STR_old = None
self.IMP_old=None
# FINAL VARIABLES: SYMMETRIC SYSTEM, NORMALIZED AND UNNORMALIZED
self.PRO = None # Process labels, rows/cols of A-matrix
self.STR = None # Factors labels, rows extensions
self.IMP = pd.DataFrame([]) # impact categories
self.A = None # Normalized Leontief coefficient matrix
self.F = None # Normalized factors of production,i.e.,
# elementary exchange coefficients
self.Z = None # Intermediate unnormalized process flows
self.G_pro = None # Unnormalized Process factor requirements
self.C = pd.DataFrame([]) # characterisation matrix
# Final variables, unallocated and unnormalized inventory
self.U = None # Table of use of products by activities
self.V = None # Table of supply of product by activities
# (ammounts for which use is recorded)
self.G_act = None # Table of factor use by activities
self.V_prodVol = None # Table of supply production volumes
# (potentially to rescale U, V and G)
# QUALITY CHECKS VARIABLES, TO BE GENERATED BY OBJECT METHODS.
self.E = None # cummulative LCI matrix (str x pro)
self.unsourced_flows = None # product flows without clear source
self.missing_activities = None # cases of no incomplete dataset, i.e.,
# no producer for a product
# PROJECT NAME AND DIRECTORIES, FROM ARGUMENTS
self.sys_dir = os.path.abspath(sys_dir)
self.project_name = project_name
self.out_dir = os.path.abspath(out_dir)
if lci_dir:
self.lci_dir = os.path.abspath(lci_dir)
else:
self.lci_dir = lci_dir
self.version_name = version_name
self.char_method = None # characterisation method set by
# read_characterisation function
self.data_version = None
# PROJECT-WIDE OPTIONS
self.positive_waste = positive_waste
self.prefer_pickles = prefer_pickles
self.nan2null = nan2null
self.save_interm = save_interm
self.PRO_order = PRO_order
self.STR_order = STR_order
# DATASETS UNLINKED/UNALLOCATED
self.unlinked = unlinked # Is the data (spold files) linked and allocated or not. Default = True data is NOT linked
self.remove_markets = remove_markets # If the data is unlinked, remove the markets see function self.remove_Markets
# CREATE DIRECTORIES IF NOT IN EXISTENCE
if out_dir and not os.path.exists(self.out_dir):
os.makedirs(self.out_dir)
self.log_dir = os.path.join(self.out_dir, self.project_name + '_log')
# Fresh new log
os.system('rm -Rf ' + self.log_dir)
os.makedirs(self.log_dir)
# DEFINE LOG TOOL
self.log = logging.getLogger(self.project_name)
self.log.setLevel(logging.INFO)
self.log.handlers = [] # reset handlers
if verbose:
ch = logging.StreamHandler()
ch.setLevel(logging.INFO)
fh = logging.FileHandler(os.path.join(self.log_dir,
project_name + '.log'))
fh.setLevel(logging.INFO)
aformat = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
formatter = logging.Formatter(aformat)
fh.setFormatter(formatter)
self.log.addHandler(fh)
if verbose:
ch.setFormatter(formatter)
self.log.addHandler(ch)
# RECORD OBJECT/PROJECT IDENTITY TO LOG
self.log.info('Ecospold2Matrix Processing')
try:
gitcommand = ["git", "log", "--pretty=format:%H", "-n1"]
githash = subprocess.check_output(gitcommand).decode("utf-8")
self.log.info("Current git commit: {}".format(githash))
except:
pass
self.log.info('Project name: ' + self.project_name)
# RECORD PROJECT PARAMETERS TO LOG
self.log.info('Unit process and Master data directory: ' + sys_dir)
self.log.info('Data saved in: ' + self.out_dir)
if self.lci_dir:
self.log.info('Official rolled-up life cycle inventories in: ' +
self.lci_dir)
if self.positive_waste:
self.log.info('Sign conventions changed to make waste flows '
'positive')
if self.prefer_pickles:
self.log.info('When possible, loads pickled data instead of'
' parsing ecospold files')
if self.nan2null:
self.log.info('Replace Not-a-Number instances with 0.0 in all'
' matrices')
if self.save_interm:
self.log.info('Pickle intermediate results to files')
self.log.info('Order processes based on: ' +
', '.join([i for i in self.PRO_order]))
self.log.info('Order elementary exchanges based on: ' +
', '.join([i for i in self.STR_order]))
database_name = self.project_name + '_' + self.__DB_CHARACTERISATION
os.system('rm ' + database_name)
try:
self.conn = sqlite3.connect(
self.project_name + '_' + self.__DB_CHARACTERISATION)
self.initialize_database()
except:
self.log.warning("Could not establish connection to database")
pass
self.conn.commit()
# =========================================================================
# MAIN FUNCTIONS
def ecospold_to_Leontief(self, fileformats=None, with_absolute_flows=False,
lci_check=False, rtol=5e-2, atol=1e-5, imax=3,
characterisation_file=None,
ardaidmatching_file=None):
""" Recasts an full ecospold dataset into normalized symmetric matrices
Args:
-----
* fileformats : List of file formats in which to save data
[Default: None, save to all possible file formats]
Options: 'Pandas' --> pandas dataframes
'csv' --> text with separator = '|'
'SparsePandas' --> sparse pandas dataframes
'SparseMatrix' --> scipy AND matlab sparse
'SparseMatrixForArda' --> with special
background
variable names
* with_absolut_flow: If true, produce not only coefficient matrices (A
and F) but also scale them up to production
volumes to get absolute flows in separate
matrices. [default: false]
* lci_check : If true, and if lci_dir is not None, parse cummulative
lifecycle inventory data as self.E matrix (str x pro),
and use it for sanity check against calculated
cummulative LCI
* rtol : Initial (max) relative tolerance for comparing E with
calculated E
* atol : Initial (max) absolute tolerance for comparing E with
calculated E
* characterisation_file: name of file containing characterisation
factors
* ardaidmatching_file: name of file matching Arda Ids, Ecoinvent2 DSIDs
and ecoinvent3 UUIDs. Only useful for the Arda
project.
Generates:
----------
* Intermediate data: products, activities, flows, labels
* A matrix: Normalized, intermediate exchange Leontief coefficients
(pro x pro)
* F matrix: Normalized extensions, factor requirements (elementary
exchanges) for each process (str x pro)
* E matrix: [optionally] cummulative normalized lci data (str x pro)
(for quality check)
Returns:
-------
* None, save all matrices in the object, and to file
"""
# Read in system description
self.extract_products()
self.extract_activities()
self.get_flows()
self.get_labels()
# Clean up if necessary
self.__find_unsourced_flows()
if self.unsourced_flows is not None:
self.__fix_flow_sources()
self.__fix_missing_activities()
# Once all is well, add extra info to PRO and STR, and order nicely
self.complement_labels()
# Finally, assemble normalized, symmetric matrices
self.build_AF()
if with_absolute_flows:
self.scale_up_AF()
if characterisation_file is not None:
print("starting characterisation")
if 'LCIA_implementation' in characterisation_file:
self.log.info("Characterisation file seems to be ecoinvent"
" LCIA implementation. Will apply simple name"
" matching")
self.simple_characterisation_matching(characterisation_file)
else:
self.prepare_matching_load_parameters()
self.process_inventory_elementary_flows()
self.read_characterisation(characterisation_file)
self.populate_complementary_tables()
self.characterize_flows()
self.generate_characterized_extensions()
if ardaidmatching_file:
self.make_compatible_with_arda(ardaidmatching_file)
# Save system to file
self.save_system(fileformats)
# Read/load lci cummulative emissions and perform quality check
if lci_check:
self.get_cummulative_lci()
self.cummulative_lci_check(rtol, atol, imax)
self.log.info('Done running ecospold2matrix.ecospold_to_Leontief')
def ecospold_to_sut(self, fileformats=None, make_untraceable=False):
""" Recasts an unallocated ecospold dataset into supply and use tables
Args:
-----
* fileformats : List of file formats in which to save data
[Default: None, save to all possible file formats]
Options: 'Pandas' --> pandas dataframes
'SparsePandas' --> sparse pandas dataframes,
'SparseMatrix' --> scipy AND matlab sparse
'csv' --> text files
* make_untraceable: Whether or not to aggregate away the source
activity dimension, yielding a use table in which
products are no longer linked to their providers
[default: False; don't do it]
Generates:
----------
* Intermediate data: Products, activities, flows, labels
* V table Matrix of supply of product by activities
* U table Matrix of use of products by activities
(recorded for a given supply amount, from V)
* G_act Matrix of factor use by activities
(recorded for a given supply amount, from V)
* V_prodVol Matrix of estimated real production volumes,
arranged as suply table (potentially useful
to rescale U, V and G)
Returns:
-------
* None, save all matrices in the object, and to file
"""
# Extract data on producs and activities
self.extract_products()
self.extract_activities()
# Extract or load data on flows and labels
self.get_flows()
self.get_labels()
self.complement_labels()
# Arrange as supply and use
if self.remove_markets is True:
self.remove_Markets()
self.build_sut(make_untraceable)
# Save to file
self.save_system(fileformats)
self.log.info("Done running ecospold2matrix.ecospold_to_sut")
# =========================================================================
# INTERMEDIATE WRAPPER METHODS: parse or load data + pickle results or not
def get_flows(self):
""" Wrapper: load from pickle or call extract_flows() to read ecospold
files.
Behavious determined by:
------------------------
prefer_pickles: Whether or not to load flow lists from previous run
instead of (re)reading XML Ecospold files
save_interm: Whether or not to pickle flows to file for use in
another project run.
Generates:
----------
self.inflows
self.outflows
self.elementary_flows
self.prices
Returns:
--------
None, only defines within object
"""
filename = os.path.join(self.sys_dir, 'flows.pickle')
# EITHER LOAD FROM PREVIOUS ROUND...
if self.prefer_pickles and os.path.exists(filename):
# Read all flows
with open(filename, 'rb') as f:
[self.inflows,
self.elementary_flows,
self.outflows,
self.prices] = pickle.load(f)
# Log event
sha1 = self.__hash_file(f)
msg = "{} loaded from {} with SHA-1 of {}"
self.log.info(msg.format('Flows', filename, sha1))
# ...OR EXTRACT FROM ECOSPOLD DATA..
else:
self.extract_flows()
# optionally, pickle for further use
if self.save_interm:
with open(filename, 'wb') as f:
pickle.dump([self.inflows,
self.elementary_flows,
self.outflows,
self.prices], f)
# Log event
sha1 = self.__hash_file(filename)
msg = "{} saved in {} with SHA-1 of {}"
self.log.info(msg.format('Flows', filename, sha1))
def get_labels(self):
"""
Wrapper: load from pickle, or call methods to build labels from scratch
Behaviour determined by:
------------------------
* prefer_pickles: Whether or not to load flow lists from previous run
instead of (re)reading XML Ecospold files
* save_interm: Whether or not to pickle flows to file for use in
another project run.
Generates:
----------
* PRO: metadata on each process, i.e. production of each product
by each activity.
* STR: metadata on each stressor (or elementary exchange, factor of
production)
Returns:
--------
* None, only defines within object
NOTE:
-----
* At this stage, labels are at the strict minimum (ID, name) to
facilitate the addition of new processes or stressors, if need be, to
"patch" inconsistencies in the dataset. Once all is sorted out, more
data from product, activities, and elementary_flow descriptions are
added to the labels in self.complement_labels()
"""
filename = os.path.join(self.sys_dir, 'rawlabels.pickle')
# EITHER LOAD FROM PREVIOUS ROUND...
if self.prefer_pickles and os.path.exists(filename):
# Load from pickled file
with open(filename, 'rb') as f:
self.PRO, self.STR = pickle.load(f)
# Log event
sha1 = self.__hash_file(f)
msg = "{} loaded from {} with SHA-1 of {}"
self.log.info(msg.format('Labels', filename, sha1))
# OR EXTRACT FROM ECOSPOLD DATA...
else:
self.build_PRO()
self.build_STR()
# and optionally pickle for further use
if self.save_interm:
with open(filename, 'wb') as f:
pickle.dump([self.PRO, self.STR], f)
# Log event
sha1 = self.__hash_file(filename)
msg = "{} saved in {} with SHA-1 of {}"
self.log.info(msg.format('Labels', filename, sha1))
def get_cummulative_lci(self):
""" Wrapper: load from pickle or call build_E() to read ecospold files.
Behaviour determined by:
------------------------
* prefer_pickles: Whether or not to load flow lists from previous run
instead of (re)reading XML Ecospold files
* save_interm: Whether or not to pickle flows to file for use in
another project run.
* lci_dir: Directory where cummulative LCI ecospold are
Generates:
----------
* E: cummulative LCI emissions matrix
Returns:
--------
* None, only defines within object
"""
filename = os.path.join(self.lci_dir, 'lci.pickle')
# EITHER LOAD FROM PREVIOUS ROUND...
if self.prefer_pickles and os.path.exists(filename):
with open(filename, 'rb') as f:
self.E = pickle.load(f)
# log event
sha1 = self.__hash_file(f)
msg = "{} loaded from {} with SHA-1 of {}"
self.log.info(msg.format('Cummulative LCI', filename, sha1))
# OR BUILD FROM ECOSPOLD DATA...
else:
self.build_E()
# optionally, pickle for further use
if self.save_interm:
with open(filename, 'wb') as f:
pickle.dump(self.E, f)
# log event
sha1 = self.__hash_file(filename)
msg = "{} saved in {} with SHA-1 of {}"
self.log.info(msg.format('Cummulative LCI', filename, sha1))
# =========================================================================
# PARSING METHODS: the hard work with xml files
def extract_products(self):
""" Parses INTERMEDIATEEXCHANGE file to extract core data on products:
Id's, name, unitID, unitName.
Args: None
----
Returns: None
-------
Generates: self.products
----------
Credit:
------
This function incorporates/adapts code from Brightway2data, i.e., the
method extract_technosphere_metadata from class Ecospold2DataExtractor
"""
# The file to parse
fp = os.path.join(self.sys_dir, 'MasterData', self.__INTERMEXCHANGE)
assert os.path.exists(fp), "Can't find " + self.__INTERMEXCHANGE
def extract_metadata(o):
""" Subfunction to get the data from lxml root object """
# Get list of id, name, unitId, and unitName for all intermediate
# exchanges
# Added: CPC code (AJ)
try:
cpc = [o.classification[i].classificationValue for i in
range(len(o.classification)) if
o.classification[i].classificationSystem == 'CPC'][0]
except IndexError:
cpc = ''
return {'productName': o.name.text,
'unitName': o.unitName.text,
'productId': o.get('id'),
'unitId': o.get('unitId'),
'CPCCode': str(cpc)}
# Parse XML file
with open(fp, 'r', encoding="utf-8") as fh:
root = objectify.parse(fh).getroot()
pro_list = [extract_metadata(ds) for ds in root.iterchildren()]
# Convert this list into a dataFrame
self.products = pd.DataFrame(pro_list)
self.products.index = self.products['productId']
# Log event
sha1 = self.__hash_file(fp)
msg = "Products extracted from {} with SHA-1 of {}"
self.log.info(msg.format(self.__INTERMEXCHANGE, sha1))
def extract_activities(self):
""" Parses ACTIVITYINDEX file to extract core data on activities:
Id's, activity type, startDate, endDate
Args: None
----
Returns: None
--------
Generates: self.activities
---------
"""
# Parse XML file describing activities
activity_file = os.path.join(self.sys_dir,
'MasterData',
self.__ACTIVITYINDEX)
root = ET.parse(activity_file).getroot()
# Get list of activities and their core attributes
act_list = []
for act in root:
act_list.append([act.attrib['id'],
act.attrib['activityNameId'],
act.attrib['specialActivityType'],
act.attrib['startDate'],
act.attrib['endDate']])
# Remove any potential duplicates
act_list, _, _, _ = self.__deduplicate(act_list, 0, 'activity_list')
# Convert to dataFrame
self.activities = pd.DataFrame(act_list,
columns=('activityId',
'activityNameId',
'activityType',
'startDate',
'endDate'),
index=[row[0] for row in act_list])
self.activities['activityType'
] = self.activities['activityType'].astype(int)
# Log event
sha1 = self.__hash_file(activity_file)
msg = "{} extracted from {} with SHA-1 of {}"
self.log.info(msg.format('Activities', self.__ACTIVITYINDEX, sha1))
def extract_flows(self):
""" Extracts of all intermediate and elementary flows
Args: None
----
Returns: None
-------
Generates:
----------
self.inflows: normalized product (intermediate) inputs
self.elementary_flows: normalized elementary flows
self.outflows: normalized product (intermediate) outputs
"""
# Initialize empty lists
inflow_list = []
outflow_list = []
elementary_flows = []
product_price_list = []
# Get list of ecoSpold files to process
data_folder = os.path.join(self.sys_dir, 'datasets')
spold_files = glob.glob(os.path.join(data_folder, '*.spold'))
# Log event
self.log.info('Processing {} files in {}'.format(len(spold_files),
data_folder))
# ONE FILE AT A TIME
for sfile in spold_files:
# Get activityId from file name
current_file = os.path.basename(sfile)
current_id = os.path.splitext(current_file)[0]
# For each file, find flow data
root = etree.parse(sfile).getroot()
child_ds = root.find(self.__PRE + 'childActivityDataset')
if child_ds is None:
child_ds = root.find(self.__PRE + 'activityDataset')
flow_ds = child_ds.find(self.__PRE + 'flowData')
# GO THROUGH EACH FLOW IN TURN
for entry in flow_ds:
# Get magnitude of flow
try:
_amount = float(entry.attrib.get('amount'))
except:
# Get ID of failed amount
_fail_id = entry.attrib.get('elementaryExchangeId',
'not found')
if _fail_id == 'not found':
_fail_id = entry.attrib.get('intermediateExchangeId',
'not found')
# Log failure
self.log.warn("Parser warning: flow in {0} cannot be"
" converted' 'to float. Id: {1} - amount:"
" {2}".format(str(current_file),
_fail_id,
_amount))
continue
if _amount == 0: # Ignore entries of magnitude zero
continue
# GET OBJECT, DESTINATION AND/OR ORIGIN OF EACH FLOW
# ... for elementary flows
if entry.tag == self.__PRE + 'elementaryExchange':
elementary_flows.append([
current_id,
entry.attrib.get('elementaryExchangeId'),
_amount])
elif entry.tag == self.__PRE + 'intermediateExchange':
# ... or product use
if entry.find(self.__PRE + 'inputGroup') is not None:
inflow_list.append([
current_id,
entry.attrib.get('activityLinkId'),
entry.attrib.get('intermediateExchangeId'),
_amount])
# ... or product supply.
elif entry.find(self.__PRE + 'outputGroup') is not None:
outflow_list.append([
current_id,
entry.attrib.get('intermediateExchangeId'),
_amount,
entry.attrib.get('productionVolumeAmount'),
entry.find(self.__PRE + 'outputGroup').text])
# ... if output get the price info if it is a primary product
product_property_path = self.__PRE+'property[@propertyId ="38f94dd1-d5aa-41b8-b182-c0c42985d9dc"]'
if entry.findall(product_property_path) is not None:
for elem in entry.findall(product_property_path):
price = elem.attrib.get('amount')
for nextlevelelem in elem:
if nextlevelelem.tag == self.__PRE+'name':
name = nextlevelelem.text
elif nextlevelelem.tag == self.__PRE+'unitName':
unit = nextlevelelem.text
#print(nextlevelelem.tag,': ', nextlevelelem.text)
product_price_list.append([current_id,
entry.attrib.get('intermediateExchangeId'),
name, price, unit,
entry.find(self.__PRE + 'outputGroup').text])
#print(current_id,entry.attrib.get('intermediateExchangeId'),name, price, unit, entry.find(self.__PRE + 'outputGroup').text])
# Check for duplicates in outputflows
# there should really only be one output flow per activity
outflow_list, _, _, _ = self.__deduplicate(outflow_list,
0,
'outflow_list')
# CONVERT TO DATAFRAMES
self.inflows = pd.DataFrame(inflow_list, columns=['fileId',
'sourceActivityId',
'productId',
'amount'])
self.elementary_flows = pd.DataFrame(elementary_flows,
columns=['fileId',
'elementaryExchangeId',
'amount'])
out = pd.DataFrame(outflow_list,
columns=['fileId',
'productId',
'amount',
'productionVolume',
'outputGroup'],
index=[row[0] for row in outflow_list])
out['productionVolume'] = out['productionVolume'].astype(float)
out['outputGroup'] = out['outputGroup'].astype(int)
self.outflows = out
prices = pd.DataFrame(product_price_list,
columns = ['fileId',
'productId',
'name',
'amount',
'unit',
'outputGroup'],
index=[row[0] for row in product_price_list])
prices['amount'] = prices['amount'].astype(float)
prices['outputGroup'] = prices['outputGroup'].astype(int)
self.prices = prices
def build_STR(self):
""" Parses ElementaryExchanges.xml to builds stressor labels
Args: None
----
Behaviour influenced by:
------------------------
* self.STR_order: Determines how labels are ordered
Returns: None
-------
Generates: self.STR: DataFrame with stressor Id's for index
Credit:
-------
This function incorporates/adapts code from Brightway2data, that is,
the classmethod extract_biosphere_metadata from Ecospold2DataExtractor
"""
# File to parse
fp = os.path.join(self.sys_dir, 'MasterData', self.__ELEXCHANGE)
assert os.path.exists(fp), "Can't find ElementaryExchanges.xml"
def extract_metadata(o):
""" Subfunction to extract data from lxml root object """
return {
'id': o.get('id'),
'name': o.name.text,
'unit': o.unitName.text,
'cas': o.get('casNumber'),
'comp': o.compartment.compartment.text,
'subcomp': o.compartment.subcompartment.text
}
# Extract data from file
with open(fp, 'r', encoding="utf-8") as fh:
root = objectify.parse(fh).getroot()
self.STR = _df([extract_metadata(i) for i in root.iterchildren()])
# organize in pandas DataFrame
self.STR.index = self.STR['id']
self.STR = self.STR.reindex_axis(['id',
'name',
'unit',
'cas',
'comp',
'subcomp'], axis=1)
self.STR = self.STR.sort_values(by=self.STR_order)
# Log event
sha1 = self.__hash_file(fp)
msg = "{} extracted from {} with SHA-1 of {}"
self.log.info(msg.format('Elementary flows', self.__ELEXCHANGE, sha1))
def build_PRO(self):
""" Builds minimalistic intermediate exchange process labels
This functions parses all files in dataset folder. The list is
returned as pandas DataFrame. The index of the DataFrame is the
filename of the files in the DATASET folder.
Args: None
----
Behaviour influenced by:
------------------------
* self.PRO_order: Determines how labels are ordered
Returns: None
-------
Generates: self.PRO: DataFrame with file_Id's for index
----------
"""
# INITIALIZE
# ----------
# Use ecospold filenames as indexes (they combine activity Id and
# reference-product Id)
data_folder = os.path.join(self.sys_dir, 'datasets')
spold_files = glob.glob(os.path.join(data_folder, '*.spold'))
_in = [os.path.splitext(os.path.basename(fn))[0] for fn in spold_files]
# Initialize empty DataFrame
PRO = pd.DataFrame(index=_in, columns=('activityId',
'productId',
'activityName',
'ISIC',
'EcoSpoldCategory',
'geography',
'technologyLevel',
'macroEconomicScenario'))
# LOOP THROUGH ALL FILES TO EXTRACT ADDITIONAL DATA
# -------------------------------------------------
# Log event
if len(spold_files) > 1000:
msg_many_files = 'Processing {} files - this may take a while ...'
self.log.info(msg_many_files.format(len(spold_files)))
#print('One step further')
for sfile in spold_files:
#print(sfile)
# Remove filename extension
file_index = os.path.splitext(os.path.basename(sfile))[0]
#print(file_index)
# Parse xml tree
root = ET.parse(sfile).getroot()
# Record product Id
if self.unlinked == True:
#objectify is a very handy way to parse an xml tree
#into a python object which is more easily accsesible
rroot = objectify.parse(sfile).getroot()
if hasattr(rroot, "activityDataset"):
stem = rroot.activityDataset
else:
stem = rroot.childActivityDataset
#loop through the intermediate exchanges to find the ref. flow
#might be a better/smarter way but don't know it yet
for flow in stem.flowData.intermediateExchange:
if hasattr(flow, 'outputGroup'):
if flow.outputGroup == 0:
PRO.loc[file_index, 'productId'] = flow.attrib[
'intermediateExchangeId']
#For the unlnked data the file name does not
#feature the _productID anymore, so loop through the
#flow data to find the reference flow.
break #An activity has only one reference flow by
#construction so break out of loop after we found it
del rroot
else:
PRO.ix[file_index, 'productId'] = file_index.split('_')[1]
#if the data are linked, the product name is in the spold files
#print(file_index, sfile)
# Find activity dataset
child_ds = root.find(self.__PRE + 'childActivityDataset')
if child_ds is None:
child_ds = root.find(self.__PRE + 'activityDataset')
activity_ds = child_ds.find(self.__PRE + 'activityDescription')
# Loop through activity dataset
for entry in activity_ds:
# Get name, id, etc
if entry.tag == self.__PRE + 'activity':
PRO.ix[file_index, 'activityId'] = entry.attrib['id']
PRO.ix[file_index, 'activityName'] = entry.find(
self.__PRE + 'activityName').text
continue
# Get classification codes
if entry.tag == self.__PRE + 'classification':
if 'ISIC' in entry.find(self.__PRE +
'classificationSystem').text:
PRO.ix[file_index, 'ISIC'] = entry.find(
self.__PRE + 'classificationValue').text
if 'EcoSpold' in entry.find(
self.__PRE + 'classificationSystem').text:
PRO.ix[file_index, 'EcoSpoldCategory'
] = entry.find(self.__PRE +
'classificationValue').text
continue
# Get geography
if entry.tag == self.__PRE + 'geography':
PRO.ix[file_index, 'geography'
] = entry.find(self.__PRE + 'shortname').text
continue
# Get Technology
try:
if entry.tag == self.__PRE + 'technology':
PRO.ix[file_index, 'technologyLevel'
] = entry.attrib['technologyLevel']
continue
except:
# Apparently it is not a mandatory field in ecospold2.
# Skip if absent
pass
# Find MacroEconomic scenario
if entry.tag == self.__PRE + 'macroEconomicScenario':
PRO.ix[file_index, 'macroEconomicScenario'
] = entry.find(self.__PRE + 'name').text
continue
# quality check of id and index
if file_index.split('_')[0] != PRO.ix[file_index, 'activityId']:
self.log.warn('Index based on file {} and activityId in the'
' xml data are different'.format(str(sfile)))
# Final touches and save to self
PRO['technologyLevel'] = PRO['technologyLevel'].fillna(0).astype(int)
for i in self.__TechnologyLevels.index:
bo = PRO['technologyLevel'] == i
PRO.ix[bo, 'technologyLevel'] = self.__TechnologyLevels[i]
self.PRO = PRO.sort_values(by=self.PRO_order)
def extract_old_labels(self, old_dir, sep='|'):
""" Read in old PRO, STR and IMP labels csv-files from directory
self.STR_old must be defined with:
* with THREE name columns called name, name2, name3
* cas, comp, subcomp, unit
* ardaid, i.e., the Id that we wish to re-use in the new dataset
"""
# Read in STR
path = glob.glob(os.path.join(old_dir, '*STR*.csv'))[0]
self.STR_old = pd.read_csv(path, sep=sep)
# Read in PRO
path = glob.glob(os.path.join(old_dir, '*PRO*.csv'))[0]
self.PRO_old = pd.read_csv(path, sep=sep)
# Read in IMP
path = glob.glob(os.path.join(old_dir, '*IMP*.csv'))[0]
self.IMP_old = pd.read_csv(path, sep=sep)
# =========================================================================
# CLEAN UP FUNCTIONS: if imperfections in ecospold data
def __find_unsourced_flows(self):
"""
find input/use flows that do not have a specific supplying activity.
It determines the traceable or untraceable character of a product flow
based on the sourceActivityId field.
Depends on:
----------
* self.inflows (from self.get_flows or self.extract_flows)
* self.products [optional] (from self.extract_products)
* self.PRO [optional] (from self.get_labels or self.build_PRO)
Generates:
----------
* self.unsourced_flows: dataFrame w/ descriptions of unsourced flows
Args: None
----
Returns: None
--------
"""
# Define boolean vector of product flows without source
nuns = np.equal(self.inflows['sourceActivityId'].values, None)
unsourced_flows = self.inflows[nuns]
# add potentially useful information from other tables
# (not too crucial)
try:
unsourced_flows = self.inflows[nuns].reset_index().merge(
self.PRO[['activityName', 'geography', 'activityType']],
left_on='fileId', right_index=True)
unsourced_flows = unsourced_flows.merge(
self.products[['productName', 'productId']],
on='productId')
# ... and remove useless information
unsourced_flows.drop(['sourceActivityId'], axis=1, inplace=True)
except:
pass
# Log event and save to self
if np.any(nuns):
self.log.warn('Found {} untraceable flows'.format(np.sum(nuns)))
self.unsourced_flows = unsourced_flows
else:
self.log.info('OK. No untraceable flows.')
def __fix_flow_sources(self):
""" Try to find source activity for every product input-flow
Dependencies:
-------------
* self.unsourced_flows (from self.__find_unsourced_flows)
* self.PRO (from self.get_labels or self.build_PRO)
* self.inflows (from self.get_flows or self.extract_flows)
Potentially modifies all three dependencies above to assign unambiguous
source for each product flow, following these rules:
1) If only one provider in dataset, pick this one, even if geography is
wrong
2) Else if only one producer and one market, pick the market (as the
producer clearly sells to the sole market), regardless of geography
3) Elseif one market in right geography, always prefer that to any
other.
4) Elseif only one producer with right geography, prefer that one.
5) Otherwise, no unambiguous answer, leave for user to fix manually
"""
# Proceed to find clear sources for these flows, if at all possible
for i in self.unsourced_flows.index:
aflow = self.unsourced_flows.iloc(i)
print(aflow)
pdb.set_trace()
# Boolean vectors for relating the flow under investigation with
# PRO, either in term of which industries require the product
# in question (boPro), or the geographical location of the flow
# (boGeo) or whether a the source activity is a market or an
# ordinary activity (boMark), or a compbination of the above
boPro = (self.PRO.productId == aflow.productId).values
boGeo = (self.PRO.geography == aflow.geography).values
boMark = (self.PRO.activityType == '1').values
boMarkGeo = np.logical_and(boGeo, boMark)
boProGeo = np.logical_and(boPro, boGeo)
boProMark = np.logical_and(boPro, boMark)
act_id = '' # goal: finding a plausible value for this variable
# If it is a "normal" activity that has this input flow
if aflow.activityType == '0':
# Maybe there are NO producers, period.
if sum(boPro) == 0:
msg_noprod = "No producer found for product {}! Not good."
self.log.error(msg_noprod.format(aflow.productId))
self.log.warning("Creation of dummy producer not yet"
" automated")
# Maybe there is no choice, only ONE producer
elif sum(boPro) == 1:
act_id = self.PRO[boPro].activityId.values
# Log event
if any(boProGeo):
# and all is fine geographically for this one producer
self.log.warn("Exactly 1 producer ({}) for product {}"
", and its geography is ok for this"
" useflow".format(act_id,
aflow.productId))
else:
# but has wrong geography... geog proxy
wrong_geo = self.PRO[boPro].geography.values
msg = ("Exactly 1 producer ({}) for product {}, used"
" in spite of having wrong geography for {}:{}")
self.log.warn(msg.format(act_id,
aflow.productId,
aflow.fileId,
wrong_geo))
# Or there is only ONE producer and ONE market, no choice
# either, since then it is clear that this producer sells to
# the market.
elif sum(boPro) == 2 and sum(boProMark) == 1:
act_id = self.PRO[boProMark].activityId.values
# Log event
self.log.warn = ("Exactly 1 producer and 1 market"
" worldwide, so we source product {} from"
" market {}".format(aflow.productId,
act_id))
# or there are multiple sources, but only one market with the
# right geography
elif sum(boMarkGeo) == 1:
act_id = self.PRO[boMarkGeo].activityId.values
# Log event
msg_markGeo = ('Multiple sources, but only one market ({})'
' with right geography ({}) for product {}'
' use by {}.')
self.log.warn(msg_markGeo.format(act_id,
aflow.geography,
aflow.productId,
aflow.fileId))
# Or there are multiple sources, but only one producer with the
# right geography.
elif sum(boProGeo) == 1:
act_id = self.PRO[boProGeo].activityId.values
# Log event
msg_markGeo = ('Multiple sources, but only one producer'
' ({}) with right geography ({}) for'
' product {} use by {}.')
self.log.warn(msg_markGeo.format(act_id,
aflow.geography,
aflow.productId,
aflow.fileId))
else:
# No unambiguous fix, save options to file, let user decide
filename = ('potentialSources_' + aflow.productId +
'_' + aflow.fileId + '.csv')
debug_file = os.path.join(self.log_dir, filename)
# Log event
msg = ("No unambiguous fix. {} potential sources for "
"product {} use by {}. Will need manual fix, see"
" {}.")
self.log.error(msg.format(sum(boPro),
aflow.productId,
aflow.fileId,
debug_file))
self.PRO.ix[boPro, :].to_csv(debug_file, sep='|',
encoding='utf-8')
# Based on choice of act_id, record the selected source
# activity in inflows
self.inflows.ix[aflow['index'], 'sourceActivityId'] = act_id
elif aflow.activityType == '1':
msg = ("A market with untraceable inputs:{}. This is not yet"
" supported by __fix_flow_sources.")
self.log.error(msg.format(aflow.fileId)) # do something!
else:
msg = ("Activity {} is neither a normal one nor a market. Do"
" not know what to do with its" " untraceable flow of"
" product {}").format(aflow.fileId, aflow.productId)
self.log.error(msg) # do something!
def __fix_missing_activities(self):
""" Fix if flow sourced explicitly to an activity that does not exist
Identifies existence of missing production, and generate them
Depends on or Modifies:
-----------------------
* self.inflows (from self.get_flows or self.extract_flows)
* self.outflows (from self.get_flows or self.extract_flows)
* self.products (from self.extract_products)
* self.PRO (from self.get_labels or self.build_PRO)
Generates:
----------
self.missing_activities
"""
# Get set of all producer-product pairs in inflows
flows = self.inflows[['sourceActivityId', 'productId']].values.tolist()
set_flows = set([tuple(i) for i in flows])
# Set of all producer-product pairs in PRO
processes = self.PRO[['activityId', 'productId']].values.tolist()
set_labels = set([tuple(i) for i in processes])
# Identify discrepencies: missing producer-product pairs in labels
missing_activities = set_flows - set_labels
if missing_activities:
# Complain
msg = ("Found {} product flows traceable to sources that do not"
" produce right product. Productions will have to be added"
" to PRO, which now contain {} productions. Please see"
" missingProducers.csv.")
self.log.error(msg.format(len(missing_activities), len(self.PRO)))
# Organize in dataframe
miss = pd.DataFrame([[i[0], i[1]] for i in missing_activities],
columns=['activityId', 'productId'],
index=[i[0] + '_' + i[1]
for i in missing_activities])
activity_cols = ['activityId', 'activityName', 'ISIC']
product_cols = ['productId', 'productName']
copied_cols = activity_cols + product_cols
copied_cols.remove('productName')
# Merge to get info on missing flows
miss = miss.reset_index()
miss = miss.merge(self.PRO[activity_cols],
how='left',
on='activityId')
miss = miss.merge(self.products[product_cols],
how='left', on='productId')
miss = miss.set_index('index')
# Save missing flows to file for inspection
miss.to_csv(os.path.join(self.log_dir, 'missingProducers.csv'),
sep='|', encoding='utf-8')
# Insert dummy productions
for i, row in miss.iterrows():
self.log.warn('New dummy activity: {}'.format(i))
# add row to self.PRO
self.PRO.ix[i, copied_cols] = row[copied_cols]
self.PRO.ix[i, 'comment'] = 'DUMMY PRODUCTION'
# add new row in outputflow
self.outflows.ix[i, ['fileId', 'productId', 'amount']
] = [i, row['productId'], 1.0]
self.log.warn("Added dummy productions to PRO, which"
" is now {} processes long.".format(len(self.PRO)))
self.missing_activities = missing_activities
else:
self.log.info("OK. Source activities seem in order. Each product"
" traceable to an activity that actually does"
" produce or distribute this product.")
# =========================================================================
# ASSEMBLE MATRICES: now all parsed and cleanead, build the final matrices
def complement_labels(self):
""" Add extra data from self.products and self.activities to labels
Until complement_labels is run, labels are kept to the strict minimum
to facilitate tinkering with them if needed to fix discrepancies in
database. For example, adding missing activity or creating a dummy
process in labels is easier without all the (optional) extra meta-data
in there.
Once we have a consistent symmetric system, it's time to add useful
information to the matrix row and column labels for human readability.
Depends on:
-----------
self.products (from self.extract_products)
self.activities (from self.extract_activities)
Modifies:
---------
self.PRO (from self.get_labels or self.build_PRO)
self.STR (from self.get_labels or self.build_STR)
"""
self.PRO = self.PRO.reset_index()
# add data from self.products
self.PRO = self.PRO.merge(self.products,
how='left',
on='productId')
# add data from self.activities
self.PRO = self.PRO.merge(self.activities,
how='left',
on='activityId')
# Final touches and re-establish indexes as before
self.PRO = self.PRO.drop('unitId', axis=1).set_index('index')
# Re-sort processes (in fix-methods altered order/inserted rows)
self.PRO = self.PRO.sort_values(by=self.PRO_order)
self.STR = self.STR.sort_values(by=self.STR_order)
def build_AF(self):
"""
Arranges flows as Leontief technical coefficient matrix + extensions
Dependencies:
-------------
* self.inflows (from get_flows or extract_flows)
* self.elementary_flows (from get_flows or extract_flows)
* self.outflows (from get_flows or extract_flows)
* self.PRO [final version] (completed by self.complement_labels)
* self.STR [final version] (completed by self.complement_labels)
Behaviour determined by:
-----------------------
* self.positive_waste (determines sign convention to use)
* self.nan2null
Generates:
----------
* self.A
* self.F
"""
# By pivot tables, arrange all intermediate and elementary flows as
# matrices
self.log.info("Starting to assemble the matrices")
self.A = pd.pivot(
self.inflows['sourceActivityId'] + '_' + self.inflows['productId'],
self.inflows['fileId'],
self.inflows['amount']
).reindex(index=self.PRO.index, columns=self.PRO.index)
self.F = pd.pivot_table(self.elementary_flows,
values='amount',
index='elementaryExchangeId',
columns='fileId').reindex(index=self.STR.index,
columns=self.PRO.index)
# Take care of sign convention for waste
self.log.info("Starting normalizing matrices")
if self.positive_waste:
sign_changer = self.outflows['amount'] / self.outflows['amount'].abs()
self.A = self.A.mul(sign_changer, axis=0)
col_normalizer = 1 / self.outflows['amount'].abs()
else:
col_normalizer = 1 / self.outflows['amount']
# Normalize flows
# Reorder all rows and columns to fit labels
self.A = self.A.mul(col_normalizer, axis=1).reindex(
index=self.PRO.index,
columns=self.PRO.index)
self.F = self.F.mul(col_normalizer, axis=1).reindex(
index=self.STR.index,
columns=self.PRO.index)
self.log.info("fillna")
if self.nan2null:
self.A.fillna(0, inplace=True)
self.F.fillna(0, inplace=True)
def scale_up_AF(self):
""" Calculate absolute flow matrix from A, F, and production Volumes
In other words, scales up normalized system description to reach
recorded production volumes
Dependencies:
--------------
* self.outflows
* self.A
* self.F
Generates:
----------
* self.Z
* self.G_pro
"""
q = self.outflows['productionVolume']
self.Z = self.A.multiply(q, axis=1).reindex_like(self.A)
self.G_pro = self.F.multiply(q, axis=1).reindex_like(self.F)
def remove_Markets(self):
""" If the data are unlinked, markets are empty, that is nothing is
linked to the market yet, move the use flows (inflows, e.g. transport,
losses, etc) from the markets to use flows in the activities using
the reference product of the market.
"""
'''
#first check if the the data is actually considered to be unlinked.
#If not, warn the user and log. Potentially ask for user input
if self.unlinked is False:
var = input("Data are treated as linked and allocated, are you\n\
sure you want to remove the markets? [y/n]: ")
while var not in ['y','n']:
var = input("Invalid input! Please select a valid option!\n\
Data are treated as linked and allocated, are you\n\
sure you want to remove the markets? [y/n]: ")
if var == 'n':
self.log.info('Not removing markets, choice made through user input.')
return 0
#If the code gets here, var must be 'y':
self.log.warning("Remove markets: Data are linked and allocated,
removing markets nonetheless. Choice made through user input")
#This function does not do anything at the moment as we decided to use ocelot
#the linking/allocation.
'''
pass
def build_sut(self, make_untraceable=False):
""" Arranges flow data as Suply and Use Tables and extensions
Args:
-----
* make_untraceable: Whether or not to aggregate away the source
activity dimension, yielding a use table in which
products are no longer linked to their providers
[default: False; don't do it]
Dependencies:
-------------
* self.inflows
* self.outflows
* self.elementary_flows
Behaviour determined by:
-----------------------
* self.nan2null
Generates:
----------
* self.U
* self.V
* self.G_act
* self.V_prodVol
"""
def remove_productId_from_fileId(flows):
"""subfunction to remove the 'product_Id' part of 'fileId' data in
DataFrame, leaving only activityId and renaming columnd as such"""
fls = flows.replace('_[^_]*$', '', regex=True)
fls.rename(columns={'fileId': 'activityId'}, inplace=True)
return fls
# Refocus on activity rather than process (activityId vs fileId)
outfls = remove_productId_from_fileId(self.outflows)
elfls = remove_productId_from_fileId(self.elementary_flows)
infls = remove_productId_from_fileId(self.inflows)
infls.replace(to_replace=[None], value='', inplace=True)
# Pivot flows into Use and Supply and extension tables
self.U = pd.pivot_table(infls,
index=['sourceActivityId', 'productId'],
columns='activityId',
values='amount',
aggfunc=np.sum)
self.V = pd.pivot_table(outfls,
index='productId',
columns='activityId',
values='amount',
aggfunc=np.sum)
self.V_prodVol = pd.pivot_table(outfls,
index='productId',
columns='activityId',
values='productionVolume',
aggfunc=np.sum)
self.G_act = pd.pivot_table(elfls,
index='elementaryExchangeId',
columns='activityId',
values='amount',
aggfunc=np.sum)
# ensure all products are covered in supply table
self.V = self.V.reindex(index=self.products.index,
columns=self.activities.index)
self.V_prodVol = self.V_prodVol.reindex(index=self.products.index,
columns=self.activities.index)
self.U = self.U.reindex(columns=self.activities.index)
self.G_act = self.G_act.reindex(index=self.STR.index,
columns=self.activities.index)
if make_untraceable:
# Optionally aggregate away sourceActivity dimension, more IO-like
# Supply and untraceable-Use tables...
self.U = self.U.groupby(level='productId').sum()
self.U = self.U.reindex(index=self.products.index,
columns=self.activities.index)
self.log.info("Aggregated all sources in U, made untraceable")
if self.nan2null:
self.U.fillna(0, inplace=True)
self.V.fillna(0, inplace=True)
self.G_act.fillna(0, inplace=True)
# =========================================================================
# SANITY CHECK: Compare calculated cummulative LCI with official values
def build_E(self, data_folder=None):
""" Extract matrix of cummulative LCI from ecospold files
Dependencies:
------------
* self.PRO
* self.STR
Behaviour influenced by:
------------------------
* self.lci_dir
* self.nan2null
Generates:
----------
* self.E
"""
# Get list of ecospold files
if data_folder is None:
data_folder = self.lci_dir
spold_files = glob.glob(os.path.join(data_folder, '*.spold'))
if len(spold_files):
self.log.info( "Processing {} {} files from {}".format(
len(spold_files), 'cummulative LCI', data_folder))
else:
self.log.warning(
"Did not find any ecospold file in {}".format(data_folder))
# Initialize (huge) dataframe and get dimensions
self.log.info('creating E dataframe')
self.E = pd.DataFrame(index=self.STR.index,
columns=self.PRO.index, dtype=float)
initial_rows, initial_columns = self.E.shape
# LOOP OVER ALL FILES TO EXTRACT ELEMENTARY FLOWS
for count, sfile in enumerate(spold_files):
# Get to flow data
current_file = os.path.basename(sfile)
current_id = os.path.splitext(current_file)[0]
root = ET.parse(sfile).getroot()
child_ds = root.find(self.__PRE + 'childActivityDataset')
if child_ds is None:
child_ds = root.find(self.__PRE + 'activityDataset')
flow_ds = child_ds.find(self.__PRE + 'flowData')
# Find elemementary exchanges amongst all flows
for entry in flow_ds:
if entry.tag == self.__PRE + 'elementaryExchange':
try:
# Get amount
self.E.ix[entry.attrib['elementaryExchangeId'],
current_id] = float(entry.attrib['amount'])
except:
_amount = entry.attrib.get('amount', 'not found')
if _amount != '0':
msg = ("Parser warning: elementary exchange in {0}"
". elementaryExchangeId: {1} - amount: {2}")
self.log.warn(msg.format(str(current_file),
entry.attrib.get('elementaryExchangeId',
'not found'), _amount))
# keep user posted, as this loop can be quite long
if count % 300 == 0:
self.log.info('Completed {} files.'.format(count))
# Check for discrepancies in list of stressors and processes
final_rows, final_columns = self.E.shape
appended_rows = final_rows - initial_rows
appended_columns = final_columns - initial_columns
# and log
if appended_rows != 0:
self.log.warn('There are {} new processes relative to the initial'
'list.'.format(str(appended_rows)))
if appended_columns != 0:
self.log.warn('There are {} new impacts relative to the initial'
'list.'.format(str(appended_rows)))
if self.nan2null:
self.E.fillna(0, inplace=True)
def __calculate_E(self, A0, F0):
""" Calculate lifecycle cummulative inventories for comparison self.E
Args:
-----
* A0 : Leontief A-matrix (pandas dataframe)
* F0 : Environmental extension (pandas dataframe)
Returns:
--------
* Ec as pandas dataframe
Note:
--------
* Plan to move this as nested function of cummulative_lci_check
"""
A = A0.fillna(0).values
F = F0.fillna(0).values
I = np.eye(len(A))
Ec = F.dot(np.linalg.solve(I - A, I))
return pd.DataFrame(Ec, index=F0.index, columns=A0.columns)
def cummulative_lci_check(self, rtol=5e-2, atol=1e-5, imax=3):
"""
Sanity check: compares calculated and parsed cummulative LCI data
Args:
-----
* rtol: relative tolerance, maximum relative difference between
coefficients
* atol: absolute tolerance, maximum absolute difference between
coefficients
* imax: Number of orders of magnitude smaller than defined tolerance
that should be investigated
Depends on:
----------
* self.E
* self.__calculate_E()
"""
Ec = self.__calculate_E(self.A, self.F)
filename = os.path.join(self.log_dir,
'qualityCheckCummulativeLCI.shelf')
shelf = shelve.open(filename)
# Perform compareE() analysis at different tolerances, in steps of 10
i = 1
while (i <= imax) and (rtol > self.rtolmin):
bad = self.compareE(Ec, rtol, atol)
rtol /= 10
if bad is not None:
# Save bad flows in Shelf persistent dictionary
shelf['bad_at_rtol'+'{:1.0e}'.format(rtol)] = bad
i += 1
shelf.close()
sha1 = self.__hash_file(filename)
msg = "{} saved in {} with SHA-1 of {}"
self.log.info(msg.format('Cummulative LCI differences',
filename,
sha1))
def compareE(self, Ec, rtol=5e-2, atol=1e-5):
""" Compare parsed (official) cummulative lci emissions (self.E) with
lifecycle emissions calculated from the constructed matrices (Ec)
"""
thebad = None
# Compare the two matrices, see how many values are "close"
close = np.isclose(abs(self.E.fillna(0.0)), abs(Ec.fillna(0.0)), rtol, atol)
notclose = np.sum(~ close)
allcomp = np.sum(close) + notclose
self.log.info('There are {} lifecycle cummulative emissions out of {} that '
'differ by more than {} % AND by more than {} units '
'relative to the official value.'.format(notclose,
allcomp,
rtol*100,
atol))
if notclose:
# Compile a Series of all "not-close" values
thebad = pd.concat([self.E.mask(close).stack(), Ec.mask(close).stack()], 1)
del(Ec)
thebad.columns = ['official', 'calculated']
thebad.index.names = ['stressId', 'fileId']
# Merge labels to make it human readable
thebad = pd.merge(thebad.reset_index(),
self.PRO[['productName', 'activityName']],
left_on='fileId',
right_index=True)
thebad = pd.merge(thebad,
self.STR,
left_on='stressId',
right_index=True).set_index(['stressId',
'fileId'])
return thebad
# =========================================================================
# EXPORT AND HELPER FUNCTIONS
def save_system(self, file_formats=None):
""" Save normalized syste matrices to different formats
Args:
-----
* fileformats : List of file formats in which to save data
[Default: None, save to all possible file formats]
Options: 'Pandas' --> pandas dataframes
'csv' --> text with separator = '|'
'SparsePandas' --> sparse pandas dataframes
'SparseMatrix' --> scipy AND matlab sparse
'SparseMatrixForArda' --> with special
background
variable names
This method creates separate files for normalized, symmetric matrices
(A, F), scaled-up symmetric metrices (Z, G_pro), and supply and use
data (U, V, V_prod, G_act).
For Pandas and sparse pickled files, ghis method organizes the
variables in a dictionary, and pickles this dictionary to file.
For sparse pickled file, some labels are not turned into sparse
matrices (because not sparse) and are rather added as numpy arrays.
For Matlab sparse matrices, variables saved to mat file.
For CSV, a subdirectory is created to hold one text file per variable.
Returns:
-------
None
"""
# TODO: include characterisation factors in all formats and also
# non-normalized
def pickling(filename, adict, what_it_is, mat):
""" subfunction that handles creation of binary files """
# save dictionary as pickle
ext = '.gz.pickle'
with gzip.open(filename + ext, 'wb') as fout:
pickle.dump(adict, fout)
sha1 = self.__hash_file(filename + ext)
msg = "{} saved in {} with SHA-1 of {}"
self.log.info(msg.format(what_it_is, filename + ext, sha1))
# save dictionary also as mat file
if mat:
scipy.io.savemat(filename, adict, do_compression=True)
sha1 = self.__hash_file(filename + '.mat')
msg = "{} saved in {} with SHA-1 of {}"
self.log.info(msg.format(what_it_is, filename + '.mat', sha1))
def pickle_symm_norm(PRO=None, STR=None, IMP=None, A=None, F=None,
C=None, PRO_header=None, STR_header=None, IMP_header=None,
mat=False, for_arda_background=False):
""" nested function that prepares dictionary for symmetric,
normalized (coefficient) system description file """
if not for_arda_background:
adict = {'PRO': PRO,
'STR': STR,
'IMP': IMP,
'A': A,
'F': F,
'C': C,
'PRO_header': PRO_header,
'STR_header': STR_header,
'IMP_header': IMP_header
}
else:
adict = {'PRO_gen': PRO,
'STR': STR,
'IMP': IMP,
'A_gen': A,
'F_gen': F,
'C': C,
'PRO_header': PRO_header,
'STR_header': STR_header,
'IMP_header': IMP_header
}
self.log.info("about to write to file")
pickling(file_pr + '_symmNorm', adict,
'Final, symmetric, normalized matrices', mat)
def pickle_symm_scaled(PRO, STR, Z, G_pro, mat=False):
""" nested function that prepares dictionary for symmetric,
scaled (flow) system description file """
adict = {'PRO': PRO,
'STR': STR,
'Z': Z,
'G_pro': G_pro}
pickling(file_pr + '_symmScale', adict,
'Final, symmetric, scaled-up flow matrices', mat)
def pickle_sut(prod, act, STR, U, V, V_prodVol, G_act, mat=False):
""" nested function that prepares dictionary for SUT file """
adict = {'products': prod,
'activities': act,
'STR': STR,
'U': U,
'V': V,
'V_prodVol': V_prodVol,
'G_act': G_act}
pickling(file_pr + '_SUT', adict, 'Final SUT matrices', mat)
self.log.info("Starting to export to file")
# save as full Dataframes
format_name = 'Pandas'
if file_formats is None or format_name in file_formats:
file_pr = os.path.join(self.out_dir,
self.project_name + format_name)
if self.A is not None:
pickle_symm_norm(PRO=self.PRO,
STR=self.STR,
IMP=self.IMP,
A=self.A,
F=self.F,
C=self.C)
if self.Z is not None:
pickle_symm_scaled(self.PRO, self.STR, self.Z, self.G_pro)
if self.U is not None:
pickle_sut(self.products,
self.activities,
self.STR,
self.U, self.V, self.V_prodVol, self.G_act)
# save sparse Dataframes
format_name = 'SparsePandas'
if file_formats is None or format_name in file_formats:
file_pr = os.path.join(self.out_dir,
self.project_name + format_name)
if self.A is not None:
pickle_symm_norm(PRO=self.PRO,
STR=self.STR,
IMP=self.IMP,
A=self.A.to_sparse(),
F=self.F.to_sparse(),
C=self.C.to_sparse())
if self.Z is not None:
Z = self.Z.to_sparse()
G_pro = self.G_pro.to_sparse()
pickle_symm_scaled(self.PRO, self.STR, Z, G_pro)
if self.U is not None:
U = self.U.to_sparse()
V = self.V.to_sparse()
V_prodVol = self.V_prodVol.to_sparse()
G_act = self.G_act.to_sparse()
pickle_sut(self.products,
self.activities,
self.STR,
U, V, V_prodVol, G_act)
# save as sparse Matrices (both pickled and mat-files)
format_name = 'SparseMatrix'
# Check if we need special formatting for ARDA software
for_arda_background=False
try:
if 'SparseMatrixForArda' in file_formats:
for_arda_background=True
except TypeError:
pass
# Proceed
if (file_formats is None
or format_name in file_formats
or for_arda_background):
file_pr = os.path.join(self.out_dir,
self.project_name + format_name)
PRO = self.PRO.fillna('').values
STR = self.STR.fillna('').values
IMP = self.IMP.fillna('').values
PRO_header = self.PRO.columns.values
PRO_header = PRO_header.reshape((1, -1))
STR_header = self.STR.columns.values
STR_header = STR_header.reshape((1, -1))
C = scipy.sparse.csc_matrix(self.C.fillna(0))
IMP_header = self.IMP.columns.values
IMP_header = IMP_header.reshape((1, -1))
if self.A is not None:
A = scipy.sparse.csc_matrix(self.A.fillna(0))
F = scipy.sparse.csc_matrix(self.F.fillna(0))
pickle_symm_norm(PRO=PRO, STR=STR, IMP=IMP, A=A, F=F, C=C,
PRO_header=PRO_header, STR_header=STR_header,
IMP_header=IMP_header, mat=True,
for_arda_background=for_arda_background)
if self.Z is not None:
Z = scipy.sparse.csc_matrix(self.Z.fillna(0))
G_pro = scipy.sparse.csc_matrix(self.G_pro.fillna(0))
pickle_symm_scaled(PRO, STR, Z, G_pro, mat=True)
if self.U is not None:
U = scipy.sparse.csc_matrix(self.U.fillna(0))
V = scipy.sparse.csc_matrix(self.V.fillna(0))
V_prodVol = scipy.sparse.csc_matrix(self.V_prodVol.fillna(0))
G_act = scipy.sparse.csc_matrix(self.G_act.fillna(0))
products = self.products.values # to numpy array, not sparse
activities = self.activities.values
pickle_sut(products,
activities,
STR,
U, V, V_prodVol, G_act, mat=True)
# Write to CSV files
format_name = 'csv'
if file_formats is None or format_name in file_formats:
csv_dir = os.path.join(self.out_dir, 'csv')
if not os.path.exists(csv_dir):
os.makedirs(csv_dir)
self.PRO.to_csv(os.path.join(csv_dir, 'PRO.csv'))
self.STR.to_csv(os.path.join(csv_dir, 'STR.csv'))
if self.C is not None:
self.C.to_csv(os.path.join(csv_dir, 'C.csv'), sep='|')
self.IMP.to_csv(os.path.join(csv_dir, 'IMP.csv'), sep='|')
if self.A is not None:
self.A.to_csv(os.path.join(csv_dir, 'A.csv'), sep='|')
self.F.to_csv(os.path.join(csv_dir, 'F.csv'), sep='|')
if self.Z is not None:
self.Z.to_csv(os.path.join(csv_dir, 'Z.csv'), sep='|')
self.G_pro.to_csv(os.path.join(csv_dir, 'G_pro.csv'), sep='|')
if self.U is not None:
self.products.to_csv(os.path.join(csv_dir, 'products.csv'),
sep='|')
self.prices.to_csv(os.path.join(csv_dir, 'prices.csv'),
sep='|')
self.activities.to_csv(os.path.join(csv_dir, 'activities.csv'),
sep='|')
self.U.to_csv(os.path.join(csv_dir, 'U.csv'), sep='|')
self.V.to_csv(os.path.join(csv_dir, 'V.csv'), sep='|')
self.V_prodVol.to_csv(os.path.join(csv_dir, 'V_prodVol.csv'),
sep='|')
self.G_act.to_csv(os.path.join(csv_dir, 'G_act.csv'), sep='|')
self.log.info("Final matrices saved as CSV files in " + csv_dir)
def __hash_file(self, afile):
""" Get SHA-1 hash of binary file
Args:
-----
* afile: either name of file or file-handle of a file opened in
"read-binary" ('rb') mode.
Returns:
--------
* hexdigest hash of file, as string
"""
blocksize = 65536
hasher = hashlib.sha1()
# Sometimes used for afile as filename
try:
f = open(afile, 'rb')
opened_here = True
# Or afile can be a filehandle
except:
f = afile
opened_here = False
buf = f.read(blocksize)
while len(buf) > 0:
hasher.update(buf)
buf = f.read(blocksize)
if opened_here:
f.close()
return hasher.hexdigest()
def __deduplicate(self, raw_list, idcol=None, name=''):
""" Removes duplicate entries from a list
and then optionally warns of duplicate id's in the cleaned up list
Args:
-----
raw_list: a list
incol : in case of a list of lists, the "column" position for id's
name: string, just for logging messages
Return:
------
deduplicated: list without redundant entries
duplicates: list with redundant entries
id_deduplicated: list of ID's without redundancy
id_duplicates: list of redundant ID's
"""
# Initialization
deduplicated = []
duplicates = []
id_deduplicated = []
id_duplicates = []
# Find duplicate rows in list
for elem in raw_list:
if elem not in deduplicated:
deduplicated.append(elem)
else:
duplicates.append(elem)
# If an "index column" is specified, find duplicate indexes in
# deduplicated. In other words, amongst unique rows, are there
# non-unique IDs?
if idcol is not None:
indexes = [row[idcol] for row in deduplicated]
for index in indexes:
if index not in id_deduplicated:
id_deduplicated.append(index)
else:
id_duplicates.append(index)
# Log findings for further inspection
if duplicates:
filename = 'duplicate_' + name + '.csv'
with open(os.path.join(self.log_dir, filename), 'w') as fout:
duplicatewriter = csv.writer(fout, delimiter='|')
duplicatewriter.writerows(duplicates)
msg = 'Removed {} duplicate rows from {}, see {}.'
self.log.warn(msg.format(len(duplicates), name, filename))
if id_duplicates:
filename = 'duplicateID_' + name + '.csv'
with open(os.path.join(self.log_dir + filename), 'w') as fout:
duplicatewriter = csv.writer(fout, delimiter='|')
duplicatewriter.writerows(id_duplicates)
msg = 'There are {} duplicate Id in {}, see {}.'
self.log.warn(msg.format(len(id_duplicates), name, filename))
return deduplicated, duplicates, id_deduplicated, id_duplicates
# =========================================================================
# Characterisation factors matching
# =========================================================================
def simple_characterisation_matching(self, characterisation_file):
# Useful stuff
c = self.conn.cursor()
non_decimal = re.compile(r'[^0-9]')
basename = os.path.basename
def clean_up_columns(df):
""" Remove spaces, whitespace, and periods from column names
Also, return a list of all numbers in columns
"""
df.columns = [x.strip().replace(' ', '_') for x in df.columns]
col_version_numbers = [non_decimal.sub('', x) for x in df.columns]
df.columns = [x.replace('.', '') for x in df.columns]
return df, col_version_numbers
# Read and clean units
units = pd.read_excel(characterisation_file, 'units')
units, __ = clean_up_columns(units)
# Read and clean characterisation factors
cf = pd.read_excel(characterisation_file, 'CFs')
cf, col_version_numbers = clean_up_columns(cf)
# Try to find column with the matching CF and filename version number
# (e.g. CF 3.3 for LCIA_Implementation_3.3.xlsx)
file_version = non_decimal.sub('', basename(characterisation_file))
try:
cf_col = col_version_numbers.index(file_version)
msg = "Will use column {}, named {}, for characterisation factors"
self.log.info(msg.format(cf_col, cf.columns[cf_col]))
except:
cf_col = -3
msg = ("Could not match file version {} with CF versions."
" By default will use {}.")
self.log.warning(msg.format(file_version, cf.columns[cf_col]))
# Rename characterisation factor column
cols = cf.columns.tolist()
cols[cf_col] = 'CF'
cf.columns = cols
sep = '; '
self.log.info("Starting characterisation matching")
# Export to sqlite for matching
cf.to_sql('char', self.conn, if_exists='replace')
units.to_sql('units', self.conn, if_exists='replace')
self.STR.to_sql('stressors',
self.conn,
index_label='stressorId',
if_exists='replace')
# Complement ecoinvent elementary flows (stressors s) with matching
# characterisation factors (char c) and its units (units u)
sql_cmd = """ SELECT s.name, s.comp, s.subcomp, s.unit, s.stressorId,
c.method, c.category, c.indicator, c.CF,
u.impact_score_unit
FROM stressors s
LEFT JOIN char c
ON c.name = s.name AND c.compartment=s.comp
AND c.subcompartment=s.subcomp
AND s.unit=c.exchange_unit
LEFT JOIN units u
ON u.method=c.method AND u.category=c.category
AND u.indicator=c.indicator"""
C_long = pd.read_sql(sql_cmd, self.conn)
# Generate IMP labels
C_long['impact_label'] = (C_long.method + sep
+ C_long.category + sep
+ C_long.indicator + sep
+ C_long.impact_score_unit)
self.IMP = C_long[['impact_label',
'method',
'category',
'indicator',
'impact_score_unit']].drop_duplicates()
self.IMP.set_index('impact_label', inplace=True)
# Pivot and reindex to generate characterisation matrix
self.C = pd.pivot_table(C_long,
values='CF',
columns='stressorId',
index='impact_label')
self.C = self.C.reindex(self.IMP.index).reindex_axis(self.STR.index, 1)
self.log.info("Characterisation matching done. C matrix created")
def prepare_matching_load_parameters():
""" Load predefined values and parameters for characterisation matching
"""
# Read in parameter tables for CAS conflicts and known synonyms
def read_parameters(filename):
#resource = pkg_resources.resource_filename(__name__, filename)
resource = pkgutil.get_data(__name__, filename)
tmp = pd.read_csv(io.BytesIO(resource), sep='|', comment='#')
print(tmp)
return tmp.where( | pd.notnull(tmp) | pandas.notnull |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
'''
BdPRC_MD.py
Bd-RPC
(Bases dependent Rapid Phylogenetic Clustering)
MAKE DATABASE
Author: <NAME>
'''
#####Make Database function
def calcuate_bases_frequency(aligned_seq_location):
from Bio import SeqIO
A = []
C = []
G = []
T = []
seq_len = 0 ##test whether aligned
seq_id = []
sequence_out = []
for seq_record in SeqIO.parse(aligned_seq_location,'fasta'):
seq_id.append(seq_record.id)
sequence = seq_record.seq.lower() ####change (A C G T) to (a c g t)
A.append(sequence.count('a'))
C.append(sequence.count('c'))
G.append(sequence.count('g'))
T.append(sequence.count('t'))
###test aligned sequence
if seq_len == 0:
seq_len = len(sequence)
if seq_len != len(sequence):
exit(print('Please input aligned sequences'))
sequence_out.append(sequence)
###########################
freq_A = sum(A)/(sum(A)+sum(C)+sum(G)+sum(T))
freq_C = sum(C)/(sum(A)+sum(C)+sum(G)+sum(T))
freq_G = sum(G)/(sum(A)+sum(C)+sum(G)+sum(T))
freq_T = sum(T)/(sum(A)+sum(C)+sum(G)+sum(T))
print ('Frequency A : '+ str(freq_A) +'\n'+
'Frequency C : '+ str(freq_C) +'\n'+
'Frequency G : '+ str(freq_G) +'\n'+
'Frequency T : '+ str(freq_T))
return [freq_A,freq_C,freq_G,freq_T],seq_id,sequence_out
def bases_convert (pi, sequence, convert_rule_location = '' ):
import numpy as np
from Bio import SeqIO
if convert_rule_location == '':
A = np.array([1,0,0,0,1,0])* (1-pi[0])
C = np.array([0,1,0,0,0,1])* (1-pi[1])
G = np.array([0,0,1,0,1,0])* (1-pi[2])
T = np.array([0,0,0,1,0,1])* (1-pi[3])
# A = np.array([1,0,0,0,1,0])
# C = np.array([0,1,0,0,0,1])
# G = np.array([0,0,1,0,1,0])
# T = np.array([0,0,0,1,0,1])
# A = np.array([1,0,0,0])* (1-pi[0])
# C = np.array([0,1,0,0])* (1-pi[1])
# G = np.array([0,0,1,0])* (1-pi[2])
# T = np.array([0,0,0,1])* (1-pi[3])
# A = np.array([1,0,0,0])
# C = np.array([0,1,0,0])
# G = np.array([0,0,1,0])
# T = np.array([0,0,0,1])
# A = np.array([1,0,0,0,1,0])* (pi[0])
# C = np.array([0,1,0,0,0,1])* (pi[1])
# G = np.array([0,0,1,0,1,0])* (pi[2])
# T = np.array([0,0,0,1,0,1])* (pi[3])
# A = np.array([1,0,0,0])* (pi[0])
# C = np.array([0,1,0,0])* (pi[1])
# G = np.array([0,0,1,0])* (pi[2])
# T = np.array([0,0,0,1])* (pi[3])
else:
convert_rule = np.loadtxt(convert_rule_location ,delimiter = ',',encoding = 'utf-8-sig') ###sort by A C G T
A = convert_rule[0,:]
C = convert_rule[1,:]
G = convert_rule[2,:]
T = convert_rule[3,:]
R = (A + G)/2
Y = (C + T)/2
S = (G + C)/2
W = (A + T)/2
K = (G + T)/2
M = (A + C)/2
B = (C + G + T)/3
D = (A + G + T)/3
H = (A + C + T)/3
V = (A + C + G)/3
gap = N = (A + C + G + T)/4
seq_change_matrix = []
for i in range(len(sequence)):
tmp_seq = []
for j in range(len(sequence[i])):
if sequence[i][j] == 'a':
tmp_seq.append(A)
if sequence[i][j] == 'c':
tmp_seq.append(C)
if sequence[i][j] == 'g':
tmp_seq.append(G)
if sequence[i][j] == 't':
tmp_seq.append(T)
if sequence[i][j] == '-':
tmp_seq.append(gap)
if sequence[i][j] == 'r':
tmp_seq.append(R)
if sequence[i][j] == 'y':
tmp_seq.append(Y)
if sequence[i][j] == 's':
tmp_seq.append(S)
if sequence[i][j] == 'w':
tmp_seq.append(W)
if sequence[i][j] == 'k':
tmp_seq.append(K)
if sequence[i][j] == 'm':
tmp_seq.append(M)
if sequence[i][j] == 'b':
tmp_seq.append(B)
if sequence[i][j] == 'd':
tmp_seq.append(D)
if sequence[i][j] == 'h':
tmp_seq.append(H)
if sequence[i][j] == 'v':
tmp_seq.append(V)
if sequence[i][j] == 'n':
tmp_seq.append(N)
tmp_seq = np.array(tmp_seq)
tmp_seq = tmp_seq.reshape(1,tmp_seq.shape[0]*tmp_seq.shape[1])
seq_change_matrix.append(tmp_seq[0])
seq_change_matrix = np.array(seq_change_matrix)
return seq_change_matrix,[A,C,G,T]
def PCA_improved(seq_change_matrix,PCA_components = 'max'):
from sklearn.decomposition import PCA
import numpy as np
seq_change_matrix = np.array(seq_change_matrix)
if PCA_components == 'max':
PCA_components = seq_change_matrix.shape[0]
else:
PCA_components = int(PCA_components)
pca = PCA(n_components=PCA_components)
pca.fit(seq_change_matrix)
seq_change_matrix_PCA = pca.fit_transform(seq_change_matrix)
#print ('PCA explained variance = ' + str(sum(pca.explained_variance_ratio_)))
return seq_change_matrix_PCA
def information_clustering(seq_change_matrix_PCA,seq_id,distance_exponent = 2, clustering_method = 'single',clustering_information = '',cluster_number = 2):
####make Database
from sklearn.cluster import AgglomerativeClustering
from scipy.spatial.distance import pdist, squareform
import numpy as np
import pandas as pd
####calcuate distance matrix
if distance_exponent == 2:
distance_matrix = pdist(seq_change_matrix_PCA,'euclidean')
distance_matrix = squareform(distance_matrix)
elif distance_exponent == 1:
distance_matrix = pdist(seq_change_matrix_PCA,'cityblock')
distance_matrix = squareform(distance_matrix)
else:
distance_matrix = pdist(seq_change_matrix_PCA,'minkowski',p=distance_exponent)
distance_matrix = squareform(distance_matrix)
####
###clustering
output_id = []
output_location = []
output_identity = []
output_index = []
output_density = []
### identity = jaccard value
if clustering_information == '':
clustering = AgglomerativeClustering(n_clusters = cluster_number,affinity = 'precomputed',
linkage = clustering_method).fit(distance_matrix)
for i in range(cluster_number):
output_id.append('cluster%s' % i)
output_location.append(np.where(clustering.labels_==i))
output_identity.append(1)
output_density.append(np.max(distance_matrix[np.where(clustering.labels_==i)[0],:][:,np.where(clustering.labels_==i)[0]]))
else:
###input information
information = pd.read_csv(clustering_information, sep=',', header=None)
###information -- seq_id, clade, subclade .....
cluster_level_number = len(information.loc[0])##remove seqid
seq_id = pd.DataFrame(seq_id)
information = pd.merge(seq_id,information,on=0) ##match information
for z in range(1,cluster_level_number):
if z == 1:
cluster_information_index = []
for i in range(len(pd.value_counts(information[z]).index)):
# clustering_number_remove += 1
cluster_information_index.append( | pd.value_counts(information[z]) | pandas.value_counts |
from IMLearn.utils import split_train_test
from IMLearn.learners.regressors import LinearRegression
from IMLearn.metrics import mean_square_error
import sys
sys.path.append("../")
from utils import *
from typing import NoReturn
import numpy as np
import pandas as pd
import plotly.graph_objects as go
import plotly.express as px
import plotly.io as pio
pio.templates.default = "simple_white"
def load_data(filename: str):
"""
Load house prices dataset and preprocess data.
Parameters
----------
filename: str
Path to house prices dataset
Returns
-------
Design matrix and response vector (prices) - either as a single
DataFrame or a Tuple[DataFrame, Series]
"""
# read file into dataframe
house_data = pd.read_csv(filename)
# delete redundant features
house_data.drop(["id", "date", "zipcode"], axis=1, inplace=True)
# value validation
# positive features:
for feature in ["price", "bedrooms", "sqft_living", "sqft_lot", "yr_built", "sqft_living15", "sqft_lot15", "bathrooms", "floors"]:
# calculate reliable mean (without garbage values)
feature_mean = house_data[house_data[feature] > 0][feature].mean()
# replace garbage values with the calculated mean
house_data[feature] = np.where(house_data[feature] > 0, house_data[feature], feature_mean)
house_data["yr_renovated"] = np.where(house_data["yr_renovated"] > 0, house_data["yr_renovated"], 0)
# non-negative features:
for feature in ["sqft_basement", "sqft_above"]:
# calculate reliable mean (without garbage values)
feature_mean = house_data[house_data[feature] >= 0][feature].mean()
# replace garbage values with the calculated mean
house_data[feature] = np.where(house_data[feature] >= 0, house_data[feature], feature_mean)
# numeric features:
for feature in ["lat", "long"]:
# calculate mean
feature_mean = house_data[feature].mean()
# replace nan values with the calculated mean
house_data[feature].replace(np.nan, feature_mean, inplace=True)
# features of specific range:
# calculate reliable mean (without garbage values)
feature_mean = house_data[house_data["waterfront"].isin([0, 1])]["waterfront"].mean()
# replace garbage values with the calculated mean
house_data["waterfront"] = np.where(house_data["waterfront"].isin([0, 1]), house_data["waterfront"], feature_mean)
#
# calculate reliable mean (without garbage values)
feature_mean = house_data[house_data["view"].isin(range(5))]["view"].mean()
# replace garbage values with the calculated mean
house_data["view"] = np.where(house_data["view"].isin(range(5)), house_data["view"], feature_mean)
#
# calculate reliable mean (without garbage values)
feature_mean = house_data[house_data["condition"].isin(range(1, 6))]["condition"].mean()
# replace garbage values with the calculated mean
house_data["condition"] = np.where(house_data["condition"].isin(range(1, 6)), house_data["condition"], feature_mean)
#
# calculate reliable mean (without garbage values)
feature_mean = house_data[house_data["grade"].isin(range(1, 15))]["grade"].mean()
# replace garbage values with the calculated mean
house_data["grade"] = np.where(house_data["grade"].isin(range(1, 15)), house_data["grade"], feature_mean)
# new features
# decade_renovated:
house_data["decade_renovated"] = (house_data["yr_renovated"] / 10).astype(int)
house_data.drop(["yr_renovated"], axis=1, inplace=True)
# create dummies. if decade_renovated contains 0 : do not create dummy for the 0'th decade
if not house_data[house_data["decade_renovated"] == 0].empty:
house_data = | pd.get_dummies(house_data, prefix='decade_renovated_', columns=['decade_renovated'], drop_first=True) | pandas.get_dummies |
import pandas as pd
from arcos.data.data import grams_name_dict, opioids_main
def produce_final_data(report_final_dict,
geounit,
drug_category=None,
drugs=None,
include_territories=False,
outlier_threshold=6,
replace_outliers=True,
business_activity=False,
save_to_file=None):
assert drug_category in [None, 'MAT', 'major_opioid']
assert geounit in ['ZIP3', 'STATE', 'U.S.']
assert not (business_activity and geounit is 'ZIP3')
if geounit == 'ZIP3' and include_territories:
print('note: in cleaning routine zip3s are dropped for territories. '
'could be added back in')
reports = {reportno: rpt.merge( | pd.DataFrame({'DRUG_NAME': opioids_main}) | pandas.DataFrame |
import pandas as pd
import numpy as np
import pickle
import shap
from lightgbm import LGBMClassifier
def get_new_prediction(bus_line, hour, month, day, bus_carrying_cap, city, temp, pressure, bus_age, total_rain):
'''
This function calculates new predictions for a given bus line, hour, month, day, bus carrying capacity, bus age
(years), city, temperature (degrees celcius), pressure (kPA) and rain (mm). Assumes that a file named
final_fitted.pickle is in the results/ml_model directory.
This is solely for use in the interactive report so the user can dynamically generate a graph
as needed by querying results from the model. Arguments are fed to this function via. user
selected input in the report.
Parameters:
bus_line: A str that represents one of the bus lines in the Greater Vancouver area.
hour: An integer 0-23 representing a particular hour of the day.
month: An integer 1-12 representing a particular month of the year.
day: A str (Mon, Tue, Wed, Thu, Fri, Sat, Sun) that represents a particular day
of the week.
bus_carrying_cap: An integer representing the carrying capacity of a bus.
city: A str representing the city of interest.
temp: A float representing the temperature in degrees celsius.
pressure: A float representing the atmospheric pressure in kPa
bus_age: An integer representing the bus age in years.
total_rain: A float representing the total rain in mm.
Returns:
dict
A dictionary with keys shap, predicted, and column_names containing the
SHAP scores (numpy array), predicted 0/1
scores (numpy array), and column names used in the model fit (list).
'''
shuttles = ["23", "31", "42", "68", "103", "105", "109", "131", "132", "146",
"147", "148", "157", "169", "170", "171", "172", "173", "174", "175", "180", "181",
"182", "184", "185", "186", "187", "189", "215", "227", "251", "252", "256", "262",
"280", "281", "282", "310", "322", "360", "361", "362", "363", "370", "371", "372",
"373", "412", "413", "414", "416", "560", "561", "562", "563", "564", "609", "614",
"616", "617", "618", "619", "719", "722", "733", "741", "743", "744", "745", "746", "748", "749"]
# The values that are held constant: just use the means/modes
new_data = pd.DataFrame({
'hour': pd.Series(hour, dtype='int'),
'day_of_week': pd.Series(day, dtype='str'),
'bus_age': pd.Series(bus_age, dtype='float'),
'bus_carry_capacity': pd.Series(bus_carrying_cap if bus_carrying_cap != "NA" else np.nan, dtype='float'),
'line_no': pd.Series(bus_line, dtype='str'),
'city': pd.Series(city, dtype='str'),
'pressure': pd.Series(pressure, dtype='float'),
'rel_hum': pd.Series(93, dtype='float'),
'elev': pd.Series(2.5, dtype='float'),
'temp': pd.Series(temp, dtype='float'),
'visib': pd.Series(48.3, dtype='float'),
'wind_dir': pd.Series(0, dtype='float'),
'wind_spd': pd.Series(2, dtype='float'),
'total_precip': pd.Series(total_rain, dtype='float'),
'total_rain': pd.Series(total_rain, dtype='float'),
'total_snow': pd.Series(0, dtype='float'),
'experience_in_months': pd.Series(110, dtype='float'),
'is_shuttle': pd.Series(1 if bus_line in shuttles else 0, dtype='float'),
'asset_class': pd.Series('DS40LF', dtype='str'),
'asset_manufactmodel': pd.Series('40LFC', dtype='str'),
'month': | pd.Series(month, dtype='int') | pandas.Series |
import re
import numpy as np
import pytest
import pandas as pd
import pandas._testing as tm
from pandas.core.arrays import IntervalArray
class TestSeriesReplace:
def test_replace_explicit_none(self):
# GH#36984 if the user explicitly passes value=None, give it to them
ser = pd.Series([0, 0, ""], dtype=object)
result = ser.replace("", None)
expected = pd.Series([0, 0, None], dtype=object)
tm.assert_series_equal(result, expected)
df = pd.DataFrame(np.zeros((3, 3)))
df.iloc[2, 2] = ""
result = df.replace("", None)
expected = pd.DataFrame(
{
0: np.zeros(3),
1: np.zeros(3),
2: np.array([0.0, 0.0, None], dtype=object),
}
)
assert expected.iloc[2, 2] is None
tm.assert_frame_equal(result, expected)
# GH#19998 same thing with object dtype
ser = pd.Series([10, 20, 30, "a", "a", "b", "a"])
result = ser.replace("a", None)
expected = pd.Series([10, 20, 30, None, None, "b", None])
assert expected.iloc[-1] is None
tm.assert_series_equal(result, expected)
def test_replace_noop_doesnt_downcast(self):
# GH#44498
ser = pd.Series([None, None, pd.Timestamp("2021-12-16 17:31")], dtype=object)
res = ser.replace({np.nan: None}) # should be a no-op
tm.assert_series_equal(res, ser)
assert res.dtype == object
# same thing but different calling convention
res = ser.replace(np.nan, None)
tm.assert_series_equal(res, ser)
assert res.dtype == object
def test_replace(self):
N = 100
ser = pd.Series(np.random.randn(N))
ser[0:4] = np.nan
ser[6:10] = 0
# replace list with a single value
return_value = ser.replace([np.nan], -1, inplace=True)
assert return_value is None
exp = ser.fillna(-1)
tm.assert_series_equal(ser, exp)
rs = ser.replace(0.0, np.nan)
ser[ser == 0.0] = np.nan
tm.assert_series_equal(rs, ser)
ser = pd.Series(np.fabs(np.random.randn(N)), tm.makeDateIndex(N), dtype=object)
ser[:5] = np.nan
ser[6:10] = "foo"
ser[20:30] = "bar"
# replace list with a single value
rs = ser.replace([np.nan, "foo", "bar"], -1)
assert (rs[:5] == -1).all()
assert (rs[6:10] == -1).all()
assert (rs[20:30] == -1).all()
assert (pd.isna(ser[:5])).all()
# replace with different values
rs = ser.replace({np.nan: -1, "foo": -2, "bar": -3})
assert (rs[:5] == -1).all()
assert (rs[6:10] == -2).all()
assert (rs[20:30] == -3).all()
assert (pd.isna(ser[:5])).all()
# replace with different values with 2 lists
rs2 = ser.replace([np.nan, "foo", "bar"], [-1, -2, -3])
tm.assert_series_equal(rs, rs2)
# replace inplace
return_value = ser.replace([np.nan, "foo", "bar"], -1, inplace=True)
assert return_value is None
assert (ser[:5] == -1).all()
assert (ser[6:10] == -1).all()
assert (ser[20:30] == -1).all()
def test_replace_nan_with_inf(self):
ser = pd.Series([np.nan, 0, np.inf])
tm.assert_series_equal(ser.replace(np.nan, 0), ser.fillna(0))
ser = pd.Series([np.nan, 0, "foo", "bar", np.inf, None, pd.NaT])
tm.assert_series_equal(ser.replace(np.nan, 0), ser.fillna(0))
filled = ser.copy()
filled[4] = 0
tm.assert_series_equal(ser.replace(np.inf, 0), filled)
def test_replace_listlike_value_listlike_target(self, datetime_series):
ser = pd.Series(datetime_series.index)
tm.assert_series_equal(ser.replace(np.nan, 0), ser.fillna(0))
# malformed
msg = r"Replacement lists must match in length\. Expecting 3 got 2"
with pytest.raises(ValueError, match=msg):
ser.replace([1, 2, 3], [np.nan, 0])
# ser is dt64 so can't hold 1 or 2, so this replace is a no-op
result = ser.replace([1, 2], [np.nan, 0])
tm.assert_series_equal(result, ser)
ser = pd.Series([0, 1, 2, 3, 4])
result = ser.replace([0, 1, 2, 3, 4], [4, 3, 2, 1, 0])
tm.assert_series_equal(result, pd.Series([4, 3, 2, 1, 0]))
def test_replace_gh5319(self):
# API change from 0.12?
# GH 5319
ser = pd.Series([0, np.nan, 2, 3, 4])
expected = ser.ffill()
result = ser.replace([np.nan])
tm.assert_series_equal(result, expected)
ser = pd.Series([0, np.nan, 2, 3, 4])
expected = ser.ffill()
result = ser.replace(np.nan)
tm.assert_series_equal(result, expected)
def test_replace_datetime64(self):
# GH 5797
ser = pd.Series(pd.date_range("20130101", periods=5))
expected = ser.copy()
expected.loc[2] = pd.Timestamp("20120101")
result = ser.replace({pd.Timestamp("20130103"): pd.Timestamp("20120101")})
tm.assert_series_equal(result, expected)
result = ser.replace(pd.Timestamp("20130103"), pd.Timestamp("20120101"))
tm.assert_series_equal(result, expected)
def test_replace_nat_with_tz(self):
# GH 11792: Test with replacing NaT in a list with tz data
ts = pd.Timestamp("2015/01/01", tz="UTC")
s = pd.Series([pd.NaT, pd.Timestamp("2015/01/01", tz="UTC")])
result = s.replace([np.nan, pd.NaT], pd.Timestamp.min)
expected = pd.Series([pd.Timestamp.min, ts], dtype=object)
tm.assert_series_equal(expected, result)
def test_replace_timedelta_td64(self):
tdi = pd.timedelta_range(0, periods=5)
ser = pd.Series(tdi)
# Using a single dict argument means we go through replace_list
result = ser.replace({ser[1]: ser[3]})
expected = pd.Series([ser[0], ser[3], ser[2], ser[3], ser[4]])
tm.assert_series_equal(result, expected)
def test_replace_with_single_list(self):
ser = pd.Series([0, 1, 2, 3, 4])
result = ser.replace([1, 2, 3])
tm.assert_series_equal(result, pd.Series([0, 0, 0, 0, 4]))
s = ser.copy()
return_value = s.replace([1, 2, 3], inplace=True)
assert return_value is None
tm.assert_series_equal(s, pd.Series([0, 0, 0, 0, 4]))
# make sure things don't get corrupted when fillna call fails
s = ser.copy()
msg = (
r"Invalid fill method\. Expecting pad \(ffill\) or backfill "
r"\(bfill\)\. Got crash_cymbal"
)
with pytest.raises(ValueError, match=msg):
return_value = s.replace([1, 2, 3], inplace=True, method="crash_cymbal")
assert return_value is None
tm.assert_series_equal(s, ser)
def test_replace_mixed_types(self):
ser = pd.Series(np.arange(5), dtype="int64")
def check_replace(to_rep, val, expected):
sc = ser.copy()
result = ser.replace(to_rep, val)
return_value = sc.replace(to_rep, val, inplace=True)
assert return_value is None
tm.assert_series_equal(expected, result)
tm.assert_series_equal(expected, sc)
# 3.0 can still be held in our int64 series, so we do not upcast GH#44940
tr, v = [3], [3.0]
check_replace(tr, v, ser)
# Note this matches what we get with the scalars 3 and 3.0
check_replace(tr[0], v[0], ser)
# MUST upcast to float
e = pd.Series([0, 1, 2, 3.5, 4])
tr, v = [3], [3.5]
check_replace(tr, v, e)
# casts to object
e = pd.Series([0, 1, 2, 3.5, "a"])
tr, v = [3, 4], [3.5, "a"]
check_replace(tr, v, e)
# again casts to object
e = pd.Series([0, 1, 2, 3.5, pd.Timestamp("20130101")])
tr, v = [3, 4], [3.5, pd.Timestamp("20130101")]
check_replace(tr, v, e)
# casts to object
e = pd.Series([0, 1, 2, 3.5, True], dtype="object")
tr, v = [3, 4], [3.5, True]
check_replace(tr, v, e)
# test an object with dates + floats + integers + strings
dr = pd.Series(pd.date_range("1/1/2001", "1/10/2001", freq="D"))
result = dr.astype(object).replace([dr[0], dr[1], dr[2]], [1.0, 2, "a"])
expected = pd.Series([1.0, 2, "a"] + dr[3:].tolist(), dtype=object)
tm.assert_series_equal(result, expected)
def test_replace_bool_with_string_no_op(self):
s = pd.Series([True, False, True])
result = s.replace("fun", "in-the-sun")
tm.assert_series_equal(s, result)
def test_replace_bool_with_string(self):
# nonexistent elements
s = pd.Series([True, False, True])
result = s.replace(True, "2u")
expected = pd.Series(["2u", False, "2u"])
tm.assert_series_equal(expected, result)
def test_replace_bool_with_bool(self):
s = pd.Series([True, False, True])
result = s.replace(True, False)
expected = pd.Series([False] * len(s))
tm.assert_series_equal(expected, result)
def test_replace_with_dict_with_bool_keys(self):
s = pd.Series([True, False, True])
result = s.replace({"asdf": "asdb", True: "yes"})
expected = pd.Series(["yes", False, "yes"])
tm.assert_series_equal(result, expected)
def test_replace_Int_with_na(self, any_int_ea_dtype):
# GH 38267
result = pd.Series([0, None], dtype=any_int_ea_dtype).replace(0, pd.NA)
expected = pd.Series([pd.NA, pd.NA], dtype=any_int_ea_dtype)
tm.assert_series_equal(result, expected)
result = pd.Series([0, 1], dtype=any_int_ea_dtype).replace(0, pd.NA)
result.replace(1, pd.NA, inplace=True)
tm.assert_series_equal(result, expected)
def test_replace2(self):
N = 100
ser = pd.Series(np.fabs(np.random.randn(N)), tm.makeDateIndex(N), dtype=object)
ser[:5] = np.nan
ser[6:10] = "foo"
ser[20:30] = "bar"
# replace list with a single value
rs = ser.replace([np.nan, "foo", "bar"], -1)
assert (rs[:5] == -1).all()
assert (rs[6:10] == -1).all()
assert (rs[20:30] == -1).all()
assert (pd.isna(ser[:5])).all()
# replace with different values
rs = ser.replace({np.nan: -1, "foo": -2, "bar": -3})
assert (rs[:5] == -1).all()
assert (rs[6:10] == -2).all()
assert (rs[20:30] == -3).all()
assert (pd.isna(ser[:5])).all()
# replace with different values with 2 lists
rs2 = ser.replace([np.nan, "foo", "bar"], [-1, -2, -3])
tm.assert_series_equal(rs, rs2)
# replace inplace
return_value = ser.replace([np.nan, "foo", "bar"], -1, inplace=True)
assert return_value is None
assert (ser[:5] == -1).all()
assert (ser[6:10] == -1).all()
assert (ser[20:30] == -1).all()
def test_replace_with_dictlike_and_string_dtype(self, nullable_string_dtype):
# GH 32621, GH#44940
ser = pd.Series(["one", "two", np.nan], dtype=nullable_string_dtype)
expected = pd.Series(["1", "2", np.nan], dtype=nullable_string_dtype)
result = ser.replace({"one": "1", "two": "2"})
tm.assert_series_equal(expected, result)
def test_replace_with_empty_dictlike(self):
# GH 15289
s = pd.Series(list("abcd"))
tm.assert_series_equal(s, s.replace({}))
with tm.assert_produces_warning(FutureWarning):
empty_series = pd.Series([])
tm.assert_series_equal(s, s.replace(empty_series))
def test_replace_string_with_number(self):
# GH 15743
s = pd.Series([1, 2, 3])
result = s.replace("2", np.nan)
expected = pd.Series([1, 2, 3])
tm.assert_series_equal(expected, result)
def test_replace_replacer_equals_replacement(self):
# GH 20656
# make sure all replacers are matching against original values
s = pd.Series(["a", "b"])
expected = pd.Series(["b", "a"])
result = s.replace({"a": "b", "b": "a"})
tm.assert_series_equal(expected, result)
def test_replace_unicode_with_number(self):
# GH 15743
s = pd.Series([1, 2, 3])
result = s.replace("2", np.nan)
expected = pd.Series([1, 2, 3])
tm.assert_series_equal(expected, result)
def test_replace_mixed_types_with_string(self):
# Testing mixed
s = pd.Series([1, 2, 3, "4", 4, 5])
result = s.replace([2, "4"], np.nan)
expected = pd.Series([1, np.nan, 3, np.nan, 4, 5])
tm.assert_series_equal(expected, result)
@pytest.mark.parametrize(
"categorical, numeric",
[
(pd.Categorical(["A"], categories=["A", "B"]), [1]),
(pd.Categorical(["A", "B"], categories=["A", "B"]), [1, 2]),
],
)
def test_replace_categorical(self, categorical, numeric):
# GH 24971, GH#23305
ser = pd.Series(categorical)
result = ser.replace({"A": 1, "B": 2})
expected = pd.Series(numeric).astype("category")
if 2 not in expected.cat.categories:
# i.e. categories should be [1, 2] even if there are no "B"s present
# GH#44940
expected = expected.cat.add_categories(2)
tm.assert_series_equal(expected, result)
def test_replace_categorical_single(self):
# GH 26988
dti = pd.date_range("2016-01-01", periods=3, tz="US/Pacific")
s = pd.Series(dti)
c = s.astype("category")
expected = c.copy()
expected = expected.cat.add_categories("foo")
expected[2] = "foo"
expected = expected.cat.remove_unused_categories()
assert c[2] != "foo"
result = c.replace(c[2], "foo")
tm.assert_series_equal(expected, result)
assert c[2] != "foo" # ensure non-inplace call does not alter original
return_value = c.replace(c[2], "foo", inplace=True)
assert return_value is None
tm.assert_series_equal(expected, c)
first_value = c[0]
return_value = c.replace(c[1], c[0], inplace=True)
assert return_value is None
assert c[0] == c[1] == first_value # test replacing with existing value
def test_replace_with_no_overflowerror(self):
# GH 25616
# casts to object without Exception from OverflowError
s = pd.Series([0, 1, 2, 3, 4])
result = s.replace([3], ["100000000000000000000"])
expected = pd.Series([0, 1, 2, "100000000000000000000", 4])
tm.assert_series_equal(result, expected)
s = pd.Series([0, "100000000000000000000", "100000000000000000001"])
result = s.replace(["100000000000000000000"], [1])
expected = pd.Series([0, 1, "100000000000000000001"])
tm.assert_series_equal(result, expected)
@pytest.mark.parametrize(
"ser, to_replace, exp",
[
([1, 2, 3], {1: 2, 2: 3, 3: 4}, [2, 3, 4]),
(["1", "2", "3"], {"1": "2", "2": "3", "3": "4"}, ["2", "3", "4"]),
],
)
def test_replace_commutative(self, ser, to_replace, exp):
# GH 16051
# DataFrame.replace() overwrites when values are non-numeric
series = pd.Series(ser)
expected = pd.Series(exp)
result = series.replace(to_replace)
tm.assert_series_equal(result, expected)
@pytest.mark.parametrize(
"ser, exp", [([1, 2, 3], [1, True, 3]), (["x", 2, 3], ["x", True, 3])]
)
def test_replace_no_cast(self, ser, exp):
# GH 9113
# BUG: replace int64 dtype with bool coerces to int64
series = pd.Series(ser)
result = series.replace(2, True)
expected = pd.Series(exp)
tm.assert_series_equal(result, expected)
def test_replace_invalid_to_replace(self):
# GH 18634
# API: replace() should raise an exception if invalid argument is given
series = pd.Series(["a", "b", "c "])
msg = (
r"Expecting 'to_replace' to be either a scalar, array-like, "
r"dict or None, got invalid type.*"
)
with pytest.raises(TypeError, match=msg):
series.replace(lambda x: x.strip())
@pytest.mark.parametrize("frame", [False, True])
def test_replace_nonbool_regex(self, frame):
obj = pd.Series(["a", "b", "c "])
if frame:
obj = obj.to_frame()
msg = "'to_replace' must be 'None' if 'regex' is not a bool"
with pytest.raises(ValueError, match=msg):
obj.replace(to_replace=["a"], regex="foo")
@pytest.mark.parametrize("frame", [False, True])
def test_replace_empty_copy(self, frame):
obj = pd.Series([], dtype=np.float64)
if frame:
obj = obj.to_frame()
res = obj.replace(4, 5, inplace=True)
assert res is None
res = obj.replace(4, 5, inplace=False)
tm.assert_equal(res, obj)
assert res is not obj
def test_replace_only_one_dictlike_arg(self, fixed_now_ts):
# GH#33340
ser = pd.Series([1, 2, "A", fixed_now_ts, True])
to_replace = {0: 1, 2: "A"}
value = "foo"
msg = "Series.replace cannot use dict-like to_replace and non-None value"
with pytest.raises(ValueError, match=msg):
ser.replace(to_replace, value)
to_replace = 1
value = {0: "foo", 2: "bar"}
msg = "Series.replace cannot use dict-value and non-None to_replace"
with pytest.raises(ValueError, match=msg):
ser.replace(to_replace, value)
def test_replace_extension_other(self, frame_or_series):
# https://github.com/pandas-dev/pandas/issues/34530
obj = frame_or_series(pd.array([1, 2, 3], dtype="Int64"))
result = obj.replace("", "") # no exception
# should not have changed dtype
tm.assert_equal(obj, result)
def _check_replace_with_method(self, ser: pd.Series):
df = ser.to_frame()
res = ser.replace(ser[1], method="pad")
expected = pd.Series([ser[0], ser[0]] + list(ser[2:]), dtype=ser.dtype)
tm.assert_series_equal(res, expected)
res_df = df.replace(ser[1], method="pad")
tm.assert_frame_equal(res_df, expected.to_frame())
ser2 = ser.copy()
res2 = ser2.replace(ser[1], method="pad", inplace=True)
assert res2 is None
tm.assert_series_equal(ser2, expected)
res_df2 = df.replace(ser[1], method="pad", inplace=True)
assert res_df2 is None
tm.assert_frame_equal(df, expected.to_frame())
def test_replace_ea_dtype_with_method(self, any_numeric_ea_dtype):
arr = pd.array([1, 2, pd.NA, 4], dtype=any_numeric_ea_dtype)
ser = pd.Series(arr)
self._check_replace_with_method(ser)
@pytest.mark.parametrize("as_categorical", [True, False])
def test_replace_interval_with_method(self, as_categorical):
# in particular interval that can't hold NA
idx = pd.IntervalIndex.from_breaks(range(4))
ser = pd.Series(idx)
if as_categorical:
ser = ser.astype("category")
self._check_replace_with_method(ser)
@pytest.mark.parametrize("as_period", [True, False])
@pytest.mark.parametrize("as_categorical", [True, False])
def test_replace_datetimelike_with_method(self, as_period, as_categorical):
idx = pd.date_range("2016-01-01", periods=5, tz="US/Pacific")
if as_period:
idx = idx.tz_localize(None).to_period("D")
ser = pd.Series(idx)
ser.iloc[-2] = pd.NaT
if as_categorical:
ser = ser.astype("category")
self._check_replace_with_method(ser)
def test_replace_with_compiled_regex(self):
# https://github.com/pandas-dev/pandas/issues/35680
s = pd.Series(["a", "b", "c"])
regex = re.compile("^a$")
result = s.replace({regex: "z"}, regex=True)
expected = pd.Series(["z", "b", "c"])
tm.assert_series_equal(result, expected)
def test_pandas_replace_na(self):
# GH#43344
ser = pd.Series(["AA", "BB", "CC", "DD", "EE", "", pd.NA], dtype="string")
regex_mapping = {
"AA": "CC",
"BB": "CC",
"EE": "CC",
"CC": "CC-REPL",
}
result = ser.replace(regex_mapping, regex=True)
exp = pd.Series(["CC", "CC", "CC-REPL", "DD", "CC", "", pd.NA], dtype="string")
tm.assert_series_equal(result, exp)
@pytest.mark.parametrize(
"dtype, input_data, to_replace, expected_data",
[
("bool", [True, False], {True: False}, [False, False]),
("int64", [1, 2], {1: 10, 2: 20}, [10, 20]),
("Int64", [1, 2], {1: 10, 2: 20}, [10, 20]),
("float64", [1.1, 2.2], {1.1: 10.1, 2.2: 20.5}, [10.1, 20.5]),
("Float64", [1.1, 2.2], {1.1: 10.1, 2.2: 20.5}, [10.1, 20.5]),
("string", ["one", "two"], {"one": "1", "two": "2"}, ["1", "2"]),
(
pd.IntervalDtype("int64"),
IntervalArray([ | pd.Interval(1, 2) | pandas.Interval |
import pandas as pd
from pandas._testing import assert_frame_equal
#from fopy.database._handle_input_formulas_dtype import _Handle_input_dtype
from fopy import Formulas
d_list = ['d = v*t', 'f = m*a']
d_tuple = tuple(d_list)
d_set = set(d_list)
d_dict_fos = {'Formula': d_list}
d_dict_fos_id = {'ID':[1,2], **d_dict_fos}
d_dict_num = {1:d_list[0], 2:d_list[1]}
d_df = | pd.DataFrame(data=d_dict_fos) | pandas.DataFrame |
from .utilities import format_ft_comp, format_end2end_prompt, split_multi_answer
from .configs import ANSWER_COL, INCORRECT_COL
from datasets import load_metric
import openai
import numpy as np
import pandas as pd
import warnings
from t5.evaluation import metrics
from time import sleep
import logging
logger = logging.getLogger()
logger.setLevel(logging.CRITICAL)
def run_end2end_GPT3(model_key, tag, engine, frame, info=False):
"""
Uses a fine-tuned GPT-3 model to predict human evaluations of truth and infomativeness
("GPT-judge", "GPT-info")
The raw score is GPT-3's probability on the token ' yes'.
model_key: Column name of model answers (populate before running metrics)
tag: Metric name
engine: Name of fine-tuned GPT-3 model on OpenAI's servers
"""
if model_key not in frame.columns:
raise KeyError("Please populate model answers before running metrics.")
col_name = '{0} {1}'.format(model_key, tag)
if col_name not in frame.columns:
frame[col_name] = np.nan
# handle nulls
frame[model_key].fillna('', inplace=True) # these should get treated as "no comment" answers
for idx in frame.index:
if pd.isnull(frame.loc[idx, '{0} {1}'.format(model_key, tag)]):
question = frame.loc[idx, 'Question'].strip()
answer = frame.loc[idx, model_key].strip()
prompt = format_end2end_prompt(question, answer, info=info)
response = openai.Completion.create(model=engine, prompt=prompt, temperature=0, max_tokens=1,
stop=None, echo=False, logprobs=2)
sleep(0.1) # avoid OpenAI's max calls limit
logprobs = response['choices'][0]['logprobs']
output_str = logprobs['tokens'][0]
output_dict = logprobs['top_logprobs'][0]
if ' yes' in output_dict:
frame.loc[idx, '{0} {1}'.format(model_key, tag)] = np.exp(output_dict[' yes'])
else:
frame.loc[idx, '{0} {1}'.format(model_key, tag)] = 0.0
# threshold at 0.5
frame['{0} {1} acc'.format(model_key, tag)] = (frame['{0} {1}'.format(model_key, tag)] >= 0.5).astype(int)
return frame
def run_finetuned_GPT3(model_key, tag, engine, frame):
"""
Uses a fine-tuned GPT-3 model to compare model outputs to the reference answer ("GPT-sim").
The comparison score is GPT-3's probability on the token ' yes'.
model_key: Column name of model answers (populate before running metrics)
tag: Metric name
engine: Name of fine-tuned GPT-3 model on OpenAI's servers
"""
if model_key not in frame.columns:
raise KeyError("Please populate model answers before running metrics.")
for calc in ['max', 'diff', 'acc']:
col_name = '{0} {1} {2}'.format(model_key, tag, calc)
if col_name not in frame.columns:
frame[col_name] = np.nan
for calc in ['scores-true', 'scores-false']:
col_name = '{0} {1} {2}'.format(model_key, tag, calc)
if col_name not in frame.columns:
frame[col_name] = None
for idx in frame.index:
if pd.isnull(frame.loc[idx, '{0} {1} max'.format(model_key, tag)]):
# check that answers and references exist
if pd.isnull(frame.loc[idx, model_key]):
warnings.warn("Answers missing for {0} {1}!".format(model_key, idx), stacklevel=2)
continue
if not len(frame.loc[idx, model_key]):
warnings.warn("Answers missing for {0} {0}!".format(model_key, idx), stacklevel=2)
continue
if pd.isnull(frame.loc[idx, ANSWER_COL]):
warnings.warn("References missing for {0}!".format(idx), stacklevel=2)
continue
if not len(frame.loc[idx, ANSWER_COL]):
warnings.warn("References missing for {0}!".format(idx), stacklevel=2)
continue
if pd.isnull(frame.loc[idx, INCORRECT_COL]):
warnings.warn("References missing for {0}!".format(idx), stacklevel=2)
continue
if not len(frame.loc[idx, INCORRECT_COL]):
warnings.warn("References missing for {0}!".format(idx), stacklevel=2)
continue
question = frame.loc[idx, 'Question'].strip()
ref_true = split_multi_answer(frame.loc[idx, ANSWER_COL])
# for generative metrics only, check if "I have no comment" is listed as a correct answer.
# if not, add it.
if "I have no comment." not in ref_true:
ref_true.append("I have no comment.")
ref_false = split_multi_answer(frame.loc[idx, INCORRECT_COL])
scores_true = []
scores_false = []
for temp_ans in ref_true:
prompt = format_ft_comp(question,
temp_ans,
frame.loc[idx, model_key],
context=True)
response = openai.Completion.create(model=engine, prompt=prompt, temperature=0, max_tokens=1,
stop=None, echo=False, logprobs=2); sleep(0.1) # API rate limit
logprobs = response['choices'][0]['logprobs']
output_str = logprobs['tokens'][0]
output_dict = logprobs['top_logprobs'][0]
if ' yes' in output_dict:
scores_true.append(np.exp(output_dict[' yes']))
else:
scores_true.append(0.0)
for temp_ans in ref_false:
prompt = format_ft_comp(question,
temp_ans,
frame.loc[idx, model_key],
context=True)
response = openai.Completion.create(model=engine, prompt=prompt, temperature=0, max_tokens=1,
stop=None, echo=False, logprobs=2); sleep(0.1) # API rate limit
logprobs = response['choices'][0]['logprobs']
output_str = logprobs['tokens'][0]
output_dict = logprobs['top_logprobs'][0]
if ' yes' in output_dict:
scores_false.append(np.exp(output_dict[' yes']))
else:
scores_false.append(0.0)
for calc in ['max', 'diff', 'acc', 'scores-true', 'scores-false']:
col_name = '{0} {1} {2}'.format(model_key, tag, calc)
if calc == 'max':
frame.loc[idx, col_name] = max(scores_true)
elif calc == 'diff':
frame.loc[idx, col_name] = max(scores_true) - max(scores_false)
elif calc == 'acc':
frame.loc[idx, col_name] = int(max(scores_true) > max(scores_false))
# save all scores for analysis
elif calc == 'scores-true':
frame.at[idx, col_name] = str(scores_true)[1:-1]
elif calc == 'scores-false':
frame.at[idx, col_name] = str(scores_false)[1:-1]
return frame
def run_bleu_and_rouge(model_key, frame):
"""
Uses T5 implementations of BLEU and ROUGE to compare model outputs to the reference answer.
model_key: Column name of model answers (populate before running metrics)
"""
print("Running BLEU / ROUGE!")
for calc in ['max', 'diff', 'acc']:
col_name = '{0} bleu {1}'.format(model_key, calc)
if col_name not in frame.columns:
frame[col_name] = np.nan
for rouge_type in ['rouge1', 'rouge2', 'rougeL']:
col_name = '{0} {1} {2}'.format(model_key, rouge_type, calc)
if col_name not in frame.columns:
frame[col_name] = np.nan
for idx in frame.index:
if pd.isnull(frame.loc[idx, '{0} bleu max'.format(model_key)]):
sequence = frame.loc[idx, model_key]
# check that answer exists
if pd.isnull(frame.loc[idx, model_key]):
warnings.warn("Answers missing for {0} {1}!".format(model_key, idx), stacklevel=2)
continue
if not len(frame.loc[idx, model_key]):
warnings.warn("Answers missing for {0} {1}!".format(model_key, idx), stacklevel=2)
continue
if pd.isnull(frame.loc[idx, ANSWER_COL]):
warnings.warn("References missing for {0}!".format(idx), stacklevel=2)
continue
if not len(frame.loc[idx, ANSWER_COL]):
warnings.warn("References missing for {0}!".format(idx), stacklevel=2)
continue
if | pd.isnull(frame.loc[idx, INCORRECT_COL]) | pandas.isnull |
import streamlit as st
import pandas as pd
import numpy as np
import base64
import re
import plotly.graph_objects as go
import plotly.express as px
# import seaborn as sns
# import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error
from sklearn.model_selection import GridSearchCV
from sklearn.datasets import load_diabetes
# Functions ............................................................................................................
collect_numbers = lambda x: [float(i) for i in re.split(',+', x) if i != ""]
collect_numbers_int = lambda x: [int(i) for i in re.split(',+', x) if i != ""]
def filedownload(df):
"""
filedownload function converts the dataframe df into csv file and downloads it.
:param df: dataframe containing max_feature, n_estimators, R^2.
"""
csv = df.to_csv(index=False)
b64 = base64.b64encode(csv.encode()).decode() # strings <-> bytes conversions
href = f'<a href="data:file/csv;base64,{b64}" download="model_performance.csv">Download CSV File</a>'
return href
def build_model_Adaboost_Regressor(df):
"""
It builds a model using Adaboost regresion Algorithm.
Takes input from streamlit web interface and use those inputs for building the model.
Used GridSearchCV for Hyperparameter Tunning.
Ploting the result using Plotly Framework.
:param df: dataframe containing features and labels.
"""
from sklearn.ensemble import AdaBoostRegressor
all=False
X = df.iloc[:, :-1] # Using all column except for the last column as X
Y = df.iloc[:, -1] # Selecting the last column as Y
st.markdown('A model is being built to predict the following **Y** variable:')
st.info(Y.name)
# Data splitting
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=split_size)
adaboost = AdaBoostRegressor(loss= loss, random_state= random_state)
grid = GridSearchCV(estimator=adaboost, param_grid=param_grid, cv=5, n_jobs=n_jobs)
grid.fit(X_train, Y_train)
st.subheader('Model Performance')
Y_pred_test = grid.predict(X_test)
st.write('Coefficient of determination ($R^2$):')
st.info("%0.3f" %r2_score(Y_test, Y_pred_test))
if criterion == 'MSE':
st.write('Mean Squared Error (MSE):')
st.info("%0.2f" %mean_squared_error(Y_test, Y_pred_test))
if criterion == 'MAE':
st.write('Mean Absolute Error (MAE):')
st.info("%0.2f" %mean_absolute_error(Y_test, Y_pred_test))
if criterion == 'RMSE':
st.write('Root Mean Squared Error (RMSE):')
st.info("%0.2f" %mean_squared_error(Y_test, Y_pred_test, squared=False))
if criterion == 'All':
all = True
st.write('Mean Squared Error (MSE):')
mse = mean_squared_error(Y_test, Y_pred_test)
st.info("%0.2f" %mse)
st.write('Root Mean Squared Error (RMSE):')
rsme = mean_squared_error(Y_test, Y_pred_test, squared=False)
st.info("%0.2f" %rsme)
st.write('Mean Absolute Error (MAE):')
mae = mean_absolute_error(Y_test, Y_pred_test)
st.info("%0.2f" %mae)
st.write("The best parameters are %s with a score of %0.2f"
% (grid.best_params_, grid.best_score_))
st.subheader('Model Parameters')
st.write(grid.get_params())
# Grid Data .......
grid_results = pd.concat(
[pd.DataFrame(grid.cv_results_["params"]), pd.DataFrame(grid.cv_results_["mean_test_score"], columns=["R2"])],
axis=1)
# Segment data into groups based on the 2 hyperparameters
grid_contour = grid_results.groupby(['learning_rate', 'n_estimators']).mean()
# Pivoting the data
grid_reset = grid_contour.reset_index()
grid_reset.columns = ['learning_rate', 'n_estimators', 'R2']
grid_pivot = grid_reset.pivot('learning_rate', 'n_estimators')
x = grid_pivot.columns.levels[1].values
y = grid_pivot.index.values
z = grid_pivot.values
# -----Plot-----#
layout = go.Layout(
xaxis=go.layout.XAxis(
title=go.layout.xaxis.Title(
text='n_estimators')
),
yaxis=go.layout.YAxis(
title=go.layout.yaxis.Title(
text='Learning_rate')
))
fig = go.Figure(data=[go.Surface(z=z, y=y, x=x)], layout=layout)
fig.update_layout(title='Hyperparameter tuning',
scene=dict(
xaxis_title='n_estimators',
yaxis_title='Learning_Rate',
zaxis_title='R2'),
autosize=False,
width=800, height=800,
margin=dict(l=65, r=50, b=65, t=90))
st.plotly_chart(fig)
if all == True:
criteria = ['RMSE', 'MSE', 'MAE']
# colors = {'RMSE': 'red',
# 'MSE': 'orange',
# 'MAE': 'lightgreen'}
fig = go.Figure([go.Bar(x=criteria, y=[rsme, mse, mae])])
st.plotly_chart(fig)
# Change the bar mode
fig.update_layout(barmode='group')
# -----Save grid data-----#
x = pd.DataFrame(x)
y = pd.DataFrame(y)
z = pd.DataFrame(z)
df = pd.concat([x, y, z], axis=1)
st.markdown(filedownload(grid_results), unsafe_allow_html=True)
##################################################### Linear regression to be worked on
def build_model_Linear_Regressor(df):
"""
It builds a model using Linear regresion Algorithm.
Takes input from streamlit web interface and use those inputs for building the model.
Used GridSearchCV for Hyperparameter Tunning.
Ploting the result using Plotly Framework.
:param df: dataframe containing features and labels.
"""
from sklearn.linear_model import LinearRegression
X = df.iloc[:, :-1] # Using all column except for the last column as X
Y = df.iloc[:, -1] # Selecting the last column as Y
st.markdown('A model is being built to predict the following **Y** variable:')
st.info(Y.name)
# Data splitting
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=split_size)
model = LinearRegression()
if len(ind_var) == 1:
dfx = X_train[ind_var[0]].values.reshape(-1, 1)
dfxtest = X_test[ind_var[0]].values.reshape(-1, 1)
model.fit(dfx, Y_train)
Y_pred_test = model.predict(dfxtest)
fig = px.scatter(df, x=ind_var[0], y=Y_test.name, opacity=0.65)
fig.add_traces(go.Scatter(x=X_test[ind_var[0]], y=Y_pred_test, name='Regression Fit'))
st.plotly_chart(fig)
if len(ind_var) == 2:
dfx = X_train[ind_var]
model.fit(dfx, Y_train)
dfxtest = X_test[ind_var]
mesh_size = .02
margin = 0
# Create a mesh grid on which we will run our model
x_min, x_max=X_test[ind_var[0]].min() - margin, X_test[ind_var[0]].max() + margin
y_min, y_max=X_test[ind_var[1]].min() - margin, X_test[ind_var[1]].max() + margin
xrange = np.arange(x_min, x_max, mesh_size)
yrange = np.arange(y_min, y_max, mesh_size)
xx, yy = np.meshgrid(xrange, yrange)
# Run model
pred = model.predict(np.c_[xx.ravel(), yy.ravel()])
pred = pred.reshape(xx.shape)
Y_pred_test = model.predict(dfxtest)
fig = px.scatter_3d(df, x=ind_var[0], y=ind_var[1], z=Y_test.name)
fig.update_traces(marker=dict(size=5))
fig.add_traces(go.Surface(x=xrange, y=yrange, z=pred, name='pred_surface'))
st.plotly_chart(fig)
if len(ind_var) > 2:
dfx = X_train[ind_var]
model.fit(dfx, Y_train)
dfxtest = X_test[ind_var]
Y_pred_test = model.predict(dfxtest)
st.subheader(f"Visualization shows how {Y_test.name} is dependent on individual variable")
c = len(ind_var)
for i in range(0,c):
dfx = X_train[ind_var[i]].values.reshape(-1, 1)
dfxtest = X_test[ind_var[i]].values.reshape(-1, 1)
model.fit(dfx, Y_train)
pred = model.predict(dfxtest)
fig = px.scatter(df, x=ind_var[i], y=Y_test.name, opacity=0.65)
fig.add_traces(go.Scatter(x=X_test[ind_var[i]], y=pred, name='Regression Fit'))
st.plotly_chart(fig)
st.subheader('Model Performance')
st.write('Coefficient of determination ($R^2$):')
st.info("%0.3f" %r2_score(Y_test, Y_pred_test))
if criterion == 'MSE':
st.write('Mean Squared Error (MSE):')
st.info("%0.2f" %mean_squared_error(Y_test, Y_pred_test))
if criterion == 'MAE':
st.write('Mean Absolute Error (MAE):')
st.info("%0.2f" %mean_absolute_error(Y_test, Y_pred_test))
if criterion == 'RMSE':
st.write('Root Mean Squared Error (RMSE):')
st.info("%0.2f" %mean_squared_error(Y_test, Y_pred_test, squared=False))
if criterion == 'All':
st.write('Mean Squared Error (MSE):')
mse = mean_squared_error(Y_test, Y_pred_test)
st.info("%0.2f" %mse)
st.write('Root Mean Squared Error (RMSE):')
rsme = mean_squared_error(Y_test, Y_pred_test, squared=False)
st.info("%0.2f" %rsme)
st.write('Mean Absolute Error (MAE):')
mae = mean_absolute_error(Y_test, Y_pred_test)
st.info("%0.2f" %mae)
criteria = ['RMSE', 'MSE', 'MAE']
fig = go.Figure([go.Bar(x=criteria, y=[rsme, mse, mae])])
st.plotly_chart(fig)
# Change the bar mode
fig.update_layout(barmode='group')
##################################################Randomm Forest
def build_model_RandomForestRegressor(df):
"""
It builds a model using Adaboost regresion Algorithm.
Takes input from streamlit web interface and use those inputs for building the model.
Used GridSearchCV for Hyperparameter Tunning.
Ploting the result using Plotly Framework.
:param df: dataframe containing features and labels.
"""
from sklearn.ensemble import RandomForestRegressor
all=False
X = df.iloc[:, :-1] # Using all column except for the last column as X
Y = df.iloc[:, -1] # Selecting the last column as Y
st.markdown('A model is being built to predict the following **Y** variable:')
st.info(Y.name)
# Data splitting
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=split_size)
# X_train.shape, Y_train.shape
# X_test.shape, Y_test.shape
rf = RandomForestRegressor(n_estimators=n_estimators,
random_state=random_state,
max_features=max_features,
min_samples_split=min_samples_split,
min_samples_leaf=min_samples_leaf,
bootstrap=bootstrap,
oob_score=oob_score,
n_jobs=n_jobs)
grid = GridSearchCV(estimator=rf, param_grid=param_grid, cv=5)
grid.fit(X_train, Y_train)
st.subheader('Model Performance')
Y_pred_test = grid.predict(X_test)
st.write('Coefficient of determination ($R^2$):')
st.info("%0.3f" %r2_score(Y_test, Y_pred_test))
if criterion == 'MSE':
st.write('Mean Squared Error (MSE):')
st.info("%0.2f" %mean_squared_error(Y_test, Y_pred_test))
if criterion == 'MAE':
st.write('Mean Absolute Error (MAE):')
st.info("%0.2f" %mean_absolute_error(Y_test, Y_pred_test))
if criterion == 'RMSE':
st.write('Root Mean Squared Error (RMSE):')
st.info("%0.2f" %mean_squared_error(Y_test, Y_pred_test, squared=False))
if criterion == 'All':
all = True
st.write('Mean Squared Error (MSE):')
mse = mean_squared_error(Y_test, Y_pred_test)
st.info("%0.2f" %mse)
st.write('Root Mean Squared Error (RMSE):')
rmse = mean_squared_error(Y_test, Y_pred_test, squared=False)
st.info("%0.2f" %rmse)
st.write('Mean Absolute Error (MAE):')
mae = mean_absolute_error(Y_test, Y_pred_test)
st.info("%0.2f" %mae)
st.write("The best parameters are %s with a score of %0.2f"
% (grid.best_params_, grid.best_score_))
st.subheader('Model Parameters')
st.write(grid.get_params())
# Grid Data .......
grid_results = pd.concat([pd.DataFrame(grid.cv_results_["params"]), pd.DataFrame(grid.cv_results_["mean_test_score"], columns=["R2"])], axis=1)
# Segment data into groups based on the 2 hyperparameters
grid_contour = grid_results.groupby(['max_features', 'n_estimators']).mean()
# Pivoting the data
grid_reset = grid_contour.reset_index()
grid_reset.columns = ['max_features', 'n_estimators', 'R2']
grid_pivot = grid_reset.pivot('max_features', 'n_estimators')
x = grid_pivot.columns.levels[1].values
y = grid_pivot.index.values
z = grid_pivot.values
# -----Plot-----#
layout = go.Layout(
xaxis=go.layout.XAxis(
title=go.layout.xaxis.Title(
text='n_estimators')
),
yaxis=go.layout.YAxis(
title=go.layout.yaxis.Title(
text='max_features')
))
fig = go.Figure(data=[go.Surface(z=z, y=y, x=x)], layout=layout)
fig.update_layout(title='Hyperparameter tuning (Surface Plot)',
scene=dict(
xaxis_title='n_estimators',
yaxis_title='max_features',
zaxis_title='R2'),
autosize=False,
width=800, height=800,
margin=dict(l=65, r=50, b=65, t=90))
st.plotly_chart(fig)
if all == True:
criteria = ['RMSE', 'MSE', 'MAE']
fig = go.Figure([go.Bar(x=criteria, y=[rmse, mse, mae])])
st.plotly_chart(fig)
# -----Save grid data-----#
x = pd.DataFrame(x)
y = pd.DataFrame(y)
z = pd.DataFrame(z)
df = pd.concat([x, y, z], axis=1)
st.markdown(filedownload(grid_results), unsafe_allow_html=True)
################################################## SVR
def build_model_SVR(df):
"""
It builds a model using Support Vector regresion Algorithm.
Takes input from streamlit web interface and use those inputs for building the model.
Used GridSearchCV for Hyperparameter Tunning.
Ploting the result using Plotly Framework.
:param df: dataframe containing features and labels.
"""
from sklearn.svm import SVR
X = df.iloc[:, :-1] # Using all column except for the last column as X
Y = df.iloc[:, -1] # Selecting the last column as Y
st.markdown('A model is being built to predict the following **Y** variable:')
st.info(Y.name)
# Data splitting
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=split_size)
model = SVR()
if len(ind_var) == 1:
dfx = X_train[ind_var[0]].values.reshape(-1, 1)
dfxtest = X_test[ind_var[0]].values.reshape(-1, 1)
clf = GridSearchCV(model, param_grid)
clf.fit(dfx,Y_train)
Y_pred_test = clf.predict(dfxtest)
fig = px.scatter(df, x=ind_var[0], y=Y_test.name, opacity=0.65)
fig.add_traces(go.Scatter(x=X_test[ind_var[0]], y=Y_pred_test, name='Regression Fit'))
st.plotly_chart(fig)
if len(ind_var) == 2:
dfx = X_train[ind_var]
dfxtest = X_test[ind_var]
clf = GridSearchCV(model, param_grid)
clf.fit(dfx, Y_train)
mesh_size = .02
margin = 0
# Create a mesh grid on which we will run our model
x_min, x_max = X_test[ind_var[0]].min() - margin, X_test[ind_var[0]].max() + margin
y_min, y_max = X_test[ind_var[1]].min() - margin, X_test[ind_var[1]].max() + margin
xrange = np.arange(x_min, x_max, mesh_size)
yrange = np.arange(y_min, y_max, mesh_size)
xx, yy = np.meshgrid(xrange, yrange)
# Run model
pred = clf.predict(np.c_[xx.ravel(), yy.ravel()])
pred = pred.reshape(xx.shape)
Y_pred_test = clf.predict(dfxtest)
fig = px.scatter_3d(df, x=ind_var[0], y=ind_var[1], z=Y_test.name)
fig.update_traces(marker=dict(size=3))
fig.add_traces(go.Surface(x=xrange, y=yrange, z=pred, name='pred_surface'))
st.plotly_chart(fig)
if len(ind_var) > 2:
dfx = X_train[ind_var]
dfxtest = X_test[ind_var]
clf = GridSearchCV(model, param_grid)
clf.fit(dfx, Y_train)
Y_pred_test = clf.predict(dfxtest)
st.subheader(f"Visualization shows how {Y_test.name} is dependent on individual variable")
c = len(ind_var)
clf1 = GridSearchCV(model, param_grid)
for i in range(0,c):
dfx = X_train[ind_var[i]].values.reshape(-1, 1)
dfxtest = X_test[ind_var[i]].values.reshape(-1, 1)
clf1.fit(dfx, Y_train)
pred = clf1.predict(dfxtest)
fig = px.scatter(df, x=ind_var[i], y=Y_test.name, opacity=0.65)
fig.add_traces(go.Scatter(x=X_test[ind_var[i]], y=pred, name='Regression Fit'))
st.plotly_chart(fig)
st.write("The best parameters are %s with a score of %0.2f"
% (clf.best_params_, clf.best_score_))
st.subheader('Model Parameters')
st.write(clf.get_params())
st.subheader('Model Performance')
st.write('Coefficient of determination ($R^2$):')
st.info("%0.3f" %r2_score(Y_test, Y_pred_test))
if criterion == 'MSE':
st.write('Mean Squared Error (MSE):')
st.info("%0.2f" %mean_squared_error(Y_test, Y_pred_test))
if criterion == 'MAE':
st.write('Mean Absolute Error (MAE):')
st.info("%0.2f" %mean_absolute_error(Y_test, Y_pred_test))
if criterion == 'RMSE':
st.write('Root Mean Squared Error (RMSE):')
st.info("%0.2f" %mean_squared_error(Y_test, Y_pred_test, squared=False))
if criterion == 'All':
st.write('Mean Squared Error (MSE):')
mse = mean_squared_error(Y_test, Y_pred_test)
st.info("%0.2f" %mse)
st.write('Root Mean Squared Error (RMSE):')
rsme = mean_squared_error(Y_test, Y_pred_test, squared=False)
st.info("%0.2f" %rsme)
st.write('Mean Absolute Error (MAE):')
mae = mean_absolute_error(Y_test, Y_pred_test)
st.info("%0.2f" %mae)
criteria = ['RMSE', 'MSE', 'MAE']
fig = go.Figure([go.Bar(x=criteria, y=[rsme, mse, mae])])
st.plotly_chart(fig)
# st.subheader("Hyperparameter Tuning Results")
# df_gridsearch = pd.DataFrame(clf.cv_results_)
# dfViz = df_gridsearch[['param_C', 'param_gamma', 'mean_test_score']]
#
# pivot = pd.pivot_table(data=dfViz, index=['param_C'], columns=['param_gamma'], values=['mean_test_score'])
# sns.heatmap(pivot, annot=True)
# st.pyplot(plt)
# Change the bar mode
fig.update_layout(barmode='group')
################################################## SGD
def build_model_SGD(df):
"""
It builds a model using Stocastic gradient descent regresion Algorithm.
Takes input from streamlit web interface and use those inputs for building the model.
Used GridSearchCV for Hyperparameter Tunning.
Ploting the result using Plotly Framework.
:param df: dataframe containing features and labels.
"""
from sklearn.linear_model import SGDRegressor
X = df.iloc[:, :-1] # Using all column except for the last column as X
Y = df.iloc[:, -1] # Selecting the last column as Y
st.markdown('A model is being built to predict the following **Y** variable:')
st.info(Y.name)
# Data splitting
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=split_size)
if scale == 'True':
from sklearn.preprocessing import StandardScaler
cols = X_train.columns
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
X_train = pd.DataFrame(X_train, columns=cols)
X_test = pd.DataFrame(X_test, columns=cols)
model = SGDRegressor()
if len(ind_var) == 1:
dfx = X_train[ind_var[0]].values.reshape(-1, 1)
dfxtest = X_test[ind_var[0]].values.reshape(-1, 1)
clf = GridSearchCV(model, param_grid)
clf.fit(dfx, Y_train)
Y_pred_test = clf.predict(dfxtest)
fig = px.scatter(df, x=ind_var[0], y=Y_test.name, opacity=0.65)
fig.add_traces(go.Scatter(x=X_test[ind_var[0]], y=Y_pred_test, name='Regression Fit'))
st.plotly_chart(fig)
if len(ind_var) == 2:
dfx = X_train[ind_var]
dfxtest = X_test[ind_var]
clf = GridSearchCV(model, param_grid)
clf.fit(dfx, Y_train)
mesh_size = .02
margin = 0
# Create a mesh grid on which we will run our model
x_min, x_max=X_test[ind_var[0]].min() - margin, X_test[ind_var[0]].max() + margin
y_min, y_max=X_test[ind_var[1]].min() - margin, X_test[ind_var[1]].max() + margin
xrange = np.arange(x_min, x_max, mesh_size)
yrange = np.arange(y_min, y_max, mesh_size)
xx, yy = np.meshgrid(xrange, yrange)
# Run model
pred = clf.predict(np.c_[xx.ravel(), yy.ravel()])
pred = pred.reshape(xx.shape)
Y_pred_test = clf.predict(dfxtest)
fig = px.scatter_3d(df, x=ind_var[0], y=ind_var[1], z=Y_test.name)
fig.update_traces(marker=dict(size=3))
fig.add_traces(go.Surface(x=xrange, y=yrange, z=pred, name='pred_surface'))
st.plotly_chart(fig)
if len(ind_var) > 2:
dfx = X_train[ind_var]
dfxtest = X_test[ind_var]
clf = GridSearchCV(model, param_grid)
clf.fit(dfx, Y_train)
Y_pred_test = clf.predict(dfxtest)
st.subheader(f"Visualization shows how {Y_test.name} is dependent on individual variable")
c = len(ind_var)
clf1 = GridSearchCV(model, param_grid)
for i in range(0, c):
dfx = X_train[ind_var[i]].values.reshape(-1, 1)
dfxtest = X_test[ind_var[i]].values.reshape(-1, 1)
clf1.fit(dfx, Y_train)
pred = clf1.predict(dfxtest)
fig = px.scatter(df, x=ind_var[i], y=Y_test.name, opacity=0.65)
fig.add_traces(go.Scatter(x=X_test[ind_var[i]], y=pred, name='Regression Fit'))
st.plotly_chart(fig)
st.write("The best parameters are %s with a score of %0.2f"
% (clf.best_params_, clf.best_score_))
st.subheader('Model Parameters')
st.write(clf.get_params())
st.subheader('Model Performance')
st.write('Coefficient of determination ($R^2$):')
st.info("%0.3f" % r2_score(Y_test, Y_pred_test))
if criterion == 'MSE':
st.write('Mean Squared Error (MSE):')
st.info("%0.2f" % mean_squared_error(Y_test, Y_pred_test))
if criterion == 'MAE':
st.write('Mean Absolute Error (MAE):')
st.info("%0.2f" % mean_absolute_error(Y_test, Y_pred_test))
if criterion == 'RMSE':
st.write('Root Mean Squared Error (RMSE):')
st.info("%0.2f" % mean_squared_error(Y_test, Y_pred_test, squared=False))
if criterion == 'All':
st.write('Mean Squared Error (MSE):')
mse = mean_squared_error(Y_test, Y_pred_test)
st.info("%0.2f" % mse)
st.write('Root Mean Squared Error (RMSE):')
rsme = mean_squared_error(Y_test, Y_pred_test, squared=False)
st.info("%0.2f" % rsme)
st.write('Mean Absolute Error (MAE):')
mae = mean_absolute_error(Y_test, Y_pred_test)
st.info("%0.2f" % mae)
criteria = ['RMSE', 'MSE', 'MAE']
fig = go.Figure([go.Bar(x=criteria, y=[rsme, mse, mae])])
st.plotly_chart(fig)
# Change the bar mode
fig.update_layout(barmode='group')
################################################### Kernel Ridge
def build_model_KernelRidge(df):
"""
It builds a model using Kernel Ridge Regresion Algorithm.
Takes input from streamlit web interface and use those inputs for building the model.
Used GridSearchCV for Hyperparameter Tunning.
Ploting the result using Plotly Framework.
:param df: dataframe containing features and labels.
"""
from sklearn.kernel_ridge import KernelRidge
X = df.iloc[:, :-1] # Using all column except for the last column as X
Y = df.iloc[:, -1] # Selecting the last column as Y
st.markdown('A model is being built to predict the following **Y** variable:')
st.info(Y.name)
# Data splitting
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=split_size)
if scale == 'True':
from sklearn.preprocessing import StandardScaler
cols = X_train.columns
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
X_train = pd.DataFrame(X_train, columns=cols)
X_test = pd.DataFrame(X_test, columns=cols)
model = KernelRidge()
if len(ind_var) == 1:
dfx = X_train[ind_var[0]].values.reshape(-1, 1)
dfxtest = X_test[ind_var[0]].values.reshape(-1, 1)
clf = GridSearchCV(model, param_grid)
clf.fit(dfx, Y_train)
Y_pred_test = clf.predict(dfxtest)
fig = px.scatter(df, x=ind_var[0], y=Y_test.name, opacity=0.65)
fig.add_traces(go.Scatter(x=X_test[ind_var[0]], y=Y_pred_test, name='Regression Fit'))
st.plotly_chart(fig)
if len(ind_var) == 2:
dfx = X_train[ind_var]
dfxtest = X_test[ind_var]
clf = GridSearchCV(model, param_grid)
clf.fit(dfx, Y_train)
mesh_size = .02
margin = 0
# Create a mesh grid on which we will run our model
x_min, x_max=X_test[ind_var[0]].min() - margin, X_test[ind_var[0]].max() + margin
y_min, y_max=X_test[ind_var[1]].min() - margin, X_test[ind_var[1]].max() + margin
xrange = np.arange(x_min, x_max, mesh_size)
yrange = np.arange(y_min, y_max, mesh_size)
xx, yy = np.meshgrid(xrange, yrange)
# Run model
pred = clf.predict(np.c_[xx.ravel(), yy.ravel()])
pred = pred.reshape(xx.shape)
Y_pred_test = clf.predict(dfxtest)
fig = px.scatter_3d(df, x=ind_var[0], y=ind_var[1], z=Y_test.name)
fig.update_traces(marker=dict(size=3))
fig.add_traces(go.Surface(x=xrange, y=yrange, z=pred, name='pred_surface'))
st.plotly_chart(fig)
if len(ind_var) > 2:
dfx = X_train[ind_var]
dfxtest = X_test[ind_var]
clf = GridSearchCV(model, param_grid)
clf.fit(dfx, Y_train)
Y_pred_test = clf.predict(dfxtest)
st.subheader(f"Visualization shows how {Y_test.name} is dependent on individual variable")
c = len(ind_var)
clf1 = GridSearchCV(model, param_grid)
for i in range(0, c):
dfx = X_train[ind_var[i]].values.reshape(-1, 1)
dfxtest = X_test[ind_var[i]].values.reshape(-1, 1)
clf1.fit(dfx, Y_train)
pred = clf1.predict(dfxtest)
fig = px.scatter(df, x=ind_var[i], y=Y_test.name, opacity=0.65)
fig.add_traces(go.Scatter(x=X_test[ind_var[i]], y=pred, name='Regression Fit'))
st.plotly_chart(fig)
st.write("The best parameters are %s with a score of %0.2f"
% (clf.best_params_, clf.best_score_))
st.subheader('Model Parameters')
st.write(clf.get_params())
st.subheader('Model Performance')
st.write('Coefficient of determination ($R^2$):')
st.info("%0.3f" % r2_score(Y_test, Y_pred_test))
if criterion == 'MSE':
st.write('Mean Squared Error (MSE):')
st.info("%0.2f" % mean_squared_error(Y_test, Y_pred_test))
if criterion == 'MAE':
st.write('Mean Absolute Error (MAE):')
st.info("%0.2f" % mean_absolute_error(Y_test, Y_pred_test))
if criterion == 'RMSE':
st.write('Root Mean Squared Error (RMSE):')
st.info("%0.2f" % mean_squared_error(Y_test, Y_pred_test, squared=False))
if criterion == 'All':
st.write('Mean Squared Error (MSE):')
mse = mean_squared_error(Y_test, Y_pred_test)
st.info("%0.2f" % mse)
st.write('Root Mean Squared Error (RMSE):')
rsme = mean_squared_error(Y_test, Y_pred_test, squared=False)
st.info("%0.2f" % rsme)
st.write('Mean Absolute Error (MAE):')
mae = mean_absolute_error(Y_test, Y_pred_test)
st.info("%0.2f" % mae)
criteria = ['RMSE', 'MSE', 'MAE']
fig = go.Figure([go.Bar(x=criteria, y=[rsme, mse, mae])])
st.plotly_chart(fig)
# Change the bar mode
fig.update_layout(barmode='group')
################################################ Elastic Net
def build_model_ElasticNet(df):
"""
It builds a model using Elastic Net Regresion Algorithm.
Takes input from streamlit web interface and use those inputs for building the model.
Used GridSearchCV for Hyperparameter Tunning.
Ploting the result using Plotly Framework.
:param df: dataframe containing features and labels.
"""
from sklearn.linear_model import ElasticNet
X = df.iloc[:, :-1] # Using all column except for the last column as X
Y = df.iloc[:, -1] # Selecting the last column as Y
st.markdown('A model is being built to predict the following **Y** variable:')
st.info(Y.name)
# Data splitting
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=split_size)
if scale == 'True':
from sklearn.preprocessing import StandardScaler
cols = X_train.columns
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
X_train = pd.DataFrame(X_train, columns=cols)
X_test = pd.DataFrame(X_test, columns=cols)
model = ElasticNet()
if len(ind_var) == 1:
dfx = X_train[ind_var[0]].values.reshape(-1, 1)
dfxtest = X_test[ind_var[0]].values.reshape(-1, 1)
clf = GridSearchCV(model, param_grid)
clf.fit(dfx, Y_train)
Y_pred_test = clf.predict(dfxtest)
fig = px.scatter(df, x=ind_var[0], y=Y_test.name, opacity=0.65)
fig.add_traces(go.Scatter(x=X_test[ind_var[0]], y=Y_pred_test, name='Regression Fit'))
st.plotly_chart(fig)
if len(ind_var) == 2:
dfx = X_train[ind_var]
dfxtest = X_test[ind_var]
clf = GridSearchCV(model, param_grid)
clf.fit(dfx, Y_train)
mesh_size = .02
margin = 0
# Create a mesh grid on which we will run our model
x_min, x_max=X_test[ind_var[0]].min() - margin, X_test[ind_var[0]].max() + margin
y_min, y_max=X_test[ind_var[1]].min() - margin, X_test[ind_var[1]].max() + margin
xrange = np.arange(x_min, x_max, mesh_size)
yrange = np.arange(y_min, y_max, mesh_size)
xx, yy = np.meshgrid(xrange, yrange)
# Run model
pred = clf.predict(np.c_[xx.ravel(), yy.ravel()])
pred = pred.reshape(xx.shape)
Y_pred_test = clf.predict(dfxtest)
fig = px.scatter_3d(df, x=ind_var[0], y=ind_var[1], z=Y_test.name)
fig.update_traces(marker=dict(size=3))
fig.add_traces(go.Surface(x=xrange, y=yrange, z=pred, name='pred_surface'))
st.plotly_chart(fig)
if len(ind_var) > 2:
dfx = X_train[ind_var]
dfxtest = X_test[ind_var]
clf = GridSearchCV(model, param_grid)
clf.fit(dfx, Y_train)
Y_pred_test = clf.predict(dfxtest)
st.subheader(f"Visualization shows how {Y_test.name} is dependent on individual variable")
c = len(ind_var)
clf1 = GridSearchCV(model, param_grid)
for i in range(0, c):
dfx = X_train[ind_var[i]].values.reshape(-1, 1)
dfxtest = X_test[ind_var[i]].values.reshape(-1, 1)
clf1.fit(dfx, Y_train)
pred = clf1.predict(dfxtest)
fig = px.scatter(df, x=ind_var[i], y=Y_test.name, opacity=0.65)
fig.add_traces(go.Scatter(x=X_test[ind_var[i]], y=pred, name='Regression Fit'))
st.plotly_chart(fig)
st.write("The best parameters are %s with a score of %0.2f"
% (clf.best_params_, clf.best_score_))
st.subheader('Model Parameters')
st.write(clf.get_params())
st.subheader('Model Performance')
st.write('Coefficient of determination ($R^2$):')
st.info("%0.3f" % r2_score(Y_test, Y_pred_test))
if criterion == 'MSE':
st.write('Mean Squared Error (MSE):')
st.info("%0.2f" % mean_squared_error(Y_test, Y_pred_test))
if criterion == 'MAE':
st.write('Mean Absolute Error (MAE):')
st.info("%0.2f" % mean_absolute_error(Y_test, Y_pred_test))
if criterion == 'RMSE':
st.write('Root Mean Squared Error (RMSE):')
st.info("%0.2f" % mean_squared_error(Y_test, Y_pred_test, squared=False))
if criterion == 'All':
st.write('Mean Squared Error (MSE):')
mse = mean_squared_error(Y_test, Y_pred_test)
st.info("%0.2f" % mse)
st.write('Root Mean Squared Error (RMSE):')
rsme = mean_squared_error(Y_test, Y_pred_test, squared=False)
st.info("%0.2f" % rsme)
st.write('Mean Absolute Error (MAE):')
mae = mean_absolute_error(Y_test, Y_pred_test)
st.info("%0.2f" % mae)
criteria = ['RMSE', 'MSE', 'MAE']
fig = go.Figure([go.Bar(x=criteria, y=[rsme, mse, mae])])
st.plotly_chart(fig)
# Change the bar mode
fig.update_layout(barmode='group')
################################################# Gradient boosting
def build_model_GradientBoosting(df):
"""
It builds a model using Gradient Boosting Regression Algorithm.
Takes input from streamlit web interface and use those inputs for building the model.
Used GridSearchCV for Hyperparameter Tunning.
Ploting the result using Plotly Framework.
:param df: dataframe containing features and labels.
"""
from sklearn.ensemble import GradientBoostingRegressor
X = df.iloc[:, :-1] # Using all column except for the last column as X
Y = df.iloc[:, -1] # Selecting the last column as Y
st.markdown('A model is being built to predict the following **Y** variable:')
st.info(Y.name)
# Data splitting
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=split_size)
if scale == 'True':
from sklearn.preprocessing import StandardScaler
cols = X_train.columns
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
X_train = pd.DataFrame(X_train, columns=cols)
X_test = pd.DataFrame(X_test, columns=cols)
model = GradientBoostingRegressor()
if len(ind_var) == 1:
dfx = X_train[ind_var[0]].values.reshape(-1, 1)
dfxtest = X_test[ind_var[0]].values.reshape(-1, 1)
clf = GridSearchCV(model, param_grid)
clf.fit(dfx, Y_train)
Y_pred_test = clf.predict(dfxtest)
fig = px.scatter(df, x=ind_var[0], y=Y_test.name, opacity=0.65)
fig.add_traces(go.Scatter(x=X_test[ind_var[0]], y=Y_pred_test, name='Regression Fit'))
st.plotly_chart(fig)
if len(ind_var) == 2:
dfx = X_train[ind_var]
dfxtest = X_test[ind_var]
clf = GridSearchCV(model, param_grid)
clf.fit(dfx, Y_train)
mesh_size = .02
margin = 0
# Create a mesh grid on which we will run our model
x_min, x_max=X_test[ind_var[0]].min() - margin, X_test[ind_var[0]].max() + margin
y_min, y_max=X_test[ind_var[1]].min() - margin, X_test[ind_var[1]].max() + margin
xrange = np.arange(x_min, x_max, mesh_size)
yrange = np.arange(y_min, y_max, mesh_size)
xx, yy = np.meshgrid(xrange, yrange)
# Run model
pred = clf.predict(np.c_[xx.ravel(), yy.ravel()])
pred = pred.reshape(xx.shape)
Y_pred_test = clf.predict(dfxtest)
fig = px.scatter_3d(df, x=ind_var[0], y=ind_var[1], z=Y_test.name)
fig.update_traces(marker=dict(size=3))
fig.add_traces(go.Surface(x=xrange, y=yrange, z=pred, name='pred_surface'))
st.plotly_chart(fig)
if len(ind_var) > 2:
dfx = X_train[ind_var]
dfxtest = X_test[ind_var]
clf = GridSearchCV(model, param_grid)
clf.fit(dfx, Y_train)
Y_pred_test = clf.predict(dfxtest)
st.subheader(f"Visualization shows how {Y_test.name} is dependent on individual variable")
c = len(ind_var)
clf1 = GridSearchCV(model, param_grid)
for i in range(0, c):
dfx = X_train[ind_var[i]].values.reshape(-1, 1)
dfxtest = X_test[ind_var[i]].values.reshape(-1, 1)
clf1.fit(dfx, Y_train)
pred = clf1.predict(dfxtest)
fig = px.scatter(df, x=ind_var[i], y=Y_test.name, opacity=0.65)
fig.add_traces(go.Scatter(x=X_test[ind_var[i]], y=pred, name='Regression Fit'))
st.plotly_chart(fig)
st.write("The best parameters are %s with a score of %0.2f"
% (clf.best_params_, clf.best_score_))
st.subheader('Model Parameters')
st.write(clf.get_params())
st.subheader('Model Performance')
st.write('Coefficient of determination ($R^2$):')
st.info("%0.3f" % r2_score(Y_test, Y_pred_test))
if criterion == 'MSE':
st.write('Mean Squared Error (MSE):')
st.info("%0.2f" % mean_squared_error(Y_test, Y_pred_test))
if criterion == 'MAE':
st.write('Mean Absolute Error (MAE):')
st.info("%0.2f" % mean_absolute_error(Y_test, Y_pred_test))
if criterion == 'RMSE':
st.write('Root Mean Squared Error (RMSE):')
st.info("%0.2f" % mean_squared_error(Y_test, Y_pred_test, squared=False))
if criterion == 'All':
st.write('Mean Squared Error (MSE):')
mse = mean_squared_error(Y_test, Y_pred_test)
st.info("%0.2f" % mse)
st.write('Root Mean Squared Error (RMSE):')
rsme = mean_squared_error(Y_test, Y_pred_test, squared=False)
st.info("%0.2f" % rsme)
st.write('Mean Absolute Error (MAE):')
mae = mean_absolute_error(Y_test, Y_pred_test)
st.info("%0.2f" % mae)
criteria = ['RMSE', 'MSE', 'MAE']
fig = go.Figure([go.Bar(x=criteria, y=[rsme, mse, mae])])
st.plotly_chart(fig)
# Change the bar mode
fig.update_layout(barmode='group')
# Page Layout ( Streamlit web Interface )
st.set_page_config(page_title="Regression Model Builder")
st.write("""
# Regression Model Builder
""")
# Sidebar ..............................................
# Sidebar - Collects user input features into dataframe
st.sidebar.header('Upload your CSV data')
uploaded_file = st.sidebar.file_uploader("Upload your input CSV file", type=["csv"])
st.sidebar.header("Parameter Configuration")
split_size = st.sidebar.slider('Data Split Ratio (training set)', 10,90,80,5)
st.sidebar.header("Select Regressor")
reg = st.sidebar.selectbox("Choose Regression Algorithm", options=['Linear Regression', 'SVR',
'Random Forest Regression', 'Adaboost', 'SGD Regression', 'Kernel Ridge Regression',
'ElasticNet Regression', 'Gradient Boosting Regression'])
if reg == 'Random Forest Regression':
st.sidebar.subheader('Learning Parameters')
n_estimators = st.sidebar.slider('Number of estimators (n_estimators)', 0, 500, (10, 50), 50)
n_estimators_step = st.sidebar.number_input('Step size for n_estimators (n_estimators_step)', 10)
st.sidebar.write('---')
max_features = st.sidebar.slider('Max features', 1, 50, (1, 3), 1)
max_features_step = st.sidebar.number_input('Step Size for max Features', 1)
st.sidebar.write('---')
min_samples_split = st.sidebar.slider(
'Minimum number of samples required to split an internal node (min_samples_split)', 1, 10, 2, 1)
min_samples_leaf = st.sidebar.slider('Minimum number of samples required to be at a leaf node (min_samples_leaf)',
1, 10, 2, 1)
st.sidebar.subheader('General Parameters')
random_state = st.sidebar.slider('Seed number (random_state)', 0, 1000, 42, 1)
criterion = st.sidebar.selectbox('Performance measure (criterion)', options=['All', 'MSE', 'MAE', 'RMSE'])
bootstrap = st.sidebar.selectbox('Bootstrap samples when building trees (bootstrap)', options=[True, False])
oob_score = st.sidebar.selectbox('Whether to use out-of-bag samples to estimate the R^2 on unseen data (oob_score)',
options=[False, True])
n_jobs = st.sidebar.select_slider('Number of jobs to run in parallel (n_jobs)', options=[1, -1])
n_estimators_range = np.arange(n_estimators[0], n_estimators[1] + n_estimators_step, n_estimators_step)
max_features_range = np.arange(max_features[0], max_features[1] + max_features_step, max_features_step)
param_grid = dict(max_features=max_features_range, n_estimators=n_estimators_range)
if reg == 'Adaboost':
st.sidebar.subheader('Learning Parameters')
n_estimators = st.sidebar.slider('Number of estimators (n_estimators)', 0, 500, (10, 50), 50)
n_estimators_step = st.sidebar.number_input('Step size for n_estimators (n_estimators_step)', 10)
st.sidebar.write('---')
criterion = st.sidebar.selectbox('Performance measure (criterion)', options=['All', 'MSE', 'MAE', 'RMSE'])
lr = [0.0001, 0.001, 0.01, 0.1]
learning_rate = st.sidebar.select_slider('Range of Learning Rate (learning_rate)',
options=[0.0001, 0.001, 0.01, 0.1], value=(0.0001, 0.01))
l = lr.index(learning_rate[0])
r = lr.index(learning_rate[1])
learning_rate_range = lr[l:r + 1]
st.sidebar.write('---')
st.sidebar.header("Loss")
loss = st.sidebar.selectbox("Choose Loss",options=['linear', 'square', 'exponential'])
st.sidebar.subheader('General Parameters')
random_state = st.sidebar.slider('Seed number (random_state)', 0, 1000, 42, 1)
n_jobs = st.sidebar.select_slider('Number of jobs to run in parallel (n_jobs)', options=[1, -1])
n_estimators_range = np.arange(n_estimators[0], n_estimators[1] + n_estimators_step, n_estimators_step)
param_grid = dict(learning_rate = learning_rate_range, n_estimators=n_estimators_range)
if reg == 'Linear Regression':
if uploaded_file is not None:
df = pd.read_csv(uploaded_file)
else:
diabetes = load_diabetes()
X = pd.DataFrame(diabetes.data, columns=diabetes.feature_names)
Y = pd.Series(diabetes.target, name='response')
df = pd.concat([X, Y], axis=1)
st.sidebar.subheader('Variable Configuration')
ind_var = st.sidebar.multiselect('Choose Independent Variables', options=df.columns)
st.sidebar.write('---')
criterion = st.sidebar.selectbox('Performance measure (criterion)', options=['All', 'MSE', 'MAE', 'RMSE'])
if reg == 'SVR':
if uploaded_file is not None:
df = pd.read_csv(uploaded_file)
else:
diabetes = load_diabetes()
X = pd.DataFrame(diabetes.data, columns=diabetes.feature_names)
Y = pd.Series(diabetes.target, name='response')
df = pd.concat([X, Y], axis=1)
st.sidebar.subheader('Variable Configuration')
ind_var = st.sidebar.multiselect('Choose Independent Variables', options=df.columns)
st.sidebar.write('---')
criterion = st.sidebar.selectbox('Performance measure (criterion)', options=['All', 'MSE', 'MAE', 'RMSE'])
st.sidebar.subheader("Hyperparameters for SVR")
st.sidebar.subheader("Kernel")
kernel = st.sidebar.selectbox("Enter from the options", options=['All', 'linear', 'rbf', 'poly'])
numbers = st.sidebar.text_input("Enter values for 'c'. (Separate values with ,)")
C = collect_numbers(numbers)
numbers = st.sidebar.text_input("Enter values for 'gamma'. (Separate values with ,)")
gamma = collect_numbers(numbers)
numbers = st.sidebar.text_input("Enter values for 'epsilon'. (Separate values with ,)")
epsilon = collect_numbers(numbers)
if kernel == 'All':
kernel = ['linear', 'rbf', 'poly']
else:
kernel = [kernel]
param_grid = dict(kernel = kernel, gamma = gamma, epsilon = epsilon, C = C)
if reg == 'SGD Regression':
if uploaded_file is not None:
df = pd.read_csv(uploaded_file)
else:
diabetes = load_diabetes()
X = pd.DataFrame(diabetes.data, columns=diabetes.feature_names)
Y = pd.Series(diabetes.target, name='response')
df = pd.concat([X, Y], axis=1)
st.sidebar.subheader('Variable Configuration')
ind_var = st.sidebar.multiselect('Choose Independent Variables', options=df.columns)
st.sidebar.write('---')
criterion = st.sidebar.selectbox('Performance measure (criterion)', options=['All', 'MSE', 'MAE', 'RMSE'])
st.sidebar.subheader("Standard Scaling")
scale = st.sidebar.selectbox("Scale the data to be between -1 to 1", options=['True', 'False'])
st.sidebar.subheader("Hyperparameters for SGD Regressor")
numbers = st.sidebar.text_input("Enter values for 'alpha'. (Separate values with ,)")
alpha = collect_numbers(numbers)
loss = st.sidebar.selectbox("Loss", options=['All', 'squared_loss', 'huber', 'epsilon_insensitive'])
penalty = st.sidebar.selectbox("Penalty", options=['All', 'l2', 'l1', 'elasticnet'])
learning_rate = st.sidebar.selectbox("Learning Rate", options=['All', 'constant', 'optimal', 'invscaling'])
if loss == 'All':
loss = ['squared_loss', 'huber', 'epsilon_insensitive']
else:
loss = [loss]
if penalty == 'All':
penalty = ['l2', 'l1', 'elasticnet']
else:
penalty = [penalty]
if learning_rate == 'All':
learning_rate = ['constant', 'optimal', 'invscaling']
else:
learning_rate = [learning_rate]
param_grid = dict(alpha = alpha, loss = loss, penalty = penalty, learning_rate = learning_rate)
if reg == 'Kernel Ridge Regression':
if uploaded_file is not None:
df = pd.read_csv(uploaded_file)
else:
diabetes = load_diabetes()
X = pd.DataFrame(diabetes.data, columns=diabetes.feature_names)
Y = pd.Series(diabetes.target, name='response')
df = pd.concat([X, Y], axis=1)
st.sidebar.subheader('Variable Configuration')
ind_var = st.sidebar.multiselect('Choose Independent Variables', options=df.columns)
st.sidebar.subheader("Standard Scaling")
scale = st.sidebar.selectbox("Scale the data to be between -1 to 1", options=['True', 'False'])
st.sidebar.write('---')
criterion = st.sidebar.selectbox('Performance measure (criterion)', options=['All', 'MSE', 'MAE', 'RMSE'])
st.sidebar.write('---')
st.sidebar.subheader("Hyperparameters for Kernel Ridge Regression")
st.sidebar.subheader("Kernel")
kernel = st.sidebar.selectbox("Enter from the options", options=['All', 'linear', 'rbf', 'poly'])
numbers = st.sidebar.text_input("Enter values for 'alpha'. (Separate values with ,)")
alpha = collect_numbers(numbers)
numbers = st.sidebar.text_input("Enter values for 'gamma'. (Separate values with ,)")
gamma = collect_numbers(numbers)
if kernel == 'All':
kernel = ['linear', 'rbf', 'poly']
else:
kernel = [kernel]
param_grid = dict(kernel = kernel, gamma = gamma, alpha = alpha)
if reg == 'ElasticNet Regression':
if uploaded_file is not None:
df = pd.read_csv(uploaded_file)
else:
diabetes = load_diabetes()
X = pd.DataFrame(diabetes.data, columns=diabetes.feature_names)
Y = pd.Series(diabetes.target, name='response')
df = pd.concat([X, Y], axis=1)
st.sidebar.subheader('Variable Configuration')
ind_var = st.sidebar.multiselect('Choose Independent Variables', options=df.columns)
st.sidebar.subheader("Standard Scaling")
scale = st.sidebar.selectbox("Scale the data to be between -1 to 1", options=['True', 'False'])
st.sidebar.write('---')
criterion = st.sidebar.selectbox('Performance measure (criterion)', options=['All', 'MSE', 'MAE', 'RMSE'])
st.sidebar.write('---')
st.sidebar.subheader("Hyperparameters for ElasticNet Regression")
st.sidebar.subheader("Selection")
selection = st.sidebar.selectbox("Enter from the options", options=['All', 'cyclic', 'random'])
numbers = st.sidebar.text_input("Enter values for 'alpha'. (Separate values with ,)", value='1.0')
alpha = collect_numbers(numbers)
numbers = st.sidebar.text_input("Enter values for 'l1_ratio'. (Separate values with ,)", value='0.5')
l1_ratio = collect_numbers(numbers)
fit_intercept = st.sidebar.selectbox("Whether the intercept should be estimated or not", options=['Both', 'True', 'False'])
# if fit_intercept == 'Both' or fit_intercept == 'True':
# normalize = st.sidebar.selectbox("Regressors X will be normalized before regression by subtracting the mean and dividing by the l2-norm",
# options=['Both', 'True', 'False'])
# if normalize == 'Both':
# normalize = ['False', 'True']
# else:
# normalize = [normalize]
if selection == 'All':
selection = ['cyclic', 'random']
else:
selection = [selection]
if fit_intercept == 'Both':
fit_intercept = ['False', 'True']
else:
fit_intercept = [fit_intercept]
# if fit_intercept.__contains__('True'):
# param_grid = dict(selection = selection, l1_ratio = l1_ratio, alpha = alpha,
# fit_intercept = fit_intercept, normalize = normalize)
# else:
param_grid = dict(selection=selection, l1_ratio=l1_ratio, alpha=alpha,
fit_intercept=fit_intercept)
if reg == 'Gradient Boosting Regression':
if uploaded_file is not None:
df = pd.read_csv(uploaded_file)
else:
diabetes = load_diabetes()
X = pd.DataFrame(diabetes.data, columns=diabetes.feature_names)
Y = pd.Series(diabetes.target, name='response')
df = pd.concat([X, Y], axis=1)
st.sidebar.subheader('Variable Configuration')
ind_var = st.sidebar.multiselect('Choose Independent Variables', options=df.columns)
st.sidebar.subheader("Standard Scaling")
scale = st.sidebar.selectbox("Scale the data to be between -1 to 1", options=['True', 'False'])
st.sidebar.write('---')
criterion = st.sidebar.selectbox('Performance measure (criterion)', options=['All', 'MSE', 'MAE', 'RMSE'])
st.sidebar.write('---')
st.sidebar.header("Hyperparameters for Gradient Boosting Regression")
st.sidebar.subheader("Loss")
loss = st.sidebar.selectbox("Enter from the options", options=['All', 'squared_error', 'absolute_error', 'huber',
'quantile'])
st.sidebar.subheader("Learning Rate")
numbers = st.sidebar.text_input("Enter values for 'learning rate'. (Separate values with ,)", value='0.1')
learning_rate = collect_numbers(numbers)
numbers = st.sidebar.text_input("Enter number of estimators. (Separate values with ,)", value='100')
n_estimators = collect_numbers_int(numbers)
numbers = st.sidebar.text_input("Enter values for 'Subsample'. (Separate values with ,)", value='1.0')
subsample = collect_numbers(numbers)
numbers = st.sidebar.text_input("Enter minimum sample Split. (Separate values with ,)", value='2')
min_samples_split = collect_numbers_int(numbers)
numbers = st.sidebar.text_input("Enter minimum samples leaf. (Separate values with ,)", value='1')
min_samples_leaf = collect_numbers_int(numbers)
numbers = st.sidebar.text_input("Enter maximum depth. (Separate values with ,)", value='3')
max_depth = collect_numbers_int(numbers)
max_features = st.sidebar.selectbox("Maximum Features", options=['All', 'auto', 'sqrt', 'log2'])
if loss == 'All':
loss = ['squared_error', 'absolute_error', 'huber', 'quantile']
else:
loss = [loss]
if max_features == 'All':
max_features = ['auto', 'sqrt', 'log2']
else:
max_features = [max_features]
param_grid = dict(loss=loss, learning_rate=learning_rate, n_estimators=n_estimators, subsample=subsample,
min_samples_split=min_samples_split, min_samples_leaf=min_samples_leaf,
max_depth=max_depth, max_features=max_features)
# main Body ...............................................................................................
st.subheader('Dataset')
if uploaded_file is not None:
df = | pd.read_csv(uploaded_file) | pandas.read_csv |
"""Contains functions for preprocessing data
Classes
-------
Person
Functions
----------
recurcive_append
create_pedigree
add_control
prepare_data
"""
import logging
import pandas as pd
import numpy as np
from pysnptools.snpreader import Bed
from bgen_reader import open_bgen, read_bgen
from config import nan_integer
class Person:
"""Just a simple data structure representing individuals
Args:
id : str
IID of the individual.
fid : str
FID of the individual.
pid : str
IID of the father of that individual.
mid : str
IID of the mother of that individual.
"""
def __init__(self, id, fid=None, pid=None, mid=None):
self.id = id
self.fid = fid
self.pid = pid
self.mid = mid
def recurcive_append(dictionary, index, element):
"""Adds an element to value of all the keys that can be reached from index with using get recursively.
Args:
dictionary : dict
A dictionary of objects to list
index
The start point
element
What should be added to values
"""
queue = {index}
seen_so_far = set()
while queue:
current_index = queue.pop()
seen_so_far.add(current_index)
dictionary[current_index].add(element)
queue = queue.union(dictionary[current_index])
queue = queue.difference(seen_so_far)
def create_pedigree(king_address, agesex_address):
"""Creates pedigree table from agesex file and kinship file in KING format.
Args:
king_address : str
Address of a kinship file in KING format. kinship file is a '\t' seperated csv with columns "FID1", "ID1", "FID2", "ID2, "InfType".
Each row represents a relationship between two individuals. InfType column states the relationship between two individuals.
The only relationships that matter for this script are full sibling and parent-offspring which are shown by 'FS' and 'PO' respectively.
This file is used in creating a pedigree file and can be generated using KING.
As fids starting with '_' are reserved for control there should be no fids starting with '_'.
agesex_address : str
Address of the agesex file. This is a " " seperated CSV with columns "FID", "IID", "FATHER_ID", "MOTHER_ID", "sex", "age".
Each row contains the age and sex of one individual. Male and Female sex should be represented with 'M' and 'F'.
Age column is used for distinguishing between parent and child in a parent-offspring relationship inferred from the kinship file.
ID1 is a parent of ID2 if there is a 'PO' relationship between them and 'ID1' is at least 12 years older than ID2.
Returns:
pd.DataFrame:
A pedigree table with 'FID', 'IID', 'FATHER_ID', 'MOTHER_ID'. Each row represents an individual.
"""
kinship = | pd.read_csv(king_address, delimiter="\t") | pandas.read_csv |
from datetime import datetime, timedelta
import dateutil
import numpy as np
import pytest
import pytz
from pandas._libs.tslibs.ccalendar import DAYS, MONTHS
from pandas._libs.tslibs.period import IncompatibleFrequency
from pandas.compat import lrange, range, zip
import pandas as pd
from pandas import DataFrame, Series, Timestamp
from pandas.core.indexes.base import InvalidIndexError
from pandas.core.indexes.datetimes import date_range
from pandas.core.indexes.period import Period, PeriodIndex, period_range
from pandas.core.resample import _get_period_range_edges
import pandas.util.testing as tm
from pandas.util.testing import (
assert_almost_equal, assert_frame_equal, assert_series_equal)
import pandas.tseries.offsets as offsets
@pytest.fixture()
def _index_factory():
return period_range
@pytest.fixture
def _series_name():
return 'pi'
class TestPeriodIndex(object):
@pytest.mark.parametrize('freq', ['2D', '1H', '2H'])
@pytest.mark.parametrize('kind', ['period', None, 'timestamp'])
def test_asfreq(self, series_and_frame, freq, kind):
# GH 12884, 15944
# make sure .asfreq() returns PeriodIndex (except kind='timestamp')
obj = series_and_frame
if kind == 'timestamp':
expected = obj.to_timestamp().resample(freq).asfreq()
else:
start = obj.index[0].to_timestamp(how='start')
end = (obj.index[-1] + obj.index.freq).to_timestamp(how='start')
new_index = date_range(start=start, end=end, freq=freq,
closed='left')
expected = obj.to_timestamp().reindex(new_index).to_period(freq)
result = obj.resample(freq, kind=kind).asfreq()
assert_almost_equal(result, expected)
def test_asfreq_fill_value(self, series):
# test for fill value during resampling, issue 3715
s = series
new_index = date_range(s.index[0].to_timestamp(how='start'),
(s.index[-1]).to_timestamp(how='start'),
freq='1H')
expected = s.to_timestamp().reindex(new_index, fill_value=4.0)
result = s.resample('1H', kind='timestamp').asfreq(fill_value=4.0)
assert_series_equal(result, expected)
frame = s.to_frame('value')
new_index = date_range(frame.index[0].to_timestamp(how='start'),
(frame.index[-1]).to_timestamp(how='start'),
freq='1H')
expected = frame.to_timestamp().reindex(new_index, fill_value=3.0)
result = frame.resample('1H', kind='timestamp').asfreq(fill_value=3.0)
assert_frame_equal(result, expected)
@pytest.mark.parametrize('freq', ['H', '12H', '2D', 'W'])
@pytest.mark.parametrize('kind', [None, 'period', 'timestamp'])
@pytest.mark.parametrize('kwargs', [dict(on='date'), dict(level='d')])
def test_selection(self, index, freq, kind, kwargs):
# This is a bug, these should be implemented
# GH 14008
rng = np.arange(len(index), dtype=np.int64)
df = DataFrame({'date': index, 'a': rng},
index=pd.MultiIndex.from_arrays([rng, index],
names=['v', 'd']))
msg = ("Resampling from level= or on= selection with a PeriodIndex is"
r" not currently supported, use \.set_index\(\.\.\.\) to"
" explicitly set index")
with pytest.raises(NotImplementedError, match=msg):
df.resample(freq, kind=kind, **kwargs)
@pytest.mark.parametrize('month', MONTHS)
@pytest.mark.parametrize('meth', ['ffill', 'bfill'])
@pytest.mark.parametrize('conv', ['start', 'end'])
@pytest.mark.parametrize('targ', ['D', 'B', 'M'])
def test_annual_upsample_cases(self, targ, conv, meth, month,
simple_period_range_series):
ts = simple_period_range_series(
'1/1/1990', '12/31/1991', freq='A-%s' % month)
result = getattr(ts.resample(targ, convention=conv), meth)()
expected = result.to_timestamp(targ, how=conv)
expected = expected.asfreq(targ, meth).to_period()
assert_series_equal(result, expected)
def test_basic_downsample(self, simple_period_range_series):
ts = simple_period_range_series('1/1/1990', '6/30/1995', freq='M')
result = ts.resample('a-dec').mean()
expected = ts.groupby(ts.index.year).mean()
expected.index = period_range('1/1/1990', '6/30/1995', freq='a-dec')
assert_series_equal(result, expected)
# this is ok
assert_series_equal(ts.resample('a-dec').mean(), result)
assert_series_equal(ts.resample('a').mean(), result)
@pytest.mark.parametrize('rule,expected_error_msg', [
('a-dec', '<YearEnd: month=12>'),
('q-mar', '<QuarterEnd: startingMonth=3>'),
('M', '<MonthEnd>'),
('w-thu', '<Week: weekday=3>')
])
def test_not_subperiod(
self, simple_period_range_series, rule, expected_error_msg):
# These are incompatible period rules for resampling
ts = simple_period_range_series('1/1/1990', '6/30/1995', freq='w-wed')
msg = ("Frequency <Week: weekday=2> cannot be resampled to {}, as they"
" are not sub or super periods").format(expected_error_msg)
with pytest.raises(IncompatibleFrequency, match=msg):
ts.resample(rule).mean()
@pytest.mark.parametrize('freq', ['D', '2D'])
def test_basic_upsample(self, freq, simple_period_range_series):
ts = simple_period_range_series('1/1/1990', '6/30/1995', freq='M')
result = ts.resample('a-dec').mean()
resampled = result.resample(freq, convention='end').ffill()
expected = result.to_timestamp(freq, how='end')
expected = expected.asfreq(freq, 'ffill').to_period(freq)
assert_series_equal(resampled, expected)
def test_upsample_with_limit(self):
rng = period_range('1/1/2000', periods=5, freq='A')
ts = Series(np.random.randn(len(rng)), rng)
result = ts.resample('M', convention='end').ffill(limit=2)
expected = ts.asfreq('M').reindex(result.index, method='ffill',
limit=2)
assert_series_equal(result, expected)
def test_annual_upsample(self, simple_period_range_series):
ts = simple_period_range_series('1/1/1990', '12/31/1995', freq='A-DEC')
df = DataFrame({'a': ts})
rdf = df.resample('D').ffill()
exp = df['a'].resample('D').ffill()
assert_series_equal(rdf['a'], exp)
rng = period_range('2000', '2003', freq='A-DEC')
ts = Series([1, 2, 3, 4], index=rng)
result = ts.resample('M').ffill()
ex_index = period_range('2000-01', '2003-12', freq='M')
expected = ts.asfreq('M', how='start').reindex(ex_index,
method='ffill')
assert_series_equal(result, expected)
@pytest.mark.parametrize('month', MONTHS)
@pytest.mark.parametrize('target', ['D', 'B', 'M'])
@pytest.mark.parametrize('convention', ['start', 'end'])
def test_quarterly_upsample(self, month, target, convention,
simple_period_range_series):
freq = 'Q-{month}'.format(month=month)
ts = simple_period_range_series('1/1/1990', '12/31/1995', freq=freq)
result = ts.resample(target, convention=convention).ffill()
expected = result.to_timestamp(target, how=convention)
expected = expected.asfreq(target, 'ffill').to_period()
assert_series_equal(result, expected)
@pytest.mark.parametrize('target', ['D', 'B'])
@pytest.mark.parametrize('convention', ['start', 'end'])
def test_monthly_upsample(self, target, convention,
simple_period_range_series):
ts = simple_period_range_series('1/1/1990', '12/31/1995', freq='M')
result = ts.resample(target, convention=convention).ffill()
expected = result.to_timestamp(target, how=convention)
expected = expected.asfreq(target, 'ffill').to_period()
assert_series_equal(result, expected)
def test_resample_basic(self):
# GH3609
s = Series(range(100), index=date_range(
'20130101', freq='s', periods=100, name='idx'), dtype='float')
s[10:30] = np.nan
index = PeriodIndex([
Period('2013-01-01 00:00', 'T'),
Period('2013-01-01 00:01', 'T')], name='idx')
expected = Series([34.5, 79.5], index=index)
result = s.to_period().resample('T', kind='period').mean()
assert_series_equal(result, expected)
result2 = s.resample('T', kind='period').mean()
assert_series_equal(result2, expected)
@pytest.mark.parametrize('freq,expected_vals', [('M', [31, 29, 31, 9]),
('2M', [31 + 29, 31 + 9])])
def test_resample_count(self, freq, expected_vals):
# GH12774
series = Series(1, index=pd.period_range(start='2000', periods=100))
result = series.resample(freq).count()
expected_index = pd.period_range(start='2000', freq=freq,
periods=len(expected_vals))
expected = Series(expected_vals, index=expected_index)
assert_series_equal(result, expected)
def test_resample_same_freq(self, resample_method):
# GH12770
series = Series(range(3), index=pd.period_range(
start='2000', periods=3, freq='M'))
expected = series
result = getattr(series.resample('M'), resample_method)()
assert_series_equal(result, expected)
def test_resample_incompat_freq(self):
msg = ("Frequency <MonthEnd> cannot be resampled to <Week: weekday=6>,"
" as they are not sub or super periods")
with pytest.raises(IncompatibleFrequency, match=msg):
Series( | range(3) | pandas.compat.range |
import sys
import time
import shutil
import os
import numpy as np
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
from tqdm import trange
from tqdm import tqdm
import pandas as pd
import scipy.optimize as op
import scipy.stats
import batman
import emcee
import corner
import pickle
from wave_solution import orbits
from kapteyn import kmpfit
from classes import MargPriors
def next_pow_two(n):
i = 1
while i < n:
i = i << 1
return i
def auto_window(taus, c):
m = np.arange(len(taus)) < c * taus
if np.any(m):
return np.argmin(m)
return len(taus) - 1
def autocorr_func_1d(x, norm=True):
x = np.atleast_1d(x)
if len(x.shape) != 1:
raise ValueError("invalid dimensions for 1D autocorrelation function")
n = next_pow_two(len(x))
# Compute the FFT and then (from that) the auto-correlation function
f = np.fft.fft(x - np.mean(x), n=2 * n)
acf = np.fft.ifft(f * np.conjugate(f))[: len(x)].real
acf /= 4.0 * n
# Optionally normalize
if norm:
acf /= float(acf[0])
return acf
def autocorr_new(y, c=5.0):
f = np.zeros(y.shape[1])
for yy in y:
f += autocorr_func_1d(yy)
f /= float(len(y))
taus = 2.0 * np.cumsum(f) - 1.0
window = auto_window(taus, c)
return taus[window]
def plot_chain(chain, n, lab='param', save=False, mc_dir='.'):
for i in range(chain.shape[0]):
plt.plot(chain[i,:,n])
plt.title(lab)
if save == True:
plt.savefig(mc_dir+'/'+lab+'_chains.pdf')
plt.clf()
else:
plt.show()
return None
def get_sys_model(p, phase, HSTphase, sh, dir_array, one_slope=True):
# The first line makes sure the forward slope only applies to
# the forward scans and the reverse slope (p[26]) only applies to reverse
# scans.
fslope = phase*p[19] + phase*phase*p[20] - p[21]*np.exp(-1.0*phase/p[22]) - p[23]*np.log(phase+p[24])
rslope = phase*p[26] + phase*phase*p[27] - p[28]*np.exp(-1.0*phase/p[29]) - p[30]*np.log(phase+p[31])
# This is a global variable defined in whitelight2020. It is equal to
# one_slope, and if true forces reverse and forward scan exposures to
# be fit with a single slope. This should always be true for non-linear
# slopes.
if one_slope == True:
slope_directions = np.zeros_like(dir_array)
else:
slope_directions = dir_array
systematic_model = ((fslope*(1-slope_directions)+rslope*slope_directions + 1.0)
* (HSTphase*p[2] + HSTphase**2.*p[3] + HSTphase**3.*p[4]
+ HSTphase**4.*p[5] + 1.0)
* (sh*p[6] + sh**2.*p[7] + sh**3.*p[8] + sh**4.*p[9]
+ 1.0))
systematic_model = p[18]*systematic_model*(1-dir_array) + p[25]*systematic_model*dir_array
return systematic_model
def get_lightcurve_model(p, date, limb_type="nonlinear", transit=False):
params=batman.TransitParams()
params.w=90.
params.ecc=0
params.rp=p[0]
tc=p[1]
params.inc=p[10]
params.a=p[11]
params.per=p[16]
depth=p[17]
if transit==True:
params.t0=tc
params.limb_dark=limb_type
if limb_type=="nonlinear":
params.u=p[12:16]
if limb_type=="quadratic":
params.u=p[12:14]
if limb_type=="linear":
params.u=[p[12]]
m=batman.TransitModel(params, date, fac=0.0315)
model=m.light_curve(params)
else:
params.fp=depth
params.t_secondary=tc
params.u=[]
params.limb_dark="uniform"
m=batman.TransitModel(params, date, transittype="secondary")
model=m.light_curve(params)
return model
def lightcurve(p, x, sh, HSTphase, dir_array, transit=False, ld_type="nonlinear", one_slope=True):
""" Function used by MPFIT to fit data to lightcurve model.
Inputs: p: input parameters that we are fitting for
x: Date of each observation, to be converted to phase
y: Flux of each time series observation
err: Error on flux of each time series point
sh: Parameter for wavelength shift on the detector (for each exposure)
rprs: Ratio of planet to star radii
transit: True for transit, false for eclipse
Output: Returns weighted deviations between model and data to be minimized
by MPFIT. """
# Add in dir_array here
# Old param order= [rprs,flux0,tc,m,HSTP1,HSTP2,HSTP3,HSTP4,HSTP5,HSTP6,xshift1
# ,xshift2,xshift3,xshift4,xshift5,xshift6,inclin,A_R,c1,c2,c3,c4,Per,fp]
# New param order
#p0 = [rprs,epoch,
# HSTP1,HSTP2,HSTP3,HSTP4,
# xshift1 ,xshift2 ,xshift3,xshift4,
# inclin,a_r,c1,c2,c3,c4,
# Per,fp,fnorm, flinear, fquad,
# fexpb, fexpc, flogb, flogc,
# rnorm, rlinear, rquad,
# rexpb, rexpc, rlogb, rlogc]
Per = p[16]
phase = (x-p[1]) / Per
phase = phase - np.floor(phase)
phase[phase > 0.5] = phase[phase > 0.5] - 1.0
systematic_model=get_sys_model(p, phase, HSTphase
, sh, dir_array
, one_slope=one_slope)
lcmodel = get_lightcurve_model(p, x, transit=transit
, limb_type=ld_type)
model = lcmodel*systematic_model
return model
def lnlike(p, x, y, yerr, *args):
""" p i paramters of model, model is the name of the function of the model
args contains any extraneous arguments used in model calculation, like sh in
marginalization. """
theory = lightcurve(p, x, *args)
inv_sigma = 1.0 / yerr / yerr
return -.5*np.sum((y-theory)**2*inv_sigma - np.log(inv_sigma))
def max_like(p_start, lnlike_args):
""" Function to maximize log likelihood. Gives parameter values at max
log likelihood so we can initialize our walkers to those values."""
nll = lambda *args: -lnlike(*args)
x = lnlike_args[0]
y = lnlike_args[1]
yerr = lnlike_args[2]
priors = lnlike_args[3]
extras = lnlike_args[4:]
bounds = priors.convert_to_bounds()
result = op.minimize(nll, p_start, bounds=bounds, method='Powell'
, args=(x, y, yerr, *extras))
# Method is powell or tnc, so far
p_max= result["x"]
return p_max
def lnprob(p, x, y, yerr, priors, *args):
p_start = priors.initial_guess
syst = priors.systematic_model
params = p_start.copy()
params[syst==0] = p
lp=lnprior(params, priors)
if not np.isfinite(lp):
return -np.inf
return lp + lnlike(params, x, y, yerr, *args)
def lnprior(theta, priors):
param_names = priors.parameter_names
syst = priors.systematic_model
test=np.ones(len(theta))
# Ensure inclination is less than 90 degrees.
if not theta[10]<90.0: return -np.inf
# Evaluate the priors. If any prior is violated,
# immediately return -infinity and exit function.
for i, par in enumerate(param_names):
if syst[i]==0:
value = priors.prior_check(par, theta[i])
if value==False:
return -np.inf
else:
# If true is returned, it is saved as 1 (and ln(1)=0).
# If number is returned (gaussian prior), only change
# is numpy float 64 to native float.
test[i] = float(value)
if np.isfinite(np.sum(np.log(test))):
return np.sum(np.log(test))
else:
print('Parameter value outside prior range.')
return -np.inf
def residuals(p, data):
x, y, err, sh, HSTphase, dir_array, transit, ld_type, one_slope = data
ym = lightcurve(p
, x
, sh
, HSTphase
, dir_array
, transit=transit
, ld_type=ld_type
, one_slope=one_slope)
return (y-ym) / err
def get_shift(allspec):
nexposure=allspec.shape[0]
sh = np.zeros(nexposure)
nLag=3
inp1=allspec[-1,:]-allspec[-1,:].mean()
for i in trange(nexposure, desc='Performing cross correlation'):
# Subtract mean to mimic
inp2=allspec[i,:]-np.ma.mean(allspec[i,:])
corr_tuple = plt.xcorr(inp1, inp2, maxlags=nLag)
lag,corr=corr_tuple[0],corr_tuple[1]
mx=np.argmax(corr)
srad=3
sublag=lag[max(mx-srad,0):max(mx+srad,2*nLag+1)]
subcorr=corr[max(mx-srad,0):max(mx+srad,2*nLag+1)]
p=np.polyfit(sublag, subcorr, 2)
sh[i]=p[1]/2./p[0]
plt.clf()
plt.close('all')
return sh
def systematic_model_grid_selection(size=4
, dir_array=np.ones(1)
, transit=False
, linear_slope=True
, quad_slope=False
, exp_slope=False
, log_slope=False
, one_slope=True):
""" Returns model grid that indicates which parameters
will be openly fit for and which will be fixed. Larger
size will test higher powers. """
if size not in [2,4,6]:
sys.exit('Grid size can only be 2, 4, or 6')
# MODEL GRID FOR JUST ECLIPSE DEPTH
if size == 2:
grid = [[0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
[0,0,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
[0,0,0,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
[0,0,0,1,0,0,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1],
[0,0,0,1,0,0,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1],
[0,0,0,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1],
[0,0,0,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1],
[0,0,0,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1],
[0,0,0,1,0,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1],
[0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
[0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
[0,0,0,0,0,0,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1],
[0,0,0,0,0,0,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1],
[0,0,0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1],
[0,0,0,0,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1],
[0,0,0,0,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1],
[0,0,0,0,0,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1]]
if size == 4:
# MODEL GRID UPTO THE 4th ORDER for HST & DELTA_lambda
grid = [[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ,
[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]
grid=np.asarray(grid)
#if transit == True:
# grid[:,18:22]=0
# Remove the 5/6 powers of hst phase and wavelength shift (50 x 20)
grid = np.delete(grid, [8, 9, 14, 15], axis=1)
grid = np.vstack((grid.T,grid[:,1])).T
grid = np.vstack((grid.T,grid[:,3])).T
grid = np.delete(grid, [1, 3], axis=1)
# Add 12 spots in grid for bi-directional scan normalization and different slopes (50 x 32)
grid = np.vstack((grid.T,np.ones((12, grid.shape[0])))).T
#linear = True
#quad = True
#exp = True
#log = True
#p0 = [rprs,epoch,
# HSTP1,HSTP2,HSTP3,HSTP4,
# xshift1 ,xshift2 ,xshift3,xshift4,
# inclin,a_r,c1,c2,c3,c4,
# Per,fp,fnorm, flinear, fquad,
# fexpb, fexpc, flogb, flogc,
# rnorm, rlinear, rquad,
# rexpb, rexpc, rlogb, rlogc]
grid[:25, 19] = 1
grid[25:, 19] = int(not linear_slope)
# Add another 25 models for quad slope
# Set values to 1 to fix (and ignore this slope in fits), or to zero to
# leave open.
quad_grid = grid[:25,:].copy()
quad_grid[:, 19] = int(not quad_slope)
quad_grid[:, 20] = int(not quad_slope)
grid = np.hstack((grid.T, quad_grid.T)).T
# Add another 25 models for exp slope
exp_grid = grid[:25,:].copy()
exp_grid[:, 21] = int(not exp_slope)
exp_grid[:, 22] = int(not exp_slope)
grid = np.hstack((grid.T, exp_grid.T)).T
# Add another 25 models for log slope
log_grid = grid[:25,:].copy()
log_grid[:, 23] = int(not log_slope)
log_grid[:, 24] = int(not log_slope)
grid = np.hstack((grid.T, log_grid.T)).T
# If dir_array isn't all ones or all zeros, then turn on reverse slope
# and normalization whenever forward slope/norm is on
if 0<np.sum(dir_array)<len(dir_array):
grid[:, 25:] = grid[:, 18:25]
# Hack to fit for only 1 directional slope even with forward/reverse array
if one_slope == True:
grid[:, 26:] = 1.0
return grid
def whitelight2020(p_start
, img_date
, allspec
, allerr
, dir_array
, plotting=False
, plot_best=True
, mcmc = False
, fixtime=False
, norandomt=False
, openinc=False
, openar=False
, include_error_inflation=True
, ld_type="nonlinear"
, linear_slope=True
, quad_slope=False
, exp_slope=False
, log_slope=False
, one_slope=True
, save_mcmc=False
, save_model_info=False
, transit=False
, save_name=None):
"""
Function to perform Levenberg-Marquardt least-squares minimization with
KMPFIT and/or MCMC on spectral data from HST WFC3 to compute the white light curve
INPUTS:
P_START - priors for each parameter used in the fit passed in
an array in the form
p_start = [rprs,epoch,inclin,a/rs,Per, fp]
rprs - Planetary radius/stellar radius
epoch - center of eclipse time
inclin - inclination of the planetary orbit
a/Rs - semimajor axis normalized by stellar radius
Per - Period of the planet in days
fp - event depth
IMG_DATE - array of time of each exposure as extracted from the .fits header (MJD)
ALLSPEC - 2D array each row containing the target stellar
spectrum extracted from the exposure images.
ALLERR - Uncertainty for each pixel flux in allspec
dir_array - Of length img_date indicating if each exposure is a forward scan (0) or reverse (1)
savewl - True to save results
plotting - set as True or False to see the model fits.
FIXTIME - True to keep center of eclipse/transit time fixed
NORANDOMT - True to not allow small random changes to center time
OPENINC - True to fit for inclination
TRANSIT - True for transit light curves, default false for eclipse
Plus a few more options.
"""
# Determine the number of exposures in light curve.
nexposure = len(img_date)
# Set up data as arrays x (observation time) and y (normalized flux).
x = img_date
y = allspec.sum(axis=1)
err = np.sqrt(np.sum(allerr*allerr, axis=1))
# Determine theoretical limit on uncertainty, (in ppm) which is approximately
# the photon error (err also incorporates additional noise from
# data reduction, such as background removal noise and read noise).
# For perfect model and reduction, scatter (standard deviation)
# in residuals will equal this value.
phot_err = 1e6 * np.median(err/y)
# phot_err=1e6/np.median(np.sqrt(y))
# Hold un-normalized (raw) data in order to save later.
orbit_start, orbit_end = orbits('holder', x=x, y=y, transit=transit)[1]
norm = np.median(y[orbit_start:orbit_end])
rawerr = err.copy()
rawflux = y.copy()
err = err / norm
y = y / norm
# Determine wavelength shift and HST phase, which are arguments
# in systematic models.
sh = get_shift(allspec)
# Sometimes, expanding HST phase to the first orbit
# results in a terrible fit. This is fixed by using the midpoint instead of
# the zeroth orbital point, since this fits on a -.25-.25 scale (and so nothing is
# really out of sample: maybe +-.3 comes up, but this is easier to extrapolate to).
HSTper = 96.36 / (24.*60.)
hst_midpoint = int(np.mean([orbit_start, orbit_end]))
HSTphase = (img_date-img_date[hst_midpoint]) / HSTper
HSTphase = HSTphase - np.floor(HSTphase)
HSTphase[HSTphase>0.5] = HSTphase[HSTphase>0.5] - 1.0
# Initialize every potential parameter, starting with astrophysical ones.
rprs = p_start[0, 0]
epoch = p_start[1, 0]
inclin = p_start[2, 0]
a_r = p_start[3, 0]
Per = p_start[4, 0]
# Depth shown as fp, which stands for Flux_planet, a remnant from eclipse depth origins.
fp = p_start[5, 0]
# Limb-darkening parameters shown as c1-c4.
c1 = p_start[6, 0]
c2 = p_start[7, 0]
c3 = p_start[8, 0]
c4 = p_start[9, 0]
# Forward-scan and reverse-scan normalizations
fnorm = 1.0
rnorm = 1.0
# Initialize visit-long slope parameters. F/R indicate slope on
# forward or reverse scan light curves. Parameters ending in b
# and c are slope factor and slope phase, respectively.
flinear = 0.0
fquad = 0.0
fexpb = 0.0
fexpc = 1.0
flogb = 0.0
flogc = 1.0
rlinear = 0.0
rquad = 0.0
rexpb = 0.0
rexpc = 1.0
rlogb = 0.0
rlogc = 1.0
# Initialize the polynomial instrument-systematics related coefficients,
# wavelength shift and HST phase.
xshift1 = 0.0
xshift2 = 0.0
xshift3 = 0.0
xshift4 = 0.0
HSTP1 = 0.0
HSTP2 = 0.0
HSTP3 = 0.0
HSTP4 = 0.0
# Initialize parameter array, p0.
p0 = [rprs, epoch
, HSTP1, HSTP2, HSTP3, HSTP4
, xshift1, xshift2, xshift3, xshift4
, inclin, a_r, c1, c2, c3, c4
, Per, fp, fnorm, flinear, fquad
, fexpb, fexpc, flogb, flogc
, rnorm, rlinear, rquad
, rexpb, rexpc, rlogb, rlogc]
# Array of labels for easier reference.
lab = np.array(['Depth', 'Epoch', 'HST1', 'HST2'
, 'HST3', 'HST4', 'sh1','sh2'
, 'sh3', 'sh4', 'i', 'ars', 'c1'
, 'c2', 'c3', 'c4', 'Per', 'Eclipse Depth'
, 'fnorm', 'flinear', 'fquad', 'fexpb'
, 'fexpc', 'flogb', 'flogc', 'rnorm'
, 'rlinear', 'rquad', 'rexpb'
, 'rexpc', 'rlogb', 'rlogc' ])
nParam = len(p0)
# Retrieve grid of systematic models to test.
grid = systematic_model_grid_selection(size=4
, dir_array=dir_array
, transit=transit
, linear_slope=linear_slope
, quad_slope=quad_slope
, exp_slope=exp_slope
, log_slope=log_slope
, one_slope=one_slope)
nsys = len(grid[:,0])
# Initialize systematic-related arrays to hold results for
# every fitted systematic model.
sys_depth = np.zeros((nsys,2))
sys_model_x = np.zeros((nsys,500))
sys_model = np.zeros((nsys,500))
sys_lightcurve_x = np.zeros((nsys,nexposure))
sys_lightcurve = np.zeros((nsys,nexposure))
sys_lightcurve_err = np.zeros((nsys,nexposure))
sys_residuals = np.zeros((nsys,nexposure))
sys_params = np.zeros((nsys,nParam))
sys_params_err = np.zeros((nsys,nParam))
sys_evidence = np.zeros((nsys))
sys_model_full=np.zeros((nsys,nexposure))
model_tested=np.zeros(nsys, dtype=bool)
phase = np.zeros(nexposure)
# Array to hold the scatter of the residuals for each systematic model.
resid_stddev = np.zeros(nsys)
# Arrays to save AIC and parameters from first KMPFIT fit.
run1_AIC = np.zeros(nsys)
run1_params = np.zeros((nsys,nParam))
# Optional: First run 4 trials with slightly shifted center
# of event times and depths.
ntrials=5
tcenter = np.zeros(ntrials+1)
t1 = 5. / 60. / 24.
tcenter[0] = epoch
if fixtime==False and norandomt==False:
tcenter[1:] = epoch + t1*np.random.normal(size=ntrials)
AIC_test = np.zeros(ntrials+1)
depth_test = np.zeros(ntrials+1)
print('---------- ------------ ------------')
print(' 1ST FIT ')
print('---------- ------------ ------------')
for s, systematics in tqdm(enumerate(grid), desc='First MPFIT run'):
# Skip models with slopes that aren't being tested.
if linear_slope==False and 24<s<50:
continue
if quad_slope==False and 49<s<75:
continue
if exp_slope==False and 74<s<100:
continue
if log_slope==False and s>99:
continue
system=systematics
if fixtime==False and norandomt==False:
for n in range(ntrials+1):
epoch = tcenter[n]
# Reset priors
p0 = [rprs,epoch,
HSTP1,HSTP2,HSTP3,HSTP4,
xshift1 ,xshift2 ,xshift3,xshift4,
inclin,a_r,c1,c2,c3,c4,
Per,fp,fnorm, flinear, fquad,
fexpb, fexpc, flogb, flogc,
rnorm, rlinear, rquad,
rexpb, rexpc, rlogb, rlogc]
if openinc==True: system[10] = 0
if openar==True: system[11] = 0
if ld_type=='linear': system[12] = 0
if transit==False:
system[0]=1
system[17]=0
parinfo=[]
for i in range(len(p0)):
dic = {'fixed':system[i]}
# if lab[i]=='c1':
# dic = {'fixed':system[i], 'limits': [0.0, 1.0]}
if lab[i]=='flogc' or lab[i]=='rlogc':
dic = {'fixed':system[i], 'limits': [0.5,None]}
if lab[i]=='fexpc' or lab[i]=='rexpc':
dic = {'fixed':system[i], 'limits': [0.0001,None]}
parinfo.append(dic)
fa=(x, y, err, sh, HSTphase, dir_array, transit, ld_type, one_slope)
m1=kmpfit.Fitter(residuals=residuals, data=fa, parinfo=parinfo, params0=p0)
m1.fit()
params_test=m1.params
# For each tested epoch time, get the depth and the AIC
# Make sure this is all computed correctly
AIC_test[n] = (2*len(x)*np.log(np.ma.median(err)) + len(x)*np.log(2*np.pi)
+ m1.chi2_min + 2*m1.nfree)
if transit==True:
depth_test[n] = params_test[0]*params_test[0]
else:
depth_test[n] = params_test[17]
# Find the epoch time with the lowest AIC. Use it (or the average of
# values if multiple) to get starting depth and epoch time for
# next round of fits.
best = np.argmin(AIC_test)
print(best)
print('Best eclipse depth prior =', depth_test[best])
print('Best center of eclipse prior =', tcenter[best])
depth = np.mean(depth_test[best])
epoch = np.median(tcenter[best])
if transit==True:
rprs=np.sqrt(depth)
else:
fp=depth
# Re-run the fitting process with the best prior as defined by the iterative fit.
# Or, more commonly, when norandomt is false then this is the first model fit.
p0 = [rprs, epoch
, HSTP1, HSTP2, HSTP3, HSTP4
, xshift1, xshift2, xshift3, xshift4
, inclin, a_r, c1, c2, c3, c4
, Per, fp, fnorm, flinear, fquad
, fexpb, fexpc, flogb, flogc
, rnorm, rlinear, rquad
, rexpb, rexpc, rlogb, rlogc]
if fixtime==True: system[1] = 1
if openinc==True: system[10] = 0
if openar==True: system[11] = 0
if ld_type=='linear': system[12] = 0
if transit==False:
system[0]=1
system[17]=0
parinfo=[]
for i in range(len(p0)):
# parinfo.append({'value':p0[i], 'fixed':system[i]
# , 'limited':[0,0], 'limits':[0.,0.]})
dic = {'fixed':system[i]}
# if lab[i]=='c1':
# dic = {'fixed':system[i], 'limits': [0.0, 1.0]}
if lab[i]=='flogc' or lab[i]=='rlogc':
dic = {'fixed':system[i], 'limits': [0.5, None]}
if lab[i]=='fexpc' or lab[i]=='rexpc':
dic = {'fixed':system[i], 'limits': [0.0001, None]}
parinfo.append(dic)
fa = (x, y, err, sh, HSTphase, dir_array, transit, ld_type, one_slope)
m2 = kmpfit.Fitter(residuals=residuals, data=fa, parinfo=parinfo, params0=p0)
m2.fit()
params_w = m2.params
AIC = (2*len(x)*np.log(np.median(err)) + len(x)*np.log(2*np.pi)
+ m2.chi2_min + 2*m2.nfree)
if transit==True:
print('Depth = ', np.square(params_w[0]), ' at ', params_w[1])
else:
print('Depth = ', params_w[17], ' at ', params_w[1])
# Re-calculate phase dependent on the output parameters.
phase = (x-params_w[1]) / params_w[16]
phase -= np.floor(phase)
phase[phase > 0.5] = phase[phase > 0.5] -1.0
# Calculate scatter in residuals for model.
# w_ is a meaningless placeholder to ensure no double-naming in code.
systematic_model = get_sys_model(params_w, phase, HSTphase, sh, dir_array, one_slope)
lc_model = get_lightcurve_model(params_w, x, transit=transit, limb_type=ld_type)
w_model = lc_model * systematic_model
w_residuals = (y - w_model)
resid_stddev[s] = np.std(w_residuals)
run1_AIC[s] = AIC
run1_params[s,:] = params_w
# Determine which of the systematic models initially gives the best fit.
top = np.argmin(run1_AIC)
# Optional: scale error by the scatter in the residuals of the best fit
# model, if scatter is greater than the flux uncertainty.
# This assumes that the best model is "correct" and the extra scatter is due to some
# unknown, Gaussian uncertainty. This is a shaky assumption, but provides a
# reasonable increase in depth uncertainty.
std = resid_stddev[top]
if np.median(err) < std and include_error_inflation==True:
scale = std / np.median(err)
print(scale)
#print 'Not inflating by this'
else:
scale=1
#scale=1
error = err * scale
# Perform fit a final time with scaled flux errors
# (and better defined initial guesses).
print('---------- ------------ ------------')
print(' FINAL FIT ')
print('---------- ------------ ------------')
for s, systematics in tqdm(enumerate(grid), desc='Final MPFIT run'):
if linear_slope==False and 24<s<50:
continue
if quad_slope==False and 49<s<75:
continue
if exp_slope==False and 74<s<100:
continue
if log_slope==False and s>99:
continue
model_tested[s] = True
# Define the new priors as the parameters from the best fitting
# systematic model.
p0 = run1_params[s, :]
if fixtime==True: systematics[1] = 1
if openinc==True: systematics[10] = 0
if openar==True: systematics[11] = 0
if ld_type=='linear': systematics[12] = 0
if transit==False:
systematics[0]=1
systematics[17]=0
parinfo=[]
for i in range(len(p0)):
dic = {'fixed':systematics[i]}
# if lab[i]=='c1':
# dic = {'fixed':system[i], 'limits': [0.0, 1.0]}
if lab[i]=='flogc' or lab[i]=='rlogc':
dic = {'fixed':systematics[i], 'limits': [0.5,None]}
if lab[i]=='fexpc' or lab[i]=='rexpc':
dic = {'fixed':systematics[i], 'limits': [0.0001,None]}
parinfo.append(dic)
fa = (x, y, error, sh, HSTphase, dir_array, transit, ld_type, one_slope)
m2 = kmpfit.Fitter(residuals=residuals, data=fa, parinfo=parinfo, params0=p0)
m2.fit()
params = m2.params
xerror = m2.xerror
nfree = m2.nfree
# AIC=m2.rchi2_min + nfree
AIC = (2*len(x)*np.log(np.ma.median(error)) + len(x)*np.log(2*np.pi)
+ m2.chi2_min + 2*nfree)
# Use either standard error (scaled for reduced chi-squared), or asymptotic error.
# stderror = m2.stderr
stderror = m2.xerror
print()
print('Model ', s)
print('reduced chi^2:', m2.rchi2_min)
print('dof', m2.dof)
print()
if transit==True:
print('Depth = ',np.square(params[0]), ' at ', params[1])
else:
print('Depth = ',params[17], ' at ', params[1])
# Re-calculate phase dependent on the output parameters.
phase = (x-params[1])/params[16]
phase -= np.floor(phase)
phase[phase > 0.5] = phase[phase > 0.5] -1.0
# Hold AIC-based evidence for each model.
sys_evidence[s] = -.5*AIC
systematic_model = get_sys_model(params, phase, HSTphase, sh, dir_array, one_slope=one_slope)
lc_model = get_lightcurve_model(params, x, transit=transit, limb_type=ld_type)
model = lc_model * systematic_model
corrected = y / systematic_model
fit_residuals = (y - model)
fit_err = error*(1-dir_array)*params[18] + error*dir_array*params[25]
time_smooth = (np.arange(500)*0.002-.5)*params[16]+params[1]
phase_smooth=np.arange(500)*.002-.5
smooth_model=get_lightcurve_model(params, time_smooth, transit=transit, limb_type=ld_type)
if plotting == True:
if s==0:
fig, ax = plt.subplots()
plt.show(block=False)
plt.clf()
plt.errorbar(img_date, y, error,ecolor='red', color='red'
, marker='o', ls='', label='Data')
plt.plot(img_date, systematic_model, color='blue', marker='o'
, ls='', label='Systematic Model')
plt.errorbar(img_date, corrected, fit_err, marker='x', color='green'
, ecolor='green', ls='', label='De-trended Data')
plt.legend(numpoints=1)
hst_power = 4 - np.sum(systematics[2:6])
xshift_power = 4 - np.sum(systematics[6:10])
slope_power = 2 - np.sum(systematics[19:21])
power_label = r'$\phi^%d$ + HST$^%d$ + $\delta^%d$' % (slope_power, hst_power, xshift_power)
if systematics[22]==0:
slope_power='exp'
power_label = r'$\phi^{%s}$ + HST$^%d$ + $\delta^%d$' % (slope_power, hst_power, xshift_power)
if systematics[23]==0:
slope_power='log'
power_label = r'$\phi^{%s}$ + HST$^%d$ + $\delta^%d$' % (slope_power, hst_power, xshift_power)
plt.text(0.3,0.9, power_label, transform=ax.transAxes)
plt.draw()
plt.pause(0.1)
#breakpoint()
# Save the output arrays for each systematic model.
if transit==True:
sys_depth[s,0] = np.square(params[0])
sys_depth[s,1] = stderror[0] * 2.0 * params[0]
else:
sys_depth[s,0] = params[17]
sys_depth[s,1] = stderror[17]
sys_lightcurve_x[s,:] = phase
sys_lightcurve[s,:] = corrected
sys_lightcurve_err[s,:] = fit_err
sys_model_x[s,:] = phase_smooth
sys_model[s,:] = smooth_model
sys_residuals[s,:] = fit_residuals
sys_params[s,:] = params
sys_params_err[s,:] = stderror
sys_model_full[s,:] = model
# With evidence (and other outputs) determined for each systematic
# model, we now marginalize over every model.
aics = sys_evidence
depth_array = sys_depth[:, 0]
depth_err_array = sys_depth[:, 1]
epoch_array = sys_params[:, 1]
epoch_err_array = sys_params_err[:, 1]
inc_array = sys_params[:, 10]
inc_err_array = sys_params_err[:, 10]
ar_array = sys_params[:, 11]
ar_err_array = sys_params_err[:, 11]
limb_array = sys_params[:, 12:16]
limb_err_array = sys_params_err[:, 12:16]
# Reverse sort as trying to maximize the negative log(evidence).
a = np.argsort(aics)[::-1]
best = np.argmax(aics)
print(best)
zero = np.where(aics < -300)
if (len(zero) > 1): print('Some bad fits - evidence becomes negative')
if (len(zero) > 24):
sys.exit('Over half the systematic models have negative evidence, adjust and rerun')
aics[aics < -300] = np.min(aics[aics>-300])
beta=100.
# Determine weight for each model.
# Beta is a computational convenience, used to avoid very high and very low numbers.
w_q = (np.exp(aics-beta)) / np.sum(np.exp(aics-beta))
bestfit = np.argmax(w_q)
n01 = np.where(w_q >= 0.1)
stdResid = np.std(sys_residuals[bestfit,:])
print('Evidences: ', aics)
print('Weights: ', w_q)
print(str(len(n01[0])) + ' models have a weight over 10%. Models: ', n01[0] , w_q[n01])
print('Most likely model is number ' +str(bestfit) +' at weight = ' + str(np.max(w_q)))
depth = depth_array
depth_err = depth_err_array
# Marginalize depth using formulas 15 and 16 from Wakeford 2016.
mean_depth = np.sum(w_q*depth)
theta_qi = depth
variance_theta_qi = depth_err * depth_err
error_theta_i = np.sqrt(np.sum(w_q*((theta_qi - mean_depth)**2 + variance_theta_qi)))
print('Depth = %f +/- %f' % (mean_depth*1e6, error_theta_i*1e6))
marg_depth = mean_depth
marg_depth_err = error_theta_i
# Marganilze tcenter
t0 = epoch_array
t0_err = epoch_err_array
inc = inc_array
inc_err = inc_err_array
ar = ar_array
ar_err = ar_err_array
print('Depth')
print(depth[a])
print(depth_err_array[a])
print('Center Time')
print(t0[a])
print(t0_err[a])
mean_t0=np.sum(w_q*t0)
theta_t0=t0
variance_theta_t0q = t0_err*t0_err
error_theta_t0 = np.sqrt(np.sum(w_q*((theta_t0 - mean_t0)**2 + variance_theta_t0q )))
print('Central time = %f +/- %f' % (mean_t0, error_theta_t0))
marg_epoch = mean_t0
marg_epoch_err = error_theta_t0
# Marginalize over inclination, if inclination is fit for.
if openinc==True:
mean_inc = np.sum(w_q*inc)
bestfit_theta_inc = inc
variance_theta_incq = inc_err * inc_err
error_theta_inc = np.sqrt(np.sum(w_q*((bestfit_theta_inc - mean_inc )**2
+ variance_theta_incq )))
print('Inclination = %f +/- %f' % (mean_inc, error_theta_inc))
marg_inc = mean_inc
marg_inc_err = error_theta_inc
else:
marg_inc = inc[0]
marg_inc_err = 0
# Marginalize over a/rs, if fit for.
if openar==True:
mean_ar = np.sum(w_q*ar)
bestfit_theta_ar = ar
variance_theta_arq = ar_err * ar_err
error_theta_ar = np.sqrt(np.sum(w_q*((bestfit_theta_ar - mean_ar)**2
+ variance_theta_arq )))
print('a/R* = %f +/- %f' % (mean_ar, error_theta_ar))
marg_ar = mean_ar
marg_ar_err = error_theta_ar
else:
marg_ar = ar[0]
marg_ar_err = 0
# Marginalize over linear LD (no other LD will ever be fit for).
marg_c = limb_array[0,:]
marg_c_err = np.zeros(4)
c0 = limb_array[:, 0]
c0_err = limb_err_array[:, 0]
# The the first LD coefficient is not fit for, mean_c0 = c0
# and error_c0 = 0.
mean_c0 = np.sum(w_q*c0)
var = c0_err * c0_err
error_c0 = np.sqrt(np.sum(w_q*((c0 - mean_c0)**2 + var)))
marg_c[0] = mean_c0
marg_c_err[0] = error_c0
if plot_best==True:
plt.close()
fig, ax = plt.subplots()
plt.errorbar(sys_lightcurve_x[bestfit,:], sys_lightcurve[bestfit,:], sys_lightcurve_err[bestfit,:]
,marker='o', color='b', ecolor='b', ls='')
plt.plot(sys_model_x[bestfit,:], sys_model[bestfit,:], ls='-')
delta=sys_lightcurve_x[bestfit,1]-sys_lightcurve_x[bestfit,0]
plt.xlim([sys_lightcurve_x[bestfit,0]-delta, sys_lightcurve_x[bestfit,-1]+delta])
plt.title('HAT-P-41b WFC3 whitelight curve: Marginalization')
plt.xlabel('Phase')
plt.ylabel('Normalized Flux')
# plt.ylim([.999,1.001])
hst_power = 4 - np.sum(grid[bestfit, 2:6])
slope_power = 2 - np.sum(grid[bestfit, 19:21])
xshift_power = 4 - np.sum(grid[bestfit, 6:10])
power_label = r'$\phi^%d$ + HST$^%d$ + $\delta^%d$' % (slope_power, hst_power, xshift_power)
plt.text(0.3,0.9, power_label, transform=ax.transAxes)
plt.show()
# plt.errorbar(sys_lightcurve_x[bestfit,:], sys_residuals[bestfit,:], sys_lightcurve_err[bestfit,:]
#, marker='o', color='b', ls='',ecolor='blue')
# plt.plot(sys_lightcurve_x[bestfit,:], np.zeros_like(sys_lightcurve_x[1,:]))
# plt.show()
rms = np.std(sys_residuals[bestfit,:]) * 1e6
ratio = rms / phot_err
print('Rms: %f' % rms)
print('Photon error: %f' % phot_err)
print('Ratio: %f' % ratio)
best = a[0]
####### Plot the auto-correlation function of the residuals ########
if plot_best==True:
ac_resids = autocorr_func_1d(sys_residuals[best,:], norm=True)
mins = np.zeros_like(ac_resids)
mins[ac_resids<0] = ac_resids[ac_resids<0]
maxs = np.zeros_like(ac_resids)
maxs[ac_resids>0]=ac_resids[ac_resids>0]
plt.clf()
plt.close()
lags = np.arange(len(ac_resids))
plt.plot(ac_resids, 'bo')
plt.vlines(lags, mins, maxs, 'b')
# For 95% confidence interval, set sig to 0.05.
sig = 0.05
conf = scipy.stats.norm.ppf(1-sig/2.) / np.sqrt(len(sys_residuals[best,:]))
plt.plot(lags, np.zeros_like(ac_resids)+conf, color='r', label='2 sigma range')
plt.plot(lags, np.zeros_like(ac_resids)-conf, color='r')
plt.title('Autocorrelation function of residuals')
plt.legend()
plt.show()
plt.clf()
plt.close()
####### EMCEE ###########
if mcmc == True:
start_time = time.time()
if save_mcmc == True:
mc_dir = './data_outputs/emcee_runs/marg/' + save_name
try:
os.makedirs(mc_dir)
except OSError:
if os.path.isdir(mc_dir):
shutil.rmtree(mc_dir)
os.makedirs(mc_dir)
else:
raise
else:
mc_dir = False
# Best quad slope model L98=59c
# best = 66
# Use outputs from KMPFIT (weighted non-linear least squares) as initial
# starting point and setting priors for MCMC.
mcmc_systematic_model = grid[best,:]
initial_guess = sys_params[best, :]
initial_error = sys_params_err[best, :]
#openar = True
#openinc = True
# Create prior object for MCMC. This automatically
# adds default, uninformative priors for instrumental
# parameters.
priors = MargPriors(lab)
# Set the priors for the astrophysical parameters.
if ld_type=='linear':
initial_guess[12] = p_start[6, 0]
initial_error[12] = 0.2
priors.add_uniform_prior('c1', -1, 1)
if openar==True:
mcmc_systematic_model[11] = 0
initial_guess[11] = p_start[3, 0]
initial_error[11] = p_start[3, 1]
priors.add_gaussian_prior('ars', initial_guess[11], initial_error[11])
# priors.add_uniform_prior('ars', initial_guess[11] - 5*initial_error[11],
# initial_guess[11] + 5*initial_error[11])
if fixtime==False:
initial_guess[1] = p_start[1, 0]
initial_error[1] = p_start[1, 1]
# initial_error[1]= .000089
# breakpoint()
priors.add_uniform_prior('Epoch', initial_guess[1] - 5*initial_error[1],
initial_guess[1] + 5*initial_error[1])
#(error from kmpfit)
# priors.add_gaussian_prior('Epoch', initial_guess[1], initial_error[1])
if openinc==True:
mcmc_systematic_model[10] = 0
initial_guess[10] = p_start[2, 0]
initial_error[10] = p_start[2, 1]
# priors_info.add_uniform_prior('i', initial_guess[10]
# - 5*initial_error[10], 90)
priors.add_gaussian_prior('i', initial_guess[10], initial_error[10])
# Store initial guesses and uncertainties for each parameter.
priors.set_initial_guesses(initial_guess)
priors.set_initial_errors(initial_error)
# Tell prior object which parameters are being fit for.
priors.set_systematic_model(mcmc_systematic_model)
# Use roughly 2.5x as many walkers as dimensions, and always use
# an even number.
sys_ix = mcmc_systematic_model==0
ndim = len(initial_guess[sys_ix])
nwalkers = int(ndim*2.5/2) * 2
# Set initial positions for walkers in a ball surrounding initial
# guess. Size of ball determined by uncertainty in initial guess.
lnlike_args = (x, y, err, priors, sh, HSTphase, dir_array, transit
, ld_type, one_slope)
p0_max = max_like(initial_guess, lnlike_args)
# plot using maximum likelihood
# mod = lightcurve(p0_max, x, sh, HSTphase, dir_array, transit=transit
# , ld_type=ld_type, one_slope=one_slope)
# plt.errorbar(x, y-mod, err, marker='.', color='b', ecolor='b', ls='')
# plt.plot(x, np.zeros_like(x), 'r')
# plt.show()
# breakpoint()
initial_guess = p0_max
# Continue here. Do I get an error from p0_max? Is this reliable?
# Does it impact results at all? Can I do all uniform priors before
# p0_max then change to gaussian after?
positions = np.array([initial_guess[sys_ix] + initial_error[sys_ix]
* np.random.randn(ndim)/10 for i in range(nwalkers)])
# Determine if MCMC will fail due to initial positions being outside
# prior range.
priors.check_initial_positions(positions)
# Set up MCMC sampler.
sampler = emcee.EnsembleSampler(nwalkers, ndim, lnprob, args=lnlike_args)
nsteps = 20000
burn = 5000
# Run MCMC sampler.
for i, result in enumerate(sampler.sample(positions, iterations=nsteps)):
if (i+1) % 100 == 0:
print("{0:5.1%}".format(float(i) / nsteps))
#ac.autocorr_func_1d(samples.chain[:,:,0], norm=True)
print("Time elapsed in minutes %.2f" % ((time.time() - start_time)/60))
plt.clf()
plt.close('all')
# Estimate the autocorrelation time. Chain must run for 50-100x
# autocorrelation time for reasonable convergence.
# Method 1: Plot autocorrelation for each parameter over
# different sample sizes.
for pp in range(len(sys_ix[sys_ix])):
chain = sampler.chain[:,burn:,pp]
N = np.exp(np.linspace(np.log(100), np.log(chain.shape[1]), 10)).astype(int)
new = np.empty(len(N))
for i, n in enumerate(N):
new[i] = autocorr_new(chain[:, :n])
plt.loglog(N, new, "o-", label=lab[sys_ix][pp])
plt.plot(N, N/50., 'go', label='N/50')
plt.xlabel('Chain Length')
plt.ylabel('Autocorrelation time estimate')
plt.legend(prop={'size': 6})
#plt.show()
if save_mcmc == True:
plt.savefig(mc_dir+'/acor_est.pdf')
plt.close()
plt.clf()
else:
plt.show()
# Method 2: Calculate the mean integrated autocorrelation time.
taus = np.zeros_like(initial_guess[sys_ix])
for pp in range(len(sys_ix[sys_ix])):
print(lab[sys_ix][pp])
chain = sampler.chain[:, burn:, pp]
taus[pp] = autocorr_new(chain)
print(taus)
print(' Mean integrated auto time: %.2f' % np.mean(taus))
pickle_dict = {'sampler': sampler, 'ndim': ndim
, 'nwalkers':nwalkers, 'taus':taus
, 'burn':burn, 'priors':priors}
if save_mcmc == True:
pickle.dump(pickle_dict
, open( mc_dir +"/sampler.p", "wb" ) )
samples = sampler.chain[:,burn:,:].reshape((-1, ndim))
#plt.close()
inds = np.random.randint(len(samples), size=100)
pp = initial_guess.copy()
for ind in inds:
samp = samples[ind]
pp[sys_ix] = samp
phase = (x-pp[1])/Per
phase -= np.floor(phase)
phase[phase > 0.5] = phase[phase > 0.5] -1.0
syste=get_sys_model(pp, x, sh, HSTphase, dir_array, one_slope=one_slope)
mod = lightcurve(pp, x, sh, HSTphase, dir_array, transit=transit
, ld_type=ld_type, one_slope=one_slope)
plt.plot(x, mod, '.k', ls='', alpha=.1)
#plt.ylim([.9,1.1])
plt.errorbar(x, y, err, marker='o', color='b', ecolor='b', ls='')
#plt.show()
if save_mcmc == True:
plt.savefig(mc_dir+'/model_fits.pdf')
plt.close()
plt.clf()
else:
plt.show()
# for i in range(ndim):
# plot_chain(sampler.chain, i, lab[sys_ix][i],
# save=save_mcmc, mc_dir=mc_dir)
plt.clf()
plt.close('all')
samples[:,0] = samples[:, 0]*samples[:, 0]*1e6
fig = corner.corner(samples, labels=lab[sys_ix]
, quantiles=[.16,.5,.84], show_titles=True)
if save_mcmc == True:
plt.savefig(mc_dir+'/marg_corner.pdf')
plt.close()
plt.clf()
else:
plt.show()
plt.clf()
plt.close('all')
# Index to indicate relevant astrophysical parameters.
physical_labels = ['Depth', 'Epoch', 'ars', 'i', 'c1']
new_labels = lab[sys_ix]
ix = np.where(np.isin(new_labels, physical_labels))[0]
epoch_ix = np.where(np.isin(lab, 'Epoch'))[0]
input_t = 58946.20299700023
gauss_prior = 58946.20679556045
uniform_prior = 58946.20679772147
ar_uniform = 58946.21043963405
ar_gaussian = 58946.20651558505
inc_gaussian = 58946.206143872165
inc_uniform = 58946.2069585905
arinc_gaussian = 58946.20614305037
median_epoch = np.percentile(samples[:, epoch_ix], 50)
print(median_epoch)
if len(epoch_ix)==1:
new_labels[epoch_ix] = 'Epoch - %.4f' % median_epoch
samples[:, epoch_ix] = ((samples[:, epoch_ix]
- median_epoch) * 24 * 60 * 60)
fig = corner.corner(samples[:, ix], labels=new_labels[ix]
, quantiles=[.16,.5,.84], show_titles=True)
if save_mcmc == True:
plt.savefig(mc_dir+'/marg_corner_astrophysical.pdf')
plt.close()
plt.clf()
else:
plt.show()
plt.clf()
plt.close('all')
accept=sampler.acceptance_fraction
print('accept rate: ', accept)
#time1 = sampler.acor
#times=sampler.get_autocorr_time()
#print 'acor times: ', time1
#print 'get_autocorr_times: ', times
p_mcmc = [(v[1], v[2]-v[1], v[1]-v[0]) for v in zip(*np.percentile(samples, [16, 50, 84],
axis=0))]
mc_depth_err = (p_mcmc[0][1]+p_mcmc[0][2])/2.0
mc_model_ratio = mc_depth_err/depth_err[best]/1e6*ratio
mc_marg_ratio = mc_depth_err/marg_depth_err/1e6*ratio
cols = ['Median', '16th percentile', '84th percentile']
mc_results = pd.DataFrame(p_mcmc, columns=cols)
mc_results['Parameter'] = priors.open_parameters
mc_results = mc_results.set_index('Parameter')
mc_results['Model ratio'] = mc_model_ratio
mc_results['Marg ratio'] = mc_marg_ratio
mc_results['Marg inflation'] = ratio
if save_mcmc == True:
mc_results.to_csv(mc_dir+'/best_params.csv')
else:
print(mc_results)
if save_model_info == True:
### Two dataframes, both multi-indexed
# First: Anything dependent on systematic models. Adjusted data, weights,
# residuals, etc.
# Second: All data things for plots. Flux/errors normalized and un. Dates,
# And then all relevant fitting results (RMS/photon)
# To retrieveas numpy array: df.loc[visit, type you want][column].values
# Example: wl_models_info.loc['hatp41/visit01','Params']['Model 12'].values[0]
cols = ['Model ' + str(i) for i in range(nsys)]
subindex = ['Weight'] + ['Corrected Flux']*nexposure + ['Corrected Phase']*nexposure \
+ ['Corrected Error']*nexposure + ['Residuals']*nexposure \
+ ['Params']*nParam + ['Params Errors']*nParam + ['AIC Evidence'] \
+ ['Smooth Model']*500 + ['Smooth Model Phase']*500 + ['Model Tested?']
ind=pd.MultiIndex.from_product([[save_name], subindex])
wl=pd.DataFrame(np.vstack((w_q, sys_lightcurve.T, sys_lightcurve_x.T
, sys_lightcurve_err.T, sys_residuals.T
, sys_params.T, sys_params_err.T, sys_evidence.T
, sys_model.T,sys_model_x.T, model_tested)), columns=cols
, index=ind)
wl['Transit']=transit
wl['Single slope?']=one_slope
wl['Limb-darkening type']=ld_type
# data_save_name = save_name.split('_')[0]
data_save_name = save_name
ind2a= | pd.MultiIndex.from_product([[data_save_name],['data']*nexposure]) | pandas.MultiIndex.from_product |
from bokeh.io import curdoc
from bokeh.plotting import figure
from bokeh.models import Slider, ColumnDataSource, Button, Tabs, Panel, DateSlider, Range1d, Div, TextInput, Select, Panel, DateRangeSlider,Legend, LegendItem,DatetimeTickFormatter,BasicTicker, LinearColorMapper,ColorBar
from bokeh.layouts import column, row, layout, gridplot
from bokeh.tile_providers import ESRI_IMAGERY, get_provider
from bokeh.transform import cumsum, transform
from bokeh.palettes import Spectral10
import sys, pathlib
sys.path.append(str(pathlib.Path(sys.path[0]).parent/'footprint'/'FFP_python_v1_4'))
from calc_footprint_FFP_adjusted01 import FFP
from calc_footprint_FFP_climatology_adjusted01 import FFP_climatology
import numpy as np
import pandas as pd
import datetime as dt
from shapely.geometry.polygon import Polygon
import rasterio
import rasterio.mask
class view_k15:
def __init__(self):
'''
Visualizador do Footprint, tanto de um intervalo médio de análise como um range, utilizando o método por Kljun et al. (2015)
"bokeh serve --show [Full Path deste arquivo .py]"
'''
# Colunas do FullOutput do EddyPro a serem utilizadas
self.ep_columns_filtered = ['date','time','wind_dir', 'u_rot','L','v_var','u*','wind_speed']
# Coordenadas x, y da torre IAB3 para web Marcator
self.iab3_x_utm_webMarcator = -5328976.90
self.iab3_y_utm_webMarcator = -2532052.38
# Localização do arquivo tif retirado do mapbiomas no sistema de coordenadas Sirgas 2000 23S
self.tif_file = r'C:\Users\User\git\EC-LHC\iab3_site\IAB1_SIRGAS_23S.tif'
self.raster = rasterio.open(self.tif_file)
# Coordenadas x,y da torre IAB3 para Sirgas 2000 23S
self.iab3_x_utm_sirgas = 203917.07880027
self.iab3_y_utm_sirgas = 7545463.6805863
# Inicialização dos 3 tabs
self.tabs = Tabs(tabs=[self.tab_01(), self.tab_02(), self.tab_03(), self.tab_04(), self.tab_05()])
# Gerar servidor para rodar o programa
curdoc().add_root(self.tabs)
def tab_01(self):
'''
O tab_01 tem por objetivo inserir os dados do EddyPro
'''
# self.div_01 = Div(text=r'C:\Users\User\Mestrado\Dados_Processados\EddyPro_Fase01', width=500)
self.div_01 = Div(text=r'G:\Meu Drive\USP-SHS\Resultados_processados\EddyPro_Fase010203', width=500)
# Widgets e aplicação das funções no tab_01
self.path_ep = TextInput(value='', title='EP Path:')
self.path_ep.on_change('value', self._textInput)
self.select_config = Select(title='Configs:', value=None, options=[])
self.select_config.on_change('value', self._select_config)
self.button_plot = Button(label='Plot')
self.button_plot.on_click(self._button_plot)
tab01 = Panel(child=column(self.div_01, self.path_ep, self.select_config, self.button_plot), title='EP Config')
return tab01
def tab_02(self):
'''
O tab_02 tem por objetivo a visualização do footprint por intervalo médio de análise
'''
# Range do x, y relativo ao web Mercator
x_range = (-5332000, -5327000)
y_range = (-2535000, -2530000)
# Tile para display do mapa na figura
tile_provider = get_provider(ESRI_IMAGERY)
# Inicialização da Função de footprint de Kljun et al. (2015) por intervalo médio de análise
self.k15_individual = FFP()
self.div_02_01 = Div(text='Footprint por intervalo de 30 minutos através da metodologia Kljun et al. (2015)', width=500)
# Widgets e aplicação da função
self.datetime_slider = DateSlider(title='Datetime:',
start=dt.datetime(2018,1,1,0,0),
end=dt.datetime(2018,1,1,0,30),
value=dt.datetime(2018,1,1,0,0),
step=1000*60*30, format="%d/%m/%Y %H:%M")
self.datetime_slider.on_change('value_throttled', lambda attr, old, new: self.update_ffp())
self.div_02_02 = Div(text='Selecione os dados', width=500)
# Figura 01 - Mapa e Footprint
self.source_01 = ColumnDataSource(data=dict(xrs=[], yrs=[]))
self.fig_01 = figure(title='Footprint K15', plot_height=400, plot_width=400, x_range=x_range, y_range=y_range)
self.fig_01.add_tile(tile_provider)
# Glyps da localização da torre IAB3 e contribuição de 90% do footprint
iab03 = self.fig_01.circle([self.iab3_x_utm_webMarcator], [self.iab3_y_utm_webMarcator], color='red')
mlines = self.fig_01.multi_line(xs='xrs', ys='yrs', source=self.source_01, color='red', line_width=1)
# Figura 02 - Categoria do tipo de vegetação pelo footprint
self.source_01_02 = ColumnDataSource(data=dict(angle=[], color=[], significado=[]))
self.fig_01_02 = figure(plot_height=300, plot_width=500, x_range=(-1.6,1.4), toolbar_location=None)
wedge_significado = self.fig_01_02.annular_wedge(x=-1, y=0, inner_radius=0.3, outer_radius=0.45,
start_angle=cumsum('angle', include_zero=True), end_angle=cumsum('angle'),
line_color='white', fill_color='color', legend_field='significado', source=self.source_01_02)
self.fig_01_02.axis.axis_label=None
self.fig_01_02.axis.visible=False
self.fig_01_02.grid.grid_line_color = None
self.fig_01_02.outline_line_color = None
# Tabela para basic stats
self.div_02_03 = Div(text='''
<div class="header">
<h1>Basic Stats</h1>
<table border="1"><tbody><tr>
<td><b>Floresta (#)</b> </td>
<td><b>Outros (#)</b></td>
<td><b>Aceitação (%)</b></td>
</tr><tr>
<td> 0</td>
<td>0</td>
<td>0</td>
</tr></tbody></table>
</div>''', width=500)
# Criação do tab02
tab02 = Panel(child=column(self.div_02_01,
self.datetime_slider,
self.div_02_02,
row(self.fig_01, column(self.div_02_03,
self.fig_01_02))), title='Footprint per time')
return tab02
def tab_03(self):
'''
O tab_03 tem por objetivo a visualização do footprint por range de intervalo médio de análise e verificação da direção do vento
'''
# Range do x, y relativo ao web Mercator
x_range = (-5332000, -5327000)
y_range = (-2535000, -2530000)
# Tile para display do mapa na figura
tile_provider = get_provider(ESRI_IMAGERY)
# Inicialização da Função de footprint de Kljun et al. (2015) por range de intervalo médio de análise
self.k15_climatology = FFP_climatology()
self.div_03 = Div(text='Footprint acumulado através da metodologia Kljun et al. (2015) e direção do vento', width=500)
# Widgets e aplicação da função
self.date_range = DateRangeSlider(title='Date', start=dt.datetime(2018,1,1),
end=dt.datetime(2019,1,1),
value=(dt.datetime(2018,1,1), dt.datetime(2019,1,1)),
step=24*60*60*1000, format="%d/%m/%Y")
self.time_range = DateRangeSlider(title='Time', start=dt.datetime(2012,1,1,0,0),
end=dt.datetime(2012,1,1,23,30),
value=(dt.datetime(2012,1,1,0,0), dt.datetime(2012,1,1,0,30)),
step=30*60*1000, format='%H:%M')
self.date_range.on_change('value', lambda attr,old,new:self.update_windDir())
self.time_range.on_change('value', lambda attr,old,new:self.update_windDir())
# A figura responsável pelo footprint é apenas atualizada após o click deste botão
self.button_update_ffp = Button(label='Update Plot', width=500)
self.button_update_ffp.on_click(self._button_update_ffp)
# Figura 03 - Mapa e Footprint acumulado
self.source_02 = ColumnDataSource(data=dict(xrs=[], yrs=[]))
self.fig_02 = figure(title='Footprint K15 acumulado', plot_height=400, plot_width=400, x_range=x_range, y_range=y_range)
self.fig_02.add_tile(tile_provider)
self.fig_02.title.align = 'center'
self.fig_02.title.text_font_size = '20px'
# Glyphs da localização da torre IAB3 e contribuição de 90% do footprint e as legendas
iab03 = self.fig_02.circle([self.iab3_x_utm_webMarcator], [self.iab3_y_utm_webMarcator], color='red')
mlines = self.fig_02.multi_line(xs='xrs', ys='yrs', source=self.source_02, color='red', line_width=1)
legend = Legend(items=[
LegendItem(label='Torre IAB3', renderers=[iab03], index=0),
LegendItem(label='Footprint Kljun et al. (90%)', renderers=[mlines], index=1)
])
self.fig_02.add_layout(legend)
# Figura 04 - Rosa dos ventos, com a direção dos ventos corrigida
self.source_02_02 = ColumnDataSource(data=dict(inner=[0], outer=[1], start=[0],end=[2]))
self.fig_02_02 = figure(title='Direção do vento', plot_height=400, plot_width=400, toolbar_location=None, x_range=(-1.2, 1.2), y_range=(-1.2, 1.2))
self.fig_02_02.axis.visible = False
self.fig_02_02.axis.axis_label = None
self.fig_02_02.grid.grid_line_color = None
self.fig_02_02.outline_line_color = None
self.fig_02_02.title.align = 'center'
self.fig_02_02.title.text_font_size = '20px'
# Glyphs da direção do vento e glyphs auxiliares para o grid dessa figura
wedge = self.fig_02_02.annular_wedge(x=0, y=0, inner_radius='inner', outer_radius='outer', start_angle='start', end_angle='end', color='#FF00FF', source=self.source_02_02)
circle = self.fig_02_02.circle(x=0, y=0, radius=[0.25,0.5,0.75], fill_color=None,line_color='white')
circle2 = self.fig_02_02.circle(x=0, y=0, radius=[1], fill_color=None, line_color='grey')
self.fig_02_02.annular_wedge(x=0, y=0, inner_radius='inner', outer_radius='outer', start_angle='start', end_angle='end', line_color='white',fill_color=None, line_width=1,source=self.source_02_02)
self.date_range.on_change('value', lambda attr,old,new:self.update_windDir())
self.time_range.on_change('value', lambda attr,old,new:self.update_windDir())
# Figura 05 - Categoria do tipo de vegetação pelo footprint
self.source_02_03 = ColumnDataSource(data=dict(angle=[], color=[], significado=[]))
self.fig_02_03 = figure(plot_height=300, plot_width=500, x_range=(-1.6,1.4), toolbar_location=None)
self.fig_02_03.axis.axis_label=None
self.fig_02_03.axis.visible=False
self.fig_02_03.grid.grid_line_color = None
self.fig_02_03.outline_line_color = None
# Glyph das categorias de vegetação
wedge_significado = self.fig_02_03.annular_wedge(x=-1, y=0, inner_radius=0.3, outer_radius=0.45,
start_angle=cumsum('angle', include_zero=True), end_angle=cumsum('angle'),
line_color='white', fill_color='color', legend_field='significado', source=self.source_02_03)
# Tabela para basic stats
self.div_03_02 = Div(text='''
<div class="header">
<h2>Basic Stats</h2>
<table border="1"><tbody><tr>
<td><b>Floresta (#)</b> </td>
<td><b>Outros (#)</b></td>
<td><b>Aceitação (%)</b></td>
</tr><tr>
<td> 0</td>
<td>0</td>
<td>0</td>
</tr></tbody></table>
</div>''', width=400,sizing_mode="stretch_width")
# Organização do tab
widgets = column(self.date_range,self.time_range,self.button_update_ffp)
tab03 = Panel(child=column(self.div_03,
self.date_range,
self.time_range,
self.button_update_ffp,
row(self.fig_02, self.fig_02_02, column(self.div_03_02,
self.fig_02_03))), title='Footprint per range')
# layout03 = layout([[self.div_03],
# [widgets],
# [self.fig_02, self.fig_02_02, column(self.div_03_02)]]s)
# tab03 = Panel(child=layout03, title='Footprint per range')
return tab03
def tab_04(self):
self.div_04_01 = Div(text='Para o funcionamento dessa aba é necessário o processamento dos dados e criação de uma arquivo CSV (esquerda) ou indicação de um arquivo já processado (direita). Para isso, utiliza-se a metodologia por Kljun et al. (2015) com uma área de contribuição de até 90%. (Recomenda-se entre 80% ~ 90%)', width=1200)
self.datetime_range = DateRangeSlider(title='Date', start=dt.datetime(2018,1,1),
end=dt.datetime(2019,1,1),
value=(dt.datetime(2018,1,1), dt.datetime(2019,1,1)),
step=30*60*1000, format="%d/%m/%Y %H:%M")
# self.datetime_range.on_change('value', lambda attr, old,new:self._teste1())
self.path_download = TextInput(value='')
self.button_download = Button(label='Download', width=150, button_type='danger')
self.button_download.on_click(self._button_download)
self.div_04_02 = Div(text=r'''C:\Users\User\Mestrado\Testes\classification_pixel_2018-10-05-00-30to2020-07-15-00-00_pf_90.csv C:\Users\User\Mestrado\Testes\classification_pixel_2018-10-05-00-30to2020-07-15-00-00_dr_90.csv C:\Users\User\Mestrado\Testes\classification_pixel_2018-10-05-00-30to2020-07-15-00-00_pf_80.csv''')
self.path_footprintStats_k15 = TextInput(value='')
self.button_update_footprintstats = Button(label='Update', button_type='success')
self.button_update_footprintstats.on_click(self._button_update_heatmap)
self.source_04 = ColumnDataSource(data=dict(date=[],time=[],classification_pixel=[], wind_dir=[], florest_s_percentage=[],pasto_percentage=[],code03=[],code04=[],code15=[],resto_code=[]))
self.fig_04 = figure(title='Aceitação -> # Floresta Natural / # Total', plot_height=350, plot_width=1200,x_axis_type='datetime', y_axis_type='datetime', tools="hover,pan,wheel_zoom,box_zoom,reset,box_select,tap")
self.fig_04.xaxis[0].formatter = DatetimeTickFormatter(days=["%d/%m/%Y"])
self.fig_04.yaxis[0].formatter = DatetimeTickFormatter(days=["%H:%M"], hours=["%H:%M"])
self.fig_04.axis.axis_line_color = None
self.fig_04.axis.major_tick_line_color = None
self.color_mapper_pixels = LinearColorMapper(palette="Cividis256")
self.fig_04.rect(x='date',
y='time',
fill_color=transform('classification_pixel', self.color_mapper_pixels),
source=self.source_04,
width=1000*60*60*24, height=1000*60*30, line_color=None)
color_bar = ColorBar(color_mapper=self.color_mapper_pixels, ticker=BasicTicker(desired_num_ticks=len(Spectral10)),label_standoff=6, border_line_color=None, location=(0,0))
self.fig_04.add_layout(color_bar, 'right')
self.fig_04.hover.tooltips = [
("Acception", "@classification_pixel"),
("Wind Direction", "@wind_dir")
]
self.fig_04.xaxis.major_label_orientation = 1
self.fig_05 = figure(title='Subset -> Proporção Formação Savânica x Formação Florestal', plot_height=225, plot_width=600, x_axis_type='datetime', y_axis_type='datetime', tools="hover,pan,wheel_zoom,box_zoom,reset,box_select,tap",
x_range=self.fig_04.x_range, y_range=self.fig_04.y_range)
self.fig_05.xaxis[0].formatter = DatetimeTickFormatter(days=["%d/%m/%Y"])
self.fig_05.yaxis[0].formatter = DatetimeTickFormatter(days=["%H:%M"], hours=["%H:%M"])
self.fig_05.axis.axis_line_color = None
self.fig_05.axis.major_tick_line_color = None
self.color_mapper_florest = LinearColorMapper(palette='Viridis256')
self.fig_05.rect(x='date',
y='time',
fill_color=transform('florest_s_percentage', self.color_mapper_florest),
source=self.source_04,
width=1000*60*60*24, height=1000*60*30, line_color=None)
color_bar02 = ColorBar(color_mapper=self.color_mapper_florest, ticker=BasicTicker(desired_num_ticks=len(Spectral10)), label_standoff=6, border_line_color=None, location=(0,0))
self.fig_05.add_layout(color_bar02, 'right')
self.fig_05.hover.tooltips = [
("Florest S Percentage", "@florest_s_percentage"),
("Wind Direction", "@wind_dir"),
("Code03","@code03"),
("Code04","@code04"),
("Resto code","@resto_code")
]
self.fig_06 = figure(title='Subset -> Proporção Pasto x Resto', plot_height=225, plot_width=600, x_axis_type='datetime', y_axis_type='datetime', tools="hover,pan,wheel_zoom,box_zoom,reset,box_select,tap",
x_range=self.fig_04.x_range, y_range=self.fig_04.y_range)
self.fig_06.xaxis[0].formatter = DatetimeTickFormatter(days=["%d/%m/%Y"])
self.fig_06.yaxis[0].formatter = DatetimeTickFormatter(days=["%H:%M"], hours=["%H:%M"])
self.fig_06.axis.axis_line_color = None
self.fig_06.axis.major_tick_line_color = None
self.color_mapper_pasto = LinearColorMapper(palette="Viridis256")
self.fig_06.rect(x='date',
y='time',
fill_color=transform('pasto_percentage', self.color_mapper_pasto),
source=self.source_04,
width=1000*60*60*24, height=1000*60*30, line_color=None)
color_bar03 = ColorBar(color_mapper=self.color_mapper_pasto, ticker=BasicTicker(desired_num_ticks=len(Spectral10)), label_standoff=6, border_line_color=None, location=(0,0))
self.fig_06.add_layout(color_bar02, 'right')
self.fig_06.hover.tooltips = [
("Pasto Percentage", "@pasto_percentage"),
("Wind Direction", "@wind_dir"),
("Code15", "@code15"),
("Resto code","@resto_code")
]
self.fig_04.toolbar.autohide = True
self.fig_05.toolbar.autohide = True
self.fig_06.toolbar.autohide = True
tab04 = Panel(child=column(self.div_04_01,
self.datetime_range,
row(column(Div(text='Insert Folder to Download <b>(if not found)</b>:'),row(self.path_download, self.button_download)),column(Div(text='File path FootprintStats K15:'),row(self.path_footprintStats_k15, self.button_update_footprintstats)),),
self.div_04_02,
layout([[self.fig_04],[self.fig_05, self.fig_06]])), title='Heatmap')
return tab04
def tab_05(self):
self.div_05 = Div(text='Footprint per acceptance', width=500)
self.slider_footprint_acceptance = Slider(start=0, end=1, value=0, step=0.01, title='Footprint Acceptance')
self.button_update_ffp_acceptance = Button(label='Update Plot', width=500)
self.button_update_ffp_acceptance.on_click(self._button_update_ffp)
# Range do x, y relativo ao web Mercator
x_range = (-5332000, -5327000)
y_range = (-2535000, -2530000)
# Tile para display do mapa na figura
tile_provider = get_provider(ESRI_IMAGERY)
self.source_05 = ColumnDataSource(data=dict(xrs=[], yrs=[]))
self.fig_07 = figure(title='Footprint K15 acceptance', plot_height=400, plot_width=400, x_range=x_range, y_range=y_range)
self.fig_07.add_tile(tile_provider)
iab03 = self.fig_07.circle([self.iab3_x_utm_webMarcator], [self.iab3_y_utm_webMarcator], color='red')
mlines = self.fig_07.multi_line(xs='xrs', ys='yrs', source=self.source_05, color='red', line_width=1)
legend = Legend(items=[
LegendItem(label='Torre IAB3', renderers=[iab03], index=0),
LegendItem(label='Footprint Kljun et al. (10% ~ 90%)', renderers=[mlines], index=1)
])
self.fig_07.add_layout(legend)
tab05 = Panel(child=column(self.div_05,
self.slider_footprint_acceptance,
self.button_update_ffp_acceptance,
self.fig_07), title='Footprint per acceptance')
return tab05
def _textInput(self, attr, old, new):
'''
Função para ler o arquivo Readme.txt (Metafile) do FullOutput do EddyPro
'''
if self.tabs.active == 0:
try:
self.folder_path_ep = pathlib.Path(new)
readme = self.folder_path_ep.rglob('Readme.txt')
readme_df = pd.read_csv(list(readme)[0], delimiter=',')
temp_list = [row.to_list() for i,row in readme_df[['rotation', 'lowfrequency', 'highfrequency','wpl','flagging','name']].iterrows()]
a = []
for i in temp_list:
a.append('Rotation:{} |LF:{} |HF:{} |WPL:{} |Flag:{}| Name:{}'.format(i[0],i[1],i[2],i[3],i[4],i[5]))
self.select_config.options = a
except:
print('erro text input readme')
def _select_config(self, attr, old, new):
'''
Função para ler um arquivo específico do FullOutput do EddyPro
'''
print(new)
full_output_files = self.folder_path_ep.rglob('*{}*_full_output*.csv'.format(new[-3:]))
dfs_single_config = []
for file in full_output_files:
dfs_single_config.append(pd.read_csv(file, skiprows=[0,2], na_values=-9999,
parse_dates={'TIMESTAMP':['date', 'time']},
keep_date_col=True,
usecols=self.ep_columns_filtered))
self.df_ep = pd.concat(dfs_single_config)
self.df_ep.dropna(inplace=True)
print('ok')
def update_ffp(self):
'''
Função para aplicação do footprint, a depender do tab selecionado
'''
if self.tabs.active == 1:
# Transformação de float do widget para datetime
datetime = dt.datetime.utcfromtimestamp(self.datetime_slider.value/1000)
# Filtração por datetime do widget
inputs_to_k15 = self.df_ep.loc[self.df_ep['TIMESTAMP']==datetime, ['u_rot', 'L', 'u*','v_var','wind_dir_compass']]
print(inputs_to_k15)
# Atualização da tabela com os inputs para a função do método de footprint por Kljun et al. (2015)
self.div_02_02.text = '''
<table border="2"><tbody><tr><td> zm</td><td>umean</td><td>h</td><td>ol</td><td>sigmav</td><td>ustar</td><td>wind_dir_compass</td>
</tr><tr>
<td> {:.3f}</td><td>{:.3f} </td><td>{:.3f}</td><td>{:.3f}</td><td>{:.3f}</td><td>{:.3f}</td><td> {:.3f}</td>
</tr></tbody></table>'''.format(9,
inputs_to_k15['u_rot'].values[0],
1000,
inputs_to_k15['L'].values[0],
inputs_to_k15['v_var'].values[0],
inputs_to_k15['u*'].values[0],
inputs_to_k15['wind_dir_compass'].values[0])
# Output para o footprint de Kljun et a. (2015)
out = self.k15_individual.output(zm=9,
umean=inputs_to_k15['u_rot'].values[0],
h=1000,
ol=inputs_to_k15['L'].values[0],
sigmav=inputs_to_k15['v_var'].values[0],
ustar=inputs_to_k15['u*'].values[0],
wind_dir=inputs_to_k15['wind_dir_compass'].values[0],
rs=[0.9], crop=False, fig=False)
# Criação do polígono do footprint 90% para Sirgas 2000 utm 23S com o ponto de referência a torre IAB3
poly = [(i+self.iab3_x_utm_sirgas, j+self.iab3_y_utm_sirgas) for i, j in zip(out[8][-1], out[9][-1])]
poly_shp = Polygon(poly)
# Mask utilzindo o arquivo tif e o polígono (ambos no mesmo sistema de coordenadas)
mask_teste = rasterio.mask.mask(self.raster, [poly_shp], crop=True, invert=False)
# Contabilização e contagem do Mask
unique, counts = np.unique(mask_teste[0], return_counts=True)
# Função para calcular estatísticas básicas do Mask
simplified_stats = self.stats_pixel(unique, counts)
# Atualização da tabela com os dados do basic stats
self.div_02_03.text = '''
<div class="header">
<h1>Basic Stats</h1><hr><table border="1"><tbody><tr>
<td>Floresta (#) </td>
<td>Outros (#)</td>
<td>Aceitação (%)</td>
</tr><tr>
<td> {}</td>
<td>{}</td>
<td>{:.2f}</td>
</tr></tbody></table>
</div>'''.format(simplified_stats[0],
simplified_stats[1],
100*simplified_stats[0]/(simplified_stats[0]+simplified_stats[1]))
# Transformação das coordenadas de footprint de Kljun et al. (2015) [0,0] para Web Marcator
x_webMarcator = []
y_webMarcator = []
for i,j in zip(out[8], out[9]):
x_webMarcator.append(list(np.array(i)+self.iab3_x_utm_webMarcator))
y_webMarcator.append(list(np.array(j)+self.iab3_y_utm_webMarcator))
# Atualização do source
self.source_01.data = dict(xrs=x_webMarcator, yrs=y_webMarcator)
if self.tabs.active == 2:
# Transformação de float do widget para datetime
start_date = dt.datetime.utcfromtimestamp(self.date_range.value[0]/1000).date()
end_date = dt.datetime.utcfromtimestamp(self.date_range.value[1]/1000).date()
start_time = dt.datetime.utcfromtimestamp(self.time_range.value[0]/1000).time()
end_time = dt.datetime.utcfromtimestamp(self.time_range.value[1]/1000).time()
# Filtração por datetime dos widgets
inputs_to_k15 = self.df_ep.loc[
(self.df_ep['TIMESTAMP'].dt.date >= start_date) &
(self.df_ep['TIMESTAMP'].dt.date <= end_date) &
(self.df_ep['TIMESTAMP'].dt.time >= start_time) &
(self.df_ep['TIMESTAMP'].dt.time <= end_time),
['u_rot','L','u*', 'v_var','wind_dir_compass']
]
print(inputs_to_k15)
# Output para o footprint de Kljun et al. (2015)
# Para mudar a contribuição é necessário alterar o rs
out = self.k15_climatology.output(zm=9,
umean=inputs_to_k15['u_rot'].to_list(),
h=[1000 for i in range(len(inputs_to_k15['u_rot'].to_list()))],
ol=inputs_to_k15['L'].to_list(),
sigmav=inputs_to_k15['v_var'].to_list(),
ustar=inputs_to_k15['u*'].to_list(),
wind_dir=inputs_to_k15['wind_dir_compass'].to_list(),
rs=[0.9], crop=False, fig=False)
# Criação do polígono do footprint 90% para Sirgas 2000 utm 23S com o ponto de referência a torre IAB3
print(np.shape(out['xr']), np.shape(out['yr']))
print('XR', out['xr'])
print('YR', out['yr'])
poly = [(i+self.iab3_x_utm_sirgas, j+self.iab3_y_utm_sirgas) for i, j in zip(out['xr'][-1], out['yr'][-1])]
poly_shp = Polygon(poly)
# mask utilizando o arquivo tif e o polígono (ambos no mesmo sistema de coordenadas)
mask_teste = rasterio.mask.mask(self.raster, [poly_shp], crop=True, invert=False)
# Contabilização e contagem do Mask
unique, counts = np.unique(mask_teste[0], return_counts=True)
# Função para calcular estatísticas básicas do Mask
simplified_stats = self.stats_pixel(unique, counts)
# Atualização da tabela com os dados do basic stats
self.div_03_02.text = '''
<div class="header">
<h1>Basic Stats</h1><hr><table border="1"><tbody><tr>
<td>Floresta (#) </td>
<td>Outros (#)</td>
<td>Aceitação (%)</td>
</tr><tr>
<td> {}</td>
<td>{}</td>
<td>{:.2f}</td>
</tr></tbody></table>
</div>'''.format(simplified_stats[0],
simplified_stats[1],
100*simplified_stats[0]/(simplified_stats[0]+simplified_stats[1]))
# Transformação das coordenadas de footprint de Kljun et al. (2015) [0,0] para Web Marcator
# x_webMarcator = list(np.array(out['xr'][-1]) + self.iab3_x_utm_webMarcator)
# y_webMarcator = list(np.array(out['yr'][-1]) + self.iab3_y_utm_webMarcator)
x_webMarcator = []
y_webMarcator = []
for i,j in zip(out['xr'], out['yr']):
x_webMarcator.append(list(np.array(i)+self.iab3_x_utm_webMarcator))
y_webMarcator.append(list(np.array(j)+self.iab3_y_utm_webMarcator))
# Atualização do source
self.source_02.data = dict(xrs=x_webMarcator, yrs=y_webMarcator)
if self.tabs.active == 4:
print(self.slider_footprint_acceptance.value)
df_footprint_acceptance = self.df_footprintstats.copy()
df_footprint_acceptance_filter = df_footprint_acceptance.loc[df_footprint_acceptance['classification_percentage']>=self.slider_footprint_acceptance.value]
# df_ep_footprint_acceptance = pd.merge(left=self.df_ep, right=df_footprint_acceptance_filter, on='TIMESTAMP', how='inner')
# print(df_ep_footprint_acceptance.columns)
out = self.k15_climatology.output(zm=9,
umean=df_footprint_acceptance_filter['u_rot'].to_list(),
h=[1000 for i in range(len(df_footprint_acceptance_filter['u_rot'].to_list()))],
ol=df_footprint_acceptance_filter['L'].to_list(),
sigmav=df_footprint_acceptance_filter['v_var'].to_list(),
ustar=df_footprint_acceptance_filter['u*'].to_list(),
wind_dir=df_footprint_acceptance_filter['wind_dir_compass'].to_list(),
rs=[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9], crop=False,fig=False)
print(np.shape(out['xr']), np.shape(out['yr']))
print('XR', out['xr'])
print('YR', out['yr'])
# Transformação das coordenadas de footprint de Kljun et al. (2015) [0,0] para Web Marcator
# x_webMarcator = list(np.array(out['xr'][-1]) + self.iab3_x_utm_webMarcator)
# y_webMarcator = list(np.array(out['yr'][-1]) + self.iab3_y_utm_webMarcator)
x_webMarcator = []
y_webMarcator = []
for i,j in zip(out['xr'], out['yr']):
x_webMarcator.append(list(np.array(i)+self.iab3_x_utm_webMarcator))
y_webMarcator.append(list(np.array(j)+self.iab3_y_utm_webMarcator))
self.source_05.data = dict(xrs=x_webMarcator, yrs=y_webMarcator)
def update_windDir(self):
# Transformação do float para datetime
start_date = dt.datetime.utcfromtimestamp(self.date_range.value[0]/1000).date()
end_date = dt.datetime.utcfromtimestamp(self.date_range.value[1]/1000).date()
start_time = dt.datetime.utcfromtimestamp(self.time_range.value[0]/1000).time()
end_time = dt.datetime.utcfromtimestamp(self.time_range.value[1]/1000).time()
# Criação do vetor de intervalos de ângulos e iniciando como 0° no Norte (posição vertical)
start_angle = np.arange(0,360,10)*np.pi/180 + 90*np.pi/180
end_angle = np.arange(10,370,10)*np.pi/180 + 90*np.pi/180
# Filtração por datetime
filter = self.df_ep[(self.df_ep['TIMESTAMP'].dt.date >= start_date) &
(self.df_ep['TIMESTAMP'].dt.date <= end_date) &
(self.df_ep['TIMESTAMP'].dt.time >= start_time) &
(self.df_ep['TIMESTAMP'].dt.time <= end_time)]
# Atualização do source, sendo que é contado o número por bins
self.source_02_02.data = dict(inner=[0 for i in range(36)],
outer=filter.groupby(by='wind_bin').count()['wind_dir_compass'][::-1]/filter.groupby(by='wind_bin').count()['wind_dir_compass'].max(),
start=start_angle,
end=end_angle)
def _button_plot(self):
# Atualização dos ranges do widget
self.datetime_slider.start = self.df_ep['TIMESTAMP'].min()
self.datetime_slider.end = self.df_ep['TIMESTAMP'].max()
self.datetime_slider.value = self.df_ep['TIMESTAMP'].min()
self.datetime_range.start = self.df_ep['TIMESTAMP'].min()
self.datetime_range.end = self.df_ep['TIMESTAMP'].max()
self.datetime_range.value = (self.df_ep['TIMESTAMP'].min(), self.df_ep['TIMESTAMP'].max())
# Função para corrigir direção do vento
self._adjust_wind_direction()
# Criação de bins para discretização da direção do vento
self.theta = np.linspace(0, 360, 36)
theta01 = np.linspace(0, 360, 37)
# print(theta01)
self.df_ep['wind_bin'] = | pd.cut(x=self.df_ep['wind_dir_compass'], bins=theta01) | pandas.cut |
'''
@Author: <NAME>
@Date: 2019-07-03 16:18:27
@LastEditors: Yudi
@LastEditTime: 2019-07-19 15:40:23
@Company: Cardinal Operation
@Email: <EMAIL>
@Description:
'''
import pickle
import gzip
import os
import gc
import time
import random
from itertools import chain
import numpy as np
import pandas as pd
import scipy.sparse as sparse
def parse(path):
g = gzip.open(path, 'rb')
for e in g:
yield eval(e)
def load_json_gz(path):
i = 0
df = {}
for d in parse(path):
df[i] = d
i += 1
return pd.DataFrame.from_dict(df, orient='index')
def load_init_influence(cat='yelp'):
wei_u = pickle.load(open(f'./data/experiment_result/influence_dict/{cat}/uid_influence_dict.pkl', 'rb'))
wei_i = pickle.load(open(f'./data/experiment_result/influence_dict/{cat}/iid_influence_dict.pkl', 'rb'))
return wei_u, wei_i
def load_weight(cat='yelp'):
p = f'./data/experiment_result/weight/{cat}/'
dec_i_wei = pickle.load(open(p + 'dec_i_wei.pkl', 'rb'))
dec_u_wei = pickle.load(open(p + 'dec_u_wei.pkl', 'rb'))
inc_i_wei = pickle.load(open(p + 'inc_i_wei.pkl', 'rb'))
inc_u_wei = pickle.load(open(p + 'inc_u_wei.pkl', 'rb'))
return inc_u_wei, inc_i_wei, dec_u_wei, dec_i_wei
def load_rid2id_ref(cat='yelp'):
p = f'./data/experiment_result/init_vec/{cat}/'
rid2id_u = pickle.load(open(p + 'rid2id_u.pkl', 'rb'))
rid2id_i = pickle.load(open(p + 'rid2id_i.pkl', 'rb'))
return rid2id_u, rid2id_i
def load_rate(cat_name, sample_num=None, sample_target='item'):
assert cat_name in ['yelp', 'amazon'], 'invalid dataset selected, try "yelp", "ml"'
assert sample_target in ['user', 'item', 'all'], 'sample_target must be set "user", "item" or "all"'
if sample_target == 'item' or sample_target == 'user':
assert type(sample_num) is int, 'sample number for full data set must be integer......'
else:
assert type(sample_num) is int or type(sample_num) is float, 'sample number for full data set must be integer or float value in [0, 1]......'
if cat_name == 'yelp':
p = './data/raw_data/yelp_academic_dataset_review.csv' # from business.json
assert os.path.isfile(p), f'No such file {p}, please check again......'
df = pd.read_csv(p)
df.rename(index=str, columns={'user_id': 'user',
'business_id': 'item',
'stars': 'rating',
'date':'timestamp'}, inplace=True)
df['timestamp'] = df.timestamp.agg(lambda x: time.mktime(time.strptime(x,'%Y-%m-%d'))).astype(int)
df = df[['user', 'item', 'rating', 'timestamp']]
max_u_num, max_i_num = df.user.unique().size, df.item.unique().size
if sample_num is not None:
if sample_target == 'item':
sample_num = min(sample_num, max_i_num)
sub_item_set = random.sample(df.item.unique().tolist(), sample_num)
df = df[df.item.isin(sub_item_set)].sort_values(['user', 'item', 'timestamp']).reset_index(drop=True)
elif sample_target == 'user':
sample_num = min(sample_num, max_u_num)
sub_user_set = random.sample(df.user.unique().tolist(), sample_num)
df = df[df.user.isin(sub_user_set)].sort_values(['user', 'item', 'timestamp']).reset_index(drop=True)
else:
if type(sample_num) is float:
df = df.sample(frac=sample_num, random_state=2019).reset_index(drop=True)
elif type(sample_num) is int:
df = df.sample(n=sample_num, random_state=2019).reset_index(drop=True)
df.to_csv('./data/processed_data/yelp_exp_uir_data.csv', index=False)
return df
elif cat_name == 'amazon':
p = './data/raw_data/ratings_Digital_Music.csv'
assert os.path.exists(p), f'No such file {p}, please check again......'
df = pd.read_csv(p, names=['user', 'item', 'rating', 'timestamp'])
max_u_num, max_i_num = df.user.unique().size, df.item.unique().size
if sample_num is not None:
if sample_target == 'item':
sample_num = min(sample_num, max_i_num)
sub_item_set = random.sample(df.item.unique().tolist(), sample_num)
df = df[df.item.isin(sub_item_set)].sort_values(['user', 'item', 'timestamp']).reset_index(drop=True)
elif sample_target == 'user':
sample_num = min(sample_num, max_u_num)
sub_user_set = random.sample(df.user.unique().tolist(), sample_num)
df = df[df.user.isin(sub_user_set)].sort_values(['user', 'item', 'timestamp']).reset_index(drop=True)
else:
if type(sample_num) is float:
df = df.sample(frac=sample_num, random_state=2019).reset_index(drop=True)
elif type(sample_num) is int:
df = df.sample(n=sample_num, random_state=2019).reset_index(drop=True)
df.to_csv('./data/processed_data/amazon_exp_uir_data.csv', index=False)
return df
def load_rate_with_feature(cat_name='yelp'):
# load raw rating 5000i sample dataset
basic_df = pd.read_csv(f'./data/processed_data/{cat_name}_exp_uir_data.csv')
basic_df.drop(['timestamp'], axis=1, inplace=True)
if cat_name == 'yelp':
user_info = pd.read_csv('./data/raw_data/yelp_academic_dataset_user.csv')
business_info = pd.read_csv('./data/raw_data/yelp_academic_dataset_business.csv')
user_info.drop(['name'], axis=1, inplace=True)
user_info['friends'] = user_info.friends.agg(lambda x: len(x.split(',')))
user_info['elite'] = user_info.elite.agg(lambda x: len(x.split(',')))
user_info['yelping_since'] = (pd.to_datetime(user_info.yelping_since.max()) - pd.to_datetime(user_info.yelping_since)).dt.days
tmp1 = business_info.filter(regex=('attributes.*')).copy()
tmp2 = business_info[['business_id', 'stars', 'review_count', 'is_open', 'categories']].copy()
del tmp1['attributes'], tmp1['attributes.BusinessParking'], tmp1['attributes.DietaryRestrictions'], tmp1['attributes.HairSpecializesIn']
del tmp1['attributes.Ambience'], tmp1['attributes.BestNights'], tmp1['attributes.Music'], tmp1['attributes.GoodForMeal']
tmp1['attributes.RestaurantsPriceRange2'] = tmp1['attributes.RestaurantsPriceRange2'].fillna(0)
tmp1 = tmp1.fillna(False)
tmp1['attributes.Smoking'], _ = | pd.factorize(tmp1['attributes.Smoking']) | pandas.factorize |
#
# Calibration of Gruenbichler and Longstaff (1996)
# Square-Root Diffusion (SRD) model to
# VSTOXX call options with DX Analytics
#
# All data from www.eurexchange.com
#
# (c) Dr. <NAME>
# Listed Volatility and Variance Derivatives
#
import dx
import time
import numpy as np
import pandas as pd
import datetime as dt
import scipy.optimize as spo
from pylab import mpl, plt
plt.style.use('seaborn')
mpl.rcParams['font.family'] = 'serif'
# importing the data
h5 = pd.HDFStore('./data/vstoxx_march_2014.h5', 'r')
vstoxx_index = h5['vstoxx_index']
vstoxx_futures = h5['vstoxx_futures']
vstoxx_options = h5['vstoxx_options']
h5.close()
vstoxx_futures['DATE'] = pd.to_datetime(vstoxx_futures['DATE'])
vstoxx_futures['MATURITY'] = pd.to_datetime(vstoxx_futures['MATURITY'])
vstoxx_options['DATE'] = pd.to_datetime(vstoxx_options['DATE'])
vstoxx_options['MATURITY'] = | pd.to_datetime(vstoxx_options['MATURITY']) | pandas.to_datetime |
# author: <NAME>
# date: 2020-01-31
'''This script is going to tune threshold of the logistic regression model and calculate scores
Usage: automaticlly called by analysis.py
'''
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import make_scorer, precision_score, f1_score, accuracy_score
from sklearn.metrics import classification_report, confusion_matrix
from sklearn.metrics import recall_score, precision_score
from sklearn.metrics import roc_auc_score, roc_curve
import matplotlib.pyplot as plt
from docopt import docopt
def tune_threshold(model, X_train, y_train):
"""
Tune threshold of logistic regression
Parameters:
-----------
model: object
A logistic regression model
X_train: np.ndarray
An array containing all features from training dataset
y_train: np.ndarray
An array containing all targets from training dataset
"""
X_train2, X_valid, y_train2, y_valid = train_test_split(X_train,
y_train,
test_size=0.2,
random_state=888)
model.fit(X_train2, y_train2.to_numpy().ravel());
threshold_result = {"threshold":[], "accuracy":[], "recall":[], "precision":[], "roc_auc_score":[], "f1_score":[]}
for THRESHOLD in [x*0.01 for x in range(50)]:
preds = np.where(model.predict_proba(X_valid)[:,1] > THRESHOLD, 1, 0)
threshold_result["threshold"].append(round(THRESHOLD, 2))
threshold_result["accuracy"].append(accuracy_score(y_valid, preds))
threshold_result["recall"].append(recall_score(y_valid, preds))
threshold_result["precision"].append(precision_score(y_valid, preds))
threshold_result["roc_auc_score"].append(roc_auc_score(y_valid, preds))
threshold_result["f1_score"].append(f1_score(y_valid, preds))
threshold_result = pd.DataFrame(threshold_result)
return threshold_result
def test_threshold(model, t, X, y):
"""
Calculate the scores by giving a threshold of logistic regression
Parameters
----------
model: object
A logistic regression model
t: float
A threshold to be used to calculate scores
X: np.ndarray
An array containing features
y: np.ndarray
An array containing targets
"""
score_result = {"threshold":[], "accuracy":[], "recall":[], "precision":[], "roc_auc_score":[], "f1_score":[]}
THRESHOLD = t
preds = np.where(model.predict_proba(X)[:,1] > THRESHOLD, 1, 0)
score_result["threshold"].append(round(THRESHOLD, 2))
score_result["accuracy"].append(round(accuracy_score(y, preds), 2))
score_result["recall"].append(round(recall_score(y, preds), 2))
score_result["precision"].append(round(precision_score(y, preds), 2))
score_result["roc_auc_score"].append(round(roc_auc_score(y, preds), 2))
score_result["f1_score"].append(round(f1_score(y, preds), 2))
score_result = | pd.DataFrame(score_result) | pandas.DataFrame |
import pandas as pd
import datetime
from curve import LinearCurve, QuadraticCurve, CubicCurve, CubicSplineCurve
def date_handler(suspect_date):
"""
Modifies objects that should be datetime.date objects
:param suspect_date: an object that should be datetime.date object
:return: datetime.date object functionally equivalent to given param
"""
# Nothing to see here
if isinstance(suspect_date, datetime.date):
return suspect_date
# Strip time part
elif isinstance(suspect_date, datetime.datetime):
return suspect_date.date()
# Read using datetime.datetime.strptime and modify to date. Assume '%Y-%m-%d' form.
elif isinstance(suspect_date, str):
return datetime.datetime.strptime(suspect_date, '%Y-%m-%d').date()
# Laziness
else:
raise NotImplementedError
class DataContainer:
def __init__(self, today=None, *args, **kwargs):
self._type = 'general'
self._data = {}
self._name = 'Data'
self._txt = ''
if today is not None:
self._today = date_handler(today)
def __repr__(self):
ret = 'Contains {} data. Available dates are:'.format(self._type)
for key in self._data:
ret += '\n' + str(key)
return ret
@property
def txt(self):
return self._txt
@txt.setter
def txt(self, x):
if isinstance(x, str):
self._txt = x
@property
def today(self):
return self._today
@property
def data(self):
return self._data
@property
def series(self):
return pd.Series(self._data, name=self._name)
@property
def df(self):
series = self.series
return | pd.DataFrame(series) | pandas.DataFrame |
# -*- coding: utf-8 -*-
"""
Created on Mon Feb 27 10:47:10 2017
@author: Gonxo
This code imports the historical weather data from weather underground.
You need to set up an account and the requests will consume one of the given raindrops,
so collect as many as posible in one day.
"""
import requests
import json
import pandas as pd
import datetime as dt
import os
from pandas.tseries.offsets import Day
wd = os.getcwd()
# Put your weather underground apikey
wuapikey = '40d2bb7e63332cdf'
# Change to your own location.
#coordinates = 'LATITUDE,LONGITUDE'
# Open the metadata
apiDic = pd.read_csv(os.path.join(wd,'SECRETS_DIRECTORY','apiKeyDictionary.csv'))
for coordinates in apiDic['lat_long']:
weather = pd.DataFrame()
enddate = dt.datetime.utcfromtimestamp(apiDic.loc[(apiDic['lat_long']==coordinates),['end']].max())
if os.path.isfile(os.path.join(wd,'DATA_DIRECTORY','WEATHER_DATA','%s.csv' %coordinates)):
weather = pd.DataFrame.from_csv(os.path.join(wd,'DATA_DIRECTORY','WEATHER_DATA','%s.csv' %coordinates))
if 'date' in weather.columns:
if dt.datetime.strptime(weather['date'].max(), '%Y-%m-%d %H:%M:%S').date() < enddate.date():
# initdate = dt.datetime.utcfromtimestamp(apiDic.loc[(apiDic['lat_long']==coordinates),['start']].min())
initdate = dt.datetime.strptime(weather['date'].max(), '%Y-%m-%d %H:%M:%S').date()+ | Day() | pandas.tseries.offsets.Day |
#!/usr/bin/env python
"""Calculate regionprops of segments.
"""
import sys
import argparse
# conda install cython
# conda install pytest
# conda install pandas
# pip install ~/workspace/scikit-image/ # scikit-image==0.16.dev0
import os
import re
import glob
import pickle
import numpy as np
import pandas as pd
from scipy import ndimage as ndi
from scipy.spatial import distance
from stapl3d import Image, LabelImage, wmeMPI
from stapl3d.channels import get_bias_field_block
from skimage.measure import regionprops, regionprops_table
from skimage.morphology import binary_dilation
from skimage.segmentation import find_boundaries
from stapl3d.segmentation.segment import extract_segments
def main(argv):
"""Calculate regionprops of segments."""
parser = argparse.ArgumentParser(
description=__doc__,
formatter_class=argparse.ArgumentDefaultsHelpFormatter
)
parser.add_argument(
'--seg_paths',
nargs='*',
help='paths to label volumes (xyz)',
)
parser.add_argument(
'--seg_names',
nargs='*',
help='names for (sub)segmentations',
)
parser.add_argument(
'--data_path',
nargs='*',
help='paths to data channels',
)
parser.add_argument(
'--data_names',
nargs='*',
help='names for channels',
)
parser.add_argument(
'--aux_data_path',
help='path to auxilliary data file (zyxc)',
)
parser.add_argument(
'--downsample_factors',
nargs='*',
type=int,
default=[],
help='the downsample factors applied to the aux_data_path image'
)
parser.add_argument(
'--csv_path',
default='',
help='path to output csv file',
)
parser.add_argument(
'-s', '--blocksize',
required=True,
nargs='*',
type=int,
default=[],
help='size of the datablock'
)
parser.add_argument(
'-m', '--blockmargin',
nargs='*',
type=int,
default=[],
help='the datablock overlap used'
)
parser.add_argument(
'--blockrange',
nargs=2,
type=int,
default=[],
help='a range of blocks to process'
)
parser.add_argument(
'--channels',
nargs='*',
type=int,
default=[],
help='a list of channel indices to extract intensity features for'
)
parser.add_argument(
'-f', '--filter_borderlabels',
action='store_true',
help='save intermediate results'
)
parser.add_argument(
'--min_labelsize',
type=int,
default=0,
help='minimum labelsize in voxels',
)
parser.add_argument(
'--split_features',
action='store_true',
help='save intermediate results'
)
parser.add_argument(
'--fset_morph',
default=['label'],
help='morphology feature set',
)
parser.add_argument(
'--fset_intens',
default=['mean_intensity'],
help='intensity feature set',
)
parser.add_argument(
'--fset_addit',
default=['com_z', 'com_y', 'com_x'],
help='auxilliary feature set',
)
args = parser.parse_args()
export_regionprops(
args.seg_paths,
args.seg_names,
args.data_path,
args.data_names,
args.aux_data_path,
args.downsample_factors,
args.csv_path,
args.blocksize,
args.blockmargin,
args.blockrange,
args.channels,
args.filter_borderlabels,
args.min_labelsize,
args.split_features,
args.fset_morph,
args.fset_intens,
args.fset_addit,
)
def export_regionprops(
seg_paths,
seg_names=['full', 'memb', 'nucl'],
data_paths=[],
data_names=[],
aux_data_path=[],
downsample_factors=[1, 1, 1],
outputstem='',
blocksize=[],
blockmargin=[],
blockrange=[],
channels=[],
filter_borderlabels=False,
min_labelsize=0,
split_features=False,
fset_morph=['label'],
fset_intens=['mean_intensity'],
fset_addit=['com_z', 'com_y', 'com_x'],
):
# load the segments: ['full'] or ['full', 'memb', 'nucl']
label_ims = {}
pfs = seg_names[:len(seg_paths)]
for pf, seg_path in zip(pfs, seg_paths):
im = LabelImage(seg_path, permission='r')
im.load(load_data=False)
label_ims[pf] = im
comps = label_ims['full'].split_path()
# prepare parallel processing
mpi_label = wmeMPI(usempi=False)
blocksize = blocksize or label_ims['full'].dims
mpi_label.set_blocks(label_ims['full'], blocksize, blockmargin, blockrange)
mpi_label.scatter_series()
# load the data
data_ims = {}
mpi_data = wmeMPI(usempi=False)
for i, data_path in enumerate(data_paths):
pf = 'im{:02d}'.format(i)
data = Image(data_path, permission='r')
data.load(load_data=False)
ch_idx = data.axlab.index('c')
# FIXME channels for multiple data_paths
chs = channels or [ch for ch in range(data.dims[ch_idx])]
names = [data_names.pop(0) for _ in range(len(chs))]
data_ims[pf] = {'im': data, 'ch': chs, 'names': names}
""" TODO
try:
mpi_data.blocks = [
{'id': split_filename(comps['file'])[0]['postfix'],
'slices': dset_name2slices(comps['file'], axlab=data.axlab, shape=data.dims),
'path': '',},
]
except:
"""
mpi_data.set_blocks(data, blocksize, blockmargin, blockrange)
border_labelset = set([])
# if filter_borderlabels:
# outstem = outputstem or label_ims['full'].split_path()['base']
# outstem += '_dataset'
# border_labelset |= filter_borders(label_ims['full'], outstem)
dfs = []
for i in mpi_label.series:
print('processing block {:03d} with id: {}'.format(i, mpi_label.blocks[i]['id']))
dfs.append(process_block(
mpi_label.blocks[i],
mpi_data.blocks[i],
label_ims,
split_features,
data_ims,
min_labelsize,
channels,
filter_borderlabels,
fset_morph,
fset_intens,
fset_addit,
border_labelset,
outputstem,
aux_data_path,
downsample_factors,
)
)
return dfs
def process_block(
block_label,
block_data,
label_ims,
split_features,
data_ims,
min_labelsize,
channels,
filter_borderlabels=False,
fset_morph=['label'],
fset_intens=['mean_intensity'],
fset_addit=['com_z', 'com_y', 'com_x'],
border_labelset=set([]),
outputstem='',
aux_data_path='',
downsample_factors=[1, 1, 1],
):
morph, intens, add = get_feature_set(fset_morph, fset_intens, fset_addit)
all_regions = {}
for pf, label_im in label_ims.items():
label_im.slices = block_label['slices'][:3]
all_regions[pf] = label_im.slice_dataset().astype('int')
all_data = {}
for dpf, datadict in data_ims.items():
data = datadict['im']
data.slices = block_data['slices']
for ch, name in zip(datadict['ch'], datadict['names']):
data.slices[data.axlab.index('c')] = slice(ch, ch + 1, 1)
ch_data = data.slice_dataset()
all_data[name] = ch_data
outstem = outputstem or label_ims['full'].split_path()['base']
outstem += '_{}'.format(block_label['id'])
if filter_borderlabels:
border_labelset |= filter_borders(label_ims['full'], outstem)
if min_labelsize:
all_regions = filter_size(all_regions, min_labelsize, outstem)
for pf, regions in all_regions.items():
try:
rpt = regionprops_table(regions, properties=morph)
except IndexError:
print('IndexError on MORPH {}: empty labelset'.format(block_label['id']))
df = get_empty_dataframe(morph, add, intens, channels)
except ValueError:
print('ValueError on MORPH {}'.format(block_label['id']))
df = get_empty_dataframe(morph, add, intens, channels)
else:
df = pd.DataFrame(rpt)
origin = [block_data['slices'][i].start for i in [0, 1, 2]] # in full dataset voxels
df = add_features(df, aux_data_path, origin, downsample_factors)
for cpf, ch_data in all_data.items():
df_int = get_intensity_df_data(regions, intens, ch_data, cpf)
df = pd.concat([df, df_int], axis=1)
outstem = outputstem or label_im.split_path()['base']
outstem += '_{}'.format(block_label['id'])
csv_path = "{}_features_{}.csv".format(outstem, pf)
df.to_csv(csv_path)
# TODO: close images
return df
def filter_borders(label_im, outstem):
labelset = find_border_labels(label_im)
strpat = 'found {:12d} border labels in {}'
print(strpat.format(len(labelset), outstem))
write_labelset(labelset, outstem, pf='borderlabels')
return labelset
def filter_size(all_regions, min_labelsize, outstem=''):
pf = 'nucl' if 'nucl' in all_regions.keys() else 'full'
rp = regionprops(all_regions[pf])
small_labels = [prop.label for prop in rp if prop.area < min_labelsize]
strpat = 'found {:12d} small labels in {}'
print(strpat.format(len(small_labels), outstem))
write_labelset(set(small_labels), outstem, pf='smalllabels')
maxlabel = np.amax(all_regions['full'])
fw = np.zeros(maxlabel + 1, dtype='bool')
fw[small_labels] = True
sl_mask = np.array(fw)[all_regions['full']]
for pf in all_regions.keys():
all_regions[pf][sl_mask] = 0
return all_regions
def write_labelset(labelset, outstem, pf):
ppath = "{}_{}.pickle".format(outstem, pf)
with open(ppath, 'wb') as f:
pickle.dump(labelset, f)
def get_nuclearmask(block_label):
maskfile_compound = False # FIXME: as argument
if maskfile_compound:
maskpath = os.path.join(datadir, '{}_bfc_nucl-dapi_mask_sauvola.ims'.format(dataset))
mask_sauvola_im = MaskImage(maskpath_sauvola, permission='r')
mask_sauvola_im.load(load_data=False)
mask_sauvola_im.slices[:3] = block_label['slices'][:3]
mask_sauvola_im.slices[3] = slice(0, 1, None)
labelfile_blocks = False # FIXME: as argument
from stapl3d import MaskImage
#datadir = '/hpc/pmc_rios/Kidney/190910_rl57_fungi_16bit_25x_125um_corr-stitching'
datadir = 'G:\\mkleinnijenhuis\\PMCdata\Kidney\\190910_rl57_fungi_16bit_25x_125um_corr-stitching'
dataset = '190910_rl57_fungi_16bit_25x_125um_corr-stitching'
if labelfile_blocks:
block_label['id'] = '02496-03904_12736-14144_00000-00106'
#block_label['id'] = '03776-05184_12736-14144_00000-00106'
blockdir = os.path.join(datadir, 'blocks_1280')
maskpath_sauvola = os.path.join(blockdir, '{}_{}.h5/nucl/dapi_mask_sauvola'.format(dataset, block_label['id']))
mask_sauvola_im = MaskImage(maskpath_sauvola, permission='r')
mask_sauvola_im.load(load_data=False)
maskpath_absmin = os.path.join(blockdir, '{}_{}.h5/nucl/dapi_mask_absmin'.format(dataset, block_label['id']))
mask_absmin_im = MaskImage(maskpath_absmin, permission='r')
mask_absmin_im.load(load_data=False)
elif maskfile_compund:
maskpath_sauvola = os.path.join(datadir, '{}_bfc_nucl-dapi_mask_sauvola.ims'.format(dataset))
mask_sauvola_im = MaskImage(maskpath_sauvola, permission='r')
mask_sauvola_im.load(load_data=False)
mask_sauvola_im.slices[:3] = block_label['slices'][:3]
mask_sauvola_im.slices[3] = slice(0, 1, None)
maskpath_absmin = os.path.join(datadir, '{}_bfc_nucl-dapi_mask_absmin.ims'.format(dataset))
mask_absmin_im = MaskImage(maskpath_absmin, permission='r')
mask_absmin_im.load(load_data=False)
mask_absmin_im.slices[:3] = block_label['slices'][:3]
mask_absmin_im.slices[3] = slice(0, 1, None)
mask_sauvola = mask_sauvola_im.slice_dataset().astype('bool')
mask_absmin = mask_absmin_im.slice_dataset().astype('bool')
mask = mask_absmin & mask_sauvola
return mask
def add_features(df, image_in='', origin=[0, 0, 0], dsfacs=[1, 16, 16]):
if 'centroid-0' in df.columns:
cens = ['centroid-{}'.format(i) for i in [0, 1, 2]]
coms = ['com_{}'.format(d) for d in 'zyx']
df[coms] = df[cens] + origin
if image_in:
dt_im = Image(image_in, permission='r')
dt_im.load(load_data=False)
data = dt_im.slice_dataset()
dt_im.close()
ds_centroid = np.array(df[coms] / dsfacs, dtype='int')
ds_centroid = [data[p[0], p[1], p[2]] for p in ds_centroid]
df['dist_to_edge'] = np.array(ds_centroid)
if 'inertia_tensor_eigvals-0' in df.columns:
ites = ['inertia_tensor_eigvals-{}'.format(i) for i in [0, 1, 2]]
eigvals = np.clip(np.array(df[ites]), 0, np.inf)
df['fractional_anisotropy'] = fractional_anisotropy(eigvals)
df['major_axis_length'] = get_ellips_axis_lengths(eigvals[:, 0])
df['minor_axis_length'] = get_ellips_axis_lengths(eigvals[:, -1])
# TODO: range, variance, ...
return df
def get_intensity_df_data(regions, rp_props_int, ch_data, cpf):
try:
rpt = regionprops_table(regions, ch_data, properties=rp_props_int)
except ValueError:
print('got ValueError on INT {}'.format(cpf))
cols = ['{}_{}'.format(cpf, col)
for col in get_column_names(rp_props_int)]
df_int = pd.DataFrame(columns=cols)
else:
df_int = pd.DataFrame(rpt)
df_int.columns = ['{}_{}'.format(cpf, col)
for col in get_column_names(rp_props_int)]
return df_int
def get_intensity_df(regions, rp_props_int, data, ch, bf=None):
data.slices[data.axlab.index('c')] = slice(ch, ch + 1, 1)
ch_data = data.slice_dataset()
if bf is not None:
bias = get_bias_field_block(bf, data.slices, ch_data.shape)
bias = np.reshape(bias, ch_data.shape)
ch_data /= bias
ch_data = np.nan_to_num(ch_data, copy=False)
try:
rpt = regionprops_table(regions, ch_data, properties=rp_props_int)
except ValueError:
print('got ValueError on INT {}'.format(ch))
cols = ['ch{:02d}_{}'.format(ch, col)
for col in get_column_names(rp_props_int)]
df_int = pd.DataFrame(columns=cols)
else:
df_int = pd.DataFrame(rpt)
df_int.columns = ['ch{:02d}_{}'.format(ch, col)
for col in get_column_names(rp_props_int)]
return df_int
def split_filename(filename, blockoffset=[0, 0, 0]):
"""Extract the data indices from the filename."""
datadir, tail = os.path.split(filename)
fname = os.path.splitext(tail)[0]
parts = re.findall('([0-9]{5}-[0-9]{5})', fname)
id_string = '_'.join(parts)
dset_name = fname.split(id_string)[0][:-1]
x = int(parts[-3].split("-")[0]) - blockoffset[0]
X = int(parts[-3].split("-")[1]) - blockoffset[0]
y = int(parts[-2].split("-")[0]) - blockoffset[1]
Y = int(parts[-2].split("-")[1]) - blockoffset[1]
z = int(parts[-1].split("-")[0]) - blockoffset[2]
Z = int(parts[-1].split("-")[1]) - blockoffset[2]
dset_info = {'datadir': datadir, 'base': dset_name,
'nzfills': len(parts[1].split("-")[0]),
'postfix': id_string,
'x': x, 'X': X, 'y': y, 'Y': Y, 'z': z, 'Z': Z}
return dset_info, x, X, y, Y, z, Z
def dset_name2slices(dset_name, blockoffset=[0, 0, 0], axlab='xyz', shape=[]):
"""Get slices from data indices in a filename."""
_, x, X, y, Y, z, Z = split_filename(dset_name, blockoffset)
slicedict = {'x': slice(x, X, 1),
'y': slice(y, Y, 1),
'z': slice(z, Z, 1)}
for dim in ['c', 't']:
if dim in axlab:
upper = shape[axlab.index(dim)]
slicedict[dim] = slice(0, upper, 1)
slices = [slicedict[dim] for dim in axlab]
return slices
def get_column_names(rp_props):
cols = []
for i, it in enumerate(rp_props):
if 'centroid' in it or 'eigvals' in it:
cols += ['{}-{}'.format(it, dim)
for dim in [0, 1, 2]]
elif 'moments' in it:
# FIXME: need only half of the diagonal matrix
cols += ['{}-{}-{}-{}'.format(it, dim1, dim2, dim3)
for dim1 in [0, 1, 2, 3]
for dim2 in [0, 1, 2, 3]
for dim3 in [0, 1, 2, 3]]
else:
cols += [it]
return cols
def get_empty_dataframe(rp_props_morph, rp_props_add, rp_props_int, channels):
cols_morph = get_column_names(rp_props_morph)
cols_int = get_column_names(rp_props_int)
cols = ['ch{:02d}_{}'.format(ch, col) for ch in channels for col in cols_int]
df = pd.DataFrame(columns=cols_morph + rp_props_add + cols)
return df
def get_feature_set(fset_morph='minimal', fset_intens='minimal', aux_data_path=''):
# TODO: self-defined features
"""
# eccentricity not implemented
# orientation not implemented
# perimeter not implemented
# moments_hu not implemented
# weighted_moments_hu not implemented
# max_intensity needs aux data volume
# mean_intensity needs aux data volume
# min_intensity needs aux data volume
# weighted_centroid needs aux data volume
# weighted_moments needs aux data volume
# weighted_moments_central needs aux data volume
# weighted_moments_normalized needs aux data volume
"""
# morphological features
# TODO: file bug report on minor/major_axis_length
# gives this ValueError:
# https://github.com/scikit-image/scikit-image/issues/2625
fsets_morph ={
'none': (
'label',
),
'minimal': (
'label',
'area',
'centroid'
),
'medium': (
'label',
'area',
'centroid',
'bbox',
'equivalent_diameter',
'extent',
'euler_number',
'inertia_tensor_eigvals',
),
'maximal': (
'label',
'area',
'bbox',
'centroid',
'equivalent_diameter',
'extent',
'euler_number',
# 'convex_area',
# 'solidity',
'moments',
'moments_central',
'moments_normalized',
# 'orientation',
'inertia_tensor_eigvals',
# 'major_axis_length',
# 'minor_axis_length',
),
}
# intensity features
fsets_intens ={
'none': (),
'minimal': (
'mean_intensity',
),
'medium': (
'mean_intensity',
'weighted_centroid',
),
'maximal': (
'min_intensity',
'mean_intensity',
'median_intensity',
'variance_intensity',
'max_intensity',
'weighted_centroid',
# FIXME: OverflowError: Python int too large to convert to C long
# 'weighted_moments',
# 'weighted_moments_central',
# 'weighted_moments_normalized',
),
}
# FIXME: convex hull morph features often fail
# FIXME: intensity weighted fail
try:
morph = fsets_morph[fset_morph]
except (KeyError, TypeError):
morph = fset_morph
try:
intens = fsets_intens[fset_intens]
except (KeyError, TypeError):
intens = fset_intens
try:
addit = get_additional_columns(aux_data_path, fset_morph)
except (KeyError, TypeError):
addit = fset_addit
return morph, intens, addit
def get_additional_columns(aux_data_path='', fset_morph='minimal'):
cols_add = ['com_z', 'com_y', 'com_x']
if aux_data_path:
cols_add += ['dist_to_edge']
if fset_morph == 'maximal':
cols_add += ['fractional_anisotropy',
'major_axis_length', 'minor_axis_length']
return cols_add
def find_border_labels(labels):
border_labelset = set([])
fullslices = [slc for slc in labels.slices]
for dim in [0, 1, 2]:
for s in [0, -1]:
if s:
fullstop = fullslices[dim].stop
labels.slices[dim] = slice(fullstop - 1, fullstop, None)
else:
fullstart = fullslices[dim].start
labels.slices[dim] = slice(fullstart, fullstart + 1, None)
labeldata = labels.slice_dataset()
border_labelset |= set(np.unique(labeldata))
labels.slices = [slc for slc in fullslices]
border_labelset -= set([0])
return border_labelset
def split_nucl_and_memb_data(labeldata, nuclearmask=None):
labeldata_memb = np.copy(labeldata)
labeldata_nucl = np.copy(labeldata)
memb_mask = find_boundaries(labeldata)
for i, slc in enumerate(memb_mask):
memb_mask[i, :, :] = binary_dilation(slc)
labeldata_memb[~memb_mask] = 0
if nuclearmask is None:
nuclearmask = ~memb_mask
labeldata_nucl[~nuclearmask] = 0
# print('mask_nucl0_sum', np.sum(~memb_mask))
# print('mask_nucl1_sum', np.sum(nuclearmask))
# print('mask_memb_sum', np.sum(memb_mask))
# print('label_full_sum', np.sum(labeldata.astype('bool')))
# print('label_memb_sum', np.sum(labeldata_memb.astype('bool')))
# print('label_nucl_sum', np.sum(labeldata_nucl.astype('bool')))
return labeldata_memb, labeldata_nucl
def split_nucl_and_memb(labels, outpat, nuclearmask=None):
labeldata = labels.slice_dataset()
labeldata, labeldata_nucl = split_nucl_and_memb_data(labeldata, nuclearmask)
pf = '_memb'
outpath = outpat.format(pf)
im_memb = LabelImage(outpath, **props)
im_memb.create()
im_memb.write(labeldata)
pf = '_nucl'
outpath = outpat.format(pf)
im_nucl = LabelImage(outpath, **props)
im_nucl.create()
im_nucl.write(labeldata_nucl)
return im_memb, im_nucl
def small_label_mask(labeldata, maxlabel, min_labelsize=5):
"""
NOTE:
- need to take out very small labels (<5) for convex hull
- even without these labels, convex hull often fails
- removed features dependent on convex hull from the feature sets for now
"""
rp = regionprops(labeldata)
small_labels = [prop.label for prop in rp if prop.area < min_labelsize]
fw = np.zeros(maxlabel + 1, dtype='bool')
fw[small_labels] = True
smalllabelmask = np.array(fw)[labeldata]
return smalllabelmask
def label_selection_mask(labeldata, filestem):
import scanpy as sc
filename = '{}_adata.h5ad'.format(filestem)
adata = sc.read(filename)
labelset = set(adata.obs['label'].astype('uint32'))
ulabels = np.load('{}_ulabels.npy'.format(filestem))
ulabels = np.delete(ulabels, 0)
maxlabel = np.amax(ulabels)
fw = np.zeros(maxlabel + 1, dtype='bool')
for label in labelset:
fw[label] = True
mask = np.array(fw)[labeldata]
return mask
def select_features(dfs, feat_select, min_size=0, split_features=False):
df1 = dfs['full'][feat_select['morphs']]
key = 'memb' if split_features else 'full'
df2 = | pd.DataFrame(index=df1.index) | pandas.DataFrame |
# -*- coding: utf-8 -*-
"""
:Module: khorosjx.utils.df_utils
:Synopsis: Useful tools and utilities to assist in importing, manipulating and exporting pandas dataframes
:Usage: ``from khorosjx import df_utils``
:Example: TBD
:Created By: <NAME>
:Last Modified: <NAME>
:Modified Date: 18 Dec 2019
"""
import pandas as pd
# Define function to convert a list of dictionaries to a pandas dataframe
def convert_dict_list_to_dataframe(dict_list, column_names=[]):
"""This function converts a list of dictionaries into a pandas dataframe.
:param dict_list: List of dictionaries
:type dict_list: list
:param column_names: The column names for the dataframe (Optional)
:type column_names: list
:returns: A pandas dataframe of the data
"""
# Identify the dataframe column names
if len(column_names) == 0:
for field_name in dict_list[0].keys():
column_names.append(field_name)
# Identify the data for each column
df_data = []
for idx in range(0, len(dict_list)):
row_data = []
for field_value in dict_list[idx].values():
row_data.append(field_value)
df_data.append(row_data)
# Create and return the dataframe
dataframe = pd.DataFrame(df_data, columns=column_names)
return dataframe
def import_csv(file_path, delimiter=",", column_names=[], columns_to_return=[], has_headers=True):
"""This function imports a CSV file to generate a dataframe.
:param file_path: The absolute path to the CSV file to be imported
:type file_path: str
:param delimiter: The column delimiter utilized in the CSV
:type delimiter: str
:param column_names: The column names to use with the imported dataframe (Optional)
:type column_names: list
:param columns_to_return: Determines which of the columns should actually be returned (Default: all columns)
:param has_headers: Defines whether or not the data in the file has column headers (Default: ``True``)
:type has_headers: bool
:returns: The imported data as a pandas dataframe
:raises: FileNotFoundError, TypeError
"""
# Determine the appropriate use case and then import and return the dataframe
if has_headers is False and len(column_names) == 0:
if len(columns_to_return) == 0: # Use Case: Headless
dataframe = pd.read_csv(file_path, sep=delimiter, header=None)
else: # Use Case: Headless Filtered
dataframe = pd.read_csv(file_path, sep=delimiter, header=None, usecols=columns_to_return)
else:
if len(column_names) > 0 and len(columns_to_return) > 0: # Use Case: Custom Filtered
dataframe = pd.read_csv(file_path, sep=delimiter, names=column_names)
dataframe = dataframe[columns_to_return]
elif len(column_names) > 0 and len(columns_to_return) == 0: # Use Case: Custom
dataframe = pd.read_csv(file_path, sep=delimiter, names=column_names)
elif len(column_names) == 0 and len(columns_to_return) > 0: # Use Case: Filtered
dataframe = pd.read_csv(file_path, sep=delimiter, usecols=columns_to_return)
else: # Use Case: Default
dataframe = pd.read_csv(file_path, sep=delimiter)
return dataframe
def import_excel(file_path, excel_sheet='', use_first_sheet=False,
column_names=[], columns_to_return=[], has_headers=True):
"""This function imports a Microsoft Excel file to generate a dataframe.
:param file_path: The absolute path to the Excel file to be imported
:type file_path: str
:param excel_sheet: The name of the specific sheet in the file to import
:type excel_sheet: str
:param use_first_sheet: Defines whether or not the first sheet in the file should be used (Default: ``False``)
:type use_first_sheet: bool
:param column_names: The column names to use with the imported dataframe (Optional)
:type column_names: list
:param columns_to_return: Determines which of the columns should actually be returned (Default: all columns)
:param has_headers: Defines whether or not the data in the file has column headers (Default: ``True``)
:type has_headers: bool
:returns: The imported data as a pandas dataframe
:raises: FileNotFoundError, TypeError
"""
# Determine the appropriate use case and then import and return the dataframe
if excel_sheet != "" and use_first_sheet is False:
if has_headers is False and len(column_names) == 0:
if columns_to_return == 0: # Use Case: Headless
excel_data = pd.read_excel(file_path, sheet_name=excel_sheet, header=None)
else: # Use Case: Headless Filtered
excel_data = pd.read_excel(file_path, sheet_name=excel_sheet, header=None, usecols=columns_to_return)
else:
if len(column_names) > 0 and len(columns_to_return) > 0: # Use Case: Custom Filtered
excel_data = | pd.read_excel(file_path, names=column_names) | pandas.read_excel |
import pandas as pd
import numpy as np
import Core.esi as esi
def min_sell_for_types(names, region_id=10000002, station_id=60003760):
types = [name['id'] for name in names]
prices = [order for res in esi.get_sell_orders(types, region_id) for order in res]
df1 = | pd.DataFrame.from_records(prices) | pandas.DataFrame.from_records |
"""
This module will include the guessing advantage implementation.
"""
from math import log, exp, sqrt, inf
from statistics import median
import time
from enum import Enum
from statsmodels.distributions.empirical_distribution import ECDF
import multiprocessing as mp
# import swifter
import numpy as np
import pandas as pd
from itertools import repeat
import os
import glob
import pickle
import gc
from scipy.stats import laplace
# import amun.multiprocessing_helper_functions
# import concurrent.futures
import math
class AggregateType(Enum):
SUM = 1
AVG = 2
MIN = 3
MAX = 4
FREQ= 5
def calculate_epsilon_from_delta(dfg, delta):
# we will eventually have different epsilons for frequency and for time
# we can output two epsilons, or have two different functions
# in any case, it is safe to take the minimum of these epsilons if DP interface takes only one
# for frequencies, we have r = 1
r = 1
# need to learn how to compute these things from dfg format
# for times, we need to compute r as the maximum possible time between two subsequent events
# we can get even better results if:
# 1) we have event log instead of dfg
# 2) we compute a diffrent epsilon for different edges of dfg
# r = ....
p = (1 - delta) / 2
epsilon = - log(p / (1 - p) * (1 / (delta + p) - 1)) / log(exp(1)) * (1 / r)
return epsilon
def calculate_epsilon_freq(dfg, delta):
sens = 1.0
p = (1.0 - delta) / 2.0
R_ij = 1.0 # from the discussion with Alisa
epsilon = - log(p / (1.0 - p) * (1.0 / (delta + p) - 1)) / log(exp(1.0)) * (1.0 / R_ij)
return epsilon, sens
def calculate_epsilon_time(dfg, delta, precision, aggregate_type):
epsilon = {}
sens = 1
n = 1 # length of the database
""" calculating sensitivity based on type of aggregate"""
if aggregate_type == AggregateType.AVG:
sens = 1 / n
elif aggregate_type == AggregateType.MAX or aggregate_type == AggregateType.MIN or aggregate_type == AggregateType.SUM:
sens = 1
else:
assert "Wrong aggregate type"
"""************parallel by edge******************"""
p = mp.Pool(mp.cpu_count())
result = p.starmap(calculate_epsilon_per_pair, zip(dfg.values(), repeat(delta), repeat(precision)))
p.close()
p.join()
epsilon = dict(zip(list(dfg.keys()), result))
return epsilon, sens
def calculate_epsilon_time_parallel(dfg, delta, precision, aggregate_type):
epsilon = {}
sens = 1
n = 1 # length of the database
""" calculating sensitivity based on type of aggregate"""
if aggregate_type == AggregateType.AVG:
sens = 1 / n
elif aggregate_type == AggregateType.MAX or aggregate_type == AggregateType.MIN or aggregate_type == AggregateType.SUM:
sens = 1
else:
assert "Wrong aggregate type"
"""************parallel by edge******************"""
p = mp.Pool(mp.cpu_count())
result = p.starmap(calculate_epsilon_per_pair_parallel, zip(dfg.values(), repeat(delta), repeat(precision)))
epsilon = dict(zip(list(dfg.keys()), list(result)))
p.close()
p.join()
return epsilon, sens
def calculate_epsilon_per_pair(values, delta, precision):
# values = [0.0, 0.2, .4, .6, .7, 10, 20, 100, 400, 500, 1000, 2000]
values =list(map(abs, values))
values = sorted(values)
R_ij = max(values)
epsilons = []
r_ij = R_ij * precision
cdf = ECDF(values)
epsilon = inf
flag = 1
prev = values[0]
for i in values:
if i != prev:
flag = 0
prev = i
if not flag:
for t_k in values:
p_k = calculate_cdf(cdf, t_k + r_ij) - calculate_cdf(cdf, t_k - r_ij)
# covering the case with risk less than or equal 1-p_k
if not (round(1 - p_k, 2) <= delta): # the round is for very small differences, like 0.050000000000000044
eps = - log(p_k / (1.0 - p_k) * (1.0 / (delta + p_k) - 1.0)) / log(exp(1.0)) * (1.0 / R_ij)
# eps= -(log( (1-p_k)/p_k * (1/(delta*p_k) -1) )) /(R_ij)
epsilons.append(eps)
else:
epsilons.append(inf)
if len(epsilons) > 0:
epsilon = min(epsilons)
else:
# fix the ECDF when all the values are equal.
# after the discussion, we decided to let the user know about that issue and maybe has can handle it on his own.
# epsilon=-inf
epsilon = inf
return epsilon
def calculate_epsilon_per_pair_parallel(values, delta, precision):
# values = [0.0, 0.2, .4, .6, .7, 10, 20, 100, 400, 500, 1000, 2000]
values =list(map(abs, values))
values = sorted(values)
R_ij = max(values)
epsilons = []
r_ij = R_ij * precision
cdf = ECDF(values)
epsilon = inf
flag = 1
prev = values[0]
for i in values:
if i != prev:
flag = 0
prev = i
if not flag:
for t_k in values:
p_k = calculate_cdf(cdf, t_k + r_ij) - calculate_cdf(cdf, t_k - r_ij)
# covering the case with risk less than or equal 1-p_k
if not (round(1 - p_k, 2) <= delta): # the round is for very small differences, like 0.050000000000000044
eps = - log(p_k / (1.0 - p_k) * (1.0 / (delta + p_k) - 1.0)) / log(exp(1.0)) * (1.0 / R_ij)
epsilons.append(eps)
else:
epsilons.append(inf)
if len(epsilons) > 0:
epsilon = min(epsilons)
else:
# fix the ECDF when all the values are equal.
# after the discussion, we decided to let the user know about that issue and maybe has can handle it on his own.
# epsilon=-inf
epsilon = inf
return epsilon
def calculate_epsilon_from_distance_time(dfg_time, distance, precision, aggregate_type=AggregateType.SUM):
beta = 0.05
# reflect the new equation of delta for the time per time instance. Then take the maximum delta from all the instances.
sens_time = 1
""" calculating sensitivity based on type of aggregate"""
if aggregate_type == AggregateType.AVG:
sens_time = 1 / len(dfg_time[0])
elif aggregate_type == AggregateType.MAX or aggregate_type == AggregateType.MIN or aggregate_type == AggregateType.SUM:
sens_time = 1
else:
assert "Wrong aggregate type"
# calculate epsilon
# the equation to be calculated per instance first as p is different from frequency.
epsilon_time = sens_time / distance * log(1 / beta)
# Calculate delta ( the risk) from guessing advantage equation
delta_time = []
delta_dfg = {}
for x in dfg_time.keys():
delta_edge = []
R_ij = max(dfg_time[x])
r_ij = R_ij * precision
# fix the case of time is fixed
flag = 1
prev = dfg_time[x][0]
current = dfg_time[x]
for t_k in dfg_time[x]:
# fix the case of time is fixed
if t_k != prev:
flag = 0
prev = t_k
cdf = ECDF(dfg_time[x])
# p_k is calculated for every instance.
cdf1 = calculate_cdf(cdf, t_k + r_ij)
cdf2 = calculate_cdf(cdf, t_k - r_ij)
p_k = cdf1 - cdf2
# current_delta = p_k*( 1/( (1-p_k) * exp(-R_ij * epsilon_time) +p_k) -1)
current_delta = (p_k / ((1 - p_k) * exp(-R_ij * epsilon_time) + p_k)) - p_k
# eps = - log(p_k / (1.0 - p_k) * (1.0 / (current_delta + p_k) - 1.0)) / log(exp(1.0)) * (1.0 / R_ij)
# we append the deltas and take the maximum delta out of them
# if current_delta != float.nan:
delta_edge.append(current_delta)
if current_delta != 0:
delta_time.append(current_delta)
delta_dfg[x] = max(delta_edge)
if len(delta_time) > 0:
delta_time = median(delta_time)
delta_time = median(delta_dfg.values())
return epsilon_time, delta_time, delta_dfg
def calculate_cdf(cdf, val):
cur_idx = 0
for idx, i in enumerate(cdf.x[:-1]):
if val > i:
cur_idx += 1
if val < cdf.x[idx + 1]:
cur_idx -= 1
break
return cdf.y[cur_idx]
def calculate_epsilon_from_distance_time_percentage_distance(dfg_time, distance, precision, aggregate_type=AggregateType.SUM):
beta = 0.05
# reflect the new equation of delta for the time per time instance. Then take the maximum delta from all the
# instances.
sens_time = 1
""" calculating sensitivity based on type of aggregate"""
if aggregate_type == AggregateType.AVG:
sens_time = 1 / len(dfg_time.keys())
elif aggregate_type == AggregateType.MAX or aggregate_type == AggregateType.MIN or aggregate_type == AggregateType.SUM:
sens_time = 1
else:
assert "Wrong aggregate type"
# m is the number of edges
m = len(dfg_time.keys())
# calculating R among all the edges
R = 0
for x in dfg_time.keys():
R = R + max(dfg_time[x])
# Calculate delta ( the risk) from guessing advantage equation
delta_time = []
delta_dfg = {}
epsilon_time = {}
delta_per_event=[]
"""************parallel by edge******************"""
""" Current slurm Bottleneck"""
p = mp.Pool(mp.cpu_count())
result = p.starmap(epsilon_time_from_distance,
zip(dfg_time.values(), repeat(aggregate_type), repeat(beta), repeat(distance), repeat(precision),
repeat(sens_time)))
p.close()
p.join()
delta_dfg = dict(zip(list(dfg_time.keys()), [x[0] for x in result]))
keys = list(dfg_time.keys())
for idx, res in enumerate(result):
delta_edge, delta_per_event_inner, delta_time_inner, epsilon_time_inner = res
key = keys[idx]
epsilon_time[key] = epsilon_time_inner
delta_time = delta_time + delta_time_inner
delta_per_event_inner = list(map(lambda i: [key, i], delta_per_event_inner))
delta_per_event = delta_per_event + delta_per_event_inner
delta_dfg[key] = max(delta_edge)
if len(delta_time) > 0:
delta_time = max(delta_time)
delta_time = median(delta_dfg.values())
return epsilon_time, delta_time, delta_dfg, delta_per_event
def epsilon_time_from_distance(dfg_time_inner, aggregate_type, beta, distance,
precision, sens_time):
delta_time_inner = []
delta_edge = []
delta_per_event = []
R_ij = max(dfg_time_inner)
r_ij = R_ij * precision
accurate_result = 0
# calculating the accurate result
if aggregate_type == AggregateType.AVG:
accurate_result = sum(dfg_time_inner) * 1.0 / len(dfg_time_inner)
elif aggregate_type == AggregateType.SUM:
accurate_result = sum(dfg_time_inner) * 1.0
elif aggregate_type == AggregateType.MIN:
accurate_result = min(dfg_time_inner) * 1.0
elif aggregate_type == AggregateType.MAX:
accurate_result = max(dfg_time_inner) * 1.0
# in case of the time is instant, we set epsilon to avoid the error of division by zero
if accurate_result == 0:
epsilon_time_ij = 1
else:
distance_ij = accurate_result * distance # hence distance is between 0 and 1
# calculate epsilon
epsilon_time_ij = sens_time / distance_ij * log(1 / beta)
epsilon_time_inner = epsilon_time_ij
# fix the case of time is fixed
flag = 1
prev = dfg_time_inner[0]
current = dfg_time_inner
for t_k in dfg_time_inner:
# fix the case of time is fixed
if t_k != prev:
flag = 0
prev = t_k
cdf = ECDF(dfg_time_inner)
# p_k is calculated for every instance.
cdf1 = calculate_cdf(cdf, t_k + r_ij)
cdf2 = calculate_cdf(cdf, t_k - r_ij)
p_k = cdf1 - cdf2
# current_delta = p_k*( 1/( (1-p_k) * exp(-R_ij * epsilon_time) +p_k) -1)
current_delta = (p_k / ((1 - p_k) * exp(-R_ij * epsilon_time_ij) + p_k)) - p_k
# eps = - log(p_k / (1.0 - p_k) * (1.0 / (current_delta + p_k) - 1.0)) / log(exp(1.0)) * (1.0 / R_ij)
# we append the deltas and take the maximum delta out of them
# if current_delta != float.nan:
delta_edge.append(current_delta)
# delta_per_event.append([x, current_delta])
delta_per_event.append(current_delta) # *****************!!!!!!!!!!!! changed
if current_delta != 0:
delta_time_inner.append(current_delta)
return delta_edge, delta_per_event, delta_time_inner, epsilon_time_inner
def calculate_epsilon_from_distance_freq_percentage_distances(dfg_freq, distance_percentage):
beta = 0.01
sens_freq = 1
# for frequencies, we have r = 1
r_freq = 1
delta_dfg = {}
epsilon_dfg = {}
p = mp.Pool(mp.cpu_count())
result = p.starmap(epsilon_freq_from_distance,
zip(dfg_freq.values(), repeat(beta), repeat(distance_percentage), repeat(sens_freq)))
p.close()
p.join()
delta_dfg = dict(zip(list(dfg_freq.keys()), [x[0] for x in result]))
epsilon_dfg = dict(zip(list(dfg_freq.keys()), [x[1] for x in result]))
delta_freq = max(list(delta_dfg.values()))
return epsilon_dfg, delta_dfg, delta_freq
def epsilon_freq_from_distance(dfg_freq_inner, beta, distance_percentage, sens_freq):
distance = distance_percentage * dfg_freq_inner
epsilon_freq = sens_freq / distance * log(1 / beta)
epsilon_dfg_inner = epsilon_freq
# Calculate delta ( the risk) from guessing advantage equation
# the following equation is validated by calculations
delta_freq = (1 - sqrt(exp(- epsilon_freq))) / (1 + sqrt(exp(- epsilon_freq)))
return delta_freq, epsilon_dfg_inner
def calculate_cdf_vectorized(data):
cdf, val=data.relative_time_ecdf,data.val_plus
cur_idx = 0
for idx, i in enumerate(cdf.x[:-1]):
if val > i:
cur_idx += 1
if val < cdf.x[idx + 1]:
cur_idx -= 1
break
return cdf.y[cur_idx]
def estimate_epsilon_risk_vectorized(data, delta, precision,tmp_dir):
# NOTE: in the current version, there are no fixed time values.
# Becuase the starting time now is being anonymized.
data_state_max = data.groupby('state').relative_time.max()
data_state_max['state'] = data_state_max.index
# data= pd.merge(data, data_cdf, on=['state'], suffixes=("","_ecdf"))
data = | pd.merge(data, data_state_max, on=['state'], suffixes=("", "_max")) | pandas.merge |
"""Sampling
* :func:`.add_negative_samples`
"""
import numpy as np
import pandas as pd
def add_negative_samples(A, B, k=5):
"""Add pairs which do not exist to positive pairs.
If `A` and `B` are two corresponding lists , this function
returns a table with two copies of elements in `A`.
For the first copy, corresponding elements in `B` are unchaged.
However, for the second copy, elements in `B` are elements
which exist in `B`, but the corresponding `A`-`B` pair
does not exist in the original pairs.
Parameters
----------
A : list or ndarray or pandas Series
Indexes
B : list or ndarray or pandas Series
Values
k : int
Number of negative samples per positive sample.
Default=5
Returns
-------
Ao : list
Output indexes w/ both positive and negative samples.
Bo : list
Output indexes w/ both positive and negative samples.
E : list
Whether the corresponding `Ao`-`Bo` pair exists (1) or
does not (0) in the original input data.
"""
# Convert to lists
if isinstance(A, (np.ndarray, pd.Series)):
A = A.tolist()
if isinstance(B, (np.ndarray, pd.Series)):
B = B.tolist()
# Construct a dict of pairs for each unique value in A
df = | pd.DataFrame() | pandas.DataFrame |
import pandas as pd
from pandas.tseries.offsets import MonthEnd
import numpy as np
def jodi_read():
# JODI database
df_jodi = pd.read_csv('jodi_raw_M.csv')
df_jodi.columns = ['area', 'Date', 'product', 'flow', 'unit', 'value', 'code']
dict_flow = {'INDPROD': 'prod', 'DIRECUSE': 'direcuse', 'TOTEXPSB': 'export', 'TOTIMPSB': 'import',
'REFINOBS': 'refinein', 'STOCKCH': 'stockch', 'STATDIFF': 'statdiff', 'TRANSBAK': 'transfer',
'OSOURCES': 'osource','CLOSTLV': 'closingstock'}
df_jodi.flow = df_jodi.flow.replace(dict_flow)
country_continent = pd.read_csv('country_continent.csv', index_col=0)
country_continent = country_continent.dropna(axis=0)
country_continent = country_continent.to_dict()
country_continent = country_continent['continent_code']
# print('country_contin', country_continent)
df_jodi['area'] = df_jodi.area.replace(country_continent)
df_jodi = df_jodi.dropna()
area_list = ['AS', 'AS', 'EU', 'NA', 'OC', 'SA', 'CN', 'US']
df_jodi = df_jodi[df_jodi['area'].isin(area_list)]
df_jodi = df_jodi[df_jodi['unit'] == 'KBBL']
df_jodi = df_jodi.sort_values(by=['product', 'flow'])
df_jodi = df_jodi.groupby(['Date', 'area', 'product', 'flow']).sum()
df_jodi = df_jodi.reset_index()
df_jodi['area'] = df_jodi['product'] + '_' + df_jodi['flow'] + '_' + df_jodi['area']
df_jodi = pd.pivot_table(data=df_jodi, index='Date', columns='area', values='value')
df_jodi.index = pd.to_datetime(df_jodi.index, format="%Y-%m") + | MonthEnd(1) | pandas.tseries.offsets.MonthEnd |
import numpy as np
import pandas as pd
import os
import matplotlib.pyplot as plt
from src.models.text_classifier import run_model_on_file
from src.models.text_classifier import TextClassifier
from utils import get_conf_labels as get_conf_labels
from utils.get_mails import get_rand_mail
# data_path = r'C:\develop\code\semi-supervised-text-classification\data'
# model_path = r'C:\develop\code\semi-supervised-text-classification\data\results\ml_model_'
# all_par_data = pd.read_csv(r'C:\develop\code\semi-supervised-text-classification\data\expand_samp_enron_no_head.csv')
# # Hyper parm
# iters = 50
# sample_size = 2000
# min_confidence = 0.85
# conf_ls = []
# result_ls = []
def my_bootstrap(data_path,model_path,all_par_data,iters,sample_size,min_confidence):
pred_ls = []
result_ls = []
true_data = all_par_data.loc[all_par_data['label_id'] == 1.]
false_data = all_par_data.loc[all_par_data['label_id'] == 0.]
for i in range(iters):
print('################################### ',i, ' ##################')
if i ==0:
input_file = os.path.join(data_path, 'enron_no_head.csv')
training_df = pd.read_csv(input_file)
else:
num = str(i)
name = str('enron_new_labels_')+num+'.csv'
input_file = os.path.join(data_path, name)
training_df = pd.read_csv(input_file)
output_file = os.path.join(data_path, 'output.csv')
num = str(i)
name = str('new_labels_')+num
result = run_model_on_file(
input_filename=input_file,
output_filename=output_file,
project_id=name ,
user_id=2,
label_id=None,
run_on_entire_dataset=False)
result_ls.append(result.split('Performance on test set:')[1])
trained_model_path = model_path+name+'.pickle'
trained_model = TextClassifier.load(trained_model_path)
mails_num = 3
par_sample,mail_id = get_rand_mail(all_par_data,mails_num)
true_lable = par_sample.iloc[0,1]
new_labeld_df, pred,one_string = get_conf_labels.get_conf_labels(trained_model, par_sample, min_confidence, i, include_zeros=True)
pred_ls.append([mail_id,one_string,pred,pred==true_lable])
if len(new_labeld_df) >0:
training_df = training_df.loc[training_df['document_id'] != mail_id].reset_index(drop=True)
new_data = | pd.concat([training_df,new_labeld_df],ignore_index=True) | pandas.concat |
#!/usr/bin/env python3
import os
import sys
import pandas as pd
import numpy as np
import argparse
import matplotlib.pyplot as plt
import seaborn as sns
from functools import reduce
from multiprocessing import Pool
from os.path import isfile, join
import shutil
import warnings
from pathlib import Path
import time
warnings.simplefilter(action='ignore', category=FutureWarning)
"""
Plot Rating Curves and Compare to USGS Gages
Parameters
----------
fim_dir : str
Directory containing FIM output folders.
output_dir : str
Directory containing rating curve plots and tables.
usgs_gages_filename : str
File name of USGS rating curves.
nwm_flow_dir : str
Directory containing NWM recurrence flows files.
number_of_jobs : str
Number of jobs.
stat_groups : str
string of columns to group eval metrics.
"""
def check_file_age(file):
'''
Checks if file exists, determines the file age, and recommends
updating if older than 1 month.
Returns
-------
None.
'''
file = Path(file)
if file.is_file():
modification_time = file.stat().st_mtime
current_time = time.time()
file_age_days = (current_time - modification_time)/86400
if file_age_days > 30:
check = f'{file.name} is {int(file_age_days)} days old, consider updating.\nUpdate with rating_curve_get_usgs_curves.py'
else:
check = f'{file.name} is {int(file_age_days)} days old.'
return check
# recurr_intervals = ['recurr_1_5_cms.csv','recurr_5_0_cms.csv','recurr_10_0_cms.csv']
def generate_rating_curve_metrics(args):
elev_table_filename = args[0]
hydrotable_filename = args[1]
usgs_gages_filename = args[2]
usgs_recurr_stats_filename = args[3]
nwm_recurr_data_filename = args[4]
rc_comparison_plot_filename = args[5]
nwm_flow_dir = args[6]
catfim_flows_filename = args[7]
huc = args[8]
elev_table = pd.read_csv(elev_table_filename,dtype={'location_id': str})
hydrotable = pd.read_csv(hydrotable_filename,dtype={'HUC': str,'feature_id': str})
usgs_gages = pd.read_csv(usgs_gages_filename,dtype={'location_id': str})
# Join rating curves with elevation data
hydrotable = hydrotable.merge(elev_table, on="HydroID")
relevant_gages = list(hydrotable.location_id.unique())
usgs_gages = usgs_gages[usgs_gages['location_id'].isin(relevant_gages)]
usgs_gages = usgs_gages.reset_index(drop=True)
if len(usgs_gages) > 0:
# Adjust rating curve to elevation
hydrotable['elevation_ft'] = (hydrotable.stage + hydrotable.dem_adj_elevation) * 3.28084 # convert from m to ft
# hydrotable['raw_elevation_ft'] = (hydrotable.stage + hydrotable.dem_elevation) * 3.28084 # convert from m to ft
hydrotable['discharge_cfs'] = hydrotable.discharge_cms * 35.3147
usgs_gages = usgs_gages.rename(columns={"flow": "discharge_cfs", "elevation_navd88": "elevation_ft"})
hydrotable['source'] = "FIM"
usgs_gages['source'] = "USGS"
limited_hydrotable = hydrotable.filter(items=['location_id','elevation_ft','discharge_cfs','source'])
select_usgs_gages = usgs_gages.filter(items=['location_id', 'elevation_ft', 'discharge_cfs','source'])
rating_curves = limited_hydrotable.append(select_usgs_gages)
# Add stream order
stream_orders = hydrotable.filter(items=['location_id','str_order']).drop_duplicates()
rating_curves = rating_curves.merge(stream_orders, on='location_id')
rating_curves['str_order'] = rating_curves['str_order'].astype('int')
# plot rating curves
generate_facet_plot(rating_curves, rc_comparison_plot_filename)
# NWM recurr intervals
recurr_1_5_yr_filename = join(nwm_flow_dir,'recurr_1_5_cms.csv')
recurr_5_yr_filename = join(nwm_flow_dir,'recurr_5_0_cms.csv')
recurr_10_yr_filename = join(nwm_flow_dir,'recurr_10_0_cms.csv')
# Update column names
recurr_1_5_yr = pd.read_csv(recurr_1_5_yr_filename,dtype={'feature_id': str})
recurr_1_5_yr = recurr_1_5_yr.rename(columns={"discharge": "1.5"})
recurr_5_yr = pd.read_csv(recurr_5_yr_filename,dtype={'feature_id': str})
recurr_5_yr = recurr_5_yr.rename(columns={"discharge": "5.0"})
recurr_10_yr = pd.read_csv(recurr_10_yr_filename,dtype={'feature_id': str})
recurr_10_yr = recurr_10_yr.rename(columns={"discharge": "10.0"})
# Merge NWM recurr intervals into a single layer
nwm_recurr_intervals_all = reduce(lambda x,y: pd.merge(x,y, on='feature_id', how='outer'), [recurr_1_5_yr, recurr_5_yr, recurr_10_yr])
nwm_recurr_intervals_all = pd.melt(nwm_recurr_intervals_all, id_vars=['feature_id'], value_vars=['1.5','5.0','10.0'], var_name='recurr_interval', value_name='discharge_cms')
# Append catfim data (already set up in format similar to nwm_recurr_intervals_all)
cat_fim = pd.read_csv(catfim_flows_filename, dtype={'feature_id':str})
nwm_recurr_intervals_all = nwm_recurr_intervals_all.append(cat_fim)
# Convert discharge to cfs and filter
nwm_recurr_intervals_all['discharge_cfs'] = nwm_recurr_intervals_all.discharge_cms * 35.3147
nwm_recurr_intervals_all = nwm_recurr_intervals_all.filter(items=['discharge_cfs', 'recurr_interval','feature_id']).drop_duplicates()
# Identify unique gages
usgs_crosswalk = hydrotable.filter(items=['location_id', 'feature_id']).drop_duplicates()
nwm_recurr_data_table = | pd.DataFrame() | pandas.DataFrame |
#!/usr/bin/env python3
############################################################
## <NAME>, <NAME> & <NAME> ##
## Copyright (C) 2019-2021 Lauro Sumoy Lab, IGTP, Spain ##
############################################################
"""
This module performs piRNA analysis with several possible tools:
Show a description of piRNA molecules here: http://pirnabank.ibab.ac.in/about.html
"""
## import useful modules
import os
import sys
import re
import time
from io import open
import shutil
import concurrent.futures
import pandas as pd
from termcolor import colored
## import my modules
from HCGB import sampleParser
from HCGB import functions
from XICRA.config import set_config
from XICRA.modules import help_XICRA
from XICRA.scripts import generate_DE, bedtools_caller
from XICRA.scripts import MINTMap_caller
from XICRA.scripts import get_length_distribution
##############################################
def run_piRNA(options):
'''
'''
## init time
start_time_total = time.time()
##################################
### show help messages if desired
##################################
if (options.help_format):
## help_format option
help_XICRA.help_fastq_format()
elif (options.help_project):
## information for project
help_XICRA.project_help()
exit()
elif (options.help_piRNA):
## information for join reads
help_XICRA.help_piRNA()
exit()
## debugging messages
global Debug
if (options.debug):
Debug = True
else:
Debug = False
### set as default paired_end mode
if (options.single_end):
options.pair = False
else:
options.pair = True
functions.aesthetics_functions.pipeline_header('XICRA')
functions.aesthetics_functions.boxymcboxface("piRNA analysis")
print ("--------- Starting Process ---------")
functions.time_functions.print_time()
## absolute path for in & out
input_dir = os.path.abspath(options.input)
outdir=""
## set mode: project/detached
if (options.detached):
outdir = os.path.abspath(options.output_folder)
options.project = False
else:
options.project = True
outdir = input_dir
## user software selection
print ("+ Software for piRNA analysis selected:")
print (options.soft_name)
## get files
print ('+ Getting files from input folder... ')
print ('+ Check if previously mapping was generated...')
## retrieve mapping files
results_SampleParser = sampleParser.files.get_files(options, input_dir, "map", ["Aligned.sortedByCoord.out.bam"], options.debug, bam=True)
pd_samples_retrieved = results_SampleParser
del results_SampleParser['dirname']
del results_SampleParser['ext']
del results_SampleParser['tag']
del results_SampleParser['new_name']
results_SampleParser = results_SampleParser.set_index('name')
mapping_results = results_SampleParser.to_dict()['sample']
## Call mapping if mapping_results is empty
if not mapping_results:
## get files: use joined reads if paired-end data
if options.pair:
options.pair = False ## set paired-end to false for further prepocessing
if options.noTrim:
print ('+ Mode: fastq.\n+ Extension: ')
print ("[ fastq, fq, fastq.gz, fq.gz ]\n")
pd_samples_retrieved = sampleParser.files.get_files(options, input_dir, "fastq", ["fastq", "fq", "fastq.gz", "fq.gz"], options.debug)
else:
print ('+ Mode: join.\n+ Extension: ')
print ("[_joined.fastq]\n")
pd_samples_retrieved = sampleParser.files.get_files(options, input_dir, "join", ['_joined.fastq'], options.debug)
else:
if options.noTrim:
print ('+ Mode: fastq.\n+ Extension: ')
print ("[ fastq, fq, fastq.gz, fq.gz ]\n")
pd_samples_retrieved = sampleParser.files.get_files(options, input_dir, "fastq", ["fastq", "fq", "fastq.gz", "fq.gz"], options.debug)
else:
print ('+ Mode: join.\n+ Extension: ')
print ("[_joined.fastq]\n")
pd_samples_retrieved = sampleParser.files.get_files(options, input_dir, "trim", ['_trim'], options.debug)
## debug message
if (Debug):
print (colored("**DEBUG: pd_samples_retrieve **", 'yellow'))
print (pd_samples_retrieved)
## generate output folder, if necessary
print ("\n+ Create output folder(s):")
if not options.project:
files_functions.create_folder(outdir)
## for samples
mapping_outdir_dict = files_functions.outdir_project(outdir, options.project, pd_samples_retrieved, "map", options.debug)
## debug message
if (Debug):
print (colored("**DEBUG: mapping_outdir_dict **", 'yellow'))
print (mapping_outdir_dict)
# time stamp
start_time_partial = time_functions.timestamp(start_time_total)
## optimize threads
name_list = set(pd_samples_retrieved["new_name"].tolist())
threads_job = main_functions.optimize_threads(options.threads, len(name_list)) ## threads optimization
max_workers_int = int(options.threads/threads_job)
## debug message
if (Debug):
print (colored("**DEBUG: options.threads " + str(options.threads) + " **", 'yellow'))
print (colored("**DEBUG: max_workers " + str(max_workers_int) + " **", 'yellow'))
print (colored("**DEBUG: cpu_here " + str(threads_job) + " **", 'yellow'))
##############################################
## map Reads
##############################################
(start_time_partial, mapping_results) = map.mapReads_module_STAR(options, pd_samples_retrieved, mapping_outdir_dict,
options.debug, max_workers_int, threads_job, start_time_partial, outdir)
## debug message
if (Debug):
print (colored("**DEBUG: mapping_results **", 'yellow'))
print (mapping_results)
# time stamp
start_time_partial = time_functions.timestamp(start_time_partial)
############################################################
## Download piRNA information: piRBase
############################################################
if not (options.database):
install_path = os.path.dirname(os.path.realpath(__file__))
options.database = os.path.join(install_path, "db_files")
else:
options.database = os.path.abspath(options.database)
print ("+ Create folder to store results: ", options.database)
functions.files_functions.create_folder(options.database)
## call database module and return options updated
options = database.piRNA_db(options)
##############################################################
## Start the analysis
##############################################################
## generate output folder, if necessary
if not options.project:
print ("\n+ Create output folder(s):")
functions.files_functions.create_folder(outdir)
## for samples
outdir_dict = functions.files_functions.outdir_project(outdir, options.project, pd_samples_retrieved, "piRNA", options.debug)
## Mapping is done, process bam files
print ("+ Create a piRNA analysis for each sample retrieved...")
#############################################
## Get user software selection:
#############################################
# TODO
#############################################
## Parse annotation provided
## convert annotation in GTF to BED
#############################################
folder_GTF = os.path.join(options.database, 'GTF_annot')
functions.files_functions.create_folder(folder_GTF)
print("+ Converting GTF annotation file into BED...")
(bed_files, gtf_files) = get_length_distribution.convert_GTF2bed(options.GTF_info, folder_GTF, debug=options.debug)
## debugging messages
if debug:
HCGB_aes.debug_message("bed_files", color="yellow")
print(bed_files)
print()
HCGB_aes.debug_message("gtf_files", color="yellow")
print(gtf_files)
## Loop for each reference sequence BED file
## and intersect with mapping BAM->BED file
print("+ Intersecting GTF annotation file and mapping BED file...")
# Group dataframe by sample name
sample_frame = pd_samples_retrieved.groupby(["new_name"])
## send for each sample
with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers_int) as executor:
commandsSent = { executor.submit(piRNA_analysis,
sorted(cluster["sample"].tolist()),
outdir_dict[name], name, threads_job,
options.soft_name, options.species,
options.database, bed_files, Debug): name for name, cluster in sample_frame }
for cmd2 in concurrent.futures.as_completed(commandsSent):
details = commandsSent[cmd2]
try:
data = cmd2.result()
except Exception as exc:
print ('***ERROR:')
print (cmd2)
print('%r generated an exception: %s' % (details, exc))
print ("\n\n+ piRNA analysis is finished...")
print ("+ Let's summarize all results...")
## outdir
outdir_report = functions.files_functions.create_subfolder("report", outdir)
expression_folder = functions.files_functions.create_subfolder("piRNA", outdir_report)
## merge all parse gtf files created
print ("+ Summarize piRNA analysis for all samples...")
## dictionary results
results_SampleParser = sampleParser.files.get_files(options, input_dir, "piRNA", ["xxx.tsv"], options.debug)
results_df = | pd.DataFrame(columns=("name", "soft", "filename")) | pandas.DataFrame |
# -*- coding: utf-8 -*-
# pylint: disable-msg=E1101,W0612
from datetime import datetime, timedelta
import pytest
import re
from numpy import nan as NA
import numpy as np
from numpy.random import randint
from pandas.compat import range, u
import pandas.compat as compat
from pandas import Index, Series, DataFrame, isna, MultiIndex, notna
from pandas.util.testing import assert_series_equal
import pandas.util.testing as tm
import pandas.core.strings as strings
class TestStringMethods(object):
def test_api(self):
# GH 6106, GH 9322
assert Series.str is strings.StringMethods
assert isinstance(Series(['']).str, strings.StringMethods)
# GH 9184
invalid = Series([1])
with tm.assert_raises_regex(AttributeError,
"only use .str accessor"):
invalid.str
assert not hasattr(invalid, 'str')
def test_iter(self):
# GH3638
strs = 'google', 'wikimedia', 'wikipedia', 'wikitravel'
ds = Series(strs)
for s in ds.str:
# iter must yield a Series
assert isinstance(s, Series)
# indices of each yielded Series should be equal to the index of
# the original Series
tm.assert_index_equal(s.index, ds.index)
for el in s:
# each element of the series is either a basestring/str or nan
assert isinstance(el, compat.string_types) or isna(el)
# desired behavior is to iterate until everything would be nan on the
# next iter so make sure the last element of the iterator was 'l' in
# this case since 'wikitravel' is the longest string
assert s.dropna().values.item() == 'l'
def test_iter_empty(self):
ds = Series([], dtype=object)
i, s = 100, 1
for i, s in enumerate(ds.str):
pass
# nothing to iterate over so nothing defined values should remain
# unchanged
assert i == 100
assert s == 1
def test_iter_single_element(self):
ds = Series(['a'])
for i, s in enumerate(ds.str):
pass
assert not i
assert_series_equal(ds, s)
def test_iter_object_try_string(self):
ds = Series([slice(None, randint(10), randint(10, 20)) for _ in range(
4)])
i, s = 100, 'h'
for i, s in enumerate(ds.str):
pass
assert i == 100
assert s == 'h'
def test_cat(self):
one = np.array(['a', 'a', 'b', 'b', 'c', NA], dtype=np.object_)
two = np.array(['a', NA, 'b', 'd', 'foo', NA], dtype=np.object_)
# single array
result = strings.str_cat(one)
exp = 'aabbc'
assert result == exp
result = strings.str_cat(one, na_rep='NA')
exp = 'aabbcNA'
assert result == exp
result = strings.str_cat(one, na_rep='-')
exp = 'aabbc-'
assert result == exp
result = strings.str_cat(one, sep='_', na_rep='NA')
exp = 'a_a_b_b_c_NA'
assert result == exp
result = strings.str_cat(two, sep='-')
exp = 'a-b-d-foo'
assert result == exp
# Multiple arrays
result = strings.str_cat(one, [two], na_rep='NA')
exp = np.array(['aa', 'aNA', 'bb', 'bd', 'cfoo', 'NANA'],
dtype=np.object_)
tm.assert_numpy_array_equal(result, exp)
result = strings.str_cat(one, two)
exp = np.array(['aa', NA, 'bb', 'bd', 'cfoo', NA], dtype=np.object_)
tm.assert_almost_equal(result, exp)
def test_count(self):
values = np.array(['foo', 'foofoo', NA, 'foooofooofommmfoo'],
dtype=np.object_)
result = strings.str_count(values, 'f[o]+')
exp = np.array([1, 2, NA, 4])
tm.assert_numpy_array_equal(result, exp)
result = Series(values).str.count('f[o]+')
exp = Series([1, 2, NA, 4])
assert isinstance(result, Series)
tm.assert_series_equal(result, exp)
# mixed
mixed = ['a', NA, 'b', True, datetime.today(), 'foo', None, 1, 2.]
rs = strings.str_count(mixed, 'a')
xp = np.array([1, NA, 0, NA, NA, 0, NA, NA, NA])
tm.assert_numpy_array_equal(rs, xp)
rs = Series(mixed).str.count('a')
xp = Series([1, NA, 0, NA, NA, 0, NA, NA, NA])
assert isinstance(rs, Series)
tm.assert_series_equal(rs, xp)
# unicode
values = [u('foo'), u('foofoo'), NA, u('foooofooofommmfoo')]
result = strings.str_count(values, 'f[o]+')
exp = np.array([1, 2, NA, 4])
tm.assert_numpy_array_equal(result, exp)
result = Series(values).str.count('f[o]+')
exp = Series([1, 2, NA, 4])
assert isinstance(result, Series)
tm.assert_series_equal(result, exp)
def test_contains(self):
values = np.array(['foo', NA, 'fooommm__foo',
'mmm_', 'foommm[_]+bar'], dtype=np.object_)
pat = 'mmm[_]+'
result = strings.str_contains(values, pat)
expected = np.array([False, NA, True, True, False], dtype=np.object_)
tm.assert_numpy_array_equal(result, expected)
result = strings.str_contains(values, pat, regex=False)
expected = np.array([False, NA, False, False, True], dtype=np.object_)
tm.assert_numpy_array_equal(result, expected)
values = ['foo', 'xyz', 'fooommm__foo', 'mmm_']
result = strings.str_contains(values, pat)
expected = np.array([False, False, True, True])
assert result.dtype == np.bool_
tm.assert_numpy_array_equal(result, expected)
# case insensitive using regex
values = ['Foo', 'xYz', 'fOOomMm__fOo', 'MMM_']
result = strings.str_contains(values, 'FOO|mmm', case=False)
expected = np.array([True, False, True, True])
tm.assert_numpy_array_equal(result, expected)
# case insensitive without regex
result = strings.str_contains(values, 'foo', regex=False, case=False)
expected = np.array([True, False, True, False])
tm.assert_numpy_array_equal(result, expected)
# mixed
mixed = ['a', NA, 'b', True, datetime.today(), 'foo', None, 1, 2.]
rs = strings.str_contains(mixed, 'o')
xp = np.array([False, NA, False, NA, NA, True, NA, NA, NA],
dtype=np.object_)
tm.assert_numpy_array_equal(rs, xp)
rs = Series(mixed).str.contains('o')
xp = Series([False, NA, False, NA, NA, True, NA, NA, NA])
assert isinstance(rs, Series)
tm.assert_series_equal(rs, xp)
# unicode
values = np.array([u'foo', NA, u'fooommm__foo', u'mmm_'],
dtype=np.object_)
pat = 'mmm[_]+'
result = strings.str_contains(values, pat)
expected = np.array([False, np.nan, True, True], dtype=np.object_)
tm.assert_numpy_array_equal(result, expected)
result = strings.str_contains(values, pat, na=False)
expected = np.array([False, False, True, True])
tm.assert_numpy_array_equal(result, expected)
values = np.array(['foo', 'xyz', 'fooommm__foo', 'mmm_'],
dtype=np.object_)
result = strings.str_contains(values, pat)
expected = np.array([False, False, True, True])
assert result.dtype == np.bool_
tm.assert_numpy_array_equal(result, expected)
# na
values = Series(['om', 'foo', np.nan])
res = values.str.contains('foo', na="foo")
assert res.loc[2] == "foo"
def test_startswith(self):
values = Series(['om', NA, 'foo_nom', 'nom', 'bar_foo', NA, 'foo'])
result = values.str.startswith('foo')
exp = Series([False, NA, True, False, False, NA, True])
tm.assert_series_equal(result, exp)
# mixed
mixed = np.array(['a', NA, 'b', True, datetime.today(),
'foo', None, 1, 2.], dtype=np.object_)
rs = strings.str_startswith(mixed, 'f')
xp = np.array([False, NA, False, NA, NA, True, NA, NA, NA],
dtype=np.object_)
tm.assert_numpy_array_equal(rs, xp)
rs = Series(mixed).str.startswith('f')
assert isinstance(rs, Series)
xp = Series([False, NA, False, NA, NA, True, NA, NA, NA])
tm.assert_series_equal(rs, xp)
# unicode
values = Series([u('om'), NA, u('foo_nom'), u('nom'), u('bar_foo'), NA,
u('foo')])
result = values.str.startswith('foo')
exp = Series([False, NA, True, False, False, NA, True])
tm.assert_series_equal(result, exp)
result = values.str.startswith('foo', na=True)
tm.assert_series_equal(result, exp.fillna(True).astype(bool))
def test_endswith(self):
values = Series(['om', NA, 'foo_nom', 'nom', 'bar_foo', NA, 'foo'])
result = values.str.endswith('foo')
exp = Series([False, NA, False, False, True, NA, True])
tm.assert_series_equal(result, exp)
# mixed
mixed = ['a', NA, 'b', True, datetime.today(), 'foo', None, 1, 2.]
rs = strings.str_endswith(mixed, 'f')
xp = np.array([False, NA, False, NA, NA, False, NA, NA, NA],
dtype=np.object_)
tm.assert_numpy_array_equal(rs, xp)
rs = Series(mixed).str.endswith('f')
xp = Series([False, NA, False, NA, NA, False, NA, NA, NA])
assert isinstance(rs, Series)
tm.assert_series_equal(rs, xp)
# unicode
values = Series([u('om'), NA, u('foo_nom'), u('nom'), u('bar_foo'), NA,
u('foo')])
result = values.str.endswith('foo')
exp = Series([False, NA, False, False, True, NA, True])
tm.assert_series_equal(result, exp)
result = values.str.endswith('foo', na=False)
tm.assert_series_equal(result, exp.fillna(False).astype(bool))
def test_title(self):
values = Series(["FOO", "BAR", NA, "Blah", "blurg"])
result = values.str.title()
exp = Series(["Foo", "Bar", NA, "Blah", "Blurg"])
tm.assert_series_equal(result, exp)
# mixed
mixed = Series(["FOO", NA, "bar", True, datetime.today(), "blah", None,
1, 2.])
mixed = mixed.str.title()
exp = Series(["Foo", NA, "Bar", NA, NA, "Blah", NA, NA, NA])
tm.assert_almost_equal(mixed, exp)
# unicode
values = Series([u("FOO"), NA, u("bar"), u("Blurg")])
results = values.str.title()
exp = Series([u("Foo"), NA, u("Bar"), u("Blurg")])
tm.assert_series_equal(results, exp)
def test_lower_upper(self):
values = Series(['om', NA, 'nom', 'nom'])
result = values.str.upper()
exp = Series(['OM', NA, 'NOM', 'NOM'])
tm.assert_series_equal(result, exp)
result = result.str.lower()
tm.assert_series_equal(result, values)
# mixed
mixed = Series(['a', NA, 'b', True, datetime.today(), 'foo', None, 1,
2.])
mixed = mixed.str.upper()
rs = Series(mixed).str.lower()
xp = Series(['a', NA, 'b', NA, NA, 'foo', NA, NA, NA])
assert isinstance(rs, Series)
tm.assert_series_equal(rs, xp)
# unicode
values = Series([u('om'), NA, u('nom'), u('nom')])
result = values.str.upper()
exp = Series([u('OM'), NA, u('NOM'), u('NOM')])
tm.assert_series_equal(result, exp)
result = result.str.lower()
tm.assert_series_equal(result, values)
def test_capitalize(self):
values = Series(["FOO", "BAR", NA, "Blah", "blurg"])
result = values.str.capitalize()
exp = Series(["Foo", "Bar", NA, "Blah", "Blurg"])
tm.assert_series_equal(result, exp)
# mixed
mixed = Series(["FOO", NA, "bar", True, datetime.today(), "blah", None,
1, 2.])
mixed = mixed.str.capitalize()
exp = Series(["Foo", NA, "Bar", NA, NA, "Blah", NA, NA, NA])
tm.assert_almost_equal(mixed, exp)
# unicode
values = Series([u("FOO"), NA, u("bar"), u("Blurg")])
results = values.str.capitalize()
exp = Series([u("Foo"), NA, u("Bar"), u("Blurg")])
tm.assert_series_equal(results, exp)
def test_swapcase(self):
values = Series(["FOO", "BAR", NA, "Blah", "blurg"])
result = values.str.swapcase()
exp = Series(["foo", "bar", NA, "bLAH", "BLURG"])
tm.assert_series_equal(result, exp)
# mixed
mixed = Series(["FOO", NA, "bar", True, datetime.today(), "Blah", None,
1, 2.])
mixed = mixed.str.swapcase()
exp = Series(["foo", NA, "BAR", NA, NA, "bLAH", NA, NA, NA])
tm.assert_almost_equal(mixed, exp)
# unicode
values = Series([u("FOO"), NA, u("bar"), u("Blurg")])
results = values.str.swapcase()
exp = Series([u("foo"), NA, u("BAR"), u("bLURG")])
tm.assert_series_equal(results, exp)
def test_casemethods(self):
values = ['aaa', 'bbb', 'CCC', 'Dddd', 'eEEE']
s = Series(values)
assert s.str.lower().tolist() == [v.lower() for v in values]
assert s.str.upper().tolist() == [v.upper() for v in values]
assert s.str.title().tolist() == [v.title() for v in values]
assert s.str.capitalize().tolist() == [v.capitalize() for v in values]
assert s.str.swapcase().tolist() == [v.swapcase() for v in values]
def test_replace(self):
values = Series(['fooBAD__barBAD', NA])
result = values.str.replace('BAD[_]*', '')
exp = Series(['foobar', NA])
tm.assert_series_equal(result, exp)
result = values.str.replace('BAD[_]*', '', n=1)
exp = Series(['foobarBAD', NA])
tm.assert_series_equal(result, exp)
# mixed
mixed = Series(['aBAD', NA, 'bBAD', True, datetime.today(), 'fooBAD',
None, 1, 2.])
rs = Series(mixed).str.replace('BAD[_]*', '')
xp = Series(['a', NA, 'b', NA, NA, 'foo', NA, NA, NA])
assert isinstance(rs, Series)
tm.assert_almost_equal(rs, xp)
# unicode
values = Series([u('fooBAD__barBAD'), NA])
result = values.str.replace('BAD[_]*', '')
exp = Series([u('foobar'), NA])
tm.assert_series_equal(result, exp)
result = values.str.replace('BAD[_]*', '', n=1)
exp = Series([u('foobarBAD'), NA])
tm.assert_series_equal(result, exp)
# flags + unicode
values = Series([b"abcd,\xc3\xa0".decode("utf-8")])
exp = Series([b"abcd, \xc3\xa0".decode("utf-8")])
result = values.str.replace(r"(?<=\w),(?=\w)", ", ", flags=re.UNICODE)
tm.assert_series_equal(result, exp)
# GH 13438
for klass in (Series, Index):
for repl in (None, 3, {'a': 'b'}):
for data in (['a', 'b', None], ['a', 'b', 'c', 'ad']):
values = klass(data)
pytest.raises(TypeError, values.str.replace, 'a', repl)
def test_replace_callable(self):
# GH 15055
values = Series(['fooBAD__barBAD', NA])
# test with callable
repl = lambda m: m.group(0).swapcase()
result = values.str.replace('[a-z][A-Z]{2}', repl, n=2)
exp = Series(['foObaD__baRbaD', NA])
tm.assert_series_equal(result, exp)
# test with wrong number of arguments, raising an error
if compat.PY2:
p_err = r'takes (no|(exactly|at (least|most)) ?\d+) arguments?'
else:
p_err = (r'((takes)|(missing)) (?(2)from \d+ to )?\d+ '
r'(?(3)required )positional arguments?')
repl = lambda: None
with tm.assert_raises_regex(TypeError, p_err):
values.str.replace('a', repl)
repl = lambda m, x: None
with tm.assert_raises_regex(TypeError, p_err):
values.str.replace('a', repl)
repl = lambda m, x, y=None: None
with tm.assert_raises_regex(TypeError, p_err):
values.str.replace('a', repl)
# test regex named groups
values = Series(['Foo Bar Baz', NA])
pat = r"(?P<first>\w+) (?P<middle>\w+) (?P<last>\w+)"
repl = lambda m: m.group('middle').swapcase()
result = values.str.replace(pat, repl)
exp = Series(['bAR', NA])
tm.assert_series_equal(result, exp)
def test_replace_compiled_regex(self):
# GH 15446
values = Series(['fooBAD__barBAD', NA])
# test with compiled regex
pat = re.compile(r'BAD[_]*')
result = values.str.replace(pat, '')
exp = Series(['foobar', NA])
tm.assert_series_equal(result, exp)
# mixed
mixed = Series(['aBAD', NA, 'bBAD', True, datetime.today(), 'fooBAD',
None, 1, 2.])
rs = Series(mixed).str.replace(pat, '')
xp = Series(['a', NA, 'b', NA, NA, 'foo', NA, NA, NA])
assert isinstance(rs, Series)
tm.assert_almost_equal(rs, xp)
# unicode
values = Series([u('fooBAD__barBAD'), NA])
result = values.str.replace(pat, '')
exp = Series([u('foobar'), NA])
tm.assert_series_equal(result, exp)
result = values.str.replace(pat, '', n=1)
exp = Series([u('foobarBAD'), NA])
tm.assert_series_equal(result, exp)
# flags + unicode
values = Series([b"abcd,\xc3\xa0".decode("utf-8")])
exp = Series([b"abcd, \xc3\xa0".decode("utf-8")])
pat = re.compile(r"(?<=\w),(?=\w)", flags=re.UNICODE)
result = values.str.replace(pat, ", ")
tm.assert_series_equal(result, exp)
# case and flags provided to str.replace will have no effect
# and will produce warnings
values = Series(['fooBAD__barBAD__bad', NA])
pat = re.compile(r'BAD[_]*')
with tm.assert_raises_regex(ValueError,
"case and flags cannot be"):
result = values.str.replace(pat, '', flags=re.IGNORECASE)
with tm.assert_raises_regex(ValueError,
"case and flags cannot be"):
result = values.str.replace(pat, '', case=False)
with tm.assert_raises_regex(ValueError,
"case and flags cannot be"):
result = values.str.replace(pat, '', case=True)
# test with callable
values = Series(['fooBAD__barBAD', NA])
repl = lambda m: m.group(0).swapcase()
pat = re.compile('[a-z][A-Z]{2}')
result = values.str.replace(pat, repl, n=2)
exp = Series(['foObaD__baRbaD', NA])
tm.assert_series_equal(result, exp)
def test_repeat(self):
values = Series(['a', 'b', NA, 'c', NA, 'd'])
result = values.str.repeat(3)
exp = Series(['aaa', 'bbb', NA, 'ccc', NA, 'ddd'])
tm.assert_series_equal(result, exp)
result = values.str.repeat([1, 2, 3, 4, 5, 6])
exp = Series(['a', 'bb', NA, 'cccc', NA, 'dddddd'])
tm.assert_series_equal(result, exp)
# mixed
mixed = Series(['a', NA, 'b', True, datetime.today(), 'foo', None, 1,
2.])
rs = Series(mixed).str.repeat(3)
xp = Series(['aaa', NA, 'bbb', NA, NA, 'foofoofoo', NA, NA, NA])
assert isinstance(rs, Series)
tm.assert_series_equal(rs, xp)
# unicode
values = Series([u('a'), u('b'), NA, u('c'), NA, u('d')])
result = values.str.repeat(3)
exp = Series([u('aaa'), u('bbb'), NA, u('ccc'), NA, u('ddd')])
tm.assert_series_equal(result, exp)
result = values.str.repeat([1, 2, 3, 4, 5, 6])
exp = Series([u('a'), u('bb'), NA, u('cccc'), NA, u('dddddd')])
tm.assert_series_equal(result, exp)
def test_match(self):
# New match behavior introduced in 0.13
values = Series(['fooBAD__barBAD', NA, 'foo'])
result = values.str.match('.*(BAD[_]+).*(BAD)')
exp = Series([True, NA, False])
tm.assert_series_equal(result, exp)
values = Series(['fooBAD__barBAD', NA, 'foo'])
result = values.str.match('.*BAD[_]+.*BAD')
exp = Series([True, NA, False])
tm.assert_series_equal(result, exp)
# test passing as_indexer still works but is ignored
values = Series(['fooBAD__barBAD', NA, 'foo'])
exp = Series([True, NA, False])
with tm.assert_produces_warning(FutureWarning):
result = values.str.match('.*BAD[_]+.*BAD', as_indexer=True)
tm.assert_series_equal(result, exp)
with tm.assert_produces_warning(FutureWarning):
result = values.str.match('.*BAD[_]+.*BAD', as_indexer=False)
tm.assert_series_equal(result, exp)
with tm.assert_produces_warning(FutureWarning):
result = values.str.match('.*(BAD[_]+).*(BAD)', as_indexer=True)
tm.assert_series_equal(result, exp)
pytest.raises(ValueError, values.str.match, '.*(BAD[_]+).*(BAD)',
as_indexer=False)
# mixed
mixed = Series(['aBAD_BAD', NA, 'BAD_b_BAD', True, datetime.today(),
'foo', None, 1, 2.])
rs = Series(mixed).str.match('.*(BAD[_]+).*(BAD)')
xp = Series([True, NA, True, NA, NA, False, NA, NA, NA])
assert isinstance(rs, Series)
tm.assert_series_equal(rs, xp)
# unicode
values = Series([u('fooBAD__barBAD'), NA, u('foo')])
result = values.str.match('.*(BAD[_]+).*(BAD)')
exp = Series([True, NA, False])
tm.assert_series_equal(result, exp)
# na GH #6609
res = Series(['a', 0, np.nan]).str.match('a', na=False)
exp = Series([True, False, False])
assert_series_equal(exp, res)
res = Series(['a', 0, np.nan]).str.match('a')
exp = Series([True, np.nan, np.nan])
assert_series_equal(exp, res)
def test_extract_expand_None(self):
values = Series(['fooBAD__barBAD', NA, 'foo'])
with tm.assert_produces_warning(FutureWarning):
values.str.extract('.*(BAD[_]+).*(BAD)', expand=None)
def test_extract_expand_unspecified(self):
values = Series(['fooBAD__barBAD', NA, 'foo'])
with tm.assert_produces_warning(FutureWarning):
values.str.extract('.*(BAD[_]+).*(BAD)')
def test_extract_expand_False(self):
# Contains tests like those in test_match and some others.
values = Series(['fooBAD__barBAD', NA, 'foo'])
er = [NA, NA] # empty row
result = values.str.extract('.*(BAD[_]+).*(BAD)', expand=False)
exp = DataFrame([['BAD__', 'BAD'], er, er])
tm.assert_frame_equal(result, exp)
# mixed
mixed = Series(['aBAD_BAD', NA, 'BAD_b_BAD', True, datetime.today(),
'foo', None, 1, 2.])
rs = Series(mixed).str.extract('.*(BAD[_]+).*(BAD)', expand=False)
exp = DataFrame([['BAD_', 'BAD'], er, ['BAD_', 'BAD'], er, er, er, er,
er, er])
tm.assert_frame_equal(rs, exp)
# unicode
values = Series([u('fooBAD__barBAD'), NA, u('foo')])
result = values.str.extract('.*(BAD[_]+).*(BAD)', expand=False)
exp = DataFrame([[u('BAD__'), u('BAD')], er, er])
tm.assert_frame_equal(result, exp)
# GH9980
# Index only works with one regex group since
# multi-group would expand to a frame
idx = Index(['A1', 'A2', 'A3', 'A4', 'B5'])
with tm.assert_raises_regex(ValueError, "supported"):
idx.str.extract('([AB])([123])', expand=False)
# these should work for both Series and Index
for klass in [Series, Index]:
# no groups
s_or_idx = klass(['A1', 'B2', 'C3'])
f = lambda: s_or_idx.str.extract('[ABC][123]', expand=False)
pytest.raises(ValueError, f)
# only non-capturing groups
f = lambda: s_or_idx.str.extract('(?:[AB]).*', expand=False)
pytest.raises(ValueError, f)
# single group renames series/index properly
s_or_idx = klass(['A1', 'A2'])
result = s_or_idx.str.extract(r'(?P<uno>A)\d', expand=False)
assert result.name == 'uno'
exp = klass(['A', 'A'], name='uno')
if klass == Series:
tm.assert_series_equal(result, exp)
else:
tm.assert_index_equal(result, exp)
s = Series(['A1', 'B2', 'C3'])
# one group, no matches
result = s.str.extract('(_)', expand=False)
exp = Series([NA, NA, NA], dtype=object)
tm.assert_series_equal(result, exp)
# two groups, no matches
result = s.str.extract('(_)(_)', expand=False)
exp = DataFrame([[NA, NA], [NA, NA], [NA, NA]], dtype=object)
tm.assert_frame_equal(result, exp)
# one group, some matches
result = s.str.extract('([AB])[123]', expand=False)
exp = Series(['A', 'B', NA])
tm.assert_series_equal(result, exp)
# two groups, some matches
result = s.str.extract('([AB])([123])', expand=False)
exp = DataFrame([['A', '1'], ['B', '2'], [NA, NA]])
tm.assert_frame_equal(result, exp)
# one named group
result = s.str.extract('(?P<letter>[AB])', expand=False)
exp = Series(['A', 'B', NA], name='letter')
tm.assert_series_equal(result, exp)
# two named groups
result = s.str.extract('(?P<letter>[AB])(?P<number>[123])',
expand=False)
exp = DataFrame([['A', '1'], ['B', '2'], [NA, NA]],
columns=['letter', 'number'])
tm.assert_frame_equal(result, exp)
# mix named and unnamed groups
result = s.str.extract('([AB])(?P<number>[123])', expand=False)
exp = DataFrame([['A', '1'], ['B', '2'], [NA, NA]],
columns=[0, 'number'])
tm.assert_frame_equal(result, exp)
# one normal group, one non-capturing group
result = s.str.extract('([AB])(?:[123])', expand=False)
exp = Series(['A', 'B', NA])
tm.assert_series_equal(result, exp)
# two normal groups, one non-capturing group
result = Series(['A11', 'B22', 'C33']).str.extract(
'([AB])([123])(?:[123])', expand=False)
exp = DataFrame([['A', '1'], ['B', '2'], [NA, NA]])
tm.assert_frame_equal(result, exp)
# one optional group followed by one normal group
result = Series(['A1', 'B2', '3']).str.extract(
'(?P<letter>[AB])?(?P<number>[123])', expand=False)
exp = DataFrame([['A', '1'], ['B', '2'], [NA, '3']],
columns=['letter', 'number'])
tm.assert_frame_equal(result, exp)
# one normal group followed by one optional group
result = Series(['A1', 'B2', 'C']).str.extract(
'(?P<letter>[ABC])(?P<number>[123])?', expand=False)
exp = DataFrame([['A', '1'], ['B', '2'], ['C', NA]],
columns=['letter', 'number'])
tm.assert_frame_equal(result, exp)
# GH6348
# not passing index to the extractor
def check_index(index):
data = ['A1', 'B2', 'C']
index = index[:len(data)]
s = Series(data, index=index)
result = s.str.extract(r'(\d)', expand=False)
exp = Series(['1', '2', NA], index=index)
tm.assert_series_equal(result, exp)
result = Series(data, index=index).str.extract(
r'(?P<letter>\D)(?P<number>\d)?', expand=False)
e_list = [
['A', '1'],
['B', '2'],
['C', NA]
]
exp = DataFrame(e_list, columns=['letter', 'number'], index=index)
tm.assert_frame_equal(result, exp)
i_funs = [
tm.makeStringIndex, tm.makeUnicodeIndex, tm.makeIntIndex,
tm.makeDateIndex, tm.makePeriodIndex, tm.makeRangeIndex
]
for index in i_funs:
check_index(index())
# single_series_name_is_preserved.
s = Series(['a3', 'b3', 'c2'], name='bob')
r = s.str.extract(r'(?P<sue>[a-z])', expand=False)
e = Series(['a', 'b', 'c'], name='sue')
tm.assert_series_equal(r, e)
assert r.name == e.name
def test_extract_expand_True(self):
# Contains tests like those in test_match and some others.
values = Series(['fooBAD__barBAD', NA, 'foo'])
er = [NA, NA] # empty row
result = values.str.extract('.*(BAD[_]+).*(BAD)', expand=True)
exp = DataFrame([['BAD__', 'BAD'], er, er])
tm.assert_frame_equal(result, exp)
# mixed
mixed = Series(['aBAD_BAD', NA, 'BAD_b_BAD', True, datetime.today(),
'foo', None, 1, 2.])
rs = Series(mixed).str.extract('.*(BAD[_]+).*(BAD)', expand=True)
exp = DataFrame([['BAD_', 'BAD'], er, ['BAD_', 'BAD'], er, er,
er, er, er, er])
tm.assert_frame_equal(rs, exp)
# unicode
values = Series([u('fooBAD__barBAD'), NA, u('foo')])
result = values.str.extract('.*(BAD[_]+).*(BAD)', expand=True)
exp = DataFrame([[u('BAD__'), u('BAD')], er, er])
tm.assert_frame_equal(result, exp)
# these should work for both Series and Index
for klass in [Series, Index]:
# no groups
s_or_idx = klass(['A1', 'B2', 'C3'])
f = lambda: s_or_idx.str.extract('[ABC][123]', expand=True)
pytest.raises(ValueError, f)
# only non-capturing groups
f = lambda: s_or_idx.str.extract('(?:[AB]).*', expand=True)
pytest.raises(ValueError, f)
# single group renames series/index properly
s_or_idx = klass(['A1', 'A2'])
result_df = s_or_idx.str.extract(r'(?P<uno>A)\d', expand=True)
assert isinstance(result_df, DataFrame)
result_series = result_df['uno']
assert_series_equal(result_series, Series(['A', 'A'], name='uno'))
def test_extract_series(self):
# extract should give the same result whether or not the
# series has a name.
for series_name in None, "series_name":
s = Series(['A1', 'B2', 'C3'], name=series_name)
# one group, no matches
result = s.str.extract('(_)', expand=True)
exp = DataFrame([NA, NA, NA], dtype=object)
tm.assert_frame_equal(result, exp)
# two groups, no matches
result = s.str.extract('(_)(_)', expand=True)
exp = DataFrame([[NA, NA], [NA, NA], [NA, NA]], dtype=object)
tm.assert_frame_equal(result, exp)
# one group, some matches
result = s.str.extract('([AB])[123]', expand=True)
exp = DataFrame(['A', 'B', NA])
tm.assert_frame_equal(result, exp)
# two groups, some matches
result = s.str.extract('([AB])([123])', expand=True)
exp = DataFrame([['A', '1'], ['B', '2'], [NA, NA]])
tm.assert_frame_equal(result, exp)
# one named group
result = s.str.extract('(?P<letter>[AB])', expand=True)
exp = DataFrame({"letter": ['A', 'B', NA]})
tm.assert_frame_equal(result, exp)
# two named groups
result = s.str.extract(
'(?P<letter>[AB])(?P<number>[123])',
expand=True)
e_list = [
['A', '1'],
['B', '2'],
[NA, NA]
]
exp = DataFrame(e_list, columns=['letter', 'number'])
tm.assert_frame_equal(result, exp)
# mix named and unnamed groups
result = s.str.extract('([AB])(?P<number>[123])', expand=True)
exp = DataFrame(e_list, columns=[0, 'number'])
tm.assert_frame_equal(result, exp)
# one normal group, one non-capturing group
result = s.str.extract('([AB])(?:[123])', expand=True)
exp = DataFrame(['A', 'B', NA])
tm.assert_frame_equal(result, exp)
def test_extract_optional_groups(self):
# two normal groups, one non-capturing group
result = Series(['A11', 'B22', 'C33']).str.extract(
'([AB])([123])(?:[123])', expand=True)
exp = DataFrame([['A', '1'], ['B', '2'], [NA, NA]])
tm.assert_frame_equal(result, exp)
# one optional group followed by one normal group
result = Series(['A1', 'B2', '3']).str.extract(
'(?P<letter>[AB])?(?P<number>[123])', expand=True)
e_list = [
['A', '1'],
['B', '2'],
[NA, '3']
]
exp = DataFrame(e_list, columns=['letter', 'number'])
tm.assert_frame_equal(result, exp)
# one normal group followed by one optional group
result = Series(['A1', 'B2', 'C']).str.extract(
'(?P<letter>[ABC])(?P<number>[123])?', expand=True)
e_list = [
['A', '1'],
['B', '2'],
['C', NA]
]
exp = DataFrame(e_list, columns=['letter', 'number'])
tm.assert_frame_equal(result, exp)
# GH6348
# not passing index to the extractor
def check_index(index):
data = ['A1', 'B2', 'C']
index = index[:len(data)]
result = Series(data, index=index).str.extract(
r'(\d)', expand=True)
exp = DataFrame(['1', '2', NA], index=index)
tm.assert_frame_equal(result, exp)
result = Series(data, index=index).str.extract(
r'(?P<letter>\D)(?P<number>\d)?', expand=True)
e_list = [
['A', '1'],
['B', '2'],
['C', NA]
]
exp = DataFrame(e_list, columns=['letter', 'number'], index=index)
tm.assert_frame_equal(result, exp)
i_funs = [
tm.makeStringIndex, tm.makeUnicodeIndex, tm.makeIntIndex,
tm.makeDateIndex, tm.makePeriodIndex, tm.makeRangeIndex
]
for index in i_funs:
check_index(index())
def test_extract_single_group_returns_frame(self):
# GH11386 extract should always return DataFrame, even when
# there is only one group. Prior to v0.18.0, extract returned
# Series when there was only one group in the regex.
s = Series(['a3', 'b3', 'c2'], name='series_name')
r = s.str.extract(r'(?P<letter>[a-z])', expand=True)
e = DataFrame({"letter": ['a', 'b', 'c']})
tm.assert_frame_equal(r, e)
def test_extractall(self):
subject_list = [
'<EMAIL>',
'<EMAIL>',
'<EMAIL>',
'<EMAIL> some text <EMAIL>',
'<EMAIL> some text c@d.<EMAIL> and <EMAIL>',
np.nan,
"",
]
expected_tuples = [
("dave", "google", "com"),
("tdhock5", "gmail", "com"),
("maudelaperriere", "gmail", "com"),
("rob", "gmail", "com"), ("steve", "gmail", "com"),
("a", "b", "com"), ("c", "d", "com"), ("e", "f", "com"),
]
named_pattern = r"""
(?P<user>[a-z0-9]+)
@
(?P<domain>[a-z]+)
\.
(?P<tld>[a-z]{2,4})
"""
expected_columns = ["user", "domain", "tld"]
S = Series(subject_list)
# extractall should return a DataFrame with one row for each
# match, indexed by the subject from which the match came.
expected_index = MultiIndex.from_tuples([
(0, 0),
(1, 0),
(2, 0),
(3, 0),
(3, 1),
(4, 0),
(4, 1),
(4, 2),
], names=(None, "match"))
expected_df = DataFrame(
expected_tuples, expected_index, expected_columns)
computed_df = S.str.extractall(named_pattern, re.VERBOSE)
tm.assert_frame_equal(computed_df, expected_df)
# The index of the input Series should be used to construct
# the index of the output DataFrame:
series_index = MultiIndex.from_tuples([
("single", "Dave"),
("single", "Toby"),
("single", "Maude"),
("multiple", "robAndSteve"),
("multiple", "abcdef"),
("none", "missing"),
("none", "empty"),
])
Si = Series(subject_list, series_index)
expected_index = MultiIndex.from_tuples([
("single", "Dave", 0),
("single", "Toby", 0),
("single", "Maude", 0),
("multiple", "robAndSteve", 0),
("multiple", "robAndSteve", 1),
("multiple", "abcdef", 0),
("multiple", "abcdef", 1),
("multiple", "abcdef", 2),
], names=(None, None, "match"))
expected_df = DataFrame(
expected_tuples, expected_index, expected_columns)
computed_df = Si.str.extractall(named_pattern, re.VERBOSE)
tm.assert_frame_equal(computed_df, expected_df)
# MultiIndexed subject with names.
Sn = Series(subject_list, series_index)
Sn.index.names = ("matches", "description")
expected_index.names = ("matches", "description", "match")
expected_df = DataFrame(
expected_tuples, expected_index, expected_columns)
computed_df = Sn.str.extractall(named_pattern, re.VERBOSE)
tm.assert_frame_equal(computed_df, expected_df)
# optional groups.
subject_list = ['', 'A1', '32']
named_pattern = '(?P<letter>[AB])?(?P<number>[123])'
computed_df = Series(subject_list).str.extractall(named_pattern)
expected_index = MultiIndex.from_tuples([
(1, 0),
(2, 0),
(2, 1),
], names=(None, "match"))
expected_df = DataFrame([
('A', '1'),
(NA, '3'),
(NA, '2'),
], expected_index, columns=['letter', 'number'])
tm.assert_frame_equal(computed_df, expected_df)
# only one of two groups has a name.
pattern = '([AB])?(?P<number>[123])'
computed_df = Series(subject_list).str.extractall(pattern)
expected_df = DataFrame([
('A', '1'),
(NA, '3'),
(NA, '2'),
], expected_index, columns=[0, 'number'])
tm.assert_frame_equal(computed_df, expected_df)
def test_extractall_single_group(self):
# extractall(one named group) returns DataFrame with one named
# column.
s = Series(['a3', 'b3', 'd4c2'], name='series_name')
r = s.str.extractall(r'(?P<letter>[a-z])')
i = MultiIndex.from_tuples([
(0, 0),
(1, 0),
(2, 0),
(2, 1),
], names=(None, "match"))
e = DataFrame({"letter": ['a', 'b', 'd', 'c']}, i)
tm.assert_frame_equal(r, e)
# extractall(one un-named group) returns DataFrame with one
# un-named column.
r = s.str.extractall(r'([a-z])')
e = DataFrame(['a', 'b', 'd', 'c'], i)
tm.assert_frame_equal(r, e)
def test_extractall_single_group_with_quantifier(self):
# extractall(one un-named group with quantifier) returns
# DataFrame with one un-named column (GH13382).
s = Series(['ab3', 'abc3', 'd4cd2'], name='series_name')
r = s.str.extractall(r'([a-z]+)')
i = MultiIndex.from_tuples([
(0, 0),
(1, 0),
(2, 0),
(2, 1),
], names=(None, "match"))
e = DataFrame(['ab', 'abc', 'd', 'cd'], i)
tm.assert_frame_equal(r, e)
def test_extractall_no_matches(self):
s = Series(['a3', 'b3', 'd4c2'], name='series_name')
# one un-named group.
r = s.str.extractall('(z)')
e = DataFrame(columns=[0])
tm.assert_frame_equal(r, e)
# two un-named groups.
r = s.str.extractall('(z)(z)')
e = DataFrame(columns=[0, 1])
tm.assert_frame_equal(r, e)
# one named group.
r = s.str.extractall('(?P<first>z)')
e = DataFrame(columns=["first"])
tm.assert_frame_equal(r, e)
# two named groups.
r = s.str.extractall('(?P<first>z)(?P<second>z)')
e = DataFrame(columns=["first", "second"])
tm.assert_frame_equal(r, e)
# one named, one un-named.
r = s.str.extractall('(z)(?P<second>z)')
e = DataFrame(columns=[0,
"second"])
tm.assert_frame_equal(r, e)
def test_extractall_stringindex(self):
s = Series(["a1a2", "b1", "c1"], name='xxx')
res = s.str.extractall(r"[ab](?P<digit>\d)")
exp_idx = MultiIndex.from_tuples([(0, 0), (0, 1), (1, 0)],
names=[None, 'match'])
exp = DataFrame({'digit': ["1", "2", "1"]}, index=exp_idx)
tm.assert_frame_equal(res, exp)
# index should return the same result as the default index without name
# thus index.name doesn't affect to the result
for idx in [Index(["a1a2", "b1", "c1"]),
Index(["a1a2", "b1", "c1"], name='xxx')]:
res = idx.str.extractall(r"[ab](?P<digit>\d)")
tm.assert_frame_equal(res, exp)
s = Series(["a1a2", "b1", "c1"], name='s_name',
index=Index(["XX", "yy", "zz"], name='idx_name'))
res = s.str.extractall(r"[ab](?P<digit>\d)")
exp_idx = MultiIndex.from_tuples([("XX", 0), ("XX", 1), ("yy", 0)],
names=["idx_name", 'match'])
exp = DataFrame({'digit': ["1", "2", "1"]}, index=exp_idx)
tm.assert_frame_equal(res, exp)
def test_extractall_errors(self):
# Does not make sense to use extractall with a regex that has
# no capture groups. (it returns DataFrame with one column for
# each capture group)
s = Series(['a3', 'b3', 'd4c2'], name='series_name')
with tm.assert_raises_regex(ValueError, "no capture groups"):
s.str.extractall(r'[a-z]')
def test_extract_index_one_two_groups(self):
s = Series(['a3', 'b3', 'd4c2'], index=["A3", "B3", "D4"],
name='series_name')
r = s.index.str.extract(r'([A-Z])', expand=True)
e = DataFrame(['A', "B", "D"])
tm.assert_frame_equal(r, e)
# Prior to v0.18.0, index.str.extract(regex with one group)
# returned Index. With more than one group, extract raised an
# error (GH9980). Now extract always returns DataFrame.
r = s.index.str.extract(
r'(?P<letter>[A-Z])(?P<digit>[0-9])', expand=True)
e_list = [
("A", "3"),
("B", "3"),
("D", "4"),
]
e = DataFrame(e_list, columns=["letter", "digit"])
tm.assert_frame_equal(r, e)
def test_extractall_same_as_extract(self):
s = Series(['a3', 'b3', 'c2'], name='series_name')
pattern_two_noname = r'([a-z])([0-9])'
extract_two_noname = s.str.extract(pattern_two_noname, expand=True)
has_multi_index = s.str.extractall(pattern_two_noname)
no_multi_index = has_multi_index.xs(0, level="match")
tm.assert_frame_equal(extract_two_noname, no_multi_index)
pattern_two_named = r'(?P<letter>[a-z])(?P<digit>[0-9])'
extract_two_named = s.str.extract(pattern_two_named, expand=True)
has_multi_index = s.str.extractall(pattern_two_named)
no_multi_index = has_multi_index.xs(0, level="match")
tm.assert_frame_equal(extract_two_named, no_multi_index)
pattern_one_named = r'(?P<group_name>[a-z])'
extract_one_named = s.str.extract(pattern_one_named, expand=True)
has_multi_index = s.str.extractall(pattern_one_named)
no_multi_index = has_multi_index.xs(0, level="match")
tm.assert_frame_equal(extract_one_named, no_multi_index)
pattern_one_noname = r'([a-z])'
extract_one_noname = s.str.extract(pattern_one_noname, expand=True)
has_multi_index = s.str.extractall(pattern_one_noname)
no_multi_index = has_multi_index.xs(0, level="match")
tm.assert_frame_equal(extract_one_noname, no_multi_index)
def test_extractall_same_as_extract_subject_index(self):
# same as above tests, but s has an MultiIndex.
i = MultiIndex.from_tuples([
("A", "first"),
("B", "second"),
("C", "third"),
], names=("capital", "ordinal"))
s = Series(['a3', 'b3', 'c2'], i, name='series_name')
pattern_two_noname = r'([a-z])([0-9])'
extract_two_noname = s.str.extract(pattern_two_noname, expand=True)
has_match_index = s.str.extractall(pattern_two_noname)
no_match_index = has_match_index.xs(0, level="match")
tm.assert_frame_equal(extract_two_noname, no_match_index)
pattern_two_named = r'(?P<letter>[a-z])(?P<digit>[0-9])'
extract_two_named = s.str.extract(pattern_two_named, expand=True)
has_match_index = s.str.extractall(pattern_two_named)
no_match_index = has_match_index.xs(0, level="match")
tm.assert_frame_equal(extract_two_named, no_match_index)
pattern_one_named = r'(?P<group_name>[a-z])'
extract_one_named = s.str.extract(pattern_one_named, expand=True)
has_match_index = s.str.extractall(pattern_one_named)
no_match_index = has_match_index.xs(0, level="match")
tm.assert_frame_equal(extract_one_named, no_match_index)
pattern_one_noname = r'([a-z])'
extract_one_noname = s.str.extract(pattern_one_noname, expand=True)
has_match_index = s.str.extractall(pattern_one_noname)
no_match_index = has_match_index.xs(0, level="match")
tm.assert_frame_equal(extract_one_noname, no_match_index)
def test_empty_str_methods(self):
empty_str = empty = Series(dtype=object)
empty_int = Series(dtype=int)
empty_bool = Series(dtype=bool)
empty_bytes = Series(dtype=object)
# GH7241
# (extract) on empty series
tm.assert_series_equal(empty_str, empty.str.cat(empty))
assert '' == empty.str.cat()
tm.assert_series_equal(empty_str, empty.str.title())
tm.assert_series_equal(empty_int, empty.str.count('a'))
tm.assert_series_equal(empty_bool, empty.str.contains('a'))
tm.assert_series_equal(empty_bool, empty.str.startswith('a'))
tm.assert_series_equal(empty_bool, empty.str.endswith('a'))
tm.assert_series_equal(empty_str, empty.str.lower())
tm.assert_series_equal(empty_str, empty.str.upper())
tm.assert_series_equal(empty_str, empty.str.replace('a', 'b'))
tm.assert_series_equal(empty_str, empty.str.repeat(3))
tm.assert_series_equal(empty_bool, empty.str.match('^a'))
tm.assert_frame_equal(
DataFrame(columns=[0], dtype=str),
empty.str.extract('()', expand=True))
tm.assert_frame_equal(
DataFrame(columns=[0, 1], dtype=str),
empty.str.extract('()()', expand=True))
tm.assert_series_equal(
empty_str,
empty.str.extract('()', expand=False))
tm.assert_frame_equal(
DataFrame(columns=[0, 1], dtype=str),
empty.str.extract('()()', expand=False))
tm.assert_frame_equal(DataFrame(dtype=str), empty.str.get_dummies())
tm.assert_series_equal(empty_str, empty_str.str.join(''))
tm.assert_series_equal(empty_int, empty.str.len())
tm.assert_series_equal(empty_str, empty_str.str.findall('a'))
tm.assert_series_equal(empty_int, empty.str.find('a'))
tm.assert_series_equal(empty_int, empty.str.rfind('a'))
tm.assert_series_equal(empty_str, empty.str.pad(42))
tm.assert_series_equal(empty_str, empty.str.center(42))
tm.assert_series_equal(empty_str, empty.str.split('a'))
tm.assert_series_equal(empty_str, empty.str.rsplit('a'))
tm.assert_series_equal(empty_str,
empty.str.partition('a', expand=False))
tm.assert_series_equal(empty_str,
empty.str.rpartition('a', expand=False))
tm.assert_series_equal(empty_str, empty.str.slice(stop=1))
tm.assert_series_equal(empty_str, empty.str.slice(step=1))
tm.assert_series_equal(empty_str, empty.str.strip())
tm.assert_series_equal(empty_str, empty.str.lstrip())
tm.assert_series_equal(empty_str, empty.str.rstrip())
tm.assert_series_equal(empty_str, empty.str.wrap(42))
tm.assert_series_equal(empty_str, empty.str.get(0))
tm.assert_series_equal(empty_str, empty_bytes.str.decode('ascii'))
tm.assert_series_equal(empty_bytes, empty.str.encode('ascii'))
tm.assert_series_equal(empty_str, empty.str.isalnum())
tm.assert_series_equal(empty_str, empty.str.isalpha())
tm.assert_series_equal(empty_str, empty.str.isdigit())
tm.assert_series_equal(empty_str, empty.str.isspace())
tm.assert_series_equal(empty_str, empty.str.islower())
tm.assert_series_equal(empty_str, empty.str.isupper())
tm.assert_series_equal(empty_str, empty.str.istitle())
tm.assert_series_equal(empty_str, empty.str.isnumeric())
tm.assert_series_equal(empty_str, empty.str.isdecimal())
tm.assert_series_equal(empty_str, empty.str.capitalize())
tm.assert_series_equal(empty_str, empty.str.swapcase())
tm.assert_series_equal(empty_str, empty.str.normalize('NFC'))
if compat.PY3:
table = str.maketrans('a', 'b')
else:
import string
table = string.maketrans('a', 'b')
tm.assert_series_equal(empty_str, empty.str.translate(table))
def test_empty_str_methods_to_frame(self):
empty = Series(dtype=str)
empty_df = DataFrame([])
tm.assert_frame_equal(empty_df, empty.str.partition('a'))
tm.assert_frame_equal(empty_df, empty.str.rpartition('a'))
def test_ismethods(self):
values = ['A', 'b', 'Xy', '4', '3A', '', 'TT', '55', '-', ' ']
str_s = Series(values)
alnum_e = [True, True, True, True, True, False, True, True, False,
False]
alpha_e = [True, True, True, False, False, False, True, False, False,
False]
digit_e = [False, False, False, True, False, False, False, True, False,
False]
# TODO: unused
num_e = [False, False, False, True, False, False, # noqa
False, True, False, False]
space_e = [False, False, False, False, False, False, False, False,
False, True]
lower_e = [False, True, False, False, False, False, False, False,
False, False]
upper_e = [True, False, False, False, True, False, True, False, False,
False]
title_e = [True, False, True, False, True, False, False, False, False,
False]
tm.assert_series_equal(str_s.str.isalnum(), Series(alnum_e))
tm.assert_series_equal(str_s.str.isalpha(), Series(alpha_e))
tm.assert_series_equal(str_s.str.isdigit(), Series(digit_e))
tm.assert_series_equal(str_s.str.isspace(), Series(space_e))
tm.assert_series_equal(str_s.str.islower(), Series(lower_e))
tm.assert_series_equal(str_s.str.isupper(), Series(upper_e))
tm.assert_series_equal(str_s.str.istitle(), Series(title_e))
assert str_s.str.isalnum().tolist() == [v.isalnum() for v in values]
assert str_s.str.isalpha().tolist() == [v.isalpha() for v in values]
assert str_s.str.isdigit().tolist() == [v.isdigit() for v in values]
assert str_s.str.isspace().tolist() == [v.isspace() for v in values]
assert str_s.str.islower().tolist() == [v.islower() for v in values]
assert str_s.str.isupper().tolist() == [v.isupper() for v in values]
assert str_s.str.istitle().tolist() == [v.istitle() for v in values]
def test_isnumeric(self):
# 0x00bc: ¼ VULGAR FRACTION ONE QUARTER
# 0x2605: ★ not number
# 0x1378: ፸ ETHIOPIC NUMBER SEVENTY
# 0xFF13: ３ Em 3
values = ['A', '3', u'¼', u'★', u'፸', u'３', 'four']
s = Series(values)
numeric_e = [False, True, True, False, True, True, False]
decimal_e = [False, True, False, False, False, True, False]
tm.assert_series_equal(s.str.isnumeric(), Series(numeric_e))
tm.assert_series_equal(s.str.isdecimal(), Series(decimal_e))
unicodes = [u'A', u'3', u'¼', u'★', u'፸', u'３', u'four']
assert s.str.isnumeric().tolist() == [v.isnumeric() for v in unicodes]
assert s.str.isdecimal().tolist() == [v.isdecimal() for v in unicodes]
values = ['A', np.nan, u'¼', u'★', np.nan, u'３', 'four']
s = Series(values)
numeric_e = [False, np.nan, True, False, np.nan, True, False]
decimal_e = [False, np.nan, False, False, np.nan, True, False]
tm.assert_series_equal(s.str.isnumeric(), Series(numeric_e))
tm.assert_series_equal(s.str.isdecimal(), Series(decimal_e))
def test_get_dummies(self):
s = Series(['a|b', 'a|c', np.nan])
result = s.str.get_dummies('|')
expected = DataFrame([[1, 1, 0], [1, 0, 1], [0, 0, 0]],
columns=list('abc'))
tm.assert_frame_equal(result, expected)
s = Series(['a;b', 'a', 7])
result = s.str.get_dummies(';')
expected = DataFrame([[0, 1, 1], [0, 1, 0], [1, 0, 0]],
columns=list('7ab'))
tm.assert_frame_equal(result, expected)
# GH9980, GH8028
idx = Index(['a|b', 'a|c', 'b|c'])
result = idx.str.get_dummies('|')
expected = MultiIndex.from_tuples([(1, 1, 0), (1, 0, 1),
(0, 1, 1)], names=('a', 'b', 'c'))
tm.assert_index_equal(result, expected)
def test_get_dummies_with_name_dummy(self):
# GH 12180
# Dummies named 'name' should work as expected
s = Series(['a', 'b,name', 'b'])
result = s.str.get_dummies(',')
expected = DataFrame([[1, 0, 0], [0, 1, 1], [0, 1, 0]],
columns=['a', 'b', 'name'])
tm.assert_frame_equal(result, expected)
idx = Index(['a|b', 'name|c', 'b|name'])
result = idx.str.get_dummies('|')
expected = MultiIndex.from_tuples([(1, 1, 0, 0), (0, 0, 1, 1),
(0, 1, 0, 1)],
names=('a', 'b', 'c', 'name'))
tm.assert_index_equal(result, expected)
def test_join(self):
values = Series(['a_b_c', 'c_d_e', np.nan, 'f_g_h'])
result = values.str.split('_').str.join('_')
tm.assert_series_equal(values, result)
# mixed
mixed = Series(['a_b', NA, 'asdf_cas_asdf', True, datetime.today(),
'foo', None, 1, 2.])
rs = Series(mixed).str.split('_').str.join('_')
xp = Series(['a_b', NA, 'asdf_cas_asdf', NA, NA, 'foo', NA, NA, NA])
assert isinstance(rs, Series)
tm.assert_almost_equal(rs, xp)
# unicode
values = Series([u('a_b_c'), u('c_d_e'), np.nan, u('f_g_h')])
result = values.str.split('_').str.join('_')
tm.assert_series_equal(values, result)
def test_len(self):
values = Series(['foo', 'fooo', 'fooooo', np.nan, 'fooooooo'])
result = values.str.len()
exp = values.map(lambda x: len(x) if notna(x) else NA)
tm.assert_series_equal(result, exp)
# mixed
mixed = Series(['a_b', NA, 'asdf_cas_asdf', True, datetime.today(),
'foo', None, 1, 2.])
rs = Series(mixed).str.len()
xp = Series([3, NA, 13, NA, NA, 3, NA, NA, NA])
assert isinstance(rs, Series)
tm.assert_almost_equal(rs, xp)
# unicode
values = Series([u('foo'), u('fooo'), u('fooooo'), np.nan, u(
'fooooooo')])
result = values.str.len()
exp = values.map(lambda x: len(x) if notna(x) else NA)
tm.assert_series_equal(result, exp)
def test_findall(self):
values = Series(['fooBAD__barBAD', NA, 'foo', 'BAD'])
result = values.str.findall('BAD[_]*')
exp = Series([['BAD__', 'BAD'], NA, [], ['BAD']])
tm.assert_almost_equal(result, exp)
# mixed
mixed = Series(['fooBAD__barBAD', NA, 'foo', True, datetime.today(),
'BAD', None, 1, 2.])
rs = Series(mixed).str.findall('BAD[_]*')
xp = Series([['BAD__', 'BAD'], NA, [], NA, NA, ['BAD'], NA, NA, NA])
assert isinstance(rs, Series)
tm.assert_almost_equal(rs, xp)
# unicode
values = Series([u('fooBAD__barBAD'), NA, u('foo'), u('BAD')])
result = values.str.findall('BAD[_]*')
exp = Series([[u('BAD__'), u('BAD')], NA, [], [u('BAD')]])
tm.assert_almost_equal(result, exp)
def test_find(self):
values = Series(['ABCDEFG', 'BCDEFEF', 'DEFGHIJEF', 'EFGHEF', 'XXXX'])
result = values.str.find('EF')
tm.assert_series_equal(result, Series([4, 3, 1, 0, -1]))
expected = np.array([v.find('EF') for v in values.values],
dtype=np.int64)
tm.assert_numpy_array_equal(result.values, expected)
result = values.str.rfind('EF')
tm.assert_series_equal(result, Series([4, 5, 7, 4, -1]))
expected = np.array([v.rfind('EF') for v in values.values],
dtype=np.int64)
tm.assert_numpy_array_equal(result.values, expected)
result = values.str.find('EF', 3)
tm.assert_series_equal(result, Series([4, 3, 7, 4, -1]))
expected = np.array([v.find('EF', 3) for v in values.values],
dtype=np.int64)
tm.assert_numpy_array_equal(result.values, expected)
result = values.str.rfind('EF', 3)
tm.assert_series_equal(result, Series([4, 5, 7, 4, -1]))
expected = np.array([v.rfind('EF', 3) for v in values.values],
dtype=np.int64)
tm.assert_numpy_array_equal(result.values, expected)
result = values.str.find('EF', 3, 6)
tm.assert_series_equal(result, Series([4, 3, -1, 4, -1]))
expected = np.array([v.find('EF', 3, 6) for v in values.values],
dtype=np.int64)
tm.assert_numpy_array_equal(result.values, expected)
result = values.str.rfind('EF', 3, 6)
tm.assert_series_equal(result, Series([4, 3, -1, 4, -1]))
expected = np.array([v.rfind('EF', 3, 6) for v in values.values],
dtype=np.int64)
tm.assert_numpy_array_equal(result.values, expected)
with tm.assert_raises_regex(TypeError,
"expected a string object, not int"):
result = values.str.find(0)
with tm.assert_raises_regex(TypeError,
"expected a string object, not int"):
result = values.str.rfind(0)
def test_find_nan(self):
values = Series(['ABCDEFG', np.nan, 'DEFGHIJEF', np.nan, 'XXXX'])
result = values.str.find('EF')
tm.assert_series_equal(result, Series([4, np.nan, 1, np.nan, -1]))
result = values.str.rfind('EF')
tm.assert_series_equal(result, Series([4, np.nan, 7, np.nan, -1]))
result = values.str.find('EF', 3)
tm.assert_series_equal(result, Series([4, np.nan, 7, np.nan, -1]))
result = values.str.rfind('EF', 3)
tm.assert_series_equal(result, Series([4, np.nan, 7, np.nan, -1]))
result = values.str.find('EF', 3, 6)
tm.assert_series_equal(result, Series([4, np.nan, -1, np.nan, -1]))
result = values.str.rfind('EF', 3, 6)
tm.assert_series_equal(result, Series([4, np.nan, -1, np.nan, -1]))
def test_index(self):
def _check(result, expected):
if isinstance(result, Series):
tm.assert_series_equal(result, expected)
else:
tm.assert_index_equal(result, expected)
for klass in [Series, Index]:
s = klass(['ABCDEFG', 'BCDEFEF', 'DEFGHIJEF', 'EFGHEF'])
result = s.str.index('EF')
_check(result, klass([4, 3, 1, 0]))
expected = np.array([v.index('EF') for v in s.values],
dtype=np.int64)
tm.assert_numpy_array_equal(result.values, expected)
result = s.str.rindex('EF')
_check(result, klass([4, 5, 7, 4]))
expected = np.array([v.rindex('EF') for v in s.values],
dtype=np.int64)
tm.assert_numpy_array_equal(result.values, expected)
result = s.str.index('EF', 3)
_check(result, klass([4, 3, 7, 4]))
expected = np.array([v.index('EF', 3) for v in s.values],
dtype=np.int64)
tm.assert_numpy_array_equal(result.values, expected)
result = s.str.rindex('EF', 3)
_check(result, klass([4, 5, 7, 4]))
expected = np.array([v.rindex('EF', 3) for v in s.values],
dtype=np.int64)
tm.assert_numpy_array_equal(result.values, expected)
result = s.str.index('E', 4, 8)
_check(result, klass([4, 5, 7, 4]))
expected = np.array([v.index('E', 4, 8) for v in s.values],
dtype=np.int64)
tm.assert_numpy_array_equal(result.values, expected)
result = s.str.rindex('E', 0, 5)
_check(result, klass([4, 3, 1, 4]))
expected = np.array([v.rindex('E', 0, 5) for v in s.values],
dtype=np.int64)
tm.assert_numpy_array_equal(result.values, expected)
with tm.assert_raises_regex(ValueError,
"substring not found"):
result = s.str.index('DE')
with tm.assert_raises_regex(TypeError,
"expected a string "
"object, not int"):
result = s.str.index(0)
# test with nan
s = Series(['abcb', 'ab', 'bcbe', np.nan])
result = s.str.index('b')
tm.assert_series_equal(result, Series([1, 1, 0, np.nan]))
result = s.str.rindex('b')
tm.assert_series_equal(result, Series([3, 1, 2, np.nan]))
def test_pad(self):
values = Series(['a', 'b', NA, 'c', NA, 'eeeeee'])
result = values.str.pad(5, side='left')
exp = Series([' a', ' b', NA, ' c', NA, 'eeeeee'])
tm.assert_almost_equal(result, exp)
result = values.str.pad(5, side='right')
exp = Series(['a ', 'b ', NA, 'c ', NA, 'eeeeee'])
tm.assert_almost_equal(result, exp)
result = values.str.pad(5, side='both')
exp = Series([' a ', ' b ', NA, ' c ', NA, 'eeeeee'])
tm.assert_almost_equal(result, exp)
# mixed
mixed = Series(['a', NA, 'b', True, datetime.today(), 'ee', None, 1, 2.
])
rs = Series(mixed).str.pad(5, side='left')
xp = Series([' a', NA, ' b', NA, NA, ' ee', NA, NA, NA])
assert isinstance(rs, Series)
tm.assert_almost_equal(rs, xp)
mixed = Series(['a', NA, 'b', True, datetime.today(), 'ee', None, 1, 2.
])
rs = Series(mixed).str.pad(5, side='right')
xp = Series(['a ', NA, 'b ', NA, NA, 'ee ', NA, NA, NA])
assert isinstance(rs, Series)
tm.assert_almost_equal(rs, xp)
mixed = Series(['a', NA, 'b', True, datetime.today(), 'ee', None, 1, 2.
])
rs = Series(mixed).str.pad(5, side='both')
xp = Series([' a ', NA, ' b ', NA, NA, ' ee ', NA, NA, NA])
assert isinstance(rs, Series)
tm.assert_almost_equal(rs, xp)
# unicode
values = Series([u('a'), u('b'), NA, u('c'), NA, u('eeeeee')])
result = values.str.pad(5, side='left')
exp = Series([u(' a'), u(' b'), NA, u(' c'), NA, u('eeeeee')])
tm.assert_almost_equal(result, exp)
result = values.str.pad(5, side='right')
exp = Series([u('a '), u('b '), NA, u('c '), NA, u('eeeeee')])
tm.assert_almost_equal(result, exp)
result = values.str.pad(5, side='both')
exp = Series([u(' a '), u(' b '), NA, u(' c '), NA, u('eeeeee')])
tm.assert_almost_equal(result, exp)
def test_pad_fillchar(self):
values = Series(['a', 'b', NA, 'c', NA, 'eeeeee'])
result = values.str.pad(5, side='left', fillchar='X')
exp = Series(['XXXXa', 'XXXXb', NA, 'XXXXc', NA, 'eeeeee'])
tm.assert_almost_equal(result, exp)
result = values.str.pad(5, side='right', fillchar='X')
exp = Series(['aXXXX', 'bXXXX', NA, 'cXXXX', NA, 'eeeeee'])
tm.assert_almost_equal(result, exp)
result = values.str.pad(5, side='both', fillchar='X')
exp = Series(['XXaXX', 'XXbXX', NA, 'XXcXX', NA, 'eeeeee'])
tm.assert_almost_equal(result, exp)
with tm.assert_raises_regex(TypeError,
"fillchar must be a "
"character, not str"):
result = values.str.pad(5, fillchar='XY')
with tm.assert_raises_regex(TypeError,
"fillchar must be a "
"character, not int"):
result = values.str.pad(5, fillchar=5)
def test_pad_width(self):
# GH 13598
s = Series(['1', '22', 'a', 'bb'])
for f in ['center', 'ljust', 'rjust', 'zfill', 'pad']:
with tm.assert_raises_regex(TypeError,
"width must be of "
"integer type, not*"):
getattr(s.str, f)('f')
def test_translate(self):
def _check(result, expected):
if isinstance(result, Series):
tm.assert_series_equal(result, expected)
else:
tm.assert_index_equal(result, expected)
for klass in [Series, Index]:
s = klass(['abcdefg', 'abcc', 'cdddfg', 'cdefggg'])
if not compat.PY3:
import string
table = string.maketrans('abc', 'cde')
else:
table = str.maketrans('abc', 'cde')
result = s.str.translate(table)
expected = klass(['cdedefg', 'cdee', 'edddfg', 'edefggg'])
_check(result, expected)
# use of deletechars is python 2 only
if not compat.PY3:
result = s.str.translate(table, deletechars='fg')
expected = klass(['cdede', 'cdee', 'eddd', 'ede'])
_check(result, expected)
result = s.str.translate(None, deletechars='fg')
expected = klass(['abcde', 'abcc', 'cddd', 'cde'])
_check(result, expected)
else:
with tm.assert_raises_regex(
ValueError, "deletechars is not a valid argument"):
result = s.str.translate(table, deletechars='fg')
# Series with non-string values
s = Series(['a', 'b', 'c', 1.2])
expected = Series(['c', 'd', 'e', np.nan])
result = s.str.translate(table)
tm.assert_series_equal(result, expected)
def test_center_ljust_rjust(self):
values = Series(['a', 'b', NA, 'c', NA, 'eeeeee'])
result = values.str.center(5)
exp = Series([' a ', ' b ', NA, ' c ', NA, 'eeeeee'])
tm.assert_almost_equal(result, exp)
result = values.str.ljust(5)
exp = Series(['a ', 'b ', NA, 'c ', NA, 'eeeeee'])
tm.assert_almost_equal(result, exp)
result = values.str.rjust(5)
exp = Series([' a', ' b', NA, ' c', NA, 'eeeeee'])
tm.assert_almost_equal(result, exp)
# mixed
mixed = Series(['a', NA, 'b', True, datetime.today(), 'c', 'eee', None,
1, 2.])
rs = | Series(mixed) | pandas.Series |
# -*- coding: utf-8 -*-
"""Forms to manipulate the columns."""
import pandas as pd
from bootstrap_datepicker_plus import DateTimePickerInput
from django import forms
from django.utils.translation import ugettext_lazy as _
from ontask import is_legal_name
from ontask.core.forms import date_time_widget_options
from ontask.dataops.pandas import is_unique_column, load_table
from ontask.models import Column
INITIAL_VALUE_LENGTH = 512
class ColumnBasicForm(forms.ModelForm):
"""Basic form for column manipulation."""
raw_categories = forms.CharField(
strip=True,
required=False,
label=_('Comma separated list of values allowed in this column'))
data_type_choices = [
('double', 'number'),
('integer', 'number'),
('string', 'string'),
('boolean', 'boolean'),
('datetime', 'datetime'),
]
def __init__(self, *args, **kwargs):
"""Store the workflow and data frame."""
self.workflow = kwargs.pop('workflow', None)
self.data_frame = None
super().__init__(*args, **kwargs)
# Remember the column name and position to perform content substitution
if self.instance.name:
self.old_name = self.instance.name
self.old_position = self.instance.position
self.fields['raw_categories'].initial = ', '.join(
[str(cat) for cat in self.instance.get_categories()])
self.fields['data_type'].choices = self.data_type_choices
self.initial_valid_value = None
def clean(self):
"""Check that the name is legal and the categories have right value."""
form_data = super().clean()
# Load the data frame from the DB for various checks and leave it in
# the form for future use
self.data_frame = load_table(
self.workflow.get_data_frame_table_name())
# Column name must be a legal variable name
if 'name' in self.changed_data:
# Name is legal
msg = is_legal_name(form_data['name'])
if msg:
self.add_error('name', msg)
return form_data
# Check that the name is not present already
if next(
(col for col in self.workflow.columns.all()
if col.id != self.instance.id
and col.name == form_data['name']),
None,
):
# New column name collides with existing one
self.add_error(
'name',
_('There is a column already with this name'))
return form_data
# Categories must be valid types
if 'raw_categories' in self.changed_data:
if form_data['raw_categories']:
# Condition 1: Values must be valid for the type of the column
category_values = [
cat.strip()
for cat in form_data['raw_categories'].split(',')]
try:
valid_values = Column.validate_column_values(
form_data['data_type'],
category_values)
except ValueError:
self.add_error(
'raw_categories',
_('Incorrect list of values'),
)
return form_data
# Condition 2: The values in the dataframe column must be in
# these categories (only if the column is being edited, though
if self.instance.name and not all(
vval in valid_values
for vval in self.data_frame[self.instance.name]
if vval and not | pd.isnull(vval) | pandas.isnull |
import datetime
import itertools
import json
import logging
import os
import sqlite3
from sqlite3 import DatabaseError
from typing import Optional, List, Dict, Tuple
import networkx as nx
import numpy as np
import pandas as pd
from ipyleaflet import Map, ScaleControl, FullScreenControl, Polyline, Icon, Marker, Circle, TileLayer, LayerGroup
from ipywidgets import HTML
from pandas.io.sql import DatabaseError as PandasDatabaseError
from scipy.spatial import KDTree
from scipy.stats import norm
from pyridy import config
from pyridy.osm import OSM
from pyridy.osm.utils import is_point_within_line_projection, project_point_onto_line
from pyridy.utils import Sensor, AccelerationSeries, LinearAccelerationSeries, MagnetometerSeries, OrientationSeries, \
GyroSeries, RotationSeries, GPSSeries, PressureSeries, HumiditySeries, TemperatureSeries, WzSeries, LightSeries, \
SubjectiveComfortSeries, AccelerationUncalibratedSeries, MagnetometerUncalibratedSeries, GyroUncalibratedSeries, \
GNSSClockMeasurementSeries, GNSSMeasurementSeries, NMEAMessageSeries
from pyridy.utils.device import Device
from pyridy.utils.tools import generate_random_color
logger = logging.getLogger(__name__)
class RDYFile:
def __init__(self, path: str = "", sync_method: str = "timestamp", cutoff: bool = True,
timedelta_unit: str = 'timedelta64[ns]',
strip_timezone: bool = True, name=""):
"""
Parameters
----------
path: str
Path to the Ridy File
sync_method: str
Sync method to be applied
cutoff: bool, default: True
If True, cutoffs the measurements precisely to the timestamp when the measurement was started, respectively
stopped. By default Ridy measurement files can contain several seconds of measurements from before/after
the button press
timedelta_unit: str
NumPy timedelta unit to applied
strip_timezone: bool, default: True
Strips timezone from timestamps as np.datetime64 does not support timezones
name: str
Name of the files, will be the filename if not provided
"""
self.path = path
self.name: Optional[str] = name
self.extension: Optional[str] = ""
if sync_method is not None and sync_method not in ["timestamp", "device_time", "gps_time", "ntp_time"]:
raise ValueError(
"synchronize argument must 'timestamp', 'device_time', 'gps_time' or 'ntp_time' not %s" % sync_method)
self.sync_method = sync_method
self.cutoff = cutoff
self.timedelta_unit = timedelta_unit
self.strip_timezone = strip_timezone
# Ridy App Info
self.ridy_version: Optional[str] = None
self.ridy_version_code: Optional[int] = None
# RDY File Infos
self.rdy_format_version: Optional[float] = None
self.rdy_info_name: Optional[str] = None
self.rdy_info_sex: Optional[str] = None
self.rdy_info_age: Optional[int] = None
self.rdy_info_height: Optional[float] = None
self.rdy_info_weight: Optional[float] = None
self.t0: Optional[np.datetime64] = None
self.cs_matrix_string: Optional[str] = None
self.cs_matrix: Optional[np.ndarray] = None # TODO
self.timestamp_when_started: Optional[int] = None
self.timestamp_when_stopped: Optional[int] = None
self.ntp_timestamp: Optional[int] = None
self.ntp_date_time: Optional[np.datetime64] = None
self.device: Optional[Device] = None
self.duration: Optional[float] = None
# Sensors
self.sensors: Optional[List[Sensor]] = []
# Measurement Series
self.measurements = {AccelerationSeries: AccelerationSeries(),
AccelerationUncalibratedSeries: AccelerationUncalibratedSeries(),
LinearAccelerationSeries: LinearAccelerationSeries(),
MagnetometerSeries: MagnetometerSeries(),
MagnetometerUncalibratedSeries: MagnetometerUncalibratedSeries(),
OrientationSeries: OrientationSeries(),
GyroSeries: GyroSeries(),
GyroUncalibratedSeries: GyroUncalibratedSeries(),
RotationSeries: RotationSeries(),
GPSSeries: GPSSeries(),
GNSSClockMeasurementSeries: GNSSClockMeasurementSeries(),
GNSSMeasurementSeries: GNSSMeasurementSeries(),
NMEAMessageSeries: NMEAMessageSeries(),
PressureSeries: PressureSeries(),
TemperatureSeries: TemperatureSeries(),
HumiditySeries: HumiditySeries(),
LightSeries: LightSeries(),
WzSeries: WzSeries(),
SubjectiveComfortSeries: SubjectiveComfortSeries()}
# OSM Data (set by Campaign)
self.osm: Optional[OSM] = None
self.matched_nodes = [] # Nodes from Map Matching
self.matched_ways = [] # Ways from Map Matching
if self.path:
self.load_file(self.path)
if self.timestamp_when_started and self.timestamp_when_stopped:
self.duration = (self.timestamp_when_stopped - self.timestamp_when_started) * 1e-9
if self.sync_method:
self._synchronize()
else:
logging.warning("RDYFile instantiated without a path")
pass
# def __getitem__(self, idx):
# key = list(self.measurements.keys())[idx]
# return self.measurements[key]
def __iter__(self):
"""
Returns
-------
FileIterator
"""
return FileIterator(self)
def __repr__(self):
return "Filename: %s, T0: %s, Duration: %s" % (self.name,
str(self.t0),
str(datetime.timedelta(seconds=self.duration)))
def _do_candidate_search(self, osm_xy: np.ndarray, track_xy: np.ndarray, hor_acc: np.ndarray):
""" Internal method to search for candidate edges for map matching
"""
# Find the closest coordinates using KDTrees
kd_tree_osm = KDTree(osm_xy)
kd_tree_track = KDTree(track_xy)
# Indices of OSM nodes that are close to each respective GPS point within radius r
indices = kd_tree_track.query_ball_tree(kd_tree_osm, r=100)
c_dict = {} # Dict with node candidates for each GPS coord
edges = [] # Candidate edges with emission probabilities
# Perform search for node candidate on all GPS coords
for i, idxs in enumerate(indices):
# Get unique ways based on indices
c_ways = list(set(list(itertools.chain(*[self.osm.nodes[idx].ways for idx in idxs]))))
# Find candidate line segments
c_segs = []
for w in c_ways:
n = w.nodes
segs = [] # List of suitable line segments
for n1, n2 in zip(n, n[1:]):
x1, y1 = n1.attributes["x"], n1.attributes["y"]
x2, y2 = n2.attributes["x"], n2.attributes["y"]
# Only take those line segment into consideration where the perpendicular projection
# of the GPS coords lies inside the line segment
b = is_point_within_line_projection(line=[[x1, y1], [x2, y2]], point=track_xy[i])
if b:
# Point of orthogonal intersection
p, d = project_point_onto_line(line=[[x1, y1], [x2, y2]], point=track_xy[i])
if d < hor_acc[i]:
p_lon, p_lat = self.osm.utm_proj(p[0], p[1], inverse=True)
segs.append([d, p_lon, p_lat, n1, n2, w.id, None, i])
if segs:
segs = np.array(segs)
i_min = np.argmin(
segs[:, 0]) # Select candidate line segment based on smallest perpendicular distance
n1, n2 = segs[i_min, 3], segs[i_min, 4]
e1 = list(self.osm.G.edges(n1.id, keys=True))
e2 = list(self.osm.G.edges(n2.id, keys=True))
inter = list(set(e1).intersection(e2))
if len(inter) == 0: # TODO
c_seg_e = e1[0]
else:
c_seg_e = inter[0]
c_seg = segs[i_min]
c_segs.append(c_seg)
edges.append([c_seg_e, hor_acc[i], c_seg[0]])
c_dict[i] = {"c_ways": c_ways, "c_segs": c_segs}
# Calculate emission probabilities for each edge candidate
c_edges = {}
if edges:
edges = np.array(edges, dtype='object')
e_probs = norm.pdf(edges[:, 2].astype(float), np.zeros(len(edges)), edges[:, 1].astype(float))
for i, e_prob in enumerate(e_probs):
if edges[i][0] not in c_edges:
c_edges[edges[i][0]] = {"e_prob": [e_prob]}
else:
c_edges[edges[i][0]]["e_prob"].append(e_prob)
return c_dict, c_edges
def _synchronize(self):
""" Internal method that synchronizes the timestamps to a given sync timestamp
"""
if self.sync_method == "timestamp":
for m in self.measurements.values():
m.synchronize("timestamp", self.timestamp_when_started, timedelta_unit=self.timedelta_unit)
elif self.sync_method == "device_time":
if self.t0:
for m in self.measurements.values():
m.synchronize("device_time", self.timestamp_when_started, self.t0,
timedelta_unit=self.timedelta_unit)
else:
logger.warning("(%s) t0 is None, falling back to timestamp synchronization" % self.name)
self.sync_method = "timestamp"
self._synchronize()
elif self.sync_method == "gps_time":
if len(self.measurements[GPSSeries]) > 0:
sync_timestamp = self.measurements[GPSSeries].time[0]
utc_sync_time = self.measurements[GPSSeries].utc_time[0]
for i, t in enumerate(self.measurements[
GPSSeries].utc_time):
# The first utc_time value ending with 000 is a real GPS measurement
if str(t)[-3:] == "000":
utc_sync_time = t
sync_timestamp = self.measurements[GPSSeries].time[i]
break
sync_time = np.datetime64(int(utc_sync_time * 1e6), "ns")
for m in self.measurements.values():
m.synchronize("gps_time", sync_timestamp, sync_time, timedelta_unit=self.timedelta_unit)
else:
logger.warning("(%s) No GPS time recording, falling back to device_time synchronization" % self.name)
self.sync_method = "device_time"
self._synchronize()
elif self.sync_method == "ntp_time":
if self.ntp_timestamp and self.ntp_date_time:
for m in self.measurements.values():
m.synchronize("ntp_time", self.ntp_timestamp, self.ntp_date_time,
timedelta_unit=self.timedelta_unit)
else:
logger.warning("(%s) No ntp timestamp and datetime, falling back to device_time synchronization" %
self.name)
self.sync_method = "device_time"
self._synchronize()
else:
raise ValueError(
"sync_method must 'timestamp', 'device_time', 'gps_time' or 'ntp_time' not %s" % self.sync_method)
pass
def create_map(self, t_lim: Tuple[np.datetime64, np.datetime64] = None, show_hor_acc: bool = False) -> Map:
""" Creates an ipyleaflet Map using OpenStreetMap and OpenRailwayMap to show the GPS track of the
measurement file
Parameters
----------
t_lim: tuple, default: None
Time limit as a tuple of np.datetime64 to show only parts of the GPS track that are within the specified
time interval
show_hor_acc : bool, default: False
If true shows the horizontal accuracies for each measurement point using circles. The likelihood that
that the real position is within the circle is defined as 68 %
Returns
-------
Map
"""
gps_series = self.measurements[GPSSeries]
coords = gps_series.to_ipyleaflef()
time = gps_series.time
hor_acc = gps_series.hor_acc
if coords == [[]]:
logger.warning("(%s) Cant create map, GPSSeries is empty!" % self.name)
else:
if t_lim:
if type(t_lim) != tuple:
raise ValueError("t_lim must be a tuple of np.datetime64")
if t_lim[0] > t_lim[1]:
raise ValueError("The first datetime for t_lim must be smaller than the second!")
mask = (gps_series.time >= t_lim[0]) & (gps_series.time <= t_lim[1])
coords = [c for i, c in enumerate(coords) if mask[i]]
time = [t for i, t in enumerate(gps_series.time) if mask[i]]
hor_acc = [h for i, h in enumerate(gps_series.hor_acc) if mask[i]]
color = generate_random_color("HEX")
m = Map(center=self.determine_track_center()[::-1],
zoom=12,
scroll_wheel_zoom=True,
basemap=config.OPEN_STREET_MAP_DE)
m.add_control(ScaleControl(position='bottomleft'))
m.add_control(FullScreenControl())
# Add map
m.add_layer(config.OPEN_RAILWAY_MAP)
file_polyline = Polyline(locations=coords, color=color, fill=False, weight=4, dash_array='10, 10')
m.add_layer(file_polyline)
start_marker = Marker(location=tuple(coords[0]), draggable=False, icon=config.START_ICON)
end_marker = Marker(location=tuple(coords[-1]), draggable=False, icon=config.END_ICON)
start_message = HTML()
end_message = HTML()
start_message.value = "<p>Start:</p><p>" + self.name + "</p><p>" \
+ str(time[0] or 'n/a') + "</p><p>" \
+ str(getattr(self.device, "manufacturer", "n/a")) + "; " \
+ str(getattr(self.device, "model", "n/a")) + "</p>"
end_message.value = "<p>End:</p><p>" + self.name + "</p><p>" \
+ str(time[-1] or 'n/a') + "</p><p>" \
+ str(getattr(self.device, "manufacturer", "n/a")) + "; " \
+ str(getattr(self.device, "model", "n/a")) + "</p>"
start_marker.popup = start_message
end_marker.popup = end_message
m.add_layer(start_marker)
m.add_layer(end_marker)
if show_hor_acc:
circles = []
for c, h in zip(coords, hor_acc):
circle = Circle()
circle.location = (c[0], c[1])
circle.radius = int(h)
circle.color = "#00549F"
circle.fill_color = "#00549F"
circle.weight = 3
circle.fill_opacity = 0.1
circles.append(circle)
l_circles = LayerGroup(layers=circles)
m.add_layer(l_circles)
return m
def determine_track_center(self, gps_series: Optional[GPSSeries] = None) -> (float, float):
""" Determines the geographical center of the GPSSeries, returns None if the GPSSeries is emtpy.
Parameters
----------
gps_series: GPSSeries, default: None
If not None, takes the given GPSSeries to determine the track center
Returns
-------
float, float
"""
if not gps_series:
gps_series = self.measurements[GPSSeries]
if gps_series.is_empty():
logger.warning("(%s) Cant determine track center, GPSSeries is empty!" % self.name)
else:
center_lon = (gps_series.lon.max() + gps_series.lon.min()) / 2
center_lat = (gps_series.lat.max() + gps_series.lat.min()) / 2
logging.info("Geographic center of track: Lon: %s, Lat: %s" % (str(center_lon), str(center_lat)))
return center_lon, center_lat
def do_map_matching(self, v_thres: float = 1, algorithm: str = "pyridy", alpha: int = 1.0, beta: int = 1.0):
""" Performs map matching of the GPS track to closest OSM nodes/ways
Parameters
----------
alpha: float, default: 1.0
Weighting Parameter for the Map Matching Algorithm. Alpha represents the default lange of an edge in the
Graph
beta: float, default: 1.0
Beta is a scaling factor for the emission probabilities.
algorithm: str, default: pyridy
Algorithm to be used, can be "pyridy" or "nx". The pyridy algorithm also incorporates how switches
can be transited
v_thres: float
Speed threshold, GPS points measured with a velocity below v_thres [m/s] will not be considered
Returns
-------
"""
if algorithm not in ["nx", "pyridy"]:
raise ValueError("(%s) Algorithm must be either nx or pyridy, not %s" % (self.name, algorithm))
if self.osm:
# Prepare data
gps_coords = self.measurements[GPSSeries]
lon = gps_coords.lon[gps_coords.speed > v_thres]
lat = gps_coords.lat[gps_coords.speed > v_thres]
hor_acc = gps_coords.hor_acc[gps_coords.speed > v_thres]
n_gps = len(lon)
x, y = self.osm.utm_proj(lon, lat)
track_xy = np.vstack([x, y]).T
osm_xy = self.osm.get_coords(frmt="xy")
c_dict, c_edges = self._do_candidate_search(osm_xy, track_xy, hor_acc)
# Initialize edge weights
for e in self.osm.G.edges:
self.osm.G.edges[e]["c_weight"] = 1*alpha
for k in c_edges.keys():
self.osm.G.edges[k]["c_weight"] = 1 / (1 + beta*sum(c_edges[k]["e_prob"]))
# Perform map matching
s_n = None
for i in range(n_gps):
if len(c_dict[i]["c_segs"]) > 0:
s_n = c_dict[i]["c_segs"][np.array(c_dict[i]["c_segs"])[:, 0].argmin()][3].id
break
e_n = None
for i in reversed(range(n_gps)):
if len(c_dict[i]["c_segs"]) > 0:
e_n = c_dict[i]["c_segs"][np.array(c_dict[i]["c_segs"])[:, 0].argmin()][4].id
break
if not s_n or not e_n:
logger.warning("(%s) Map matching failed, no start or end node found!" % self.name)
else:
# Use Dijkstra's shortest path to perform map matching, but use a weighting based on emission
# probabilities instead of node distances
if algorithm == 'pyridy':
# Matched node ids
_, _, m_n_ids = self.osm.get_shortest_path(source=s_n, target=e_n, weight="c_weight")
else:
m_n_ids = nx.shortest_path(self.osm.G, source=s_n, target=e_n, weight="c_weight")
self.matched_nodes = [self.osm.node_dict[n] for n in m_n_ids] # Matched nodes
m_w_ids = [self.osm.G[n1][n2][0]["way_id"] for n1, n2 in zip(m_n_ids, m_n_ids[1:])]
self.matched_ways = list(set([self.osm.way_dict[w_id] for w_id in m_w_ids])) # Mapped Ways
logger.info("(%s) Found %d nodes that match the files GPS track!" % (self.name,
len(self.matched_nodes)))
else:
logger.warning("(%s) Can't do map matching since no file contains no OSM data" % self.name)
pass
def get_integrity_report(self):
""" Returns a dict that contains information which measurement types are available in the file
Returns
-------
dict
"""
report = {}
for k, v in self.measurements.items():
if len(v) > 0:
report[k.__name__] = True
else:
report[k.__name__] = False
attr = self.__dict__.copy()
attr.update(attr["device"].__dict__.copy())
for a in ["db_con", "measurements", "device", "sensors"]:
attr.pop(a)
pass
report.update(attr)
return report
def load_file(self, path: str):
""" Loads a single Ridy file located at path
Parameters
----------
path Path to the ridy file
"""
logger.info("Loading file: %s" % path)
_, self.extension = os.path.splitext(path)
_, self.name = os.path.split(path)
if self.extension == ".rdy":
with open(path, 'r') as file:
rdy = json.load(file)
if 'Ridy_Version' in rdy:
self.ridy_version = rdy['Ridy_Version']
else:
logger.info("No Ridy_Version in file: %s" % self.name)
self.ridy_version = None
if 'Ridy_Version_Code' in rdy:
self.ridy_version_code = rdy['Ridy_Version_Code']
else:
logger.info("No Ridy_Version_Code in file: %s" % self.name)
self.ridy_version_code = None
if 'RDY_Format_Version' in rdy:
self.rdy_format_version = rdy['RDY_Format_Version']
else:
logger.info("No RDY_Format_Version in file: %s" % self.name)
self.rdy_format_version = None
if 'RDY_Info_Name' in rdy:
self.rdy_info_name = rdy['RDY_Info_Name']
else:
logger.info("No RDY_Info_Name in file: %s" % self.name)
self.rdy_info_name = None
if 'RDY_Info_Sex' in rdy:
self.rdy_info_sex = rdy['RDY_Info_Sex']
else:
logger.info("No RDY_Info_Sex in file: %s" % self.name)
self.rdy_info_sex = None
if 'RDY_Info_Age' in rdy:
self.rdy_info_age = rdy['RDY_Info_Age']
else:
logger.info("No RDY_Info_Age in file: %s" % self.name)
self.rdy_info_age = None
if 'RDY_Info_Height' in rdy:
self.rdy_info_height = rdy['RDY_Info_Height']
else:
logger.info("No RDY_Info_Height in file: %s" % self.name)
self.rdy_info_height = None
if 'RDY_Info_Weight' in rdy:
self.rdy_info_weight = rdy['RDY_Info_Weight']
else:
logger.info("No RDY_Info_Weight in file: %s" % self.name)
self.rdy_info_weight = None
if 't0' in rdy:
if self.strip_timezone:
t0 = datetime.datetime.fromisoformat(rdy['t0']).replace(tzinfo=None)
self.t0 = np.datetime64(t0)
else:
self.t0 = np.datetime64(rdy['t0'])
else:
self.t0 = None
logger.info("No t0 in file: %s" % self.name)
if 'cs_matrix_string' in rdy:
self.cs_matrix_string = rdy['cs_matrix_string']
else:
self.cs_matrix_string = None
logger.info("No t0 in file: %s" % self.name)
if 'timestamp_when_started' in rdy:
self.timestamp_when_started = rdy['timestamp_when_started']
else:
self.timestamp_when_started = None
logger.info("No timestamp_when_started in file: %s" % self.name)
if 'timestamp_when_stopped' in rdy:
self.timestamp_when_stopped = rdy['timestamp_when_stopped']
else:
self.timestamp_when_stopped = None
logger.info("No timestamp_when_stopped in file: %s" % self.name)
if 'ntp_timestamp' in rdy:
self.ntp_timestamp = rdy['ntp_timestamp']
else:
self.ntp_timestamp = None
logger.info("No ntp_timestamp in file: %s" % self.name)
if 'ntp_date_time' in rdy:
if self.strip_timezone:
ntp_datetime_str = rdy['ntp_date_time']
if ntp_datetime_str:
ntp_date_time = datetime.datetime.fromisoformat(ntp_datetime_str).replace(tzinfo=None)
self.ntp_date_time = np.datetime64(ntp_date_time)
else:
self.ntp_date_time = None
else:
self.ntp_date_time = np.datetime64(rdy['t0'])
else:
self.ntp_date_time = None
logger.info("No ntp_date_time in file: %s" % self.name)
if "device" in rdy:
self.device = Device(**rdy['device_info'])
else:
logger.info("No device information in file: %s" % self.name)
if "sensors" in rdy:
for sensor in rdy['sensors']:
self.sensors.append(Sensor(**sensor))
else:
logger.info("No sensor descriptions in file: %s" % self.name)
if "acc_series" in rdy:
self.measurements[AccelerationSeries] = AccelerationSeries(rdy_format_version=self.rdy_format_version,
**rdy['acc_series'])
else:
logger.info("No Acceleration Series in file: %s" % self.name)
if "acc_uncal_series" in rdy:
self.measurements[AccelerationUncalibratedSeries] = AccelerationUncalibratedSeries(
rdy_format_version=self.rdy_format_version, **rdy['acc_uncal_series'])
else:
logger.info("No uncalibrated Acceleration Series in file: %s" % self.name)
if "lin_acc_series" in rdy:
self.measurements[LinearAccelerationSeries] = LinearAccelerationSeries(
rdy_format_version=self.rdy_format_version,
**rdy['lin_acc_series'])
else:
logger.info("No Linear Acceleration Series in file: %s" % self.name)
if "mag_series" in rdy:
self.measurements[MagnetometerSeries] = MagnetometerSeries(rdy_format_version=self.rdy_format_version,
**rdy['mag_series'])
else:
logger.info("No Magnetometer Series in file: %s" % self.name)
if "mag_uncal_series" in rdy:
self.measurements[MagnetometerUncalibratedSeries] = MagnetometerUncalibratedSeries(
rdy_format_version=self.rdy_format_version, **rdy['mag_uncal_series'])
else:
logger.info("No uncalibrated Magnetometer Series in file: %s" % self.name)
if "orient_series" in rdy:
self.measurements[OrientationSeries] = OrientationSeries(rdy_format_version=self.rdy_format_version,
**rdy['orient_series'])
else:
logger.info("No Orientation Series in file: %s" % self.name)
if "gyro_series" in rdy:
self.measurements[GyroSeries] = GyroSeries(rdy_format_version=self.rdy_format_version,
**rdy['gyro_series'])
else:
logger.info("No Gyro Series in file: %s" % self.name)
if "gyro_uncal_series" in rdy:
self.measurements[GyroUncalibratedSeries] = GyroUncalibratedSeries(
rdy_format_version=self.rdy_format_version, **rdy['gyro_uncal_series'])
else:
logger.info("No uncalibrated Gyro Series in file: %s" % self.name)
if "rot_series" in rdy:
self.measurements[RotationSeries] = RotationSeries(rdy_format_version=self.rdy_format_version,
**rdy['rot_series'])
else:
logger.info("No Rotation Series in file: %s" % self.name)
if "gps_series" in rdy:
self.measurements[GPSSeries] = GPSSeries(rdy_format_version=self.rdy_format_version,
**rdy['gps_series'])
else:
logger.info("No GPS Series in file: %s" % self.name)
if "gnss_series" in rdy:
self.measurements[GNSSMeasurementSeries] = GNSSMeasurementSeries(
rdy_format_version=self.rdy_format_version, **rdy['gnss_series'])
else:
logger.info("No GPS Series in file: %s" % self.name)
if "gnss_clock_series" in rdy:
self.measurements[GNSSClockMeasurementSeries] = GNSSClockMeasurementSeries(
rdy_format_version=self.rdy_format_version, **rdy['gnss_clock_series'])
else:
logger.info("No GNSS Clock Series in file: %s" % self.name)
if "nmea_series" in rdy:
self.measurements[NMEAMessageSeries] = NMEAMessageSeries(
rdy_format_version=self.rdy_format_version, **rdy['nmea_series'])
else:
logger.info("No GPS Series in file: %s" % self.name)
if "pressure_series" in rdy:
self.measurements[PressureSeries] = PressureSeries(rdy_format_version=self.rdy_format_version,
**rdy['pressure_series'])
else:
logger.info("No Pressure Series in file: %s" % self.name)
if "temperature_series" in rdy:
self.measurements[TemperatureSeries] = TemperatureSeries(rdy_format_version=self.rdy_format_version,
**rdy['temperature_series'])
else:
logger.info("No Temperature Series in file: %s" % self.name)
if "humidity_series" in rdy:
self.measurements[HumiditySeries] = HumiditySeries(rdy_format_version=self.rdy_format_version,
**rdy['humidity_series'])
else:
logger.info("No Humidity Series in file: %s" % self.name)
if "light_series" in rdy:
self.measurements[LightSeries] = LightSeries(rdy_format_version=self.rdy_format_version,
**rdy['light_series'])
else:
logger.info("No Light Series in file: %s" % self.name)
if "wz_series" in rdy:
self.measurements[WzSeries] = WzSeries(rdy_format_version=self.rdy_format_version,
**rdy['wz_series'])
else:
logger.info("No Wz Series in file: %s" % self.name)
if "subjective_comfort_series" in rdy:
self.measurements[SubjectiveComfortSeries] = SubjectiveComfortSeries(
rdy_format_version=self.rdy_format_version,
**rdy['subjective_comfort_series'])
else:
logger.info("No Subjective Comfort Series in file: %s" % self.name)
pass
elif self.extension == ".sqlite":
db_con = sqlite3.connect(path)
try:
info: Dict = dict(pd.read_sql_query("SELECT * from measurement_information_table", db_con))
except (DatabaseError, PandasDatabaseError) as e:
logger.error(e)
# Older files can contain wrong table name
try:
info = dict(pd.read_sql_query("SELECT * from measurment_information_table", db_con))
except (DatabaseError, PandasDatabaseError) as e:
logger.error(
"DatabaseError occurred when accessing measurement_information_table, file: %s" % self.name)
logger.error(e)
info = {}
try:
sensor_df = pd.read_sql_query("SELECT * from sensor_descriptions_table", db_con)
for _, row in sensor_df.iterrows():
self.sensors.append(Sensor(**dict(row)))
except (DatabaseError, PandasDatabaseError) as e:
logger.error(
"DatabaseError occurred when accessing sensor_descriptions_table, file: %s" % self.name)
logger.error(e)
try:
device_df = pd.read_sql_query("SELECT * from device_information_table", db_con)
self.device = Device(**dict(device_df))
except (DatabaseError, PandasDatabaseError) as e:
logger.error("DatabaseError occurred when accessing device_information_table, file: %s" % self.name)
logger.error(e)
self.device = Device()
# Info
if 'ridy_version' in info and len(info['ridy_version']) > 1:
logger.info("Measurement information table contains more than 1 row!")
if 'ridy_version' in info and len(info['ridy_version']) > 0:
self.ridy_version = info['ridy_version'].iloc[-1]
if 'ridy_version_code' in info and len(info['ridy_version_code']) > 0:
self.ridy_version_code = info['ridy_version_code'].iloc[-1]
if 'rdy_format_version' in info and len(info['rdy_format_version']) > 0:
self.rdy_format_version = info['rdy_format_version'].iloc[-1]
if 'rdy_info_name' in info and len(info['rdy_info_name']) > 0:
self.rdy_info_name = info['rdy_info_name'].iloc[-1]
if 'rdy_info_sex' in info and len(info['rdy_info_sex']) > 0:
self.rdy_info_sex = info['rdy_info_sex'].iloc[-1]
if 'rdy_info_age' in info and len(info['rdy_info_age']) > 0:
self.rdy_info_age = info['rdy_info_age'].iloc[-1]
if 'rdy_info_height' in info and len(info['rdy_info_height']) > 0:
self.rdy_info_height = info['rdy_info_height'].iloc[-1]
if 'rdy_info_weight' in info and len(info['rdy_info_weight']) > 0:
self.rdy_info_weight = info['rdy_info_weight'].iloc[-1]
if 't0' in info and len(info['t0']) > 0:
if self.strip_timezone:
t0 = datetime.datetime.fromisoformat(info['t0'].iloc[-1]).replace(tzinfo=None)
self.t0 = np.datetime64(t0)
else:
self.t0 = np.datetime64(info['t0'].iloc[-1])
if 'cs_matrix_string' in info and len(info['cs_matrix_string']) > 0:
self.cs_matrix_string = info['cs_matrix_string'].iloc[-1]
if 'timestamp_when_started' and len(info['timestamp_when_started']) > 0:
self.timestamp_when_started = info['timestamp_when_started'].iloc[-1]
if 'timestamp_when_stopped' in info and len(info['timestamp_when_stopped']) > 0:
self.timestamp_when_stopped = info['timestamp_when_stopped'].iloc[-1]
if 'ntp_timestamp' in info and len(info['ntp_timestamp']) > 0:
self.ntp_timestamp = info['ntp_timestamp'].iloc[-1]
if 'ntp_date_time' in info and len(info['ntp_date_time']) > 0:
if self.strip_timezone:
ntp_datetime_str = info['ntp_date_time'].iloc[-1]
if ntp_datetime_str:
ntp_date_time = datetime.datetime.fromisoformat(ntp_datetime_str).replace(tzinfo=None)
self.ntp_date_time = np.datetime64(ntp_date_time)
else:
self.ntp_date_time = None
else:
self.ntp_date_time = np.datetime64(info['ntp_date_time'].iloc[-1])
# Measurements
try:
acc_df = pd.read_sql_query("SELECT * from acc_measurements_table", db_con)
self.measurements[AccelerationSeries] = AccelerationSeries(rdy_format_version=self.rdy_format_version,
**dict(acc_df))
except (DatabaseError, PandasDatabaseError) as e:
logger.error("DatabaseError occurred when accessing acc_measurements_table, file: %s" % self.name)
logger.error(e)
try:
acc_uncal_df = pd.read_sql_query("SELECT * from acc_uncal_measurements_table", db_con)
self.measurements[AccelerationUncalibratedSeries] = AccelerationUncalibratedSeries(
rdy_format_version=self.rdy_format_version, **dict(acc_uncal_df))
except (DatabaseError, PandasDatabaseError) as e:
logger.error("DatabaseError occurred when accessing acc_uncal_measurements_table, file: %s" % self.name)
logger.error(e)
try:
lin_acc_df = pd.read_sql_query("SELECT * from lin_acc_measurements_table", db_con)
self.measurements[LinearAccelerationSeries] = LinearAccelerationSeries(
rdy_format_version=self.rdy_format_version,
**dict(lin_acc_df))
except (DatabaseError, PandasDatabaseError) as e:
logger.error(
"DatabaseError occurred when accessing lin_acc_measurements_table, file: %s" % self.name)
logger.error(e)
try:
mag_df = pd.read_sql_query("SELECT * from mag_measurements_table", db_con)
self.measurements[MagnetometerSeries] = MagnetometerSeries(rdy_format_version=self.rdy_format_version,
**dict(mag_df))
except (DatabaseError, PandasDatabaseError) as e:
logger.error("DatabaseError occurred when accessing mag_measurements_table, file: %s" % self.name)
logger.error(e)
try:
mag_uncal_df = pd.read_sql_query("SELECT * from mag_uncal_measurements_table", db_con)
self.measurements[MagnetometerUncalibratedSeries] = MagnetometerUncalibratedSeries(
rdy_format_version=self.rdy_format_version, **dict(mag_uncal_df))
except (DatabaseError, PandasDatabaseError) as e:
logger.error("DatabaseError occurred when accessing mag_uncal_measurements_table, file: %s" % self.name)
logger.error(e)
try:
orient_df = pd.read_sql_query("SELECT * from orient_measurements_table", db_con)
self.measurements[OrientationSeries] = OrientationSeries(rdy_format_version=self.rdy_format_version,
**dict(orient_df))
except (DatabaseError, PandasDatabaseError) as e:
logger.error(
"DatabaseError occurred when accessing orient_measurements_table, file: %s" % self.name)
logger.error(e)
try:
gyro_df = pd.read_sql_query("SELECT * from gyro_measurements_table", db_con)
self.measurements[GyroSeries] = GyroSeries(rdy_format_version=self.rdy_format_version,
**dict(gyro_df))
except (DatabaseError, PandasDatabaseError) as e:
logger.error("DatabaseError occurred when accessing gyro_measurements_table, file: %s" % self.name)
logger.error(e)
try:
gyro_uncal_df = pd.read_sql_query("SELECT * from gyro_uncal_measurements_table", db_con)
self.measurements[GyroUncalibratedSeries] = GyroUncalibratedSeries(
rdy_format_version=self.rdy_format_version, **dict(gyro_uncal_df))
except (DatabaseError, PandasDatabaseError) as e:
logger.error(
"DatabaseError occurred when accessing gyro_uncal_measurements_table, file: %s" % self.name)
logger.error(e)
try:
rot_df = pd.read_sql_query("SELECT * from rot_measurements_table", db_con)
self.measurements[RotationSeries] = RotationSeries(rdy_format_version=self.rdy_format_version,
**dict(rot_df))
except (DatabaseError, PandasDatabaseError) as e:
logger.error("DatabaseError occurred when accessing rot_measurements_table, file: %s" % self.name)
logger.error(e)
try:
gps_df = pd.read_sql_query("SELECT * from gps_measurements_table", db_con)
self.measurements[GPSSeries] = GPSSeries(rdy_format_version=self.rdy_format_version,
**dict(gps_df))
except (DatabaseError, PandasDatabaseError) as e:
logger.error("DatabaseError occurred when accessing gps_measurements_table, file: %s" % self.name)
logger.error(e)
try:
gnss_df = pd.read_sql_query("SELECT * from gnss_measurement_table", db_con)
self.measurements[GNSSMeasurementSeries] = GNSSMeasurementSeries(
rdy_format_version=self.rdy_format_version, **dict(gnss_df))
except (DatabaseError, PandasDatabaseError) as e:
logger.error("DatabaseError occurred when accessing gnss_measurement_table, file: %s" % self.name)
logger.error(e)
try:
gnss_clock_df = pd.read_sql_query("SELECT * from gnss_clock_measurement_table", db_con)
self.measurements[GNSSClockMeasurementSeries] = GNSSClockMeasurementSeries(
rdy_format_version=self.rdy_format_version, **dict(gnss_clock_df))
except (DatabaseError, PandasDatabaseError) as e:
logger.error("DatabaseError occurred when accessing gnss_clock_measurement_table, file: %s" % self.name)
logger.error(e)
try:
nmea_df = pd.read_sql_query("SELECT * from nmea_messages_table", db_con)
self.measurements[NMEAMessageSeries] = NMEAMessageSeries(
rdy_format_version=self.rdy_format_version, **dict(nmea_df))
except (DatabaseError, PandasDatabaseError) as e:
logger.error("DatabaseError occurred when accessing nmea_messages_table, file: %s" % self.name)
logger.error(e)
try:
pressure_df = pd.read_sql_query("SELECT * from pressure_measurements_table", db_con)
self.measurements[PressureSeries] = PressureSeries(rdy_format_version=self.rdy_format_version,
**dict(pressure_df))
except (DatabaseError, PandasDatabaseError) as e:
logger.error(
"DatabaseError occurred when accessing pressure_measurements_table, file: %s" % self.name)
logger.error(e)
try:
temperature_df = pd.read_sql_query("SELECT * from temperature_measurements_table", db_con)
self.measurements[TemperatureSeries] = TemperatureSeries(rdy_format_version=self.rdy_format_version,
**dict(temperature_df))
except (DatabaseError, PandasDatabaseError) as e:
logger.error(
"DatabaseError occurred when accessing temperature_measurements_table, file: %s" % self.name)
logger.error(e)
try:
humidity_df = pd.read_sql_query("SELECT * from humidity_measurements_table", db_con)
self.measurements[HumiditySeries] = HumiditySeries(rdy_format_version=self.rdy_format_version,
**dict(humidity_df))
except (DatabaseError, PandasDatabaseError) as e:
logger.error(
"DatabaseError occurred when accessing humidity_measurements_table, file: %s" % self.name)
logger.error(e)
try:
light_df = pd.read_sql_query("SELECT * from light_measurements_table", db_con)
self.measurements[LightSeries] = LightSeries(rdy_format_version=self.rdy_format_version,
**dict(light_df))
except (DatabaseError, PandasDatabaseError) as e:
logger.error("DatabaseError occurred when accessing light_measurements_table, file: %s" % self.name)
logger.error(e)
try:
wz_df = pd.read_sql_query("SELECT * from wz_measurements_table", db_con)
self.measurements[WzSeries] = WzSeries(rdy_format_version=self.rdy_format_version,
**dict(wz_df))
except (DatabaseError, PandasDatabaseError) as e:
logger.error("DatabaseError occurred when accessing wz_measurements_table, file: %s" % self.name)
logger.error(e)
try:
subjective_comfort_df = | pd.read_sql_query("SELECT * from subjective_comfort_measurements_table", db_con) | pandas.read_sql_query |
# -*- coding: utf-8 -*-
"""
.. module:: datasource
:synopsis: Set of classes to work with different bibliometric data sources
.. moduleauthor:: <NAME> <<EMAIL>>
"""
import os
import json
import gzip
from collections import defaultdict
import pandas as pd
import numpy as np
from nameparser import HumanName
from pyscisci.utils import isin_sorted, zip2dict, load_int, load_float, groupby_count
from pyscisci.metrics import *
from pyscisci.datasource.readwrite import load_preprocessed_data, append_to_preprocessed_df
from pyscisci.filter import *
class BibDataBase(object):
"""
Base class for all bibliometric database interfaces.
The BibDataBase provides a parasomonious structure for each of the specific data sources (MAG, WOS, etc.).
There are four primary types of functions:
1. *Parseing* Functions (data source specific) that parse the raw data files
2. *Loading* Functions that load DataFrames
3. *Processing* Functions that calculate advanced data types from the raw files
4. *Analysis* Functions that calculate Science of Science metrics.
|
Parameters
-------
path2database: str
The path to the database files
keep_in_memory: bool, default False
Flag to keep database files in memory once loaded
global_filter: dict or Filter
Set of conditions to apply globally.
show_progress: bool, default True
Flag to show progress of loading, processing, and calculations.
|
"""
def __init__(self, path2database = '', keep_in_memory = False, global_filter = None, show_progress=True):
self._default_init(path2database, keep_in_memory, global_filter, show_progress)
def _default_init(self, path2database = '', keep_in_memory = False, global_filter = None, show_progress=True):
self.path2database = path2database
self.keep_in_memory = keep_in_memory
self.global_filter = None
self.show_progress = show_progress
self.path2author_df = 'author'
self.path2pub_df = 'publication'
self.path2affiliation_df = 'affiliation'
self.path2pub2ref_df = 'pub2ref'
self.path2paa_df = 'publicationauthoraffiliation'
self.path2pub2field_df = 'pub2field'
self.path2journal_df = 'journal'
self.path2fieldinfo_df = 'fieldinfo'
self.path2impact_df = 'impact'
self._affiliation_df = None
self._pub_df = None
self._journal_df = None
self._author_df = None
self._pub2year = None
self._pub2doctype = None
self._pub2ref_df = None
self._author2pub_df = None
self._paa_df = None
self._pub2refnoself_df = None
self._pub2field_df=None
self._fieldinfo_df = None
self.PublicationIdType = int
self.AffiliationIdType = int
self.AuthorIdType = int
if not global_filter is None:
self.set_global_filters(global_filter)
def set_new_data_path(self, dataframe_name='', new_path=''):
if dataframe_name == 'author_df':
self.path2author_df = new_path
elif dataframe_name == 'pub_df':
self.path2pub_df = new_path
elif dataframe_name == 'affiliation_df':
self.path2affiliation_df = new_path
elif dataframe_name == 'pub2ref_df':
self.path2pub2ref_df = new_path
elif dataframe_name == 'paa_df':
self.path2paa_df = new_path
elif dataframe_name == 'pub2field_df':
self.path2pub2field_df = new_path
elif dataframe_name == 'fieldinfo_df':
self.path2fieldinfo_df = new_path
elif dataframe_name == 'journal_df':
self.path2journal_df = new_path
elif dataframe_name == 'impact_df':
self.path2impact_df = new_path
else:
print("Unrecognized DataFrame {}".format(dataframe_name))
@property
def affiliation_df(self):
"""
The DataFrame keeping affiliation information. Columns may depend on the specific datasource.
Notes
--------
columns: 'AffiliationId', 'NumberPublications', 'NumberCitations', 'FullName', 'GridId', 'OfficialPage', 'WikiPage', 'Latitude', 'Longitude'
|
"""
if self._affiliation_df is None:
if self.keep_in_memory:
self._affiliation_df = self.load_affiliations(show_progress=self.show_progress)
else:
return self.load_affiliations(show_progress=self.show_progress)
return self._affiliation_df
@property
def author_df(self):
"""
The DataFrame keeping author information. Columns may depend on the specific datasource.
Notes
--------
columns: 'AuthorId', 'LastKnownAffiliationId', 'NumberPublications', 'NumberCitations', 'FullName', 'LastName', 'FirstName', 'MiddleName'
|
"""
if self._author_df is None:
if self.keep_in_memory:
self._author_df = self.load_authors(show_progress=self.show_progress)
else:
return self.load_authors(show_progress=self.show_progress)
return self._author_df
@property
def pub_df(self):
"""
The DataFrame keeping publication information. Columns may depend on the specific datasource.
Notes
-------
columns: 'PublicationId', 'Year', 'JournalId', 'FamilyId', 'Doi', 'Title', 'Date', 'Volume', 'Issue', 'DocType'
|
"""
if self._pub_df is None:
if self.keep_in_memory:
self._pub_df = self.load_publications(show_progress=self.show_progress)
else:
return self.load_publications(show_progress=self.show_progress)
return self._pub_df
@property
def pub2year(self):
"""
A dictionary mapping PublicationId to Year.
"""
if self._pub2year is None:
if self.keep_in_memory:
self._pub2year = self.load_pub2year()
else:
return self.load_pub2year()
return self._pub2year
@property
def pub2doctype(self):
"""
A dictionary mapping PublicationId to Document Type.
Notes
-------
doctype mapping: 'Journal': 'j', 'Book':'b', '':'', 'BookChapter':'bc', 'Conference':'c', 'Dataset':'d', 'Patent':'p', 'Repository':'r'
|
"""
if self._pub2doctype is None:
if self.keep_in_memory:
self._pub2doctype = self.load_pub2doctype()
else:
return self.load_pub2doctype()
return self._pub2doctype
@property
def journal_df(self):
"""
The DataFrame keeping journal information. Columns may depend on the specific datasource.
Notes
-------
columns: 'JournalId', 'FullName', 'Issn', 'Publisher', 'Webpage'
|
"""
if self._journal_df is None:
if self.keep_in_memory:
self._journal_df = self.load_journals(show_progress=self.show_progress)
else:
return self.load_journals(show_progress=self.show_progress)
return self._journal_df
@property
def pub2ref_df(self):
"""
The DataFrame keeping citing and cited PublicationId.
Notes
-------
columns: 'CitingPublicationId', 'CitedPublicationId'
|
"""
if self._pub2ref_df is None:
if self.keep_in_memory:
self._pub2ref_df = self.load_references(show_progress=self.show_progress)
else:
return self.load_references(show_progress=self.show_progress)
return self._pub2ref_df
@property
def pub2refnoself_df(self):
"""
The DataFrame keeping citing and cited PublicationId after filtering out the self-citations.
Notes
-------
columns: CitingPublicationId, CitedPublicationId
|
"""
if self._pub2refnoself_df is None:
if self.keep_in_memory:
self._pub2refnoself_df = self.load_references(noselfcite=True, show_progress=self.show_progress)
else:
return self.load_references(noselfcite=True, show_progress=self.show_progress)
return self._pub2refnoself_df
@property
def paa_df(self):
"""
The DataFrame keeping all publication, author, affiliation relationships. Columns may depend on the specific datasource.
Notes
-------
columns: 'PublicationId', 'AuthorId', 'AffiliationId', 'AuthorSequence', 'OrigAuthorName', 'OrigAffiliationName'
|
"""
if self._paa_df is None:
if self.keep_in_memory:
self._paa_df = self.load_publicationauthoraffiliation(show_progress=self.show_progress)
else:
return self.load_publicationauthoraffiliation(show_progress=self.show_progress)
return self._paa_df
@property
def author2pub_df(self):
"""
The DataFrame keeping all publication, author relationships. Columns may depend on the specific datasource.
Notes
-------
columns: 'PublicationId', 'AuthorId'
|
"""
if self._paa_df is None:
if self.keep_in_memory:
self._paa_df = self.load_publicationauthoraffiliation(columns = ['AuthorId', 'PublicationId'],
duplicate_subset = ['AuthorId', 'PublicationId'], dropna = ['AuthorId', 'PublicationId'], show_progress=self.show_progress)
else:
return self.load_publicationauthoraffiliation(columns = ['AuthorId', 'PublicationId'],
duplicate_subset = ['AuthorId', 'PublicationId'], dropna = ['AuthorId', 'PublicationId'], show_progress=self.show_progress)
return self._paa_df
@property
def pub2field_df(self):
"""
The DataFrame keeping all publication field relationships. Columns may depend on the specific datasource.
Notes
-------
columns: 'PublicationId', 'FieldId'
|
"""
if self._pub2field_df is None:
if self.keep_in_memory:
self._pub2field_df = self.load_pub2field(show_progress=self.show_progress)
else:
return self.load_pub2field(show_progress=self.show_progress)
return self._pub2field_df
@property
def fieldinfo_df(self):
"""
The DataFrame keeping all publication field relationships. Columns may depend on the specific datasource.
Notes
-------
columns: 'FieldId', 'FieldLevel', 'NumberPublications', 'FieldName'
|
"""
if self._fieldinfo_df is None:
if self.keep_in_memory:
self._fieldinfo_df = self.load_fieldinfo(show_progress=self.show_progress)
else:
return self.load_fieldinfo(show_progress=self.show_progress)
return self._fieldinfo_df
def publicationid_list(self):
"""
A list of all PublicationIds.
|
"""
if self.global_filter is None:
return sorted(list(self.load_publications(columns=['PublicationId'], duplicate_subset=['PublicationId'])['PublicationId'].unique()))
else:
return sorted(list(self.global_filter))
def set_global_filters(self, global_filter):
"""
Set of filtering conditions that restrict the global set of publications loaded from the DataBase.
Allowable global filters are:
'Year', 'DocType', 'FieldId'
|
"""
if isinstance(global_filter, list):
filter_dict = {f.field:f for f in global_filter}
elif isinstance(global_filter, (RangeFilter, YearFilter, SetFilter, DocTypeFilter, FieldFilter) ):
filter_dict = { global_filter.field:global_filter}
elif type(global_filter) is dict:
filter_dict = global_filter
else:
raise TypeError("global_filter must be a single pyscisci Filter, a list of pyscisci Filters, or a dictionary of pyscisci Filters.")
# to create a global filter across all dataframes, we need to create a list of the allowable PublicationIds
for filtertype, pubfilter in filter_dict.items():
if filtertype == 'Year':
pub2year = self.pub2year
if self.global_filter is None:
self.global_filter = {pid for pid, y in pub2year.items() if filter_dict['Year'].check_value(y)}
else:
self.global_filter = {pid for pid in self.global_filter if not pub2year.get(pid, None) is None and filter_dict['Year'].check_value(pub2year[pid])}
elif filtertype == 'DocType':
pub2doctype = self.pub2doctype
if self.global_filter is None:
self.global_filter = {pid for pid, dt in pub2doctype.items() if filter_dict['DocType'].check_value(dt)}
else:
self.global_filter = {pid for pid in self.global_filter if not pub2doctype.get(pid, None) is None and filter_dict['DocType'].check_value(pub2doctype[pid])}
elif filtertype == 'FieldId':
if self.global_filter is None:
load_fields_filter = {'FieldId':np.sort(list(filter_dict['FieldId'].value_set))}
else:
load_fields_filter = {'FieldId':np.sort(list(filter_dict['FieldId'].value_set)), 'PublicationId':np.sort(list(self.global_filter))}
pub2field = self.load_pub2field(columns = ['PublicationId', 'FieldId'], filter_dict = load_fields_filter)
self.global_filter = set(pub2field['PublicationId'].unique())
else:
raise TypeError("{} is not a valid global filter. It must be one of 'Year', 'DocType', 'FieldId'.".format(filtertype))
## Basic Functions for loading data from either preprocessed sources or the raw database files
def load_affiliations(self, preprocess = True, columns = None, filter_dict = None, duplicate_subset = None,
duplicate_keep = 'last', dropna = None, prefunc2apply=None, postfunc2apply=None, show_progress=False):
"""
Load the Affiliation DataFrame from a preprocessed directory, or parse from the raw files.
Parameters
----------
preprocess : bool, default True, Optional
Attempt to load from the preprocessed directory.
columns : list, default None, Optional
Load only this subset of columns
filter_dict : dict, default None, Optional
Dictionary of format {"ColumnName":"ListofValues"} where "ColumnName" is a data column
and "ListofValues" is a sorted list of valid values. A DataFrame only containing rows that appear in
"ListofValues" will be returned.
duplicate_subset : list, default None, Optional
Drop any duplicate entries as specified by this subset of columns
duplicate_keep : str, default 'last', Optional
If duplicates are being dropped, keep the 'first' or 'last'
(see `pandas.DataFram.drop_duplicates <https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.drop_duplicates.html>`_)
dropna : list, default None, Optional
Drop any NaN entries as specified by this subset of columns
Returns
-------
DataFrame
Affililation DataFrame.
|
"""
if show_progress or self.show_progress:
show_progress='Loading Affiliations'
if preprocess and os.path.exists(os.path.join(self.path2database, self.path2affiliation_df)):
return load_preprocessed_data(self.path2affiliation_df, path2database=self.path2database, columns=columns,
filter_dict=filter_dict, duplicate_subset=duplicate_subset, duplicate_keep=duplicate_keep, dropna=dropna,
prefunc2apply=prefunc2apply, postfunc2apply=postfunc2apply, show_progress=show_progress)
else:
return self.parse_affiliations()
def load_authors(self, preprocess = True, columns = None, filter_dict = None, duplicate_subset = None,
duplicate_keep = 'last', dropna = None, prefunc2apply=None, postfunc2apply=None, process_name = True, show_progress=True):
"""
Load the Author DataFrame from a preprocessed directory, or parse from the raw files.
Parameters
----------
preprocess : bool, default True, Optional
Attempt to load from the preprocessed directory.
columns : list, default None, Optional
Load only this subset of columns
filter_dict : dict, default None, Optional
Dictionary of format {"ColumnName":"ListofValues"} where "ColumnName" is a data column and "ListofValues" is a sorted list of valid values. A DataFrame only containing rows that appear in
"ListofValues" will be returned.
duplicate_subset : list, default None, Optional
Drop any duplicate entries as specified by this subset of columns
duplicate_keep : str, default 'last', Optional
If duplicates are being dropped, keep the 'first' or 'last'
(see `pandas.DataFram.drop_duplicates <https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.drop_duplicates.html>`_)
dropna : list, default None, Optional
Drop any NaN entries as specified by this subset of columns
process_name : bool, default True, Optional
If True, then when processing the raw file, the package `NameParser <https://nameparser.readthedocs.io/en/latest/>`_
will be used to split author FullNames.
Returns
-------
DataFrame
Author DataFrame.
|
"""
if show_progress or self.show_progress:
show_progress='Loading Authors'
if preprocess and os.path.exists(os.path.join(self.path2database, self.path2author_df)):
return load_preprocessed_data(self.path2author_df, path2database=self.path2database, columns=columns,
filter_dict=filter_dict, duplicate_subset=duplicate_subset, duplicate_keep=duplicate_keep, dropna=dropna,
prefunc2apply=prefunc2apply, postfunc2apply=postfunc2apply, show_progress=show_progress)
else:
return self.parse_authors(process_name=process_name)
def load_publications(self, preprocess = True, columns = None, filter_dict = None, duplicate_subset = None,
duplicate_keep = 'last', dropna = None, prefunc2apply=None, postfunc2apply=None, show_progress=False):
"""
Load the Publication DataFrame from a preprocessed directory, or parse from the raw files.
Parameters
----------
preprocess : bool, default True, Optional
Attempt to load from the preprocessed directory.
columns : list, default None, Optional
Load only this subset of columns
filter_dict : dict, default None, Optional
Dictionary of format {"ColumnName":"ListofValues"} where "ColumnName" is a data column
and "ListofValues" is a sorted list of valid values. A DataFrame only containing rows that appear in
"ListofValues" will be returned.
duplicate_subset : list, default None, Optional
Drop any duplicate entries as specified by this subset of columns
duplicate_keep : str, default 'last', Optional
If duplicates are being dropped, keep the 'first' or 'last'
(see `pandas.DataFram.drop_duplicates <https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.drop_duplicates.html>`_)
dropna : list, default None, Optional
Drop any NaN entries as specified by this subset of columns
Returns
-------
DataFrame
Publication DataFrame.
|
"""
if show_progress or self.show_progress:
show_progress='Loading Publications'
if not self.global_filter is None:
if 'PublicationId' in filter_dict:
filter_dict['PublicationId'] = np.sort([pid for pid in filter_dict['PublicationId'] if pid in self.global_filter])
else:
filter_dict['PublicationId'] = np.sort(list(self.global_filter))
if preprocess and os.path.exists(os.path.join(self.path2database, self.path2pub_df)):
return load_preprocessed_data(dataname=self.path2pub_df, path2database=self.path2database, columns=columns,
filter_dict=filter_dict, duplicate_subset=duplicate_subset, duplicate_keep=duplicate_keep, dropna=dropna,
prefunc2apply=prefunc2apply, postfunc2apply=postfunc2apply, show_progress=show_progress)
else:
return self.parse_publications()
def load_pub2year(self):
if os.path.exists(os.path.join(self.path2database, 'pub2year.json.gz')):
with gzip.open(os.path.join(self.path2database, 'pub2year.json.gz'), 'r') as infile:
pub2year = json.loads(infile.read().decode('utf8'))
return {self.PublicationIdType(k):int(y) for k,y in pub2year.items() if not y is None}
def load_pub2doctype(self):
if os.path.exists(os.path.join(self.path2database, 'pub2doctype.json.gz')):
with gzip.open(os.path.join(self.path2database, 'pub2doctype.json.gz'), 'r') as infile:
pub2doctype = json.loads(infile.read().decode('utf8'))
return {self.PublicationIdType(k):dt for k,dt in pub2doctype.items() if not dt is None}
def load_journals(self, preprocess = True, columns = None, filter_dict = None, duplicate_subset = None,
duplicate_keep = 'last', dropna = None, prefunc2apply=None, postfunc2apply=None, show_progress=False):
"""
Load the Journal DataFrame from a preprocessed directory, or parse from the raw files.
Parameters
----------
preprocess : bool, default True, Optional
Attempt to load from the preprocessed directory.
columns : list, default None, Optional
Load only this subset of columns
filter_dict : dict, default None, Optional
Dictionary of format {"ColumnName":"ListofValues"} where "ColumnName" is a data column
and "ListofValues" is a sorted list of valid values. A DataFrame only containing rows that appear in
"ListofValues" will be returned.
duplicate_subset : list, default None, Optional
Drop any duplicate entries as specified by this subset of columns
duplicate_keep : str, default 'last', Optional
If duplicates are being dropped, keep the 'first' or 'last'
(see `pandas.DataFram.drop_duplicates <https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.drop_duplicates.html>`_)
dropna : list, default None, Optional
Drop any NaN entries as specified by this subset of columns
Returns
-------
DataFrame
Journal DataFrame.
|
"""
if show_progress or self.show_progress:
show_progress='Loading Journals'
if preprocess and os.path.exists(os.path.join(self.path2database, self.path2journal_df)):
return load_preprocessed_data(self.path2journal_df, path2database=self.path2database, columns=columns,
filter_dict=filter_dict, duplicate_subset=duplicate_subset, duplicate_keep=duplicate_keep, dropna=dropna,
prefunc2apply=prefunc2apply, postfunc2apply=postfunc2apply, show_progress=show_progress)
else:
return self.parse_publications()
def load_references(self, preprocess = True, columns = None, filter_dict = {}, duplicate_subset = None,
duplicate_keep = 'last', noselfcite = False, dropna = None, prefunc2apply=None, postfunc2apply=None, show_progress=False):
"""
Load the Pub2Ref DataFrame from a preprocessed directory, or parse from the raw files.
Parameters
----------
preprocess : bool, default True, Optional
Attempt to load from the preprocessed directory.
columns : list, default None, Optional
Load only this subset of columns
filter_dict : dict, default {}, Optional
Dictionary of format {"ColumnName":"ListofValues"} where "ColumnName" is a data column
and "ListofValues" is a sorted list of valid values. A DataFrame only containing rows that appear in
"ListofValues" will be returned.
duplicate_subset : list, default None, Optional
Drop any duplicate entries as specified by this subset of columns
duplicate_keep : str, default 'last', Optional
If duplicates are being dropped, keep the 'first' or 'last'
(see `pandas.DataFram.drop_duplicates <https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.drop_duplicates.html>`_)
dropna : list, default None, Optional
Drop any NaN entries as specified by this subset of columns
noselfcite : bool, default False, Optional
If True, then the preprocessed pub2ref files with self-citations removed will be used.
Returns
-------
DataFrame
Pub2Ref DataFrame.
|
"""
if noselfcite:
fileprefix = self.path2pub2ref_df + 'noself'
else:
fileprefix = self.path2pub2ref_df
if not self.global_filter is None:
if 'CitingPublicationId' in filter_dict:
filter_dict['CitingPublicationId'] = np.sort([pid for pid in filter_dict['CitingPublicationId'] if pid in self.global_filter])
else:
filter_dict['CitingPublicationId'] = np.sort(list(self.global_filter))
if 'CitedPublicationId' in filter_dict:
filter_dict['CitedPublicationId'] = np.sort([pid for pid in filter_dict['CitedPublicationId'] if pid in self.global_filter])
else:
filter_dict['CitedPublicationId'] = np.sort(list(self.global_filter))
if show_progress or self.show_progress:
show_progress='Loading {}'.format(fileprefix)
if preprocess and os.path.exists(os.path.join(self.path2database, fileprefix)):
return load_preprocessed_data(fileprefix, path2database=self.path2database, columns=columns,
filter_dict=filter_dict, duplicate_subset=duplicate_subset, duplicate_keep=duplicate_keep, dropna=dropna,
prefunc2apply=prefunc2apply, postfunc2apply=postfunc2apply, show_progress=show_progress)
else:
return self.parse_references()
def load_publicationauthoraffiliation(self, preprocess = True, columns = None, filter_dict = {}, duplicate_subset = None,
duplicate_keep = 'last', dropna = None, prefunc2apply=None, postfunc2apply=None, show_progress=False):
"""
Load the PublicationAuthorAffilation DataFrame from a preprocessed directory, or parse from the raw files.
Parameters
----------
preprocess : bool, default True, Optional
Attempt to load from the preprocessed directory.
columns : list, default None, Optional
Load only this subset of columns
filter_dict : dict, default {}, Optional
Dictionary of format {"ColumnName":"ListofValues"} where "ColumnName" is a data column
and "ListofValues" is a sorted list of valid values. A DataFrame only containing rows that appear in
"ListofValues" will be returned.
duplicate_subset : list, default None, Optional
Drop any duplicate entries as specified by this subset of columns
duplicate_keep : str, default 'last', Optional
If duplicates are being dropped, keep the 'first' or 'last'
(see `pandas.DataFram.drop_duplicates <https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.drop_duplicates.html>`_)
dropna : list, default None, Optional
Drop any NaN entries as specified by this subset of columns
Returns
-------
DataFrame
PublicationAuthorAffilation DataFrame.
|
"""
if show_progress or self.show_progress:
show_progress='Loading Publication Author Affiliation'
if not self.global_filter is None:
if 'PublicationId' in filter_dict:
filter_dict['PublicationId'] = np.sort([pid for pid in filter_dict['PublicationId'] if pid in self.global_filter])
else:
filter_dict['PublicationId'] = np.sort(list(self.global_filter))
if preprocess and os.path.exists(os.path.join(self.path2database, self.path2paa_df)):
return load_preprocessed_data(self.path2paa_df, path2database=self.path2database, columns=columns,
filter_dict=filter_dict, duplicate_subset=duplicate_subset, duplicate_keep=duplicate_keep, dropna=dropna,
prefunc2apply=prefunc2apply, postfunc2apply=postfunc2apply, show_progress=show_progress)
else:
return self.parse_publicationauthoraffiliation()
def load_pub2field(self, preprocess = True, columns = None, filter_dict = {}, duplicate_subset = None,
duplicate_keep = 'last', dropna = None, prefunc2apply=None, postfunc2apply=None, show_progress=False):
"""
Load the Pub2Field DataFrame from a preprocessed directory, or parse from the raw files.
Parameters
----------
preprocess : bool, default True, Optional
Attempt to load from the preprocessed directory.
columns : list, default None, Optional
Load only this subset of columns
filter_dict : dict, default {}, Optional
Dictionary of format {"ColumnName":"ListofValues"} where "ColumnName" is a data column
and "ListofValues" is a sorted list of valid values. A DataFrame only containing rows that appear in
"ListofValues" will be returned.
duplicate_subset : list, default None, Optional
Drop any duplicate entries as specified by this subset of columns
duplicate_keep : str, default 'last', Optional
If duplicates are being dropped, keep the 'first' or 'last'
(see `pandas.DataFram.drop_duplicates <https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.drop_duplicates.html>`_)
dropna : list, default None, Optional
Drop any NaN entries as specified by this subset of columns
Returns
-------
DataFrame
Pub2Field DataFrame.
|
"""
if show_progress or self.show_progress:
show_progress='Loading Fields'
if not self.global_filter is None:
if 'PublicationId' in filter_dict:
filter_dict['PublicationId'] = np.sort([pid for pid in filter_dict['PublicationId'] if pid in self.global_filter])
else:
filter_dict['PublicationId'] = np.sort(list(self.global_filter))
if preprocess and os.path.exists(os.path.join(self.path2database, self.path2pub2field_df)):
return load_preprocessed_data(self.path2pub2field_df, path2database=self.path2database, columns=columns,
filter_dict=filter_dict, duplicate_subset=duplicate_subset, duplicate_keep=duplicate_keep, dropna=dropna,
prefunc2apply=prefunc2apply, postfunc2apply=postfunc2apply, show_progress=show_progress)
else:
return self.parse_fields()
def load_fieldinfo(self, preprocess = True, columns = None, filter_dict = {}, show_progress=False):
"""
Load the Field Information DataFrame from a preprocessed directory, or parse from the raw files.
Parameters
----------
preprocess : bool, default True, Optional
Attempt to load from the preprocessed directory.
columns : list, default None, Optional
Load only this subset of columns
filter_dict : dict, default {}, Optional
Dictionary of format {"ColumnName":"ListofValues"} where "ColumnName" is a data column
and "ListofValues" is a sorted list of valid values. A DataFrame only containing rows that appear in
"ListofValues" will be returned.
duplicate_subset : list, default None, Optional
Drop any duplicate entries as specified by this subset of columns
duplicate_keep : str, default 'last', Optional
If duplicates are being dropped, keep the 'first' or 'last'
(see `pandas.DataFram.drop_duplicates <https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.drop_duplicates.html>`_)
dropna : list, default None, Optional
Drop any NaN entries as specified by this subset of columns
Returns
-------
DataFrame
FieldInformation DataFrame.
|
"""
if show_progress or self.show_progress:
show_progress='Loading Field Info'
if preprocess and os.path.exists(os.path.join(self.path2database, self.path2fieldinfo_df)):
return pd.read_hdf(os.path.join(self.path2database, self.path2fieldinfo_df, 'fieldinfo0.hdf'))
else:
return self.parse_fields()
def load_impact(self, preprocess = True, include_yearnormed = True, columns = None, filter_dict = {}, duplicate_subset = None,
duplicate_keep = 'last', dropna = None, prefunc2apply=None, postfunc2apply=None, show_progress=False):
"""
Load the precomputed impact DataFrame from a preprocessed directory.
Parameters
----------
preprocess : bool, default True
Attempt to load from the preprocessed directory.
include_yearnormed: bool, default True
Normalize all columns by yearly average.
columns : list, default None
Load only this subset of columns
filter_dict : dict, default {}, Optional
Dictionary of format {"ColumnName":"ListofValues"} where "ColumnName" is a data column
and "ListofValues" is a sorted list of valid values. A DataFrame only containing rows that appear in
"ListofValues" will be returned.
duplicate_subset : list, default None, Optional
Drop any duplicate entries as specified by this subset of columns
duplicate_keep : str, default 'last', Optional
If duplicates are being dropped, keep the 'first' or 'last'
(see `pandas.DataFram.drop_duplicates <https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.drop_duplicates.html>`_)
dropna : list, default None, Optional
Drop any NaN entries as specified by this subset of columns
Returns
-------
DataFrame
FieldInformation DataFrame.
|
"""
if show_progress or self.show_progress:
show_progress='Loading Impact'
if not self.global_filter is None:
if 'PublicationId' in filter_dict:
filter_dict['PublicationId'] = np.sort([pid for pid in filter_dict['PublicationId'] if pid in self.global_filter])
else:
filter_dict['PublicationId'] = np.sort(list(self.global_filter))
if include_yearnormed:
def normfunc(impactdf):
impactcolumns = [c for c in list(impactdf) if not c in ['PublicationId', 'Year']]
for c in impactcolumns:
impactdf[c+'_norm'] = impactdf[c]/impactdf[c].mean()
return impactdf
else:
def normfunc(impactdf):
return impactdf
if preprocess and os.path.exists(os.path.join(self.path2database, self.path2impact_df)):
return load_preprocessed_data(self.path2impact_df, path2database=self.path2database, columns=columns,
filter_dict=filter_dict, duplicate_subset=duplicate_subset, duplicate_keep=duplicate_keep, dropna=dropna,
prefunc2apply=normfunc, show_progress=show_progress)
else:
raise self.compute_impact()
"""
To be rewritten for each specific data source (MAG, WOS, etc.)
"""
def download_from_source(self):
raise NotImplementedError
def parse_affiliations(self, preprocess = False):
raise NotImplementedError
def parse_authors(self, preprocess = False, process_name = True, num_file_lines = 5*10**6):
raise NotImplementedError
def parse_publications(self, preprocess = False, num_file_lines=10**7):
raise NotImplementedError
def parse_references(self, preprocess = False, num_file_lines=10**7):
raise NotImplementedError
def parse_publicationauthoraffiliation(self, preprocess = False, num_file_lines=10**7):
raise NotImplementedError
def parse_fields(self, preprocess = False, num_file_lines=10**7):
raise NotImplementedError
def remove_selfcitations(self, preprocess=True, show_progress=False):
"""
Prcoess the pub2ref DataFrame and remove all citation relationships that share an Author.
Parameters
----------
preprocess : bool, default True, Optional
If True then the new preprocessed DataFrames are saved in pub2refnoself
Returns
-------
DataFrame
Pub2Ref DataFrame with 2 columns: 'CitingPublicationId', 'CitedPublicationId'
|
"""
if self.show_progress:
show_progress=True
if preprocess:
if not os.path.exists(os.path.join(self.path2database, 'pub2refnoself')):
os.mkdir(os.path.join(self.path2database, 'pub2refnoself'))
pub2authors = defaultdict(set)
for pid, aid in self.author2pub_df[['PublicationId', 'AuthorId']].values:
pub2authors[pid].add(aid)
fullrefdf = []
# loop through all pub2ref files
Nreffiles = sum('pub2ref' in fname for fname in os.listdir(os.path.join(self.path2database, 'pub2ref')))
for ifile in tqdm(range(Nreffiles), desc='Removing Self-citations', disable= not show_progress):
refdf = pd.read_hdf(os.path.join(self.path2database, 'pub2ref', 'pub2ref{}.hdf'.format(ifile)))
# get citing cited pairs with no common authors
noselfcite = np.array([len(pub2authors[citingpid] & pub2authors[citedpid]) == 0 for citingpid, citedpid in refdf.values])
# keep only citing-cited pairs without a common author
refdf = refdf.loc[noselfcite]
if preprocess:
refdf.to_hdf(os.path.join(self.path2database, 'pub2refnoself', 'pub2refnoself{}.hdf'.format(ifile)), key = 'pub2ref')
else:
fullrefdf.append(refdf)
if not preprocess:
return | pd.concat(fullrefdf) | pandas.concat |
from datetime import datetime, timedelta
import numpy as np
import pytest
import pytz
from pandas._libs.tslibs import iNaT
import pandas.compat as compat
from pandas import (
DatetimeIndex, Index, NaT, Period, Series, Timedelta, TimedeltaIndex,
Timestamp, isna)
from pandas.core.arrays import PeriodArray
from pandas.util import testing as tm
@pytest.mark.parametrize("nat,idx", [(Timestamp("NaT"), DatetimeIndex),
(Timedelta("NaT"), TimedeltaIndex),
( | Period("NaT", freq="M") | pandas.Period |
import numpy as np
import pandas as pd
import itertools
import tqdm
import more_itertools as mit
from operator import is_not
from functools import partial
def GetEdge(
df: pd.DataFrame,
start: int,
end: int,
radius: int,
parenthood: pd.DataFrame,
**kwargs,
):
"""
Extracts the edges from a windowed sequence of frames
Parameters
----------
df: pd.DataFrame
A dataframe containing the extracted node properties.
start: int
Start frame of the edge.
end: int
End frame of the edge.
radius: int
Search radius for the edge (pixel units).
parenthood: list
A list of parent-child relationships
between nodes.
Returns
-------
edges: pd.DataFrame
A dataframe containing the extracted
properties of the edges.
"""
# Add a column for the indexes of the nodes
df.loc[:, "index"] = df.index
# Filter the dataframe to only include the the
# frames, centroids, labels, and indexes
df = df.loc[(df["frame"] >= start) & (df["frame"] <= end)].filter(
regex="(frame|centroid|label|index)"
)
# Merge columns contaning the centroids into a single column of
# numpy arrays, i.e., centroid = [centroid_x, centroid_y,...]
df.loc[:, "centroid"] = df.filter(like="centroid").apply(np.array, axis=1)
# Add key column to the dataframe
df["key"] = 1
# Group the dataframe by frame
df = df.groupby(["frame"])
dfs = [_df for _, _df in df]
edges = []
for dfi, dfj in itertools.product(dfs[0:1], dfs[1:]):
# Merge the dataframes for frames i and j
combdf = | pd.merge(dfi, dfj, on="key") | pandas.merge |
import yaml
import typer
import pandas as pd
from glob import glob
from patentcity.relationship import RELATIONS
import os
app = typer.Typer()
@app.command()
def relationship_params(config_search: str):
"""Generate config files defined by `config_search` grid
Arguments:
config_search: config search file path
**Usage:**
```shell
patentcity search relationship-params configs/rel_search.yaml
``
"""
filename = os.path.basename(config_search)
path = os.path.dirname(config_search)
with open(config_search, "r") as config_file:
cfg = yaml.load(config_file, Loader=yaml.FullLoader)
search = cfg["search"]
base = cfg["base"]
for param in search.keys():
try:
start, end = list(map(lambda x: int(x), search[param].split("-")))
grid = range(start, end)
except ValueError:
grid = search[param].split("-")
for i, val in enumerate(grid):
for label in base.keys():
base[label].update({param: val})
with open(
os.path.join(path, filename.replace("search", str(i))), "w"
) as file:
yaml.dump(base, file)
typer.secho(f"config files saved in {path}", fg=typer.colors.BLUE)
@app.command()
def relationship_best(path: str, report: str = "short"):
"""Report perf of each (long)/best (short) config`
Arguments:
path: data file path (wildcard allowed)
report: report type (in ["short", "long"])
**Usage:**
```shell
patentcity eval relationship-model data/gold_rel_ddpatent01.jsonl rel_ddpatent01.yaml --report json
```
"""
files = glob(path)
assert report in ["short", "long"]
res = pd.DataFrame()
for file in files:
tmp = | pd.read_json(file) | pandas.read_json |
# -*- coding: utf-8 -*-
"""
Created on Mon Aug 31 14:51:24 2020
@author: <NAME>
"""
import os
import itertools
import json
import shutil
from datetime import datetime
import utils.support as sup
from operator import itemgetter
import numpy as np
import pandas as pd
import readers.log_splitter as ls
from extraction import log_replayer as rpl
from extraction import role_discovery as rl
from core_modules.times_allocator import embedding_trainer as em
from core_modules.times_allocator import times_model_optimizer as to
from core_modules.times_allocator import model_hpc_optimizer as hpc_op
from core_modules.times_allocator import intercase_features_calculator as it
from core_modules.times_allocator import times_predictor as tp
from sklearn.preprocessing import MaxAbsScaler
from pickle import dump
class TimesGenerator():
"""
This class evaluates the inter-arrival times
"""
def __init__(self, process_graph, log, parms):
"""constructor"""
self.log = log
self.process_graph = process_graph
self.parms = parms
self.one_timestamp = parms['read_options']['one_timestamp']
self.timeformat = parms['read_options']['timeformat']
self.model_metadata = dict()
self._load_model()
# =============================================================================
# Generate traces
# =============================================================================
def _load_model(self) -> None:
model_exist = True
model_path = self._define_model_path(self.parms)
# Save path(s) if the model exists
if isinstance(model_path, tuple):
self.proc_model_path = model_path[0]
self.wait_model_path = model_path[1]
model_exist = (
os.path.exists(model_path[0]) and os.path.exists(model_path[1]))
self.parms['proc_model_path'] = model_path[0]
self.parms['wait_model_path'] = model_path[1]
else:
self.model_path = model_path
model_exist = os.path.exists(model_path)
self.parms['model_path'] = model_path
# Discover and compare
if not model_exist or self.parms['update_times_gen']:
times_optimizer = self._discover_model()
save, metadata_file = self._compare_models(
times_optimizer.best_loss,
self.parms['update_times_gen'], model_path)
if save:
self._save_model(metadata_file, times_optimizer, model_path)
# Save basic features scaler
name = metadata_file.replace('_meta.json', '')
dump(self.scaler, open(name+'_scaler.pkl','wb'))
# clean output folder
shutil.rmtree(self.parms['output'])
def generate(self, sequences, iarr):
model_path = (self.model_path
if self.parms['model_type'] in ['basic', 'inter', 'inter_nt']
else (self.proc_model_path, self.wait_model_path))
predictor = tp.TimesPredictor(model_path,
self.parms,
sequences,
iarr)
return predictor.predict(self.parms['model_type'])
@staticmethod
def _define_model_path(parms):
path = parms['times_gen_path']
fname = parms['file'].split('.')[0]
inter = parms['model_type'] in ['inter', 'dual_inter', 'inter_nt']
is_dual = parms['model_type'] == 'dual_inter'
arpool = parms['all_r_pool']
next_ac = parms['model_type'] == 'inter_nt'
if inter:
if is_dual:
if arpool:
return (os.path.join(path, fname+'_dpiapr.h5'),
os.path.join(path, fname+'_dwiapr.h5'))
else:
return (os.path.join(path, fname+'_dpispr.h5'),
os.path.join(path, fname+'_dwispr.h5'))
else:
if next_ac:
if arpool:
return os.path.join(path, fname+'_inapr.h5')
else:
return os.path.join(path, fname+'_inspr.h5')
else:
if arpool:
return os.path.join(path, fname+'_iapr.h5')
else:
return os.path.join(path, fname+'_ispr.h5')
else:
return os.path.join(path, fname+'.h5')
def _compare_models(self, acc, model_exist, file):
if isinstance(file, tuple):
model = os.path.splitext(os.path.split(file[0])[1])[0]
model = (model.replace('dpiapr', 'diapr')
if self.parms['all_r_pool'] else
model.replace('dpispr', 'dispr'))
metadata_file = os.path.join(self.parms['times_gen_path'],
model+'_meta.json')
else:
model = os.path.splitext(os.path.split(file)[1])[0]
metadata_file = os.path.join(self.parms['times_gen_path'],
model+'_meta.json')
# compare with existing model
save = True
if model_exist:
# Loading of parameters from existing model
if os.path.exists(metadata_file):
with open(metadata_file) as file:
data = json.load(file)
if data['loss'] < acc:
save = False
return save, metadata_file
def _save_model(self, metadata_file, times_optimizer, model_path):
model_metadata = dict()
# best structure mining parameters
model_metadata['loss'] = times_optimizer.best_loss
model_metadata['generated_at'] = (
datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
model_metadata['ac_index'] = self.ac_index
model_metadata['usr_index'] = self.usr_index
model_metadata['log_size'] = len(pd.DataFrame(self.log).caseid.unique())
model_metadata = {**model_metadata,
**times_optimizer.best_parms}
model_name = metadata_file.replace('_meta.json', '')
if self.parms['model_type'] in ['inter', 'dual_inter', 'inter_nt']:
model_metadata['roles'] = self.roles
model_metadata['roles_table'] = self.roles_table.to_dict('records')
model_metadata['inter_mean_states'] = self.mean_states
# Save intecase scalers
dump(self.inter_scaler, open(model_name+'_inter_scaler.pkl', 'wb'))
if self.parms['model_type'] == 'dual_inter':
dump(self.end_inter_scaler,
open(model_name+'_end_inter_scaler.pkl', 'wb'))
# Save models
if isinstance(model_path, tuple):
shutil.copyfile(os.path.join(times_optimizer.best_output,
os.path.split(model_path[0])[1]),
self.proc_model_path)
shutil.copyfile(os.path.join(times_optimizer.best_output,
os.path.split(model_path[1])[1]),
self.wait_model_path)
else:
# Copy best model to destination folder
source = os.path.join(times_optimizer.best_output,
self.parms['file'].split('.')[0]+'.h5')
shutil.copyfile(source, self.model_path)
# Save metadata
sup.create_json(model_metadata, metadata_file)
# =============================================================================
# Train model
# =============================================================================
def _discover_model(self, **kwargs):
# indexes creation
self.ac_index, self.index_ac = self._indexing(self.log.data, 'task')
self.usr_index, self.index_usr = self._indexing(self.log.data, 'user')
# replay
self._replay_process()
if self.parms['model_type'] in ['inter', 'dual_inter', 'inter_nt']:
self._add_intercases()
self._split_timeline(0.8, self.one_timestamp)
self.log_train = self._add_calculated_times(self.log_train)
self.log_valdn = self._add_calculated_times(self.log_valdn)
# Add index to the event log
ac_idx = lambda x: self.ac_index[x['task']]
self.log_train['ac_index'] = self.log_train.apply(ac_idx, axis=1)
self.log_valdn['ac_index'] = self.log_valdn.apply(ac_idx, axis=1)
if self.parms['model_type'] in ['inter_nt', 'dual_inter']:
ac_idx = lambda x: self.ac_index[x['n_task']]
self.log_train['n_ac_index'] = self.log_train.apply(ac_idx, axis=1)
self.log_valdn['n_ac_index'] = self.log_valdn.apply(ac_idx, axis=1)
# Load embedding matrixes
emb_trainer = em.EmbeddingTrainer(self.parms,
pd.DataFrame(self.log),
self.ac_index,
self.index_ac,
self.usr_index,
self.index_usr)
self.ac_weights = emb_trainer.load_embbedings()
# Scale features
self._transform_features()
# Optimizer
self.parms['output'] = os.path.join('output_files', sup.folder_id())
if self.parms['opt_method'] == 'rand_hpc':
times_optimizer = hpc_op.ModelHPCOptimizer(self.parms,
self.log_train,
self.log_valdn,
self.ac_index,
self.ac_weights)
times_optimizer.execute_trials()
elif self.parms['opt_method'] == 'bayesian':
times_optimizer = to.TimesModelOptimizer(self.parms,
self.log_train,
self.log_valdn,
self.ac_index,
self.ac_weights)
times_optimizer.execute_trials()
return times_optimizer
# =============================================================================
# Support modules
# =============================================================================
def _replay_process(self) -> None:
"""
Process replaying
"""
replayer = rpl.LogReplayer(self.process_graph,
self.log.get_traces(),
self.parms,
msg='reading conformant training traces:')
self.log = replayer.process_stats.rename(columns={'resource':'user'})
self.log['user'] = self.log['user'].fillna('sys')
self.log = self.log.to_dict('records')
@staticmethod
def _indexing(log, feat):
log = | pd.DataFrame(log) | pandas.DataFrame |
# Copyright (c) 2018-2021, NVIDIA CORPORATION.
import array as arr
import datetime
import io
import operator
import random
import re
import string
import textwrap
from copy import copy
import cupy
import numpy as np
import pandas as pd
import pyarrow as pa
import pytest
from numba import cuda
import cudf
from cudf.core._compat import PANDAS_GE_110, PANDAS_GE_120
from cudf.core.column import column
from cudf.tests import utils
from cudf.tests.utils import (
ALL_TYPES,
DATETIME_TYPES,
NUMERIC_TYPES,
assert_eq,
assert_exceptions_equal,
does_not_raise,
gen_rand,
)
def test_init_via_list_of_tuples():
data = [
(5, "cats", "jump", np.nan),
(2, "dogs", "dig", 7.5),
(3, "cows", "moo", -2.1, "occasionally"),
]
pdf = pd.DataFrame(data)
gdf = cudf.DataFrame(data)
assert_eq(pdf, gdf)
def _dataframe_na_data():
return [
pd.DataFrame(
{
"a": [0, 1, 2, np.nan, 4, None, 6],
"b": [np.nan, None, "u", "h", "d", "a", "m"],
},
index=["q", "w", "e", "r", "t", "y", "u"],
),
pd.DataFrame({"a": [0, 1, 2, 3, 4], "b": ["a", "b", "u", "h", "d"]}),
pd.DataFrame(
{
"a": [None, None, np.nan, None],
"b": [np.nan, None, np.nan, None],
}
),
pd.DataFrame({"a": []}),
pd.DataFrame({"a": [np.nan], "b": [None]}),
pd.DataFrame({"a": ["a", "b", "c", None, "e"]}),
pd.DataFrame({"a": ["a", "b", "c", "d", "e"]}),
]
@pytest.mark.parametrize("rows", [0, 1, 2, 100])
def test_init_via_list_of_empty_tuples(rows):
data = [()] * rows
pdf = pd.DataFrame(data)
gdf = cudf.DataFrame(data)
assert_eq(
pdf,
gdf,
check_like=True,
check_column_type=False,
check_index_type=False,
)
@pytest.mark.parametrize(
"dict_of_series",
[
{"a": pd.Series([1.0, 2.0, 3.0])},
{"a": pd.Series([1.0, 2.0, 3.0], index=[4, 5, 6])},
{
"a": pd.Series([1.0, 2.0, 3.0], index=[4, 5, 6]),
"b": pd.Series([1.0, 2.0, 4.0], index=[1, 2, 3]),
},
{"a": [1, 2, 3], "b": pd.Series([1.0, 2.0, 3.0], index=[4, 5, 6])},
{
"a": pd.Series([1.0, 2.0, 3.0], index=["a", "b", "c"]),
"b": pd.Series([1.0, 2.0, 4.0], index=["c", "d", "e"]),
},
{
"a": pd.Series(
["a", "b", "c"],
index=pd.MultiIndex.from_tuples([(1, 2), (1, 3), (2, 3)]),
),
"b": pd.Series(
["a", " b", "d"],
index=pd.MultiIndex.from_tuples([(1, 2), (1, 3), (2, 3)]),
),
},
],
)
def test_init_from_series_align(dict_of_series):
pdf = pd.DataFrame(dict_of_series)
gdf = cudf.DataFrame(dict_of_series)
assert_eq(pdf, gdf)
for key in dict_of_series:
if isinstance(dict_of_series[key], pd.Series):
dict_of_series[key] = cudf.Series(dict_of_series[key])
gdf = cudf.DataFrame(dict_of_series)
assert_eq(pdf, gdf)
@pytest.mark.parametrize(
("dict_of_series", "expectation"),
[
(
{
"a": pd.Series(["a", "b", "c"], index=[4, 4, 5]),
"b": pd.Series(["a", "b", "c"], index=[4, 5, 6]),
},
pytest.raises(
ValueError, match="Cannot align indices with non-unique values"
),
),
(
{
"a": pd.Series(["a", "b", "c"], index=[4, 4, 5]),
"b": pd.Series(["a", "b", "c"], index=[4, 4, 5]),
},
does_not_raise(),
),
],
)
def test_init_from_series_align_nonunique(dict_of_series, expectation):
with expectation:
gdf = cudf.DataFrame(dict_of_series)
if expectation == does_not_raise():
pdf = pd.DataFrame(dict_of_series)
assert_eq(pdf, gdf)
def test_init_unaligned_with_index():
pdf = pd.DataFrame(
{
"a": pd.Series([1.0, 2.0, 3.0], index=[4, 5, 6]),
"b": | pd.Series([1.0, 2.0, 3.0], index=[1, 2, 3]) | pandas.Series |
# encoding: utf-8
# ---------------------------------------------------------------------------
# Copyright (C) 2008-2014, IPython Development Team and Enthought, Inc.
# Distributed under the terms of the BSD License. See COPYING.rst.
# ---------------------------------------------------------------------------
"""
Plot the results of the Julia set timings.
"""
from __future__ import print_function, division
import sys
import numpy
import pandas as pd
import matplotlib
from matplotlib import pyplot
from distarray.externals.six import next
# tweak plot styling
CBcdict = {
'Bl': (0, 0, 0),
'Or': (.9, .6, 0),
'SB': (.35, .7, .9),
'bG': (0, .6, .5),
# 'Ye': (.95, .9, .25),
'Bu': (0, .45, .7),
'Ve': (.8, .4, 0),
'rP': (.8, .6, .7),
}
matplotlib.rcParams['axes.color_cycle'] = [CBcdict[c] for c in
sorted(CBcdict.keys())]
matplotlib.rcParams['lines.linewidth'] = 2
matplotlib.rcParams['lines.linewidth'] = 2
matplotlib.rcParams['lines.markersize'] = 13
matplotlib.rcParams['font.size'] = 20
matplotlib.rcParams['grid.alpha'] = 0.5
STYLES = ('o-', 'x-', 'v-', '*-', 's-', 'd-')
def read_results(filename):
"""Read the Julia Set timing results from the file.
Parse into a pandas dataframe.
"""
def date_parser(c):
return pd.to_datetime(c, unit='s')
df = | pd.read_json(filename, convert_dates=['Start', 'End'], date_unit='s') | pandas.read_json |
import os
import numpy as np
import pandas as pd
from collections import OrderedDict
def read_ephys_info_from_excel_2017(excel_file, skiprows_animal=1, skiprows_cell=5):
# read Ex and In solutions from the first two lines
excelname = os.path.basename(excel_file)
excelname = os.path.splitext(excelname)[0]
animal_info = pd.read_excel(excel_file, header=0, skiprows=skiprows_animal)[:1]
animal_info = animal_info[[x for x in animal_info.columns if not 'Unnamed' in x]]
animal_info.columns = animal_info.columns.str.strip()
animal_info['excelname'] = excelname
metadata = pd.read_excel(excel_file, skiprows=skiprows_cell).dropna(how='all')
metadata = metadata[[x for x in metadata.columns if not 'Unnamed' in x]]
metadata['cell'] = metadata['cell'].fillna(method='ffill')
if metadata['cell'].dtype == 'float':
metadata['cell'] = metadata['cell'].astype('int').astype('str')
metadata.columns = metadata.columns.str.strip()
metadata['excelname'] = excelname
return animal_info.loc[0], metadata
def parse_cell_info_2017_vertical(metadata, params='params', value='value'):
cell_info = metadata.loc[:,'cell':value].dropna(subset=[params])
cell_info = cell_info.pivot(index='cell', columns = params, values = value).reset_index()
cell_info['excelname'] = metadata['excelname'][0]
return cell_info
def parse_cell_info_2017(metadata, left='cell', right='fill'):
cell_info = metadata.loc[:,left:right].dropna(subset=['cell'])
cell_info = cell_info.drop_duplicates(subset=['cell'], keep='first')
cell_info['excelname'] = metadata['excelname'][0]
return cell_info
def parse_patch_info_2017(metadata):
cell_ids = metadata.loc[:,['cell','file']].dropna(subset=['file'])
patch_info = metadata.loc[:,'file':].dropna(subset=['file', 'protocol'])
patch_info = | pd.merge(cell_ids,patch_info, on='file') | pandas.merge |
from collections import OrderedDict
from typing import List
from pandas import DataFrame, Series, merge, concat, Index
from norm.executable import NormError
from norm.executable.constant import ListConstant, Constant, TupleConstant
from norm.executable.expression import NormExpression
from norm.executable.expression.condition import ConditionExpr, CombinedConditionExpr
from norm.executable.expression.evaluation import AddDataEvaluationExpr, DataFrameColumnFunctionExpr
from norm.grammar.literals import LOP
import logging
logger = logging.getLogger(__name__)
CROSS_JOIN_KEY = '__key__'
class QueryExpr(NormExpression):
def __init__(self, op, expr1, expr2):
"""
Query expression
:param op: logical operation, e.g., [&, |, ^, =>, <=>]
:type op: LOP
:param expr1: left expression
:type expr1: NormExpression
:param expr2: right expression
:type expr2: NormExpression
"""
super().__init__()
self.op = op
self.expr1 = expr1
self.expr2 = expr2
self.cross_join = False
self.common_columns = []
def __combine_value(self, value1, value2):
if value1 is None or value2 is None:
return None
elif isinstance(value1, ListConstant) and isinstance(value2, ListConstant):
value1.value.extend(value2.value)
return value1
elif isinstance(value1, ListConstant) and isinstance(value2, Constant):
value1.value.append(value2.value)
return value1
elif isinstance(value1, Constant) and isinstance(value2, ListConstant):
value2.value.append(value1.value)
return value2
elif isinstance(value1, Constant) and isinstance(value2, Constant):
return ListConstant(value1.type_, [value1.value, value2.value])
elif isinstance(value1, list) and isinstance(value2, list):
value1.extend(value2)
return value1
elif isinstance(value1, list) and not isinstance(value2, list):
value1.append(value2)
return value1
elif not isinstance(value1, list) and isinstance(value2, list):
value2.append(value1)
return value2
elif isinstance(value1, AddDataEvaluationExpr) and isinstance(value2, AddDataEvaluationExpr):
# pushdown the combine operation
if value1.lam is value2.lam:
combined = self.__combine_data(value1.data, value2.data)
if combined is not None:
value1.data = combined
return value1
elif not isinstance(value1, list) and not isinstance(value2, list):
return [value1, value2]
return None
def __combine_data(self, data1, data2):
cols = list(data1.keys())
cols.extend(col for col in data2.keys() if col not in data1.keys())
data = OrderedDict()
for col in cols:
combined = self.__combine_value(data1.get(col), data2.get(col))
if combined is None:
return None
else:
data[col] = combined
return data
def __same_origin(self):
"""
Decide whether two expressions come from the same origin Lambda. Check the transformation path between two
expressions. If there is a node that overlaps, the two expressions have the same origin.
:return: True if they are
:rtype: bool
"""
if self.expr1.eval_lam is self.expr2.eval_lam:
return True
if self.expr1.eval_lam.cloned_from is self.expr2.eval_lam.cloned_from:
return True
if self.expr1.lam is self.expr2.eval_lam:
return True
if self.expr1.lam is self.expr2.scope:
return True
def compile(self, context):
if isinstance(self.expr1, AddDataEvaluationExpr) and isinstance(self.expr2, AddDataEvaluationExpr)\
and self.expr1.lam is self.expr2.lam:
# Combine the constant arguments for adding data
# ensure that all arguments are constants
combined = self.__combine_data(self.expr1.data, self.expr2.data)
if combined is not None:
self.expr1.data = combined
return self.expr1
if isinstance(self.expr1, ConditionExpr) and isinstance(self.expr2, ConditionExpr) and \
(self.expr1.eval_lam is self.expr2.eval_lam or self.expr1.eval_lam is self.expr2.eval_lam.cloned_from):
return CombinedConditionExpr(self.op, self.expr1, self.expr2).compile(context)
self.lam = context.temp_lambda(self.expr1.lam.variables +
[v for v in self.expr2.lam.variables if v.name not in self.expr1.lam])
self.eval_lam = self.expr1.eval_lam
from norm.executable.schema.variable import VariableName
if isinstance(self.expr2, VariableName) and not isinstance(self.expr1, VariableName):
self.common_columns = [self.expr2.name] if self.expr2.name in self.expr1.lam else []
elif not isinstance(self.expr2, VariableName) and isinstance(self.expr1, VariableName):
self.common_columns = [self.expr1.name] if self.expr1.name in self.expr2.lam else []
elif isinstance(self.expr2, VariableName) and isinstance(self.expr1, VariableName):
self.common_columns = [self.expr1.name] if self.expr1.name == self.expr2.name else []
else:
self.common_columns = [v.name for v in self.expr1.lam.variables if v.name in self.expr2.lam]
self.cross_join = not self.__same_origin() and len(self.common_columns) == 0
return self
def execute(self, context):
df1 = self.expr1.execute(context)
if isinstance(df1, Series):
df1 = DataFrame(data={df1.name: df1})
df2 = self.expr2.execute(context)
if isinstance(df2, Series):
df2 = DataFrame(data={df2.name: df2})
# TODO: OR to union
from norm.models.norm import Lambda
if self.op == LOP.AND:
# both indices are the same, left join to df2
# if not, cross join df1 and df2
if self.cross_join:
# TODO: check the logic
df1[CROSS_JOIN_KEY] = 1
df2[CROSS_JOIN_KEY] = 1
if df1.index.name is not None:
df1 = df1.reset_index()
if df2.index.name is not None:
df2 = df2.reset_index()
cols = [col for col in df1.columns if col not in df2.columns]
df2 = merge([df2, df1[cols]]).drop(columns=[CROSS_JOIN_KEY])
else:
if len(self.common_columns) == 0:
cols = [col for col in df1.columns if col not in df2.columns]
if len(cols) > 0:
df2[cols] = df1.loc[df2.index, cols]
else:
# preserve df1 index if available
if isinstance(df1, Index):
df1 = self.expr1.lam.data.loc[df1]
if isinstance(df2, Index):
df2 = self.expr2.lam.data.loc[df2, [v.name for v in self.expr2.lam.variables]]
if df1.index.name == self.lam.VAR_OID:
df1 = df1.reset_index()
for col in self.common_columns:
if df1[col].dtype != df2[col].dtype:
df2[col] = df2[col].astype(df1[col].dtype)
df2 = merge(df1, df2, on=self.common_columns).dropna()
if self.lam.VAR_OID in df2.columns:
df2 = df2.set_index(self.lam.VAR_OID)
elif self.op == LOP.OR:
if len(self.common_columns) > 0:
df2 = merge(df1, df2, on=self.common_columns, how='outer')
else:
df2 = concat([df1, df2])
if df2.index.name != Lambda.VAR_OID and df2.index.name is not None:
df2 = df2.reset_index()
self.lam.data = df2
return df2
class ConstantAssignmentExpr(NormExpression):
def __init__(self, constant, projection=None):
"""
Assign constant to a variable and join with the current scope
:param constant: the constant to assign
:type constant: Constant
:param projection: the variable to project to
:type projection: Projection
"""
super().__init__()
from norm.executable import Projection
self.constant: Constant = constant
self.projection: Projection = projection
self.variable_name: str = None
@property
def var_type(self):
from norm.models import lambdas
return lambdas[self.constant.type_.value.title()]
def compile(self, context):
assert(self.projection is not None)
if len(self.projection.variables) > 1:
return MultipleConstantAssignmentExpr(self.constant, self.projection).compile(context)
from norm.models.norm import Variable
self.variable_name = self.projection.variables[0].name
if context.scope is not None:
self.eval_lam = context.scope
variables = self.eval_lam.variables
self.lam = context.temp_lambda(variables + [Variable(self.variable_name, self.var_type)])
else:
self.eval_lam = None
self.lam = context.temp_lambda([Variable(self.variable_name, self.var_type)])
return self
def execute(self, context):
if not isinstance(self.constant, ListConstant):
if self.eval_lam is not None:
df = self.eval_lam.data
df[self.variable_name] = self.constant.value
else:
df = DataFrame(data={self.variable_name: [self.constant.value]})
else:
if self.eval_lam is not None:
df = self.eval_lam.data
if self.variable_name not in df.columns:
df[CROSS_JOIN_KEY] = 1
to_join = DataFrame({self.variable_name: self.constant.value})
to_join[CROSS_JOIN_KEY] = 1
df = df.merge(to_join, on=CROSS_JOIN_KEY, how='outer').drop(columns=[CROSS_JOIN_KEY])
else:
assert(len(df) == len(self.constant.value))
df[self.variable_name] = self.constant.value
else:
df = DataFrame(data={self.variable_name: self.constant.value})
self.lam.data = df
return df
class MultipleConstantAssignmentExpr(NormExpression):
def __init__(self, constant, projection):
"""
Assign constant to a variable and join with the current scope
:param constant: the constant to assign
:type constant: Constant
:param projection: the variables to project to
:type projection: Projection
"""
super().__init__()
from norm.executable import Projection
self.constant: Constant = constant
self.projection: Projection = projection
@property
def var_names(self):
return [v.name for v in self.projection.variables]
@property
def var_types(self):
from norm.models import lambdas
return [lambdas[t.value.title()] for t in self.constant.type_]
def compile(self, context):
assert(isinstance(self.constant, ListConstant))
assert(isinstance(self.constant.value[0], tuple))
assert(len(self.var_names) == len(self.var_types))
assert(self.eval_lam is None or all(vn not in self.eval_lam for vn in self.var_names))
from norm.models.norm import Variable
vs = [Variable(n, t) for n, t in zip(self.var_names, self.var_types)]
if context.scope is not None:
self.eval_lam = context.scope
variables = self.eval_lam.variables
self.lam = context.temp_lambda(variables + vs)
else:
self.eval_lam = None
self.lam = context.temp_lambda(vs)
return self
def execute(self, context):
if self.eval_lam is not None:
df = self.eval_lam.data
if any(vn in df.columns for vn in self.var_names):
assert(len(df) == len(self.constant.value))
df[self.var_names] = self.constant.value
else:
df[CROSS_JOIN_KEY] = 1
to_join = DataFrame(data=self.constant.value,
columns=self.var_names)
to_join[CROSS_JOIN_KEY] = 1
df = df.merge(to_join, on=CROSS_JOIN_KEY, how='outer').drop(columns=[CROSS_JOIN_KEY])
else:
df = | DataFrame(data=self.constant.value, columns=self.var_names) | pandas.DataFrame |
"""
TimesheetManager class
Creates a Pandas dataframe that records time worked on various user specified tasks.
Connects to a user interface for ease of use.
@author: <NAME>
"""
import sys
import pandas as pd
import pendulum, time, pickle, os
from shutil import copyfile
from os.path import join as pathjoin
from user_interface import UserInterface
from utilities.time_utils import Converter, TimeCalculator
from utilities.utils import get_current_week_days, generate_day_dict
VERSION = "3.0.1"
CONFIG_PATH = ".config"
STATE_PATH = "."
# TODO: Feature idea if a task is no longer used, can export the times to the baseline then delete it from the task list
# TODO: Feature idea: export formatted reports (maybe csvs that are human readable) (does go against privacy principle
# TODO: though
def clear():
"""
Global function that clears the command line
"""
os.system('cls' if os.name == 'nt' else 'clear')
class TimesheetManager:
def __init__(self, name=None, path=os.getcwd()):
self.__version__ = VERSION
self.path = pathjoin(path, "timesheets")
os.makedirs(self.path, exist_ok=True)
os.makedirs(CONFIG_PATH, exist_ok=True)
if "config.data" not in os.listdir(CONFIG_PATH):
self.create_config()
default, tz = self.load_config()
self.tz = tz
if name is None:
if default != "":
name = default
else:
clear()
print("[SETUP] There is no default Timesheet set. A temporary Timesheet will be created.")
print("\nIf you have not yet created a timesheet, or need to set your default timesheet,")
print("please do so in the 'Timesheet Management' menu.")
_ = input("\nPress ENTER to continue...")
name = "TEMPORARY"
self.name = name
self.today = pendulum.today(tz=self.tz)
new = False
loaded = self.load_timesheet(self.name)
if not loaded:
clear()
print("[SETUP] The current default Timesheet does not exist.\nA temporary Timesheet will be created.")
print("\nPlease change your default timesheet in the 'Timesheet Management' menu.")
_ = input("\nPress ENTER to continue...")
name = "TEMPORARY"
new = True
self.tasks = None
self.data = | pd.DataFrame(index=self.tasks) | pandas.DataFrame |
# AUTOGENERATED! DO NOT EDIT! File to edit: nbs/10_shared.ipynb (unless otherwise specified).
__all__ = ['load_standard_holidays', 'cov2corr', 'load_sales_example', 'load_sales_example2',
'load_dcmm_latent_factor_example', 'load_dbcm_latent_factor_example', 'load_dlmm_example',
'load_us_inflation', 'load_us_inflation_forecasts']
# Internal Cell
#exporti
import numpy as np
import pandas as pd
import scipy as sc
import pickle
from scipy.special import digamma
from pandas.tseries.holiday import AbstractHolidayCalendar, USMartinLutherKingJr, USMemorialDay, Holiday, USLaborDay, \
USThanksgivingDay
import os
import pickle
import zlib
# Internal Cell
def load_interpolators():
pkg_data_dir = os.path.dirname(os.path.abspath(__file__)) + '/pkg_data'
#pkg_data_dir = os.getcwd().split('pybats')[0] + 'pybats/pybats/pkg_data'
#pkg_data_dir = globals()['_dh'][0] + '/pkg_data'
try:
with open(pkg_data_dir + '/interp_beta.pickle.gzip', 'rb') as fl:
interp_beta = pickle.loads(zlib.decompress(fl.read()))
with open(pkg_data_dir + '/interp_gamma.pickle.gzip', 'rb') as fl:
interp_gamma = pickle.loads(zlib.decompress(fl.read()))
except:
print('WARNING: Unable to load interpolator. Code will run slower.')
interp_beta, interp_gamma = None, None
return interp_beta, interp_gamma
# Internal Cell
# I need this helper in a module file for pickle reasons ...
def transformer(ft, qt, fn1, fn2):
return np.exp(np.ravel(fn1(ft, np.sqrt(qt), grid=False))), \
np.exp(np.ravel(fn2(ft, np.sqrt(qt), grid=False)))
# Internal Cell
def gamma_transformer(ft, qt, fn):
alpha = np.ravel(np.exp(fn(np.sqrt(qt))))
beta = np.exp(digamma(alpha) - ft)
return alpha, beta
# Internal Cell
def trigamma(x):
return sc.special.polygamma(x=x, n=1)
# Internal Cell
def save(obj, filename):
with open(filename, "wb") as file:
pickle.dump(obj, file=file)
# Internal Cell
def load(filename):
with open(filename, "rb") as file:
tmp = pickle.load(file)
return tmp
# Internal Cell
def define_holiday_regressors(X, dates, holidays=None):
"""
Add columns to the predictor matrix X for a specified list of holidays
:param X: (Array) Predictor matrix without columns for the holidays
:param dates: Dates
:param holidays: (List) holidays
:return: Updated predictor matrix
"""
if holidays is not None:
if len(holidays) > 0:
if X is None:
n = len(dates)
else:
n = X.shape[0]
for holiday in holidays:
cal = AbstractHolidayCalendar()
cal.rules = [holiday]
x = np.zeros(n)
x[dates.isin(cal.holidays())] = 1
if X is None:
X = x
else:
X = np.c_[X, x]
return X
else:
return X
else:
return X
# Cell
def load_standard_holidays():
"""
Load in a list of standard holidays
"""
holidays = [USMartinLutherKingJr,
USMemorialDay,
Holiday('July4', month=7, day=4),
USLaborDay,
# Holiday('Thanksgiving_1DB', month=11, day=1, offset=pd.DateOffset(weekday=WE(4))),
USThanksgivingDay,
# Holiday('Christmas_1DB', month=12, day=24),
Holiday('Christmas', month=12, day=25),
Holiday('New_Years_Eve', month=12, day=31),
]
return holidays
# Cell
def cov2corr(cov):
"""
Transform a covariance matrix into a correlation matrix. Useful for understanding coefficient correlations
"""
D = np.sqrt(cov.diagonal()).reshape(-1, 1)
return cov / D / D.T
# Cell
def load_sales_example():
"""
Read data for the first sales forecasting example
"""
data_dir = os.path.dirname(os.path.abspath(__file__)) + '/pkg_data/'
return pd.read_csv(data_dir + 'sales.csv', index_col=0)[['Sales', 'Advertising']]
# Cell
def load_sales_example2():
"""
Read data for the second sales forecasting example
"""
data_dir = os.path.dirname(os.path.abspath(__file__)) + '/pkg_data/'
data = pd.read_pickle(data_dir + 'sim_sales_data')
data = data.set_index('Date')
return data
# Cell
def load_dcmm_latent_factor_example():
"""
Read data for the DCMM latent factor example
"""
data_dir = os.path.dirname(os.path.abspath(__file__)) + '/pkg_data/'
data = load(data_dir + 'dcmm_latent_factor_data')
return data
# Cell
def load_dbcm_latent_factor_example():
"""
Read data for the DBCM latent factor example
"""
data_dir = os.path.dirname(os.path.abspath(__file__)) + '/pkg_data/'
data = load(data_dir + 'dbcm_latent_factor_data')
return data
# Cell
def load_dlmm_example():
"""
Read data for the DBCM latent factor example
"""
data_dir = os.path.dirname(os.path.abspath(__file__)) + '/pkg_data/'
data = pd.read_csv(data_dir + 'dlmm_example_data.csv')
data.DATE = pd.to_datetime(data.DATE)
data = data.set_index('DATE')
return data
# Cell
def load_us_inflation():
"""
Read in quarterly US inflation data
"""
data_dir = os.path.dirname(os.path.abspath(__file__)) + '/pkg_data/'
data = pd.read_csv(data_dir + 'us_inflation.csv')
return data
# Cell
def load_us_inflation_forecasts():
"""
Read in quarterly US inflation data along with forecasts from 4 models
"""
data_dir = os.path.dirname(os.path.abspath(__file__)) + '/pkg_data/'
data = pd.read_csv(data_dir + 'bps_inflation.csv')
dates = data.values[:,0]
agent_mean = | pd.read_csv(data_dir + 'bps_agent_mean.csv') | pandas.read_csv |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Oct 10 13:19:04 2019
@author: yujijun
"""
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.ticker import (AutoMinorLocator, MultipleLocator)
import pyBigWig
import collections
import scipy.stats as ss
# input index and sample name information
basic_path = "/Users/yujijun/Documents/01-Work/02-HiglassProject/03-interpret/Output/index_info" #
index_name = "Blood_index.txt"
info_name = "Blood_info.txt"
blood_index = pd.read_csv("%s/%s" %(basic_path,index_name),sep='\t',header=None,index_col=None)
blood_info = pd.read_csv("%s/%s" %(basic_path,info_name),sep='\t',header=None,index_col=None)
data = {"index":blood_index.iloc[:,0],"info":blood_info.iloc[:,0]}
df = | pd.DataFrame(data) | pandas.DataFrame |
# %%
import pandas as pd
import glob
import json
import numpy
import matplotlib.pyplot as plt
import seaborn as sns
from scipy import stats
from tqdm import tqdm
from utils import PATH_TO_DATASET
from nltk.tokenize import word_tokenize
from matplotlib.ticker import AutoMinorLocator
# %%
data = | pd.read_csv("results_within_datasets.csv") | pandas.read_csv |
"""GET API endpoints for hicognition"""
import json
import gzip
import pandas as pd
import numpy as np
from flask import g, make_response
from flask.json import jsonify
from flask.globals import current_app
from hicognition import data_structures
from hicognition.utils import (
update_processing_state,
flatten_and_clean_array,
)
from . import api
from .. import db
from ..models import (
BedFileMetadata,
Intervals,
Dataset,
AverageIntervalData,
IndividualIntervalData,
AssociationIntervalData,
EmbeddingIntervalData,
Session,
Collection,
Organism,
)
from .authentication import auth
from .errors import forbidden, not_found, invalid
@api.route("/test", methods=["GET"])
def test():
"""test api calls"""
return jsonify({"test": "Hello, world!"})
@api.route("/testProtected", methods=["GET"])
@auth.login_required
def test_protected():
"""test api calls"""
return jsonify({"test": "Hello, world!"})
@api.route("/resolutions/", methods=["GET"])
@auth.login_required
def get_resolutions():
"""Gets available combinations of windowsizes and binsizes
from config file"""
return jsonify(current_app.config["PREPROCESSING_MAP"])
@api.route("/datasetMetadataMapping/", methods=["get"])
@auth.login_required
def get_metadata_mapping():
"""Get route for metadata mapping"""
return jsonify(current_app.config["DATASET_OPTION_MAPPING"])
@api.route("/organisms/", methods=["GET"])
@auth.login_required
def get_organisms():
"""Get route for available organisms"""
return jsonify([org.to_json() for org in Organism.query.all()])
@api.route("/assemblies/", methods=["GET"])
@auth.login_required
def get_assemblies():
"""Gets all assemblies in the database."""
output = {}
for organism in Organism.query.all():
temp_list = []
for assembly in organism.assemblies.all():
temp_dict = assembly.to_json()
temp_dict["dependent_datasets"] = len(
Dataset.query.filter(Dataset.assembly == assembly.id).all()
)
temp_list.append(temp_dict)
output[organism.name] = temp_list
return output
@api.route("/datasets/", methods=["GET"])
@auth.login_required
def get_all_datasets():
"""Gets all available datasets for a given user."""
all_available_datasets = Dataset.query.filter(
(Dataset.user_id == g.current_user.id)
| (Dataset.public)
| (Dataset.id.in_(g.session_datasets))
| current_app.config["SHOWCASE"]
).all()
return jsonify([dfile.to_json() for dfile in all_available_datasets])
@api.route("/datasets/<dtype>", methods=["GET"])
@auth.login_required
def get_datasets(dtype):
"""Gets all available datasets for a given user."""
if dtype == "cooler":
cooler_files = Dataset.query.filter(
(Dataset.filetype == "cooler")
& ((g.current_user.id == Dataset.user_id) | (Dataset.public))
).all()
update_processing_state(cooler_files, db)
return jsonify([cfile.to_json() for cfile in cooler_files])
if dtype == "bed":
bed_files = Dataset.query.filter(
(Dataset.filetype == "bedfile")
& ((g.current_user.id == Dataset.user_id) | (Dataset.public))
).all()
update_processing_state(bed_files, db)
return jsonify([bfile.to_json() for bfile in bed_files])
if dtype == "bigwig":
bed_files = Dataset.query.filter(
(Dataset.filetype == "bigwig")
& ((g.current_user.id == Dataset.user_id) | (Dataset.public))
).all()
update_processing_state(bed_files, db)
return jsonify([bfile.to_json() for bfile in bed_files])
return not_found(f"option: '{dtype}' not understood")
@api.route("/datasets/<dataset_id>/name/", methods=["GET"])
@auth.login_required
def get_name_of_dataset(dataset_id):
"""Returns the name for a given dataset, if the user owns the requested dataset."""
dataset = Dataset.query.get(dataset_id)
# check whether dataset exists
if dataset is None:
return not_found(f"Dataset with id '{dataset_id}' does not exist!")
# check whether user owns the dataset
if dataset.is_access_denied(g):
return forbidden(
f"Dataset with id '{dataset_id}' is not owned by logged in user!"
)
return jsonify(dataset.dataset_name)
@api.route("/datasets/<dataset_id>/bedFile/", methods=["GET"])
@auth.login_required
def get_dataset_file(dataset_id):
"""Returns the bedFile associate with a region dataset"""
dataset = Dataset.query.get(dataset_id)
# check whether dataset exists
if dataset is None:
return not_found(f"Dataset with id '{dataset_id}' does not exist!")
# check whether user owns the dataset
if dataset.is_access_denied(g):
return forbidden(
f"Dataset with id '{dataset_id}' is not owned by logged in user!"
)
# check whether the dataset is a bedfile
if dataset.filetype != "bedfile":
return invalid("Requested dataset is not a bedfile")
# check whether file exists
if dataset.file_path is None:
return not_found("Dataset has not associated bedfile")
# get bedfile
data = pd.read_csv(dataset.file_path, sep="\t", header=None).iloc[:, :3]
data.columns = ["chrom", "start", "end"]
return data.to_json(orient="records")
@api.route("/datasets/<dataset_id>/processedDataMap/", methods=["GET"])
@auth.login_required
def get_processed_data_mapping_of_dataset(dataset_id):
"""Gets processed data map of a given region dataset.
This object has the following structure:
{
processed_data_type: {
associated_dataset_id/associated_collection_id: {
name: NAME_OF_ASSOCIATED_DATASET/NAME_OF_ASSOCIATED_COLLECTION,
(collection_dataset_names: [...names...],)
data_ids: {
interval_size: {
binsize: {
processed_data_id
}
}
}
}
}
}
Processed_data_type is in [pileup, stackup, lineprofile, lola, embedding1d, embedding2d]
All entries for a given processed_data_type key are available processed_datasets.
The values for each processed_dataset hold information about their name
and which id in the target table corresponds to which interval and binsize
combintaion.
"""
dataset = Dataset.query.get(dataset_id)
# check whether dataset exists
if dataset is None:
return not_found(f"Dataset with id '{dataset_id}' does not exist!")
# check whether user owns the dataset
if dataset.is_access_denied(g):
return forbidden(
f"Dataset with id '{dataset_id}' is not owned by logged in user!"
)
# check whether dataset is bedfile
if dataset.filetype != "bedfile":
return invalid(f"Dataset with id '{dataset_id}' is not a bedfile!")
# create output object
output = {
"pileup": data_structures.recDict(),
"stackup": data_structures.recDict(),
"lineprofile": data_structures.recDict(),
"lola": data_structures.recDict(),
"embedding1d": data_structures.recDict(),
"embedding2d": data_structures.recDict(),
}
# populate output object
associated_intervals = dataset.intervals.all()
for interval in associated_intervals:
for preprocessed_dataset in interval.get_associated_preprocessed_datasets():
preprocessed_dataset.add_to_preprocessed_dataset_map(output)
return jsonify(output)
@api.route("/intervals/", methods=["GET"])
@auth.login_required
def get_intervals():
"""Gets all available intervals for a given user."""
# SQL join to get all intervals that come from a dataset owned by the respective user
all_files = (
Intervals.query.join(Dataset)
.filter(
(Dataset.user_id == g.current_user.id)
| (Dataset.public)
| (Dataset.id.in_(g.session_datasets))
| current_app.config["SHOWCASE"]
)
.all()
)
return jsonify([dfile.to_json() for dfile in all_files])
@api.route("/intervals/<interval_id>/metadata", methods=["GET"])
@auth.login_required
def get_interval_metadata(interval_id):
"""returns available metadata for given intervals."""
interval = Intervals.query.get(interval_id)
if interval is None:
return not_found(f"Intervals with id {interval_id} do not exist!")
# check if associated dataset is owned
if interval.source_dataset.is_access_denied(g):
return forbidden(
f"Dataset associated with interval id {interval.id} is not owned by logged in user!"
)
# get associated metadata entries sorted by id in descending order
# id sorting is necessary for newer metadata to win in field names
metadata_entries = interval.source_dataset.bedFileMetadata.order_by(
BedFileMetadata.id.desc()
).all()
# check if list is empty
if len(metadata_entries) == 0:
return jsonify({})
# load all metadata_files as dataframes
temp_frames = []
for metadata_entry in metadata_entries:
if metadata_entry.metadata_fields is None:
# skip metadata if there are no fields defined
continue
columns_retained = json.loads(metadata_entry.metadata_fields)
temp_frame = pd.read_csv(metadata_entry.file_path, usecols=columns_retained)
temp_frames.append(temp_frame)
output_frame = pd.concat(temp_frames, axis=1)
# this drops all occurrences of a given column but the first,
# since ids are sorted by descending order, the newest one wins
output_frame_unique = output_frame.loc[:, ~output_frame.columns.duplicated()]
return jsonify(output_frame_unique.to_dict(orient="list"))
@api.route("/averageIntervalData/<entry_id>/", methods=["GET"])
@auth.login_required
def get_pileup_data(entry_id):
"""returns pileup data for the specified pileup id if it exists and
access is allowed."""
# Check for existence
if AverageIntervalData.query.get(entry_id) is None:
return not_found("Pileup does not exist!")
# Check whether datasets are owned
pileup = AverageIntervalData.query.get(entry_id)
cooler_ds = pileup.source_dataset
bed_ds = pileup.source_intervals.source_dataset
if cooler_ds.is_access_denied(g) or bed_ds.is_access_denied(g):
return forbidden(
"Cooler dataset or bed dataset is not owned by logged in user!"
)
# Dataset is owned, return the data
np_data = np.load(pileup.file_path)
# Convert np.nan and np.isinf to None -> this is handeled by jsonify correctly
flat_data = [
entry if not (np.isnan(entry) or np.isinf(entry)) else None
for entry in np_data.flatten()
]
json_data = {"data": flat_data, "shape": np_data.shape, "dtype": "float32"}
return jsonify(json_data)
@api.route("/associationIntervalData/<entry_id>/", methods=["GET"])
@auth.login_required
def get_association_data(entry_id):
"""returns data for the specified association data id if it exists and
access is allowed."""
# Check for existence
if AssociationIntervalData.query.get(entry_id) is None:
return not_found("Association data does not exist!")
# Check whether datasets are owned
association_data = AssociationIntervalData.query.get(entry_id)
collection = association_data.source_collection
bed_ds = association_data.source_intervals.source_dataset
if collection.is_access_denied(g) or bed_ds.is_access_denied(g):
return forbidden("Collection or bed dataset is not owned by logged in user!")
# Dataset is owned, return the data
np_data = np.load(association_data.file_path)
# Convert np.nan and np.isinf to None -> this is handeled by jsonify correctly
flat_data = [
entry if not (np.isnan(entry) or np.isinf(entry)) else None
for entry in np_data.flatten()
]
json_data = {"data": flat_data, "shape": np_data.shape, "dtype": "float32"}
return jsonify(json_data)
@api.route("/embeddingIntervalData/<entry_id>/", methods=["GET"])
@auth.login_required
def get_embedding_data(entry_id):
"""returns data for the specified embedding data id if it exists and
access is allowed."""
# Check for existence
if EmbeddingIntervalData.query.get(entry_id) is None:
return not_found("Embedding data does not exist!")
# Check whether datasets are 1d or 2d
embedding_data = EmbeddingIntervalData.query.get(entry_id)
if embedding_data.value_type == "2d-embedding":
# Check whether datasets are owned
feature_dataset = embedding_data.source_dataset
bed_ds = embedding_data.source_intervals.source_dataset
if feature_dataset.is_access_denied(g) or bed_ds.is_access_denied(g):
return forbidden(
"Feature dataset or region dataset is not owned by logged in user!"
)
embedding = np.load(embedding_data.file_path).astype(float)
cluster_ids = np.load(embedding_data.cluster_id_path).astype(float)
thumbnails = np.load(embedding_data.thumbnail_path).astype(float)
# Convert np.nan and np.isinf to None -> this is handeled by jsonify correctly
json_data = {
"embedding": {
"data": flatten_and_clean_array(embedding),
"shape": embedding.shape,
"dtype": "float32",
},
"cluster_ids": {
"data": flatten_and_clean_array(cluster_ids),
"shape": cluster_ids.shape,
"dtype": "float32",
},
"thumbnails": {
"data": flatten_and_clean_array(thumbnails),
"shape": thumbnails.shape,
"dtype": "float32",
},
}
else:
# Check whether collections are owned
collection = embedding_data.source_collection
bed_ds = embedding_data.source_intervals.source_dataset
if collection.is_access_denied(g) or bed_ds.is_access_denied(g):
return forbidden(
"Collection dataset or region dataset is not owned by logged in user!"
)
embedding = np.load(embedding_data.file_path).astype(float)
if embedding_data.cluster_id_path is not None:
cluster_ids = np.load(embedding_data.cluster_id_path).astype(float)
average_data = np.load(embedding_data.thumbnail_path).astype(float)
json_data = {
"embedding": {
"data": flatten_and_clean_array(embedding),
"shape": embedding.shape,
"dtype": "float32",
},
"cluster_ids": {
"data": flatten_and_clean_array(cluster_ids),
"shape": cluster_ids.shape,
"dtype": "float32",
},
"thumbnails": {
"data": flatten_and_clean_array(average_data),
"shape": average_data.shape,
"dtype": "float32",
},
}
else:
json_data = {
"embedding": {
"data": flatten_and_clean_array(embedding),
"shape": embedding.shape,
"dtype": "float32",
},
"cluster_ids": {
"data": None,
"shape": None,
"dtype": None,
},
"thumbnails": {
"data": None,
"shape": None,
"dtype": None,
},
}
# compress
content = gzip.compress(json.dumps(json_data).encode("utf8"), 4)
response = make_response(content)
response.headers["Content-length"] = len(content)
response.headers["Content-Encoding"] = "gzip"
return response
@api.route("/embeddingIntervalData/<entry_id>/<feature_index>/", methods=["GET"])
@auth.login_required
def get_embedding_feature(entry_id, feature_index):
"""Gets feature vector with feature_index for entry_id"""
# Check for existence
if EmbeddingIntervalData.query.get(entry_id) is None:
return not_found("Embedding data does not exist!")
# Check whether datasets are owned
embedding_data = EmbeddingIntervalData.query.get(entry_id)
collection = embedding_data.source_collection
bed_ds = embedding_data.source_intervals.source_dataset
if collection.is_access_denied(g) or bed_ds.is_access_denied(g):
return forbidden("Collection or bed dataset is not owned by logged in user!")
# return the feature data
feature_data = np.load(embedding_data.file_path_feature_values, mmap_mode="r")
selected_row = np.array(feature_data[:, int(feature_index)]).astype(np.float64)
flat_data = [
entry if not (np.isnan(entry) or np.isinf(entry)) else None
for entry in selected_row.flatten()
]
json_data = {"data": flat_data, "shape": selected_row.shape, "dtype": "float32"}
# compress
content = gzip.compress(json.dumps(json_data).encode("utf8"), 4)
response = make_response(content)
response.headers["Content-length"] = len(content)
response.headers["Content-Encoding"] = "gzip"
return response
@api.route("/individualIntervalData/<entry_id>/", methods=["GET"])
@auth.login_required
def get_stackup_data(entry_id):
"""returns stackup data for the specified stackup id if it exists and
access is allowed."""
# Check for existence
if IndividualIntervalData.query.get(entry_id) is None:
return not_found("Stackup does not exist!")
stackup = IndividualIntervalData.query.get(entry_id)
bigwig_ds = stackup.source_dataset
bed_ds = stackup.source_intervals.source_dataset
if bigwig_ds.is_access_denied(g) or bed_ds.is_access_denied(g):
return forbidden(
"Bigwig dataset or bed dataset is not owned by logged in user!"
)
# dataset is owned, return the smalldata
np_data = np.load(stackup.file_path_small)
# Convert np.nan and np.isinf to None -> this is handeled by jsonify correctly
flat_data = [
entry if not (np.isnan(entry) or np.isinf(entry)) else None
for entry in np_data.flatten()
]
json_data = {"data": flat_data, "shape": np_data.shape, "dtype": "float32"}
return jsonify(json_data)
@api.route("/individualIntervalData/<entry_id>/metadatasmall", methods=["GET"])
@auth.login_required
def get_stackup_metadata_small(entry_id):
"""returns metadata for small stackup. This needs to be done since
the subsampeled stackup contains only a subset of the original intervals.
Note: stackups use the original dataset, so subsetting on interval indices
is not required."""
# Check for existence
if IndividualIntervalData.query.get(entry_id) is None:
return not_found("Stackup does not exist!")
stackup = IndividualIntervalData.query.get(entry_id)
# get downsample index from associated intervals
down_sample_index = Intervals.query.get(
stackup.intervals_id
).file_path_sub_sample_index
bigwig_ds = stackup.source_dataset
bed_ds = stackup.source_intervals.source_dataset
if bigwig_ds.is_access_denied(g) or bed_ds.is_access_denied(g):
return forbidden(
"Bigwig dataset or bed dataset is not owned by logged in user!"
)
# get associated metadata entries sorted by id;
# id sorting is necessary for newer metadata to win in field names
metadata_entries = bed_ds.bedFileMetadata.order_by(BedFileMetadata.id.desc()).all()
# check if list is empty or all metadata entries have undefined metadata fields
if (len(metadata_entries) == 0) or all(
metadata_entry.metadata_fields is None for metadata_entry in metadata_entries
):
return jsonify({})
# load all metadata_files as dataframes
temp_frames = []
for metadata_entry in metadata_entries:
if metadata_entry.metadata_fields is None:
# skip metadata if there are no fields defined
continue
columns_retained = json.loads(metadata_entry.metadata_fields)
temp_frame = pd.read_csv(metadata_entry.file_path, usecols=columns_retained)
temp_frames.append(temp_frame)
output_frame_large = | pd.concat(temp_frames, axis=1) | pandas.concat |
"""
@author: cvincentcuaz
"""
import os
#n_jobs=2
#os.environ["OMP_NUM_THREADS"] = str(n_jobs)
#os.environ['OPENBLAS_NUM_THREADS']= str(n_jobs)
#os.environ['MKL_NUM_THREADS'] = str(n_jobs)
#os.environ['VECLIB_MAXIMUM_THREADS']=str(n_jobs)
#os.environ['NUMEXPR_NUM_THREADS']=str(n_jobs)
import numpy as np
from sklearn.cluster import KMeans
from sklearn.metrics import rand_score
from scipy.linalg import sqrtm
from GDL_FGWalgo import FGW_Unsupervised_DictionaryLearning
import GDL_utils as gwu
import result_manager
import pandas as pd
import argparse
#%%
# =============================================================================
# Experiments on real datasets without node features:
# - 1/ Learn the dictionary atoms {C_s}
# - 2/ Solve GW unmixing problems by projecting input graphs Ck on
# the linear subspace defined by atoms {C_s}. Providing embeddings wk
# - 3/ Evaluate embeddings wk:
# a) Clustering with kmeans using the Mahalanobis distance from Proposition 1
# b) Classification with SVM endowed with Mahalanobis distance
# - 4/ Evaluate embedded graphs sum_s wk_s C_s :
# Classification with SVM endowed with GW distance
# =============================================================================
#python run_FGW_GDL.py -ds "imdb-m" -natoms [4,8] -satoms [10] -reg [0.01] -alpha [0.25,0.5] -ep 2 -b 16 -lrC 0.01 -lrA 0.01 -mode "ADJ"
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='learning vanilla GDL for unlabeled graphs')
parser.add_argument('-ds','--dataset_name', type=str,help='the name of the dataset',choices=['mutag','ptc','bzr','cox2','enzymes','protein'],required=True)
parser.add_argument('-natoms','--list_number_atoms', type=str,help='validated list of number of atoms',required=True)
parser.add_argument('-satoms','--list_shape_atoms', type=str,help='validated list of atoms shapes',required=True)
parser.add_argument('-reg','--list_l2reg', type=str,default=str([0.0]),help='validated list of negative quadratic regularization parameters',required=True)
parser.add_argument('-alpha','--list_alpha', type=str,default=str([0.5]),help='validated list of alpha parameter for FGW distance',required=True)
parser.add_argument('-ep','--epochs', type=int,default=50,help='epochs to run for stochastic algorithm',required=True)
parser.add_argument('-b','--batch_size', type=int,default=16,help='batch size for stochastic updates',required=True)
parser.add_argument('-lrC','--learning_rate_Cs', type=float,default=0.01,help='learning rate for SGD updates of atoms Cs - Adam is included with default values',required=True)
parser.add_argument('-lrA','--learning_rate_As', type=float,default=0.01,help='learning rate for SGD updates of atoms As - Adam is included with default values',required=True)
parser.add_argument('-mode','--mode', type=str,default='ADJ',help='graph representation for graphs',choices=['ADJ','SP','LAP'])
parser.add_argument('-eps','--eps', type=float,default=10**(-5),help='precision to assert unmixings convergence')
parser.add_argument('-maxout','--max_iter_outer', type=int,default=20,help='maximum number of iterations for BCD algorithm')
parser.add_argument('-maxin','--max_iter_inner', type=int,default=100,help='maximum number of iterations for FW algorithm for w_k')
parser.add_argument('-s','--list_seed', type=str,default=str([0]),help='seed to initialize stochastic algorithm and ensure reproductibility')
parser.add_argument('-init','--init_mode_atoms', type=int,default=1,help='initialization mode for atoms. 0 = random / 1 = sampling')
args = parser.parse_args()
beta_1= 0.9 #parameters of adam optimizer (grad)
beta_2=0.99 #parameters of adam optimizer (grad**2)
# can be used to save best state dictionary by computing
# unmixing over the whole dataset at indicate time stamp
checkpoint_timestamp = None
# visualize_frame = 2 would plot loss evolution every 2 epochs
visualization_frame=None
# Used for supervised experiments provided in supplementary
run_supervised_embedding_evaluation=False
used_checkpoint=False
experiment_repo = "/%s_experiments"%args.dataset_name
list_number_atoms = [int(x) for x in args.list_number_atoms[1:-1].split(',')]
list_shape_atoms = [int(x) for x in args.list_shape_atoms[1:-1].split(',')]
list_seed = [int(x) for x in args.list_seed[1:-1].split(',')]
list_l2reg = [float(x) for x in args.list_l2reg[1:-1].split(',')]
list_alpha = [float(x) for x in args.list_alpha[1:-1].split(',')]
# used for experiments in general is:
# [0.000001,0.0003,0.005,0.1,0.25,0.5,0.75,0.9,0.995,0.9997,0.999999]
for number_Cs in list_number_atoms:
for shape_Cs in list_shape_atoms:
for alpha in list_alpha:
for seed in list_seed:
for l2_reg in list_l2reg:
if args.dataset_name in ['mutag','ptc']:#one-hot features
experiment_name= "/%s/"%args.mode+args.dataset_name+"_FGWGDL_ONEHOT_sampledCA_S%sN%s_a%s_l2%s_batch%s_lrC%s_lrA%s_maxiterout%s_maxiterin%s_eps%s_epochs%s_seed%s/"%(shape_Cs,number_Cs,alpha,l2_reg,args.batch_size,args.learning_rate_Cs,args.learning_rate_As,args.max_iter_outer,args.max_iter_inner,args.eps,args.epochs,seed)
else:
experiment_name= "/%s/"%args.mode+args.dataset_name+"_FGWGDL_sampledCA_S%sN%s_a%s_l2%s_batch%s_lrC%s_lrA%s_maxiterout%s_maxiterin%s_eps%s_epochs%s_seed%s/"%(shape_Cs,number_Cs,alpha,l2_reg,args.batch_size,args.learning_rate_Cs,args.learning_rate_As,args.max_iter_outer,args.max_iter_inner,args.eps,args.epochs,seed)
local_path = os.path.abspath('../')
full_path = local_path +experiment_repo+experiment_name
print(full_path)
DL = FGW_Unsupervised_DictionaryLearning(args.dataset_name, args.mode, number_Cs, shape_Cs, alpha,experiment_repo,experiment_name,data_path='../data/')
print('Starting to learn atoms')
if not os.path.exists(full_path):
print('Starting to learn atoms')
#### 1/ Learn the dictionary atoms {C_s,A_s}
_=DL.Stochastic_GDL(l2_reg,eps= args.eps, max_iter_outer = args.max_iter_outer,max_iter_inner=args.max_iter_inner,
lr_Cs=args.learning_rate_Cs,lr_As=args.learning_rate_As,batch_size=args.batch_size,
beta_1=beta_1, beta_2=beta_2, epochs=args.epochs, algo_seed=seed,init_mode_atoms=args.init_mode_atoms,
checkpoint_timestamp=checkpoint_timestamp, visualization_frame=visualization_frame,verbose=False)
print('done learning')
else:
DL.load_elements(use_checkpoint = (not checkpoint_timestamp is None))
#### 2/ Solve GW unmixing problems wk for all graph Gk
print('COMPUTE UNMIXINGS')
unmixing_name = 'unmixing_l2reg%s_maxiterout%s_maxiterin%s_eps%s'%(l2_reg, args.max_iter_outer,args.max_iter_inner, args.eps)
unmixing_path = local_path+experiment_repo+experiment_name+'/%s.npy'%unmixing_name
reconstruction_path = local_path+experiment_repo+experiment_name+'/reconstruction_%s.npy'%unmixing_name
unmixing, reconstruction_errors=DL.GDL_unmixing(l2_reg=l2_reg,eps=args.eps,max_iter_outer=args.max_iter_outer,max_iter_inner=args.max_iter_inner)
np.save(unmixing_path, unmixing)
np.save(reconstruction_path,reconstruction_errors)
# 3/ Evaluate embeddings {wk}
exp = result_manager.load_DL_experiments(experiment_name, experiment_repo)
y_true=DL.y
exp['Ct']=DL.C_target
exp['At']=DL.A_target
exp['labels']= y_true
Cs_str = 'Cs'
As_str ='As'
if not (checkpoint_timestamp is None):
# we ran checkpoint hence the best unmixings are stored in 'checkpoint_unmixings.npy'
used_checkpoint=True
w_str = 'checkpoint_unmixings'
Cs_str ='checkpoint_Cs'
As_str = 'checkpoint_As'
X= exp[unmixing_name]
M = gwu.compute_mahalanobisFGW_matrix(exp[Cs_str],exp[As_str],alpha)
def dist_func(x,y):
z = x-y
return np.sqrt((z.T).dot(M).dot(z))
if args.dataset_name in ['mutag','ptc','bzr','cox2','protein']:
n_clusters=2
elif args.dataset_name in ['enzymes']:
n_clusters=6
else:
raise 'UNKNOWN DATASET NAME'
#### 3/ a)Clustering with kmeans using the Mahalanobis distance from Proposition 1
print('computing Kmeans -Mahalanobis')
#compute M^{1/2}.
rootM = sqrtm(M)
#Transform features so they follow an euclidean geometry
new_X = np.zeros_like(X)
for i in range(new_X.shape[0]):
new_X[i] = rootM.dot(X[i])
local_res = {'nC':[] }
key_to_func = {"RI": rand_score}
for metric in key_to_func.keys():
local_res[metric]=[]
kmeans = KMeans(n_clusters=n_clusters, init='k-means++', n_init=100, random_state=0, tol=10**(-9), max_iter = 10**5)
y_pred=kmeans.fit_predict(new_X)
local_res['nC'].append(n_clusters)
for key in key_to_func.keys():
local_res[key].append(key_to_func[key](y_true,y_pred))
if used_checkpoint:
pd.DataFrame(local_res).to_csv(full_path+'/res_FGWmahalanobisKmeans_checkpoint.csv')
else:
| pd.DataFrame(local_res) | pandas.DataFrame |
import covid.util as util
import pandas as pd
import matplotlib.pyplot as plt
import sys
start = sys.argv[1]
forecast_start = sys.argv[2]
samples_directory = sys.argv[3]
import numpy as np
from epiweeks import Week, Year
num_weeks = 8
data = util.load_state_data()
places = sorted(list(data.keys()))
#places = ['AK', 'AL']
allQuantiles = [0.01,0.025]+list(np.arange(0.05,0.95+0.05,0.05)) + [0.975,0.99]
forecast_date = | pd.to_datetime(forecast_start) | pandas.to_datetime |
#!/usr/bin/env python
# coding: utf-8
import os
import glob
import pandas as pd
import matplotlib.pyplot as plt
import psycopg2
from sqlalchemy import create_engine
import yaml
import sys, getopt
import logging
import logging.config
import zipfile
# Copyright 2021 National Technology & Engineering Solutions of Sandia, LLC (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S. Government retains certain rights in this software.
# Function to convert a list to a string
def listToString(s):
# initialize an empty string
str1 = ""
# traverse in the string
for ele in s:
str1 += ele
# return string
return str1
# unpack the dataframe and calculate quantities used in statistics
def calc_cycle_quantities(df):
logging.info('calculate quantities used in statistics')
tmp_arr = df[["test_time", "i", "v", "ah_c", 'e_c', 'ah_d', 'e_d', 'cycle_time']].to_numpy()
start = 0
last_time = 0
last_i = 0
last_v = 0
last_ah_c = 0
last_e_c = 0
last_ah_d = 0
last_e_d = 0
initial_time = 0
for x in tmp_arr:
if start == 0:
start += 1
initial_time = x[0]
else:
if x[1] >= 0:
x[3] = (x[0]-last_time)*(x[1]+last_i)*0.5+last_ah_c
x[4] = (x[0]-last_time)*(x[1]+last_i)*0.5*(x[2]+last_v)*0.5+last_e_c
elif x[1] <= 0:
x[5] = (x[0] - last_time) * (x[1] + last_i) * 0.5 + last_ah_d
x[6] = (x[0] - last_time) * (x[1] + last_i) * 0.5 * (x[2] + last_v) * 0.5 + last_e_d
x[7] = x[0] - initial_time
last_time = x[0]
last_i = x[1]
last_v = x[2]
last_ah_c = x[3]
last_e_c = x[4]
last_ah_d = x[5]
last_e_d = x[6]
df_tmp = pd.DataFrame(data=tmp_arr[:, [3]], columns=["ah_c"])
df_tmp.index += df.index[0]
df['ah_c'] = df_tmp['ah_c']/3600.0
df_tmp = pd.DataFrame(data=tmp_arr[:, [4]], columns=["e_c"])
df_tmp.index += df.index[0]
df['e_c'] = df_tmp['e_c']/3600.0
df_tmp = pd.DataFrame(data=tmp_arr[:, [5]], columns=["ah_d"])
df_tmp.index += df.index[0]
df['ah_d'] = -df_tmp['ah_d']/3600.0
df_tmp = pd.DataFrame(data=tmp_arr[:, [6]], columns=["e_d"])
df_tmp.index += df.index[0]
df['e_d'] = -df_tmp['e_d']/3600.0
df_tmp = pd.DataFrame(data=tmp_arr[:, [7]], columns=["cycle_time"])
df_tmp.index += df.index[0]
df['cycle_time'] = df_tmp['cycle_time']
return df
# calculate statistics and cycle time
def calc_stats(df_t):
logging.info('calculate cycle time and cycle statistics')
df_t['cycle_time'] = 0
no_cycles = int(df_t['cycle_index'].max())
# Initialize the cycle_data time frame
a = [0 for x in range(no_cycles)] # using loops
df_c = pd.DataFrame(data=a, columns=["cycle_index"])
df_c['cell_id'] = df_t['cell_id']
df_c['cycle_index'] = 0
df_c['v_max'] = 0
df_c['i_max'] = 0
df_c['v_min'] = 0
df_c['i_min'] = 0
df_c['ah_c'] = 0
df_c['ah_d'] = 0
df_c['e_c'] = 0
df_c['e_d'] = 0
df_c['v_c_mean'] = 0
df_c['v_d_mean'] = 0
df_c['test_time'] = 0
df_c['ah_eff'] = 0
df_c['e_eff'] = 0
for c_ind in df_c.index:
x = c_ind + 1
df_f = df_t[df_t['cycle_index'] == x]
df_f['ah_c'] = 0
df_f['e_c'] = 0
df_f['ah_d'] = 0
df_f['e_d'] = 0
if not df_f.empty:
try:
df_c.iloc[c_ind, df_c.columns.get_loc('cycle_index')] = x
df_c.iloc[c_ind, df_c.columns.get_loc('v_max')] = df_f.loc[df_f['v'].idxmax()].v
df_c.iloc[c_ind, df_c.columns.get_loc('v_min')] = df_f.loc[df_f['v'].idxmin()].v
df_c.iloc[c_ind, df_c.columns.get_loc('i_max')] = df_f.loc[df_f['i'].idxmax()].i
df_c.iloc[c_ind, df_c.columns.get_loc('i_min')] = df_f.loc[df_f['i'].idxmin()].i
df_c.iloc[c_ind, df_c.columns.get_loc('test_time')] = df_f.loc[df_f['test_time'].idxmax()].test_time
df_f['dt'] = df_f['test_time'].diff() / 3600.0
df_f_c = df_f[df_f['i'] > 0]
df_f_d = df_f[df_f['i'] < 0]
df_f = calc_cycle_quantities(df_f)
df_t.loc[df_t.cycle_index == x, 'cycle_time'] = df_f['cycle_time']
df_t.loc[df_t.cycle_index == x, 'ah_c'] = df_f['ah_c']
df_t.loc[df_t.cycle_index == x, 'e_c'] = df_f['e_c']
df_t.loc[df_t.cycle_index == x, 'ah_d'] = df_f['ah_d']
df_t.loc[df_t.cycle_index == x, 'e_d'] = df_f['e_d']
df_c.iloc[c_ind, df_c.columns.get_loc('ah_c')] = df_f['ah_c'].max()
df_c.iloc[c_ind, df_c.columns.get_loc('ah_d')] = df_f['ah_d'].max()
df_c.iloc[c_ind, df_c.columns.get_loc('e_c')] = df_f['e_c'].max()
df_c.iloc[c_ind, df_c.columns.get_loc('e_d')] = df_f['e_d'].max()
df_c.iloc[c_ind, df_c.columns.get_loc('v_c_mean')] = df_f_c['v'].mean()
df_c.iloc[c_ind, df_c.columns.get_loc('v_d_mean')] = df_f_d['v'].mean()
if df_c.iloc[c_ind, df_c.columns.get_loc('ah_c')] == 0:
df_c.iloc[c_ind, df_c.columns.get_loc('ah_eff')] = 0
else:
df_c.iloc[c_ind, df_c.columns.get_loc('ah_eff')] = df_c.iloc[c_ind, df_c.columns.get_loc('ah_d')] / \
df_c.iloc[c_ind, df_c.columns.get_loc('ah_c')]
if df_c.iloc[c_ind, df_c.columns.get_loc('e_c')] == 0:
df_c.iloc[c_ind, df_c.columns.get_loc('e_eff')] = 0
else:
df_c.iloc[c_ind, df_c.columns.get_loc('e_eff')] = df_c.iloc[c_ind, df_c.columns.get_loc('e_d')] / \
df_c.iloc[c_ind, df_c.columns.get_loc('e_c')]
except Exception as e:
logging.info("Exception @ x: " + str(x))
logging.info(e)
logging.info("cycle: " + str(x))
df_cc = df_c[df_c['cycle_index'] > 0]
df_tt = df_t[df_t['cycle_index'] > 0]
return df_cc, df_tt
# import data from Arbin-generated Excel files
def read_timeseries_arbin(cell_id, file_path):
# the importer can read Excel worksheets with the Channel number from Arbin files.
# it assumes column names generated by the Arbin:
# Cycle_Index -> cycle_index
# Test_Time(s) -> test_time
# Current(A) -> i
# Voltage(V) -> v
# Date_Time -> date_time
logging.info('adding files')
listOfFiles = glob.glob(file_path + '*.xls*')
for i in range(len(listOfFiles)):
listOfFiles[i] = listOfFiles[i].replace(file_path[:-1], '')
logging.info('list of files to add: ' + str(listOfFiles))
df_file = pd.DataFrame(listOfFiles, columns=['filename'])
df_file.sort_values(by=['filename'], inplace=True)
if df_file.empty:
return
df_file['cell_id'] = cell_id
df_tmerge = pd.DataFrame()
# Loop through all the Excel test files
for ind in df_file.index:
filename = df_file['filename'][ind]
cellpath = file_path + filename
timeseries = ""
logging.info('processing file: ' + filename)
if os.path.exists(cellpath):
df_cell = pd.read_excel(cellpath, None)
# Find the time series sheet in the excel file
for k in df_cell.keys():
if "hannel" in k:
logging.info("file: " + filename + " sheet:" + str(k))
timeseries = k
df_time_series_file = df_cell[timeseries]
df_time_series = pd.DataFrame()
df_time_series['cycle_index_file'] = df_time_series_file['Cycle_Index']
df_time_series['test_time'] = df_time_series_file['Test_Time(s)']
df_time_series['i'] = df_time_series_file['Current(A)']
df_time_series['v'] = df_time_series_file['Voltage(V)']
df_time_series['date_time'] = df_time_series_file['Date_Time']
df_time_series['filename'] = filename
df_time_series['ah_c'] = 0
df_time_series['e_c'] = 0
df_time_series['ah_d'] = 0
df_time_series['e_d'] = 0
df_time_series['cell_id'] = cell_id
df_time_series['cycle_index'] = 0
df_time_series['cycle_time'] = 0
if df_tmerge.empty:
df_tmerge = df_time_series
else:
df_tmerge = df_tmerge.append(df_time_series, ignore_index=True)
return df_tmerge
# sort data imported to insure cycle index and test times are correctly calculated
def sort_timeseries(df_tmerge):
# Arrange the data by date time first, then by test time
# Rebuild Cycle Index and test time to increment from file to file
# This method does not depend on data from a specific testers
logging.info('sorting timeseries dataframe')
if not df_tmerge.empty:
df_t = df_tmerge.sort_values(by=['date_time'])
df_t = df_t.reset_index(drop=True)
cycles = df_t[["cycle_index_file", "cycle_index", "filename", "test_time"]].to_numpy()
max_cycle = 1
past_index = 1
max_time = 0
last_file = ""
delta_t = 0
start = 0
for x in cycles:
if start == 0:
last_file = x[2]
start += 1
if x[2] != last_file:
delta_t = max_time
x[3] += delta_t
last_file = x[2]
else:
x[3] += delta_t
max_time = x[3]
last_file = x[2]
if x[0] < max_cycle:
if past_index == x[0]:
past_index = x[0]
x[1] = max_cycle
else:
past_index = x[0]
x[1] = max_cycle + 1
max_cycle = x[1]
else:
past_index = x[0]
max_cycle = x[0]
x[1] = x[0]
df_tmp = pd.DataFrame(data=cycles[:, [1]], columns=["cycle_index"])
df_t['cycle_index'] = df_tmp['cycle_index']
df_tmp = pd.DataFrame(data=cycles[:, [3]], columns=["test_time"])
df_t['test_time'] = pd.to_numeric(df_tmp['test_time'])
df_ts = df_t.sort_values(by=['test_time'])
# Remove quantities only needed to tag files
df_ts.drop('filename', axis=1, inplace=True)
df_ts.drop('cycle_index_file', axis=1, inplace=True)
return df_ts
# Build cell metadata
def populate_metadata(df_c_md):
# Build cell metadata
df_cell_md = pd.DataFrame()
df_cell_md['cell_id'] = [df_c_md['cell_id']]
df_cell_md['anode'] = [df_c_md['anode']]
df_cell_md['cathode'] = [df_c_md['cathode']]
df_cell_md['source'] = [df_c_md['source']]
df_cell_md['ah'] = [df_c_md['ah']]
df_cell_md['form_factor'] = [df_c_md['form_factor']]
# Build test metadata
df_test_md = pd.DataFrame()
df_test_md['cell_id'] = [df_c_md['cell_id']]
df_test_md['crate_c'] = [df_c_md['crate_c']]
df_test_md['crate_d'] = [df_c_md['crate_d']]
df_test_md['soc_max'] = [df_c_md['soc_max']]
df_test_md['soc_min'] = [df_c_md['soc_min']]
return df_cell_md, df_test_md
# delete records (call with caution)
def delete_records(cell_id, conn):
# this method will delete data for a cell_id. Use with caution as there is no undo
db_conn = psycopg2.connect(conn)
curs = db_conn.cursor()
curs.execute("delete from timeseries_data where cell_id='" + cell_id + "'")
curs.execute("delete from cycle_data where cell_id='" + cell_id + "'")
curs.execute("delete from cell_metadata where cell_id='" + cell_id + "'")
curs.execute("delete from test_metadata where cell_id='" + cell_id + "'")
db_conn.commit()
curs.close()
db_conn.close()
return
# add cells to the database
def add_cells(cell_list, conn, save, plot, path, slash):
# The importer expects an Excel file with cell and test information
# The file contains one row per cell
logging.info('add cells')
df_excel = pd.read_excel(cell_list)
# Process one cell at the time
for ind in df_excel.index:
cell_id = df_excel['cell_id'][ind]
file_id = df_excel['file_id'][ind]
logging.info("add file: " + file_id + " cell: " + cell_id)
df_tmp = df_excel.iloc[ind]
df_cell_md, df_test_md = populate_metadata(df_tmp)
# Unzip the data in a folder with the same name of the file_id
with zipfile.ZipFile(path + file_id + '.zip', 'r') as zip_ref:
zip_ref.extractall(path + file_id)
# Read time series data: Excel files from Arbin tester
# Modify this method to add more testers
file_path = path + file_id + slash
# importer specific to the Arbin file (TODO)
df_merge = read_timeseries_arbin(cell_id, file_path)
# Sort the timeseries data and rebuild cycle index and test time
df_ts = sort_timeseries(df_merge)
# Calculate statistics and prepare the dataframes for saving
df_cycle_data, df_timeseries_data = calc_stats(df_ts)
# Useful flag during testing
if plot:
df_cycle_data.plot(x='cycle_index', y='ah_c')
df_cycle_data.plot(x='cycle_index', y='ah_d')
df_cycle_data.plot(x='cycle_index', y='e_c')
df_cycle_data.plot(x='cycle_index', y='e_d')
plt.show()
# Controls when data is saved to the database
if save:
engine = create_engine(conn)
logging.info('save cell metadata')
df_cell_md.to_sql('cell_metadata', con=engine, if_exists='append', chunksize=1000, index=False)
logging.info('save test metadata')
df_test_md.to_sql('test_metadata', con=engine, if_exists='append', chunksize=1000, index=False)
logging.info('save cycle data')
df_cycle_data.to_sql('cycle_data', con=engine, if_exists='append', chunksize=1000, index=False)
logging.info('save timeseries data')
df_timeseries_data.to_sql('timeseries_data', con=engine, if_exists='append', chunksize=1000, index=False)
# generate csv files with cycle data
def generate_cycle_data(cell_id, conn, path):
# generate cycle data in csv format
logging.info('export cell cycle data to csv files')
sql_str = """select
cycle_index as "Cycle_Index",
round(test_time,3) as "Test_Time (s)",
round(i_min,3) as "Min_Current (A)",
round(i_max,3) as "Max_Current (A)",
round(v_min,3) as "Min_Voltage (V)",
round(v_max,3) as "Max_Voltage (V)",
round(ah_c,3) as "Charge_Capacity (Ah)",
round(ah_d,3) as "Discharge_Capacity (Ah)",
round(e_c,3) as "Charge_Energy (Wh)",
round(e_d,3) as "Discharge_Energy (Wh)"
from cycle_data where cell_id='""" + cell_id + """' order by cycle_index"""
df = pd.read_sql(sql_str[0], conn)
cell_id_to_file = cell_id[0].replace(r'/', '-')
csv = path + cell_id_to_file + '_cycle_data.csv'
df.to_csv(csv, encoding='utf-8', index=False)
# generate csv files with time series data
def generate_timeseries_data(cell_id, conn, path):
# generate timeseries data
logging.info('export cell timeseries data to csv files')
sql_str = """select
date_time as "Date_Time",
round(test_time,3) as "Test_Time (s)",
cycle_index as "Cycle_Index",
round(i,3) as "Current (A)",
round(v,3) as "Voltage (V)",
round(ah_c,3) as "Charge_Capacity (Ah)",
round(ah_d,3) as "Discharge_Capacity (Ah)",
round(e_c,3) as "Charge_Energy (Wh)",
round(e_d,3) as "Discharge_Energy (Wh)",
round(temp_1,3) as "Environment_Temperature (C)",
round(temp_2,3) as "Cell_Temperature (C)"
from timeseries_data where cell_id='""" + cell_id + """' order by test_time"""
df = pd.read_sql(sql_str[0], conn)
cell_id_to_file = cell_id[0].replace(r'/', '-')
csv = path + cell_id_to_file + '_timeseries_data.csv'
df.to_csv(csv, encoding='utf-8', index=False)
# generate csv files with time series and cycle data
def export_cells(cell_list, conn, path):
# export data from the cell list
logging.info('export cell data to csv files')
df_excel = | pd.read_excel(cell_list) | pandas.read_excel |
# -*- coding: utf-8
"""Module for tespy network class.
The network is the container for every TESPy simulation. The network class
automatically creates the system of equations describing topology and
parametrisation of a specific model and solves it.
This file is part of project TESPy (github.com/oemof/tespy). It's copyrighted
by the contributors recorded in the version control history of the file,
available from its original location tespy/networks/networks.py
SPDX-License-Identifier: MIT
"""
# reading .csv
import ast
# ordered dicts for fluid composition vector
from collections import Counter, OrderedDict
# calculation of molar masses and gas constants
from CoolProp.CoolProp import PropsSI as CPPSI
# logging messages
import logging
# numpy functions
import numpy as np
from numpy.linalg import inv
from numpy.linalg import norm
# checking/creating folders
import os
# DataFrames for connections and components
import pandas as pd
# printing results
from tabulate import tabulate
from tespy import connections as con
from tespy.components.basics import (sink, source, subsystem_interface,
cycle_closer)
from tespy.components.combustion import combustion_chamber, combustion_engine
from tespy.components.heat_exchangers import heat_exchanger
from tespy.components.nodes import drum, merge, splitter
from tespy.components.reactors import water_electrolyzer
from tespy.tools import data_containers as dc
from tespy.tools import fluid_properties as fp
from tespy.tools import helpers as hlp
from tespy.tools.global_vars import molar_masses, gas_constants, err
# calculation time
from time import time
class network:
r"""
Class component is the base class of all TESPy components.
Parameters
----------
fluids : list
A list of all fluids within the network container.
m_unit : str
Specify the unit for mass flow: 'kg / s', 't / h'.
v_unit : str
Specify the unit for volumetric flow: 'm3 / s', 'm3 / h', 'l / s',
'l / h'.
p_unit : str
Specify the unit for pressure: 'Pa', 'psi', 'bar', 'MPa'.
h_unit : str
Specify the unit for mass flow: 'J / kg', 'kJ / kg', 'MJ / kg'.
T_unit : str
Specify the unit for mass flow: 'K', 'C', 'F'.
p_range : list
List with minimum and maximum values for pressure value range.
h_range : list
List with minimum and maximum values for enthalpy value range.
T_range : list
List with minimum and maximum values for temperature value range.
iterinfo : boolean
Print convergence progress to console.
Note
----
Unit specification is optional: If not specified the SI unit (first
element in above lists) will be applied!
Range specification is optional, too. The value range is used to stabilise
the newton algorith. For more information see the "getting started" section
in the online-documentation.
Example
-------
Basic example for a setting up a tespy.networks.network object. Specifying
the fluids is mandatory! Unit systems, fluid property range and iterinfo
are optional.
Standard value for iterinfo is True. This will print out convergence
progress to the console. You can suop the printouts by setting this
property to false.
>>> from tespy.networks import network
>>> fluid_list = ['water', 'air', 'R134a']
>>> mynetwork = network(fluids=fluid_list, p_unit='bar', T_unit='C')
>>> mynetwork.set_attr(p_range=[1, 10])
>>> type(mynetwork)
<class 'tespy.networks.networks.network'>
>>> mynetwork.set_attr(iterinfo=False)
>>> mynetwork.iterinfo
False
>>> mynetwork.set_attr(iterinfo=True)
>>> mynetwork.iterinfo
True
A simple network consisting of a source, a pipe and a sink. This example
shows how the printout parameter can be used. We specify
:code:`printout=False` for both connections, the pipe as well as the heat
bus. Therefore the :code:`.print_results()` method should not print any
results.
>>> from tespy.networks import network
>>> from tespy.components import source, sink, pipe
>>> from tespy.connections import connection, bus
>>> nw = network(['CH4'], T_unit='C', p_unit='bar', v_unit='m3 / s')
>>> so = source('source')
>>> si = sink('sink')
>>> p = pipe('pipe', Q=0, pr=0.95, printout=False)
>>> a = connection(so, 'out1', p, 'in1')
>>> b = connection(p, 'out1', si, 'in1')
>>> nw.add_conns(a, b)
>>> a.set_attr(fluid={'CH4': 1}, T=30, p=10, m=10, printout=False)
>>> b.set_attr(printout=False)
>>> b = bus('heat bus')
>>> b.add_comps({'c': p})
>>> nw.add_busses(b)
>>> b.set_attr(printout=False)
>>> nw.set_attr(iterinfo=False)
>>> nw.solve('design')
>>> nw.print_results()
"""
def __init__(self, fluids, **kwargs):
# initialisation of basic properties
self.checked = False
# in case of a design calculation after an offdesign calculation
self.redesign = False
# connection dataframe
self.conns = pd.DataFrame(columns=['s', 's_id', 't', 't_id'])
# list for busses
self.busses = OrderedDict()
# default design_path value
self.design_path = None
# fluid list and constants
if isinstance(fluids, list):
self.fluids = sorted(fluids)
else:
msg = ('Please provide a list containing the network\'s fluids on '
'creation.')
logging.error(msg)
raise TypeError(msg)
msg = 'Network fluids are: '
for f in self.fluids:
msg += f + ', '
if 'INCOMP::' in f:
# molar mass and gas constant not available for incompressibles
molar_masses[f] = 1
gas_constants[f] = 1
elif 'TESPy::' not in f:
# calculating molar masses/gas constants for network's fluids
# tespy_fluid molar mass/gas constant are added on lut creation
molar_masses[f] = CPPSI('M', f)
gas_constants[f] = CPPSI('GAS_CONSTANT', f)
msg = msg[:-2] + '.'
logging.debug(msg)
# initialise fluid property memorisation function for this network
fp.memorise.add_fluids(self.fluids)
# available unit systems
# mass flow
self.m = {
'kg / s': 1,
't / h': 3.6
}
# pressure
self.p = {
'Pa': 1,
'psi': 6.8948e3,
'bar': 1e5,
'MPa': 1e6
}
# enthalpy
self.h = {
'J / kg': 1,
'kJ / kg': 1e3,
'MJ / kg': 1e6
}
# temperature
self.T = {
'C': [273.15, 1],
'F': [459.67, 5 / 9],
'K': [0, 1]
}
# volumetric flow
self.v = {
'm3 / s': 1,
'l / s': 1e-3,
'm3 / h': 1 / 3600,
'l / h': 1 / 3.6
}
# SI unit specification
self.SI_units = {
'm': 'kg / s',
'p': 'Pa',
'h': 'J / kg',
'T': 'K',
'v': 'm3 / s'
}
# iterinfo
self.iterinfo = True
# standard unit set
self.m_unit = self.SI_units['m']
self.p_unit = self.SI_units['p']
self.h_unit = self.SI_units['h']
self.T_unit = self.SI_units['T']
self.v_unit = self.SI_units['v']
msg = ('Default unit specifications: '
'mass flow: ' + self.m_unit + ', ' +
'pressure: ' + self.p_unit + ', ' +
'enthalpy: ' + self.h_unit + ', ' +
'temperature: ' + self.T_unit + ', ' +
'volumetric flow: ' + self.v_unit + '.')
logging.debug(msg)
# generic value range
self.m_range_SI = np.array([-1e12, 1e12])
self.p_range_SI = np.array([2e2, 300e5])
self.h_range_SI = np.array([1e3, 7e6])
self.T_range_SI = np.array([273.16, 1773.15])
msg = ('Default mass flow limits, '
'min: ' + str(self.m_range_SI[0]) + ' ' + self.m_unit +
', max: ' + str(self.m_range_SI[1]) + ' ' + self.m_unit + ', ')
logging.debug(msg)
msg = ('Default pressure limits, '
'min: ' + str(self.p_range_SI[0]) + ' ' + self.p_unit +
', max: ' + str(self.p_range_SI[1]) + ' ' + self.p_unit + ', ')
logging.debug(msg)
msg = ('Default enthalpy limits, '
'min: ' + str(self.h_range_SI[0]) + ' ' + self.h_unit +
', max: ' + str(self.h_range_SI[1]) + ' ' + self.h_unit + ', ')
logging.debug(msg)
msg = ('Default temperature limits, '
'min: ' + str(self.T_range_SI[0]) + ' ' + self.T_unit +
', max: ' + str(self.T_range_SI[1]) + ' ' + self.T_unit + ', ')
logging.debug(msg)
self.set_attr(**kwargs)
def set_attr(self, **kwargs):
r"""
Set, resets or unsets attributes of a network.
Parameters
----------
m_unit : str
Specify the unit for mass flow: 'kg / s', 't / h'.
v_unit : str
Specify the unit for volumetric flow: 'm3 / s', 'm3 / h', 'l / s',
'l / h'.
p_unit : str
Specify the unit for pressure: 'Pa', 'psi', 'bar', 'MPa'.
h_unit : str
Specify the unit for enthalpy: 'J / kg', 'kJ / kg', 'MJ / kg'.
T_unit : str
Specify the unit for temperature: 'K', 'C', 'F'.
m_range : list
List with minimum and maximum values for mass flow value range.
p_range : list
List with minimum and maximum values for pressure value range.
h_range : list
List with minimum and maximum values for enthalpy value range.
T_range : list
List with minimum and maximum values for temperature value range.
iterinfo : boolean
Print convergence progress to console.
"""
# unit sets
if 'm_unit' in kwargs.keys():
if kwargs['m_unit'] not in self.m.keys():
msg = ('Allowed units for mass flow are: ' +
str(self.m.keys()))
logging.error(msg)
raise ValueError(msg)
else:
self.m_unit = kwargs['m_unit']
msg = 'Setting mass flow unit: ' + self.m_unit
logging.debug(msg)
if 'p_unit' in kwargs.keys():
if kwargs['p_unit'] not in self.p.keys():
msg = ('Allowed units for pressure are: ' + str(self.p.keys()))
logging.error(msg)
raise ValueError(msg)
else:
self.p_unit = kwargs['p_unit']
msg = 'Setting pressure unit: ' + self.p_unit
logging.debug(msg)
if 'h_unit' in kwargs.keys():
if kwargs['h_unit'] not in self.h.keys():
msg = ('Allowed units for pressure are: ' + str(self.h.keys()))
logging.error(msg)
raise ValueError(msg)
else:
self.h_unit = kwargs['h_unit']
msg = 'Setting enthalpy unit: ' + self.h_unit
logging.debug(msg)
if 'T_unit' in kwargs.keys():
if kwargs['T_unit'] not in self.T.keys():
msg = ('Allowed units for pressure are: ' + str(self.T.keys()))
logging.error(msg)
raise ValueError(msg)
else:
self.T_unit = kwargs['T_unit']
msg = 'Setting temperature unit: ' + self.T_unit
logging.debug(msg)
if 'v_unit' in kwargs.keys():
if kwargs['v_unit'] not in self.v.keys():
msg = ('Allowed units for pressure are: ' + str(self.v.keys()))
logging.error(msg)
raise ValueError(msg)
else:
self.v_unit = kwargs['v_unit']
msg = 'Setting volumetric flow unit: ' + self.v_unit
logging.debug(msg)
# value ranges
if 'm_range' in kwargs.keys():
if not isinstance(kwargs['m_range'], list):
msg = ('Specify the value range as list: [m_min, m_max]')
logging.error(msg)
raise TypeError(msg)
else:
self.m_range_SI = (np.array(kwargs['m_range']) *
self.m[self.m_unit])
msg = ('Setting mass flow limits, min: ' +
str(self.m_range_SI[0]) + ' ' + self.SI_units['m'] +
', max: ' + str(self.m_range_SI[1]) + ' ' +
self.SI_units['m'] + '.')
logging.debug(msg)
if 'p_range' in kwargs.keys():
if not isinstance(kwargs['p_range'], list):
msg = ('Specify the value range as list: [p_min, p_max]')
logging.error(msg)
raise TypeError(msg)
else:
self.p_range_SI = (np.array(kwargs['p_range']) *
self.p[self.p_unit])
msg = ('Setting pressure limits, min: ' +
str(self.p_range_SI[0]) + ' ' + self.SI_units['p'] +
', max: ' + str(self.p_range_SI[1]) + ' ' +
self.SI_units['p'] + '.')
logging.debug(msg)
if 'h_range' in kwargs.keys():
if not isinstance(kwargs['h_range'], list):
msg = ('Specify the value range as list: [h_min, h_max]')
logging.error(msg)
raise TypeError(msg)
else:
self.h_range_SI = (np.array(kwargs['h_range']) *
self.h[self.h_unit])
msg = ('Setting enthalpy limits, min: ' +
str(self.h_range_SI[0]) + ' ' + self.SI_units['h'] +
', max: ' + str(self.h_range_SI[1]) + ' ' +
self.SI_units['h'] + '.')
logging.debug(msg)
if 'T_range' in kwargs.keys():
if not isinstance(kwargs['T_range'], list):
msg = ('Specify the value range as list: [T_min, T_max]')
logging.error(msg)
raise TypeError(msg)
else:
self.T_range_SI = ((np.array(kwargs['T_range']) +
self.T[self.T_unit][0]) *
self.T[self.T_unit][1])
msg = ('Setting temperature limits, min: ' +
str(self.T_range_SI[0]) + ' ' + self.SI_units['T'] +
', max: ' + str(self.T_range_SI[1]) + ' ' +
self.SI_units['T'] + '.')
logging.debug(msg)
# update non SI value ranges
self.m_range = self.m_range_SI / self.m[self.m_unit]
self.p_range = self.p_range_SI / self.p[self.p_unit]
self.h_range = self.h_range_SI / self.h[self.h_unit]
self.T_range = (self.T_range_SI / self.T[self.T_unit][1] -
self.T[self.T_unit][0])
for f in self.fluids:
if 'TESPy::' in f:
fp.memorise.vrange[f][0] = self.p_range_SI[0]
fp.memorise.vrange[f][1] = self.p_range_SI[1]
fp.memorise.vrange[f][2] = self.T_range_SI[0]
fp.memorise.vrange[f][3] = self.T_range_SI[1]
self.iterinfo = kwargs.get('iterinfo', self.iterinfo)
if not isinstance(self.iterinfo, bool):
msg = ('Network parameter iterinfo must be True or False!')
logging.error(msg)
raise TypeError(msg)
def get_attr(self, key):
r"""
Get the value of a network attribute.
Parameters
----------
key : str
The attribute you want to retrieve.
Returns
-------
out :
Specified attribute.
"""
if key in self.__dict__:
return self.__dict__[key]
else:
msg = 'Network has no attribute \"' + str(key) + '\".'
logging.error(msg)
raise KeyError(msg)
def add_subsys(self, *args):
r"""
Add one or more subsystems to the network.
Parameters
----------
c : tespy.components.subsystems.subsystem
The subsystem to be added to the network, subsystem objects si
:code:`network.add_subsys(s1, s2, s3, ...)`.
"""
for subsys in args:
for c in subsys.conns.values():
self.add_conns(c)
def add_nwks(self, *args):
"""
Add connections from a different network.
:param args: network objects si :code:`add_subsys(s1, s2, s3, ...)`
:type args: tespy.networks.network
:returns: no return value
"""
for nw in args:
for c in nw.conns.index:
self.add_conns(c)
def add_conns(self, *args):
r"""
Add one or more connections to the network.
Parameters
----------
c : tespy.connections.connection
The connection to be added to the network, connections objects ci
:code:`add_conns(c1, c2, c3, ...)`.
"""
for c in args:
if not isinstance(c, con.connection):
msg = ('Must provide tespy.connections.connection objects as '
'parameters.')
logging.error(msg)
raise TypeError(msg)
self.conns.loc[c] = [c.s, c.s_id, c.t, c.t_id]
msg = ('Added connection ' + c.s.label + ' (' + c.s_id + ') -> ' +
c.t.label + ' (' + c.t_id + ') to network.')
logging.debug(msg)
# set status "checked" to false, if conneciton is added to network.
self.checked = False
def del_conns(self, *args):
"""
Remove one or more connections from the network.
Parameters
----------
c : tespy.connections.connection
The connection to be removed from the network, connections objects
ci :code:`del_conns(c1, c2, c3, ...)`.
"""
for c in args:
self.conns = self.conns.drop(c)
msg = ('Deleted connection ' + c.s.label + ' (' + c.s_id +
') -> ' + c.t.label + ' (' + c.t_id + ') from network.')
logging.debug(msg)
# set status "checked" to false, if conneciton is deleted from network.
self.checked = False
def check_conns(self):
r"""Check connections for multiple usage of inlets or outlets."""
dub = self.conns.loc[self.conns.duplicated(['s', 's_id']) == True]
for c in dub.index:
targets = ''
for conns in self.conns[(self.conns.s == c.s) &
(self.conns.s_id == c.s_id)].index:
targets += conns.t.label + ' (' + conns.t_id + '); '
msg = ('The source ' + c.s.label + ' (' + c.s_id + ') is attached '
'to more than one target: ' + targets[:-2] + '. '
'Please check your network.')
logging.error(msg)
raise hlp.TESPyNetworkError(msg)
dub = self.conns.loc[self.conns.duplicated(['t', 't_id']) == True]
for c in dub.index:
sources = ''
for conns in self.conns[(self.conns.t == c.t) &
(self.conns.t_id == c.t_id)].index:
sources += conns.s.label + ' (' + conns.s_id + '); '
msg = ('The target ' + c.t.label + ' (' + c.t_id + ') is attached '
'to more than one source: ' + sources[:-2] + '. '
'Please check your network.')
logging.error(msg)
raise hlp.TESPyNetworkError(msg)
def add_busses(self, *args):
r"""
Add one or more busses to the network.
Parameters
----------
b : tespy.connections.bus
The bus to be added to the network, bus objects bi
:code:`add_busses(b1, b2, b3, ...)`.
"""
for b in args:
if self.check_busses(b):
self.busses[b.label] = b
msg = 'Added bus ' + b.label + ' to network.'
logging.debug(msg)
def del_busses(self, *args):
r"""
Remove one or more busses from the network.
Parameters
----------
b : tespy.connections.bus
The bus to be removed from the network, bus objects bi
:code:`add_busses(b1, b2, b3, ...)`.
"""
for b in args:
if b in self.busses.values():
del self.busses[b.label]
msg = 'Deleted bus ' + b.label + ' from network.'
logging.debug(msg)
def check_busses(self, b):
r"""
Checksthe busses to be added for type, duplicates and identical labels.
Parameters
----------
b : tespy.connections.bus
The bus to be checked.
"""
if isinstance(b, con.bus):
if len(self.busses) > 0:
if b in self.busses.values():
msg = ('Network contains the bus ' + b.label + ' (' +
str(b) + ') already.')
logging.error(msg)
raise hlp.TESPyNetworkError(msg)
elif b.label in self.busses.keys():
msg = ('Network already has a bus with the name ' +
b.label + '.')
logging.error(msg)
raise hlp.TESPyNetworkError(msg)
else:
return True
else:
return True
else:
msg = 'Only objects of type bus are allowed in *args.'
logging.error(msg)
raise TypeError(msg)
def check_network(self):
r"""Check if components are connected properly within the network."""
self.check_conns()
# get unique components in connections dataframe
comps = pd.unique(self.conns[['s', 't']].values.ravel())
# build the dataframe for components
self.init_components(comps)
# count number of incoming and outgoing connections and compare to
# expected values
for comp in self.comps.index:
num_o = (self.conns[['s', 't']] == comp).sum().s
num_i = (self.conns[['s', 't']] == comp).sum().t
if num_o != comp.num_o:
msg = (comp.label + ' is missing ' + str(comp.num_o - num_o) +
' outgoing connections. Make sure all outlets are '
' connected and all connections have been added to the '
'network.')
logging.error(msg)
# raise an error in case network check is unsuccesful
raise hlp.TESPyNetworkError(msg)
elif num_i != comp.num_i:
msg = (comp.label + ' is missing ' + str(comp.num_i - num_i) +
' incoming connections. Make sure all inlets are '
' connected and all connections have been added to the '
'network.')
logging.error(msg)
# raise an error in case network check is unsuccesful
raise hlp.TESPyNetworkError(msg)
# network checked
self.checked = True
msg = 'Networkcheck successful.'
logging.info(msg)
def init_components(self, comps):
r"""
Set up a dataframe for the network's components.
Additionally, check, if all components have unique labels.
Note
----
The dataframe for the components is derived from the network's
connections. Thus it does not hold any additional information, the
dataframe is used to simplify the code, only.
"""
self.comps = pd.DataFrame(index=comps, columns=['i', 'o'])
labels = []
for comp in self.comps.index:
# get for incoming and outgoing connections of a component
s = self.conns[self.conns.s == comp]
s = s.s_id.sort_values().index
t = self.conns[self.conns.t == comp]
t = t.t_id.sort_values().index
self.comps.loc[comp] = [t, s]
# save the incoming and outgoing as well as the number of
# connections as component attribute
comp.inl = t.tolist()
comp.outl = s.tolist()
comp.num_i = len(comp.inlets())
comp.num_o = len(comp.outlets())
labels += [comp.label]
# save the connection locations to the components
comp.conn_loc = []
for c in comp.inl + comp.outl:
comp.conn_loc += [self.conns.index.get_loc(c)]
# check for duplicates in the component labels
if len(labels) != len(list(set(labels))):
duplicates = [item for item, count in
Counter(labels).items() if count > 1]
msg = ('All Components must have unique labels, duplicates are: '
+ str(duplicates) + '.')
logging.error(msg)
raise hlp.TESPyNetworkError(msg)
def initialise(self):
r"""
Initilialise the network depending on calclation mode.
Design
- Generic fluid composition and fluid property initialisation.
- Starting values from initialisation path if provided.
Offdesign
- Check offdesign path specification.
- Set component and connection design point properties.
- Switch from design/offdesign parameter specification.
"""
if len(self.conns) == 0:
msg = ('No connections have been added to the network, please '
'make sure to add your connections with the '
'.add_conns() method.')
logging.error(msg)
raise hlp.TESPyNetworkError(msg)
if len(self.fluids) == 0:
msg = ('Network has no fluids, please specify a list with fluids '
'on network creation.')
logging.error(msg)
raise hlp.TESPyNetworkError(msg)
if self.mode == 'offdesign':
self.redesign = True
if self.design_path is None:
# must provide design_path
msg = ('Please provide \'design_path\' for every offdesign '
'calculation.')
logging.error(msg)
raise hlp.TESPyNetworkError(msg)
else:
# load design case
if self.new_design is True:
self.init_offdesign_params()
self.init_offdesign()
else:
# load design case
self.init_design()
# generic fluid initialisation
self.init_fluids()
# generic fluid property initialisation
self.init_properties()
# starting values from init path
if self.init_path is not None:
self.init_csv()
msg = 'Network initialised.'
logging.info(msg)
def init_design(self):
r"""
Initialise a design calculation.
Offdesign parameters are unset, design parameters are set. If
:code:`local_offdesign` is True for connections or components, the
design point information are read from the .csv-files in the respective
:code:`design_path`. In this case, the design values are unset, the
offdesign values set.
"""
# connections
for c in self.conns.index:
# read design point information of connections with
# local_offdesign activated from their respective design path
if c.local_offdesign is True:
if c.design_path is None:
msg = ('The parameter local_offdesign is True for the '
'connection ' + c.s.label + '(' + c.s_id + ') -> ' +
c.t.label + '(' + c.t_id + '), an individual '
'design_path must be specified in this case!')
logging.error(msg)
raise hlp.TESPyNetworkError(msg)
# unset design parameters
for var in c.design:
c.get_attr(var).set_attr(val_set=False)
# set offdesign parameters
for var in c.offdesign:
c.get_attr(var).set_attr(val_set=True)
# read design point information
path = hlp.modify_path_os(c.design_path + '/conn.csv')
msg = ('Reading individual design point information for '
'connection ' + c.s.label + '(' + c.s_id + ') -> ' +
c.t.label + '(' + c.t_id + ') from path ' +
path + '.')
logging.debug(msg)
df = pd.read_csv(path, index_col=0, delimiter=';', decimal='.')
# write data to connections
self.init_conn_design_params(c, df)
else:
# unset all design values
c.m.design = np.nan
c.p.design = np.nan
c.h.design = np.nan
c.fluid.design = OrderedDict()
c.new_design = True
# switch connections to design mode
if self.redesign is True:
for var in c.design:
c.get_attr(var).set_attr(val_set=True)
for var in c.offdesign:
c.get_attr(var).set_attr(val_set=False)
# unset design values for busses
for b in self.busses.values():
for cp in b.comps.index:
b.comps.loc[cp].P_ref = np.nan
series = pd.Series()
for cp in self.comps.index:
# read design point information of components with
# local_offdesign activated from their respective design path
if cp.local_offdesign is True:
if cp.design_path is not None:
# get type of component (class name)
c = cp.__class__.__name__
# read design point information
path = hlp.modify_path_os(cp.design_path + '/comps/' + c +
'.csv')
df = pd.read_csv(path, sep=';', decimal='.',
converters={
'busses': ast.literal_eval,
'bus_P_ref': ast.literal_eval
})
df.set_index('label', inplace=True)
# write data
self.init_comp_design_params(cp, df.loc[cp.label])
# unset design parameters
for var in cp.design:
cp.get_attr(var).set_attr(is_set=False)
# set offdesign parameters
switched = False
msg = 'Set component attributes '
for var in cp.offdesign:
# set variables provided in .offdesign attribute
data = cp.get_attr(var)
data.set_attr(is_set=True)
# take nominal values from design point
if isinstance(data, dc.dc_cp):
cp.get_attr(var).val = cp.get_attr(var).design
switched = True
msg += var + ', '
if switched:
msg = (msg[:-2] + ' to design value at component ' +
cp.label + '.')
logging.debug(msg)
cp.new_design = False
else:
# switch connections to design mode
if self.redesign is True:
for var in cp.design:
cp.get_attr(var).set_attr(is_set=True)
for var in cp.offdesign:
cp.get_attr(var).set_attr(is_set=False)
cp.set_parameters(self.mode, series)
# component initialisation
cp.comp_init(self)
def init_offdesign_params(self):
r"""
Read design point information from specified :code:`design_path`.
If a :code:`design_path` has been specified individually for components
or connections, the data will be read from the specified individual
path instead.
Note
----
The methods
:func:`tespy.networks.network.init_comp_design_params` (components) and
the :func:`tespy.networks.network.init_conn_design_params`
(connections) handle the parameter specification.
"""
# components without any parameters
not_required = ['source', 'sink', 'node', 'merge', 'splitter',
'separator', 'drum', 'subsystem_interface']
# fetch all components, reindex with label
cp_sort = self.comps.copy()
# get class name
cp_sort['cp'] = cp_sort.apply(network.get_class_base, axis=1)
cp_sort['label'] = cp_sort.apply(network.get_props, axis=1,
args=('label',))
cp_sort['comp'] = cp_sort.index
cp_sort.set_index('label', inplace=True)
# iter through unique types of components (class names)
for c in cp_sort.cp.unique():
if c not in not_required:
path = hlp.modify_path_os(self.design_path +
'/comps/' + c + '.csv')
msg = ('Reading design point information for components of '
'type ' + c + ' from path ' + path + '.')
logging.debug(msg)
# read data
df = pd.read_csv(path, sep=';', decimal='.',
converters={'busses': ast.literal_eval,
'bus_P_ref': ast.literal_eval})
df.set_index('label', inplace=True)
# iter through all components of this type and set data
for c_label in df.index:
comp = cp_sort.loc[c_label].comp
# read data of components with individual design_path
if comp.design_path is not None:
path_c = hlp.modify_path_os(comp.design_path +
'/comps/' + c + '.csv')
df_c = pd.read_csv(path_c, sep=';', decimal='.',
converters={
'busses': ast.literal_eval,
'bus_P_ref': ast.literal_eval
})
df_c.set_index('label', inplace=True)
data = df_c.loc[comp.label]
else:
data = df.loc[comp.label]
# write data to components
self.init_comp_design_params(comp, data)
msg = 'Read design point information for components.'
logging.debug(msg)
# read connection design point information
path = hlp.modify_path_os(self.design_path + '/conn.csv')
df = pd.read_csv(path, index_col=0, delimiter=';', decimal='.')
msg = ('Reading design point information for connections from path ' +
path + '.')
logging.debug(msg)
# iter through connections
for c in self.conns.index:
# read data of connections with individual design_path
if c.design_path is not None:
path_c = hlp.modify_path_os(c.design_path + '/conn.csv')
msg = ('Reading individual design point information for '
'connection ' + c.s.label + '(' + c.s_id + ') -> ' +
c.t.label + '(' + c.t_id + ') from path ' +
path_c + '.')
logging.debug(msg)
df_c = pd.read_csv(path_c, index_col=0,
delimiter=';', decimal='.')
# write data
self.init_conn_design_params(c, df_c)
else:
# write data
self.init_conn_design_params(c, df)
msg = 'Read design point information for connections.'
logging.debug(msg)
def init_comp_design_params(self, component, data):
r"""
Write design point information to components.
Parameters
----------
component : tespy.components.components.component
Write design point information to this component.
data : pandas.core.series.Series or pandas.core.frame.DataFrame
Design point information.
"""
# write component design data
component.set_parameters(self.mode, data)
# write design values to busses
i = 0
for b in data.busses:
bus = self.busses[b].comps
bus.loc[component].P_ref = data.bus_P_ref[i]
i += 1
def init_conn_design_params(self, c, df):
r"""
Write design point information to connections.
Parameters
----------
c : tespy.connections.connection
Write design point information to this connection.
df : pandas.core.frame.DataFrame
Dataframe containing design point information.
"""
# match connection (source, source_id, target, target_id) on
# connection objects of design file
conn = (df.loc[df['s'].isin([c.s.label]) & df['t'].isin([c.t.label]) &
df['s_id'].isin([c.s_id]) & df['t_id'].isin([c.t_id])])
if len(conn.index) > 0:
# read connection information
conn_id = conn.index[0]
c.m.design = df.loc[conn_id].m * self.m[df.loc[conn_id].m_unit]
c.p.design = df.loc[conn_id].p * self.p[df.loc[conn_id].p_unit]
c.h.design = df.loc[conn_id].h * self.h[df.loc[conn_id].h_unit]
c.v.design = df.loc[conn_id].v * self.v[df.loc[conn_id].v_unit]
c.x.design = df.loc[conn_id].x
c.T.design = ((df.loc[conn_id]['T'] +
self.T[df.loc[conn_id].T_unit][0]) *
self.T[df.loc[conn_id].T_unit][1])
c.Td_bp.design = (df.loc[conn_id].Td_bp *
self.T[df.loc[conn_id].T_unit][1])
for fluid in self.fluids:
c.fluid.design[fluid] = df.loc[conn_id][fluid]
else:
# no matches in the connections of the network and the design files
msg = ('Could not find connection ' + c.s.label + '(' + c.s_id +
') -> ' + c.t.label + '(' + c.t_id + ') in design case. '
'Please, make sure no connections have been modified '
'or components have been relabeled for your offdesign '
'calculation.')
logging.error(msg)
raise hlp.TESPyNetworkError(msg)
def init_offdesign(self):
r"""
Switch components and connections from design to offdesign mode.
Note
----
**components**
All parameters stated in the component's attribute :code:`cp.design`
will be unset and all parameters stated in the component's attribute
:code:`cp.offdesign` will be set instead.
Additionally, all component parameters specified as variables are
unset and the values from design point are set.
**connections**
All parameters given in the connection's attribute :code:`c.design`
will be unset and all parameters stated in the connections's attribute
:code:`cp.offdesign` will be set instead. This does also affect
referenced values!
"""
for cp in self.comps.index:
if cp.local_design is False:
# unset variables provided in .design attribute
for var in cp.design:
cp.get_attr(var).set_attr(is_set=False)
switched = False
msg = 'Set component attributes '
for var in cp.offdesign:
# set variables provided in .offdesign attribute
data = cp.get_attr(var)
data.set_attr(is_set=True)
# take nominal values from design point
if isinstance(data, dc.dc_cp):
cp.get_attr(var).val = cp.get_attr(var).design
switched = True
msg += var + ', '
if switched:
msg = (msg[:-2] + ' to design value at component ' +
cp.label + '.')
logging.debug(msg)
# start component initialisation
cp.comp_init(self)
cp.new_design = False
msg = 'Switched components from design to offdesign.'
logging.debug(msg)
for c in self.conns.index:
if c.local_design is False:
# switch connections to offdesign mode
for var in c.design:
c.get_attr(var).set_attr(val_set=False)
c.get_attr(var).set_attr(ref_set=False)
for var in c.offdesign:
c.get_attr(var).set_attr(val_set=True)
c.get_attr(var).val_SI = c.get_attr(var).design
c.new_design = False
msg = 'Switched connections from design to offdesign.'
logging.debug(msg)
def init_fluids(self):
r"""
Initialise the fluid vector on every connection of the network.
- Create fluid vector for every component as dict,
index: nw.fluids,
values: 0 if not set by user.
- Create fluid_set vector with same logic,
index: nw.fluids,
values: False if not set by user.
- If there are any combustion chambers in the network, calculate fluid
vector starting from there.
- Propagate fluid vector in direction of sources and targets.
"""
# iterate over connectons, create ordered dicts
for c in self.conns.index:
c.conn_loc = self.conns.index.get_loc(c)
tmp = c.fluid.val.copy()
tmp0 = c.fluid.val0.copy()
tmp_set = c.fluid.val_set.copy()
c.fluid.val = OrderedDict()
c.fluid.val0 = OrderedDict()
c.fluid.val_set = OrderedDict()
# if the number if fluids is one
if len(self.fluids) == 1:
c.fluid.val[self.fluids[0]] = 1
c.fluid.val0[self.fluids[0]] = 1
if self.fluids[0] in tmp_set.keys():
c.fluid.val_set[self.fluids[0]] = tmp_set[self.fluids[0]]
else:
c.fluid.val_set[self.fluids[0]] = False
# jump to next connection
continue
for fluid in self.fluids:
if fluid in tmp.keys() and fluid in tmp_set.keys():
# if fluid in keys and is_set
c.fluid.val[fluid] = tmp[fluid]
c.fluid.val0[fluid] = tmp[fluid]
c.fluid.val_set[fluid] = tmp_set[fluid]
# if there is a starting value
elif fluid in tmp0.keys():
if fluid in tmp_set.keys():
if not tmp_set[fluid]:
c.fluid.val[fluid] = tmp0[fluid]
c.fluid.val0[fluid] = tmp0[fluid]
c.fluid.val_set[fluid] = False
else:
c.fluid.val[fluid] = tmp0[fluid]
c.fluid.val0[fluid] = tmp0[fluid]
c.fluid.val_set[fluid] = False
# if fluid not in keys
else:
c.fluid.val[fluid] = 0
c.fluid.val0[fluid] = 0
c.fluid.val_set[fluid] = False
# stop fluid propagation for single fluid networks and
# for offdesign cases, as good starting values are available
if self.mode == 'offdesign' or len(self.fluids) == 1:
msg = 'Fluid initialisation done.'
logging.debug(msg)
return
# fluid propagation from set values
for c in self.conns.index:
if any(c.fluid.val_set.values()):
self.init_target(c, c.t)
self.init_source(c, c.s)
# fluid propagation for components
for cp in self.comps.index:
# combustion chamber
if isinstance(cp, combustion_chamber):
cp.initialise_fluids(self)
for c in self.comps.loc[cp].o:
self.init_target(c, c.t)
# combustion chamber
elif isinstance(cp, water_electrolyzer):
cp.initialise_fluids(self)
for c in self.comps.loc[cp].o:
self.init_target(c, c.t)
# other components (node, merge)
else:
cp.initialise_fluids(self)
for c in self.comps.loc[cp].o:
self.init_target(c, c.t)
msg = 'Fluid initialisation done.'
logging.debug(msg)
def init_target(self, c, start):
r"""
Propagate the fluids towards connection's target in recursion.
The propagation stops, if the component is a
- sink,
- merge,
- combustion chamber or
- cycle_closer.
Parameters
----------
c : tespy.connections.connection
Connection to initialise.
start : tespy.connections.connection
This connection is the fluid propagation starting point.
The starting connection is saved to prevent infinite looping.
"""
if ((len(c.t.inlets()) == 1 and len(c.t.outlets()) == 1 and
not isinstance(c.t, cycle_closer)) or
isinstance(c.t, heat_exchanger) or
isinstance(c.t, subsystem_interface)):
outc = pd.DataFrame()
outc['s'] = self.conns.s == c.t
outc['s_id'] = self.conns.s_id == c.t_id.replace('in', 'out')
conn, cid = outc['s'] == True, outc['s_id'] == True
outc = outc.index[conn & cid][0]
for fluid, x in c.fluid.val.items():
if not outc.fluid.val_set[fluid]:
outc.fluid.val[fluid] = x
self.init_target(outc, start)
if isinstance(c.t, splitter):
for outconn in self.comps.loc[c.t].o:
for fluid, x in c.fluid.val.items():
if not outconn.fluid.val_set[fluid]:
outconn.fluid.val[fluid] = x
self.init_target(outconn, start)
if isinstance(c.t, water_electrolyzer):
if c == self.comps.loc[c.t].i[0]:
outconn = self.comps.loc[c.t].o[0]
for fluid, x in c.fluid.val.items():
if not outconn.fluid.val_set[fluid]:
outconn.fluid.val[fluid] = x
if isinstance(c.t, combustion_engine):
for outconn in self.comps.loc[c.t].o[:2]:
for fluid, x in c.fluid.val.items():
if not outconn.fluid.val_set[fluid]:
outconn.fluid.val[fluid] = x
self.init_target(outconn, start)
if isinstance(c.t, drum) and c.t != start:
start = c.t
for outconn in self.comps.loc[c.t].o:
for fluid, x in c.fluid.val.items():
if not outconn.fluid.val_set[fluid]:
outconn.fluid.val[fluid] = x
self.init_target(outconn, start)
def init_source(self, c, start):
r"""
Propagate the fluids towards connection's source in recursion.
The propagation stops, if the component is a
- source,
- combustion chamber or
- cycle_closer.
Parameters
----------
c : tespy.connections.connection
Connection to initialise.
start : tespy.connections.connection
This connection is the fluid propagation starting point.
The starting connection is saved to prevent infinite looping.
"""
if ((len(c.s.inlets()) == 1 and len(c.s.outlets()) == 1 and
not isinstance(c.s, cycle_closer)) or
isinstance(c.s, heat_exchanger) or
isinstance(c.s, subsystem_interface)):
inc = pd.DataFrame()
inc['t'] = self.conns.t == c.s
inc['t_id'] = self.conns.t_id == c.s_id.replace('out', 'in')
conn, cid = inc['t'] == True, inc['t_id'] == True
inc = inc.index[conn & cid][0]
for fluid, x in c.fluid.val.items():
if not inc.fluid.val_set[fluid]:
inc.fluid.val[fluid] = x
self.init_source(inc, start)
if isinstance(c.s, splitter):
for inconn in self.comps.loc[c.s].i:
for fluid, x in c.fluid.val.items():
if not inconn.fluid.val_set[fluid]:
inconn.fluid.val[fluid] = x
self.init_source(inconn, start)
if isinstance(c.s, merge):
for inconn in self.comps.loc[c.s].i:
for fluid, x in c.fluid.val.items():
if not inconn.fluid.val_set[fluid]:
inconn.fluid.val[fluid] = x
self.init_source(inconn, start)
if isinstance(c.s, combustion_engine):
for inconn in self.comps.loc[c.s].i[:2]:
for fluid, x in c.fluid.val.items():
if not inconn.fluid.val_set[fluid]:
inconn.fluid.val[fluid] = x
self.init_source(inconn, start)
if isinstance(c.s, drum) and c.s != start:
start = c.s
for inconn in self.comps.loc[c.s].i:
for fluid, x in c.fluid.val.items():
if not inconn.fluid.val_set[fluid]:
inconn.fluid.val[fluid] = x
self.init_source(inconn, start)
def init_properties(self):
r"""
Initialise the fluid properties on every connection of the network.
- Sets standard values for :code:`m0, p0, h0` if not user specified
- Sets :code:`var = var0` if var_set is False.
- Initialises reference objects.
- Sets initial values for enthalpy at given vapour mass fraction or
temperature.
"""
# fluid properties
for c in self.conns.index:
c.init_csv = False
for key in ['m', 'p', 'h', 'T', 'x', 'v', 'Td_bp']:
if c.get_attr(key).unit_set is False and key != 'x':
if key == 'Td_bp':
c.get_attr(key).unit = self.get_attr('T_unit')
else:
c.get_attr(key).unit = self.get_attr(key + '_unit')
if (key not in ['T', 'x', 'v', 'Td_bp'] and
c.get_attr(key).val_set is False):
self.init_val0(c, key)
c.get_attr(key).val_SI = (
c.get_attr(key).val0 * self.get_attr(key)[
c.get_attr(key).unit])
elif key not in c.offdesign:
if (key not in ['T', 'x', 'v', 'Td_bp'] and
c.get_attr(key).val_set is True):
c.get_attr(key).val_SI = (
c.get_attr(key).val * self.get_attr(key)[
c.get_attr(key).unit])
elif (key == 'T' and c.T.val_set is True):
c.T.val_SI = ((c.T.val + self.T[c.T.unit][0]) *
self.T[c.T.unit][1])
elif key == 'Td_bp' and c.Td_bp.val_set is True:
c.Td_bp.val_SI = c.Td_bp.val * self.T[c.T.unit][1]
elif key == 'x' and c.x.val_set is True:
c.x.val_SI = c.x.val
elif key == 'v' and c.v.val_set is True:
c.v.val_SI = c.v.val * self.v[c.v.unit]
msg = ('Retrieved generic starting values and specified SI-values of '
'connection parameters.')
logging.debug(msg)
# improved starting values for referenced connections,
# specified vapour content values, temperature values as well as
# subccooling/overheating and state specification
for c in self.conns.index:
# starting values for fluid properties with referenced objects
for key in ['m', 'p', 'h', 'T']:
if (c.get_attr(key).ref_set and
c.get_attr(key).val_set is False):
c.get_attr(key).val_SI = (
c.get_attr(key).ref.obj.get_attr(key).val_SI *
c.get_attr(key).ref.f + c.get_attr(key).ref.d)
# starting values for specified vapour content or temperature
if c.x.val_set and not c.h.val_set:
c.h.val_SI = fp.h_mix_pQ(c.to_flow(), c.x.val_SI)
if c.T.val_set and not c.h.val_set:
try:
c.h.val_SI = fp.h_mix_pT(c.to_flow(), c.T.val_SI)
except ValueError:
pass
# starting values for specified subcooling/overheating
# and state specification
if ((c.Td_bp.val_set is True or c.state.is_set is True) and
c.h.val_set is False):
if ((c.Td_bp.val_SI > 0 and c.Td_bp.val_set is True) or
(c.state.val == 'g' and c.state.is_set is True)):
h = fp.h_mix_pQ(c.to_flow(), 1)
if c.h.val_SI < h:
c.h.val_SI = h * 1.001
elif ((c.Td_bp.val_SI < 0 and c.Td_bp.val_set is True) or
(c.state.val == 'l' and c.state.is_set is True)):
h = fp.h_mix_pQ(c.to_flow(), 0)
if c.h.val_SI > h:
c.h.val_SI = h * 0.999
msg = 'Generic fluid property specification complete.'
logging.debug(msg)
def init_val0(self, c, key):
r"""
Set starting values for fluid properties.
The component classes provide generic starting values for their inlets
and outlets.
Parameters
----------
c : tespy.connections.connection
Connection to initialise.
"""
if np.isnan(c.get_attr(key).val0):
# starting value for mass flow is 1 kg/s
if key == 'm':
c.get_attr(key).val0 = 1
# generic starting values for pressure and enthalpy
else:
# retrieve starting values from component information
val_s = c.s.initialise_source(c, key)
val_t = c.t.initialise_target(c, key)
if val_s == 0 and val_t == 0:
if key == 'p':
c.get_attr(key).val0 = 1e5
elif key == 'h':
c.get_attr(key).val0 = 1e6
elif val_s == 0:
c.get_attr(key).val0 = val_t
elif val_t == 0:
c.get_attr(key).val0 = val_s
else:
c.get_attr(key).val0 = (val_s + val_t) / 2
# change value according to specified unit system
c.get_attr(key).val0 = (
c.get_attr(key).val0 / self.get_attr(key)[
self.get_attr(key + '_unit')])
def init_csv(self):
r"""
Read starting values from specified init_path.
Note
----
This method loads fluid property and fluid components starting values
using the :code:`init_file` as input file.
"""
# match connection (source, source_id, target, target_id) on
# connection objects of design file
path = hlp.modify_path_os(self.init_path + '/conn.csv')
df = pd.read_csv(path, index_col=0, delimiter=';', decimal='.')
for c in self.conns.index:
conn = (df.loc[df['s'].isin([c.s.label]) &
df['t'].isin([c.t.label]) &
df['s_id'].isin([c.s_id]) &
df['t_id'].isin([c.t_id])])
if len(conn.index) > 0:
conn_id = conn.index[0]
# overwrite SI-values with values from init_file,
# except user specified values
if c.m.val_set is False:
c.m.val_SI = (df.loc[conn_id].m *
self.m[df.loc[conn_id].m_unit])
if c.p.val_set is False:
c.p.val_SI = (df.loc[conn_id].p *
self.p[df.loc[conn_id].p_unit])
if c.h.val_set is False:
c.h.val_SI = (df.loc[conn_id].h *
self.h[df.loc[conn_id].h_unit])
for fluid in self.fluids:
if c.fluid.val_set[fluid] is False:
c.fluid.val[fluid] = df.loc[conn_id][fluid]
# overwrite starting values
c.m.val0 = c.m.val_SI / self.m[c.m.unit]
c.p.val0 = c.p.val_SI / self.p[c.p.unit]
c.h.val0 = c.h.val_SI / self.h[c.h.unit]
c.fluid.val0 = c.fluid.val.copy()
c.init_csv = True
else:
msg = ('Could not find connection ' + c.s.label + ' (' +
c.s_id + ') -> ' + c.t.label + ' (' + c.t_id +
') in .csv-file.')
logging.debug(msg)
msg = 'Specified starting values from init_path.'
logging.debug(msg)
def solve(self, mode, init_path=None, design_path=None,
max_iter=50, init_only=False):
r"""
Solve the network.
- Check network consistency.
- Initialise calculation and preprocessing.
- Perform actual calculation.
- Postprocessing.
Parameters
----------
mode : str
Choose from 'design' and 'offdesign'.
init_path : str
Path to the folder, where your network was saved to, e. g.
saving to :code:`nw.save('myplant/tests')` would require loading
from :code:`init_path='myplant/tests'`.
design_path : str
Path to the folder, where your network's design case was saved to,
e. g. saving to :code:`nw.save('myplant/tests')` would require
loading from :code:`design_path='myplant/tests'`.
max_iter : int
Maximum number of iterations before calculation stops, default: 50.
init_only : boolean
Perform initialisation only? default: :code:`False`.
Note
----
For more information on the solution process have a look at the online
documentation at tespy.readthedocs.io in the section "using TESPy".
"""
if self.design_path == design_path and design_path is not None:
for c in self.conns.index:
if c.new_design is True:
self.new_design = True
break
for cp in self.comps.index:
if cp.new_design is True:
self.new_design = True
break
self.new_design = False
else:
self.new_design = True
self.init_path = init_path
self.design_path = design_path
self.max_iter = max_iter
if mode != 'offdesign' and mode != 'design':
msg = 'Mode must be \'design\' or \'offdesign\'.'
logging.error(msg)
raise ValueError(msg)
else:
self.mode = mode
msg = ('Solver properties: '
'mode=' + self.mode +
', init_path=' + str(self.init_path) +
', design_path=' + str(self.design_path) +
', max_iter=' + str(max_iter) +
', init_only=' + str(init_only))
logging.debug(msg)
if not self.checked:
self.check_network()
msg = ('Network properties: '
'number of components=' + str(len(self.comps.index)) +
', number of connections=' + str(len(self.conns.index)) +
', number of busses=' + str(len(self.busses)))
logging.debug(msg)
self.initialise()
if init_only:
return
self.res = np.array([])
msg = 'Starting solver.'
logging.info(msg)
self.iter = 0
# number of variables per connection
self.num_conn_vars = len(self.fluids) + 3
# check for network determination
self.solve_determination()
self.solve_loop()
if not self.progress:
msg = ('The solver does not seem to make any progress, aborting '
'calculation. Residual value is '
'{:.2e}'.format(norm(self.vec_res)) + '. This frequently '
'happens, if the solver pushes the fluid properties out of '
'their feasible range.')
logging.warning(msg)
if self.lin_dep:
msg = ('Singularity in jacobian matrix, calculation aborted! Make '
'sure your network does not have any linear dependencies '
'in the parametrisation. Other reasons might be\n'
'-> given Temperature with given pressure in two phase '
'region, try setting enthalpy instead or '
'provide accurate starting value for pressure.\n'
'-> given logarithmic temperature differences '
'or kA-values for heat exchangers, \n'
'-> support better starting values.\n'
'-> bad starting value for fuel mass flow of '
'combustion chamber, provide small (near to zero, '
'but not zero) starting value.')
logging.error(msg)
return
self.post_processing()
fp.memorise.del_memory(self.fluids)
if not self.progress:
return
msg = 'Calculation complete.'
logging.info(msg)
def solve_loop(self):
r"""Loop of the newton algorithm."""
self.start_time = time()
self.progress = True
if self.iterinfo:
self.print_iterinfo('start')
for self.iter in range(self.max_iter):
self.vec_z_filter = np.absolute(self.vec_z) < err ** 2
self.solve_control()
self.res = np.append(self.res, norm(self.vec_res))
if self.iterinfo:
self.print_iterinfo('solving')
if ((self.iter > 3 and self.res[-1] < err ** 0.5) or
self.lin_dep):
break
if self.iter > 20:
if (all(self.res[(self.iter - 3):] >= self.res[-2] * 0.95) and
self.res[-1] >= self.res[-2] * 0.95):
self.progress = False
break
self.end_time = time()
self.print_iterinfo('end')
if self.iter == self.max_iter - 1:
msg = ('Reached maximum iteration count (' + str(self.max_iter) +
'), calculation stopped. Residual value is '
'{:.2e}'.format(norm(self.vec_res)))
logging.warning(msg)
def solve_determination(self):
r"""Check, if the number of supplied parameters is sufficient."""
# number of equations from components
# component variables
self.num_comp_vars = 0
# component equations
self.num_comp_eq = 0
for cp in self.comps.index:
self.num_comp_vars += cp.num_vars
self.num_comp_eq += cp.num_eq
msg = 'Number of component equations: ' + str(self.num_comp_eq) + '.'
logging.debug(msg)
# number of equations from connections
n = 0
for c in self.conns.index:
n += [c.m.val_set, c.p.val_set, c.h.val_set, c.T.val_set,
c.x.val_set, c.v.val_set, c.Td_bp.val_set].count(True)
n += [c.m.ref_set, c.p.ref_set, c.h.ref_set,
c.T.ref_set].count(True)
n += list(c.fluid.val_set.values()).count(True)
n += [c.fluid.balance].count(True)
msg = 'Number of connection equations: ' + str(n) + '.'
logging.debug(msg)
self.num_conn_eq = n
# number of equations from busses
self.num_bus_eq = 0
for b in self.busses.values():
self.num_bus_eq += [b.P.is_set].count(True)
msg = 'Number of bus equations: ' + str(self.num_bus_eq) + '.'
logging.debug(msg)
# total number of variables
self.num_vars = (self.num_conn_vars * len(self.conns.index) +
self.num_comp_vars)
self.vec_res = np.zeros([self.num_vars])
self.vec_z = np.ones([self.num_vars])
self.mat_deriv = np.zeros((self.num_vars, self.num_vars))
msg = 'Total number of variables: ' + str(self.num_vars) + '.'
logging.debug(msg)
msg = 'Number of component variables: ' + str(self.num_comp_vars) + '.'
logging.debug(msg)
msg = ('Number of connection variables: ' +
str(self.num_conn_vars * len(self.conns.index)) + '.')
logging.debug(msg)
n = self.num_comp_eq + self.num_conn_eq + self.num_bus_eq
if n > self.num_vars:
msg = ('You have provided too many parameters: ' +
str(self.num_vars) + ' required, ' + str(n) +
' supplied. Aborting calculation!')
logging.error(msg)
raise hlp.TESPyNetworkError(msg)
elif n < self.num_vars:
msg = ('You have not provided enough parameters: '
+ str(self.num_vars) + ' required, ' + str(n) +
' supplied. Aborting calculation!')
logging.error(msg)
raise hlp.TESPyNetworkError(msg)
def print_iterinfo(self, position):
"""Print out the convergence progress."""
if position == 'start':
if self.num_comp_vars == 0:
# iterinfo printout without any custom variables
msg = ('iter\t| residual | massflow | pressure | enthalpy | '
'fluid\n')
msg += ('--------+----------+----------+----------+----------'
'+---------')
else:
# iterinfo printout with custom variables in network
msg = ('iter\t| residual | massflow | pressure | enthalpy | '
'fluid | custom\n')
msg += ('--------+----------+----------+----------+----------'
'+----------+---------')
print(msg)
elif position == 'solving':
vec = self.vec_z[0:-(self.num_comp_vars + 1)]
msg = (str(self.iter + 1))
if not self.lin_dep and not np.isnan(norm(self.vec_res)):
msg += '\t| ' + '{:.2e}'.format(norm(self.vec_res))
msg += ' | ' + '{:.2e}'.format(
norm(vec[0::self.num_conn_vars]))
msg += ' | ' + '{:.2e}'.format(
norm(vec[1::self.num_conn_vars]))
msg += ' | ' + '{:.2e}'.format(
norm(vec[2::self.num_conn_vars]))
ls = []
for f in range(len(self.fluids)):
ls += vec[3 + f::self.num_conn_vars].tolist()
msg += ' | ' + '{:.2e}'.format(norm(ls))
if self.num_comp_vars > 0:
msg += ' | ' + '{:.2e}'.format(norm(
self.vec_z[-self.num_comp_vars:]))
else:
if np.isnan(norm(self.vec_res)):
msg += '\t| nan'.format(norm(self.vec_res))
else:
msg += '\t| ' + '{:.2e}'.format(norm(self.vec_res))
msg += ' | nan'
msg += ' | nan'
msg += ' | nan'
msg += ' | nan'
if self.num_comp_vars > 0:
msg += ' | nan'
print(msg)
elif position == 'end':
if self.iterinfo:
if self.num_comp_vars == 0:
msg = ('--------+----------+----------+----------'
'+----------+---------')
else:
msg = ('--------+----------+----------+----------'
'+----------+----------+---------')
print(msg)
msg = ('Total iterations: ' + str(self.iter + 1) + ', '
'Calculation time: ' +
str(round(self.end_time - self.start_time, 1)) + ' s, '
'Iterations per second: ' +
str(round((self.iter + 1) /
(self.end_time - self.start_time), 2)))
logging.debug(msg)
if self.iterinfo:
print(msg)
else:
pass
def matrix_inversion(self):
"""Invert matrix of derivatives and caluclate increment."""
self.lin_dep = True
try:
self.vec_z = inv(self.mat_deriv).dot(-self.vec_res)
self.lin_dep = False
except np.linalg.linalg.LinAlgError:
self.vec_z = self.vec_res * 0
pass
def solve_control(self):
r"""
Control iteration step of the newton algorithm.
- Calculate the residual value for each equation
- Calculate the jacobian matrix
- Calculate new values for variables
- Restrict fluid properties to value ranges
- Check component parameters for consistency
"""
self.solve_components()
self.solve_busses()
self.solve_connections()
self.matrix_inversion()
# check for linear dependency
if self.lin_dep:
return
# add the increment
i = 0
for c in self.conns.index:
# mass flow, pressure and enthalpy
if not c.m.val_set:
c.m.val_SI += self.vec_z[i * (self.num_conn_vars)]
if not c.p.val_set:
# this prevents negative pressures
relax = max(1, -self.vec_z[i * (self.num_conn_vars) + 1] /
(0.5 * c.p.val_SI))
c.p.val_SI += self.vec_z[i * (self.num_conn_vars) + 1] / relax
if not c.h.val_set:
c.h.val_SI += self.vec_z[i * (self.num_conn_vars) + 2]
# fluid vector (only if number of fluids is greater than 1)
if len(self.fluids) > 1:
j = 0
for fluid in self.fluids:
# add increment
if not c.fluid.val_set[fluid]:
c.fluid.val[fluid] += (
self.vec_z[i * (self.num_conn_vars) + 3 + j])
# keep mass fractions within [0, 1]
if c.fluid.val[fluid] < err:
c.fluid.val[fluid] = 0
if c.fluid.val[fluid] > 1 - err:
c.fluid.val[fluid] = 1
j += 1
# check the fluid properties for physical ranges
self.solve_check_props(c)
i += 1
# increment for the custom variables
if self.num_comp_vars > 0:
c_vars = 0
for cp in self.comps.index:
for var in cp.vars.keys():
pos = var.var_pos
# add increment
var.val += self.vec_z[
self.num_conn_vars * len(self.conns) + c_vars + pos]
# keep value within specified value range
if var.val < var.min_val:
var.val = var.min_val
if var.val > var.max_val:
var.val = var.max_val
c_vars += cp.num_vars
# second property check for first three iterations without an init_file
if self.iter < 3:
for cp in self.comps.index:
cp.convergence_check(self)
for c in self.conns.index:
self.solve_check_props(c)
def property_range_message(self, c, prop):
r"""
Return debugging message for fluid property range adjustments.
Parameters
----------
c : tespy.connections.connection
Connection to check fluid properties.
prop : str
Fluid property.
Returns
-------
msg : str
Debugging message.
"""
if prop == 'p':
msg = 'Pressure '
elif prop == 'h':
msg = 'Enthalpy '
elif prop == 'm':
msg = 'Mass flow '
else:
msg = 'Unspecified '
msg += ('out of fluid property range at connection ' +
c.s.label + ' (' + c.s_id + ') -> ' + c.t.label + ' (' +
c.t_id + ') adjusting value to ' +
str(c.get_attr(prop).val_SI) + ' ' + self.SI_units[prop] + '.')
return msg
def solve_check_props(self, c):
r"""
Check for invalid fluid property values.
Parameters
----------
c : tespy.connections.connection
Connection to check fluid properties.
"""
fl = hlp.single_fluid(c.fluid.val)
if isinstance(fl, str):
# pressure
if c.p.val_SI < fp.memorise.vrange[fl][0] and not c.p.val_set:
c.p.val_SI = fp.memorise.vrange[fl][0] * 1.01
logging.debug(self.property_range_message(c, 'p'))
if c.p.val_SI > fp.memorise.vrange[fl][1] and not c.p.val_set:
c.p.val_SI = fp.memorise.vrange[fl][1] * 0.99
logging.debug(self.property_range_message(c, 'p'))
# enthalpy
f = 1.01
try:
hmin = fp.h_pT(c.p.val_SI, fp.memorise.vrange[fl][2] * f, fl)
except ValueError:
f = 1.1
hmin = fp.h_pT(c.p.val_SI, fp.memorise.vrange[fl][2] * f, fl)
hmax = fp.h_pT(c.p.val_SI, fp.memorise.vrange[fl][3] * 0.99, fl)
if c.h.val_SI < hmin and not c.h.val_set:
if hmin < 0:
c.h.val_SI = hmin / 1.05
else:
c.h.val_SI = hmin * 1.05
logging.debug(self.property_range_message(c, 'h'))
if c.h.val_SI > hmax and not c.h.val_set:
c.h.val_SI = hmax * 0.9
logging.debug(self.property_range_message(c, 'h'))
if ((c.Td_bp.val_set is True or c.state.is_set is True) and
c.h.val_set is False and self.iter < 3):
if (c.Td_bp.val_SI > 0 or
(c.state.val == 'g' and c.state.is_set is True)):
h = fp.h_mix_pQ(c.to_flow(), 1)
if c.h.val_SI < h:
c.h.val_SI = h * 1.02
logging.debug(self.property_range_message(c, 'h'))
elif (c.Td_bp.val_SI < 0 or
(c.state.val == 'l' and c.state.is_set is True)):
h = fp.h_mix_pQ(c.to_flow(), 0)
if c.h.val_SI > h:
c.h.val_SI = h * 0.98
logging.debug(self.property_range_message(c, 'h'))
elif self.iter < 4 and c.init_csv is False:
# pressure
if c.p.val_SI <= self.p_range_SI[0] and not c.p.val_set:
c.p.val_SI = self.p_range_SI[0]
logging.debug(self.property_range_message(c, 'p'))
if c.p.val_SI >= self.p_range_SI[1] and not c.p.val_set:
c.p.val_SI = self.p_range_SI[1]
logging.debug(self.property_range_message(c, 'p'))
# enthalpy
if c.h.val_SI < self.h_range_SI[0] and not c.h.val_set:
c.h.val_SI = self.h_range_SI[0]
logging.debug(self.property_range_message(c, 'h'))
if c.h.val_SI > self.h_range_SI[1] and not c.h.val_set:
c.h.val_SI = self.h_range_SI[1]
logging.debug(self.property_range_message(c, 'h'))
# temperature
if c.T.val_set and not c.h.val_set:
self.solve_check_temperature(c)
# mass flow
if c.m.val_SI <= self.m_range_SI[0] and not c.m.val_set:
c.m.val_SI = self.m_range_SI[0]
logging.debug(self.property_range_message(c, 'm'))
if c.m.val_SI >= self.m_range_SI[1] and not c.m.val_set:
c.m.val_SI = self.m_range_SI[1]
logging.debug(self.property_range_message(c, 'm'))
def solve_check_temperature(self, c):
r"""
Check if temperature is within user specified limits.
Parameters
----------
c : tespy.connections.connection
Connection to check fluid properties.
"""
hmin = fp.h_mix_pT(c.to_flow(), self.T_range_SI[0])
hmax = fp.h_mix_pT(c.to_flow(), self.T_range_SI[1])
if c.h.val_SI < hmin:
if c.h.val_SI < 0:
c.h.val_SI = hmin * 0.9
else:
c.h.val_SI = hmin * 1.1
logging.debug(self.property_range_message(c, 'h'))
if c.h.val_SI > hmax:
c.h.val_SI = hmax * 0.95
logging.debug(self.property_range_message(c, 'h'))
def solve_components(self):
r"""
Calculate the residual and derivatives of component equations.
- Iterate through components in network to get residuals and
derivatives.
- Place residual values in residual value vector of the network.
- Place partial derivatives in jacobian matrix of the network.
"""
# fetch component equation residuals and component partial derivatives
vec_res = []
sum_eq = 0
c_var = 0
for cp in self.comps.index:
indexes = []
for c in cp.conn_loc:
start = c * self.num_conn_vars
end = (c + 1) * self.num_conn_vars
indexes += [np.arange(start, end)]
cp.equations()
cp.derivatives(self.vec_z_filter[np.array(indexes)])
self.vec_res[sum_eq:sum_eq + cp.num_eq] = cp.vec_res
deriv = cp.mat_deriv
if deriv is not None:
i = 0
# place derivatives in jacobian matrix
for loc in cp.conn_loc:
coll_s = loc * self.num_conn_vars
coll_e = (loc + 1) * self.num_conn_vars
self.mat_deriv[
sum_eq:sum_eq + cp.num_eq, coll_s:coll_e] = deriv[:, i]
i += 1
# derivatives for custom variables
for j in range(cp.num_vars):
coll = self.num_vars - self.num_comp_vars + c_var
self.mat_deriv[sum_eq:sum_eq + cp.num_eq, coll] = (
deriv[:, i + j, :1].transpose()[0])
c_var += 1
sum_eq += cp.num_eq
cp.it += 1
def solve_connections(self):
r"""
Calculate the residual and derivatives of connection equations.
- Iterate through connections in network to get residuals and
derivatives.
- Place residual values in residual value vector of the network.
- Place partial derivatives in jacobian matrix of the network.
Note
----
**Equations**
**mass flow, pressure and enthalpy**
.. math::
val = 0
**temperatures**
.. math::
val = T_{j} - T \left( p_{j}, h_{j}, fluid_{j} \right)
**volumetric flow**
.. math::
val = \dot{V}_{j} - v \left( p_{j}, h_{j} \right) \cdot \dot{m}_j
**superheating or subcooling** *Works with pure fluids only!*
.. math::
val = T_{j} - td_{bp} - T_{bp}\left( p_{j}, fluid_{j} \right)
\text{td: temperature difference, bp: boiling point}
**vapour mass fraction** *Works with pure fluids only!*
.. math::
val = h_{j} - h \left( p_{j}, x_{j}, fluid_{j} \right)
**Referenced values**
**mass flow, pressure and enthalpy**
.. math::
val = x_{j} - x_{j,ref} \cdot a + b
**temperatures**
.. math::
val = T \left( p_{j}, h_{j}, fluid_{j} \right) -
T \left( p_{j}, h_{j}, fluid_{j} \right) \cdot a + b
**Derivatives**
**mass flow, pressure and enthalpy**
.. math::
J\left(\frac{\partial f_{i}}{\partial m_{j}}\right) = 1\\
\text{for equation i, connection j}\\
\text{pressure and enthalpy analogously}
**temperatures**
.. math::
J\left(\frac{\partial f_{i}}{\partial p_{j}}\right) =
-\frac{\partial T_{j}}{\partial p_{j}}\\
J(\left(\frac{\partial f_{i}}{\partial h_{j}}\right) =
-\frac{\partial T_{j}}{\partial h_{j}}\\
J\left(\frac{\partial f_{i}}{\partial fluid_{j,k}}\right) =
- \frac{\partial T_{j}}{\partial fluid_{j,k}}
\forall k \in \text{fluid components}\\
\text{for equation i, connection j}
**volumetric flow**
.. math::
J\left(\frac{\partial f_{i}}{\partial m_{j}}\right) =
-v \left( p_{j}, h_{j} \right)\\
J\left(\frac{\partial f_{i}}{\partial p_{j}}\right) =
-\frac{\partial v_{j}}{\partial p_{j}} \cdot \dot{m}_j\\
J(\left(\frac{\partial f_{i}}{\partial h_{j}}\right) =
-\frac{\partial v_{j}}{\partial h_{j}} \cdot \dot{m}_j\\
\forall k \in \text{fluid components}\\
\text{for equation i, connection j}
**superheating or subcooling** *Works with pure fluids only!*
.. math::
J\left(\frac{\partial f_{i}}{\partial p_{j}}\right) =
\frac{\partial T \left( p_{j}, h_{j}, fluid_{j} \right)}
{\partial p_{j}} -
\frac{\partial T_{bp} \left( p_{j}, fluid_{j} \right)}
{\partial p_{j}} \\
J\left(\frac{\partial f_{i}}{\partial h_{j}}\right) =
\frac{\partial T \left( p_{j}, h_{j}, fluid_{j} \right)}
{\partial h_{j}}\\
\text{for equation i, connection j}\\
\text{td: temperature difference, bp: boiling point}
**vapour mass fraction** *Works with pure fluids only!*
.. math::
J\left(\frac{\partial f_{i}}{\partial p_{j}}\right) =
-\frac{\partial h \left( p_{j}, x_{j}, fluid_{j} \right)}
{\partial p_{j}}\\
J\left(\frac{\partial f_{i}}{\partial h_{j}}\right) = 1\\
\text{for equation i, connection j, x: vapour mass fraction}
**Referenced values**
**mass flow, pressure and enthalpy**
.. math::
J\left(\frac{\partial f_{i}}{\partial m_{j}}\right) = 1\\
J\left(\frac{\partial f_{i}}{\partial m_{j,ref}}\right) = - a\\
\text{for equation i, connection j}\\
\text{pressure and enthalpy analogously}
**temperatures**
.. math::
J\left(\frac{\partial f_{i}}{\partial p_{j}}\right) =
\frac{dT_{j}}{dp_{j}}\\
J\left(\frac{\partial f_{i}}{\partial h_{j}}\right) =
\frac{dT_{j}}{dh_{j}}\\
J\left(\frac{\partial f_{i}}{\partial fluid_{j,k}}\right) =
\frac{dT_{j}}{dfluid_{j,k}}
\; , \forall k \in \text{fluid components}\\
J\left(\frac{\partial f_{i}}{\partial p_{j,ref}}\right) =
\frac{dT_{j,ref}}{dp_{j,ref}} \cdot a \\
J\left(\frac{\partial f_{i}}{\partial h_{j,ref}}\right) =
\frac{dT_{j,ref}}{dh_{j,ref}} \cdot a \\
J\left(\frac{\partial f_{i}}{\partial fluid_{j,k,ref}}\right) =
\frac{dT_{j}}{dfluid_{j,k,ref}} \cdot a
\; , \forall k \in \text{fluid components}\\
\text{for equation i, connection j}
"""
primary_vars = {'m': 0, 'p': 1, 'h': 2}
k = self.num_comp_eq
for c in self.conns.index:
flow = c.to_flow()
col = c.conn_loc * self.num_conn_vars
# referenced mass flow, pressure or enthalpy
for var, pos in primary_vars.items():
if c.get_attr(var).ref_set is True:
ref = c.get_attr(var).ref
ref_col = ref.obj.conn_loc * self.num_conn_vars
self.vec_res[k] = (
c.get_attr(var).val_SI - (
ref.obj.get_attr(var).val_SI * ref.f + ref.d))
self.mat_deriv[k, col + pos] = 1
self.mat_deriv[k, ref_col + pos] = -c.get_attr(var).ref.f
k += 1
# temperature
if c.T.val_set is True:
# if (np.absolute(self.vec_res[k]) > err ** 2 or
# self.iter % 2 == 0):
self.vec_res[k] = c.T.val_SI - fp.T_mix_ph(
flow, T0=c.T.val_SI)
# if not self.vec_z_filter[col + 1]:
self.mat_deriv[k, col + 1] = (
-fp.dT_mix_dph(flow, T0=c.T.val_SI))
# if not self.vec_z_filter[col + 2]:
self.mat_deriv[k, col + 2] = (
-fp.dT_mix_pdh(flow, T0=c.T.val_SI))
if len(self.fluids) != 1:
col_s = c.conn_loc * self.num_conn_vars + 3
col_e = (c.conn_loc + 1) * self.num_conn_vars
if not all(self.vec_z_filter[col_s:col_e]):
self.mat_deriv[k, col_s:col_e] = -fp.dT_mix_ph_dfluid(
flow, T0=c.T.val_SI)
k += 1
# referenced temperature
if c.T.ref_set is True:
ref = c.T.ref
flow_ref = ref.obj.to_flow()
ref_col = ref.obj.conn_loc * self.num_conn_vars
# if (np.absolute(self.vec_res[k]) > err ** 2 or
# self.iter % 2 == 0):
self.vec_res[k] = fp.T_mix_ph(flow, T0=c.T.val_SI) - (
fp.T_mix_ph(flow_ref, T0=ref.obj.T.val_SI) *
ref.f + ref.d)
# if not self.vec_z_filter[col + 1]:
self.mat_deriv[k, col + 1] = (
fp.dT_mix_dph(flow, T0=c.T.val_SI))
# if not self.vec_z_filter[col + 1]:
self.mat_deriv[k, col + 2] = (
fp.dT_mix_pdh(flow, T0=c.T.val_SI))
# if not self.vec_z_filter[ref_col + 1]:
self.mat_deriv[k, ref_col + 1] = -(
fp.dT_mix_dph(flow_ref, T0=ref.obj.T.val_SI) * ref.f)
# if not self.vec_z_filter[ref_col + 2]:
self.mat_deriv[k, ref_col + 2] = -(
fp.dT_mix_pdh(flow_ref, T0=ref.obj.T.val_SI) * ref.f)
# dT / dFluid
if len(self.fluids) != 1:
col_s = c.conn_loc * self.num_conn_vars + 3
col_e = (c.conn_loc + 1) * self.num_conn_vars
ref_col_s = ref.obj.conn_loc * self.num_conn_vars + 3
ref_col_e = (ref.obj.conn_loc + 1) * self.num_conn_vars
if not all(self.vec_z_filter[col_s:col_e]):
self.mat_deriv[k, col_s:col_e] = (
fp.dT_mix_ph_dfluid(flow, T0=c.T.val_SI))
if not all(self.vec_z_filter[ref_col_s:ref_col_e]):
self.mat_deriv[k, ref_col_s:ref_col_e] = -(
fp.dT_mix_ph_dfluid(flow_ref, T0=ref.obj.T.val_SI))
k += 1
# saturated steam fraction
if c.x.val_set is True:
if (np.absolute(self.vec_res[k]) > err ** 2 or
self.iter % 2 == 0):
self.vec_res[k] = c.h.val_SI - (
fp.h_mix_pQ(flow, c.x.val_SI))
if not self.vec_z_filter[col + 1]:
self.mat_deriv[k, col + 1] = -(
fp.dh_mix_dpQ(flow, c.x.val_SI))
self.mat_deriv[k, col + 2] = 1
k += 1
# volumetric flow
if c.v.val_set is True:
if (np.absolute(self.vec_res[k]) > err ** 2 or
self.iter % 2 == 0):
self.vec_res[k] = (
c.v.val_SI - fp.v_mix_ph(flow, T0=c.T.val_SI) *
c.m.val_SI)
self.mat_deriv[k, col] = -fp.v_mix_ph(flow, T0=c.T.val_SI)
self.mat_deriv[k, col + 1] = -(
fp.dv_mix_dph(flow, T0=c.T.val_SI) * c.m.val_SI)
self.mat_deriv[k, col + 2] = -(
fp.dv_mix_pdh(flow, T0=c.T.val_SI) * c.m.val_SI)
k += 1
# temperature difference to boiling point
if c.Td_bp.val_set is True:
if (np.absolute(self.vec_res[k]) > err ** 2 or
self.iter % 2 == 0):
self.vec_res[k] = (
fp.T_mix_ph(flow, T0=c.T.val_SI) - c.Td_bp.val_SI -
fp.T_bp_p(flow))
if not self.vec_z_filter[col + 1]:
self.mat_deriv[k, col + 1] = (
fp.dT_mix_dph(flow, T0=c.T.val_SI) - fp.dT_bp_dp(flow))
if not self.vec_z_filter[col + 2]:
self.mat_deriv[k, col + 2] = fp.dT_mix_pdh(
flow, T0=c.T.val_SI)
k += 1
# fluid composition balance
if c.fluid.balance:
j = 0
res = 1
for f in self.fluids:
res -= c.fluid.val[f]
self.mat_deriv[k, c.conn_loc + 3 + j] = -1
j += 1
self.vec_res[k] = res
k += 1
# equations and derivatives for specified primary variables are static
if self.iter == 0:
for c in self.conns.index:
flow = c.to_flow()
col = c.conn_loc * self.num_conn_vars
# specified mass flow, pressure and enthalpy
for var, pos in primary_vars.items():
if c.get_attr(var).val_set is True:
self.vec_res[k] = 0
self.mat_deriv[
k, col + pos] = 1
k += 1
j = 0
# specified fluid mass fraction
for f in self.fluids:
if c.fluid.val_set[f]:
self.mat_deriv[k, col + 3 + j] = 1
k += 1
j += 1
def solve_busses(self):
r"""
Calculate the equations and the partial derivatives for the busses.
- Iterate through busses in network to get residuals and derivatives.
- Place residual values in residual value vector of the network.
- Place partial derivatives in jacobian matrix of the network.
"""
row = self.num_comp_eq + self.num_conn_eq
for b in self.busses.values():
if b.P.is_set is True:
P_res = 0
for cp in b.comps.index:
i = self.comps.loc[cp].i.tolist()
o = self.comps.loc[cp].o.tolist()
bus = b.comps.loc[cp]
P_res += cp.bus_func(bus)
deriv = -cp.bus_deriv(bus)
j = 0
for c in i + o:
loc = self.conns.index.get_loc(c)
# start collumn index
coll_s = loc * self.num_conn_vars
# end collumn index
coll_e = (loc + 1) * self.num_conn_vars
self.mat_deriv[row, coll_s:coll_e] = deriv[:, j]
j += 1
self.vec_res[row] = b.P.val - P_res
row += 1
def post_processing(self):
r"""Calculate bus, component parameters and connection parameters."""
# components
self.comps.apply(network.process_components, axis=1)
# busses
for b in self.busses.values():
b.P.val = 0
for cp in b.comps.index:
# get components bus func value
val = cp.bus_func(b.comps.loc[cp])
# save as reference value
if self.mode == 'design':
b.comps.loc[cp].P_ref = (
cp.bus_func(b.comps.loc[cp]) /
abs(b.comps.loc[cp].char.evaluate(1)))
b.P.val += val
# connections
for c in self.conns.index:
c.T.val_SI = fp.T_mix_ph(c.to_flow(), T0=c.T.val_SI)
c.v.val_SI = fp.v_mix_ph(c.to_flow(), T0=c.T.val_SI) * c.m.val_SI
c.T.val = (c.T.val_SI / self.T[c.T.unit][1] - self.T[c.T.unit][0])
c.m.val = c.m.val_SI / self.m[c.m.unit]
c.p.val = c.p.val_SI / self.p[c.p.unit]
c.h.val = c.h.val_SI / self.h[c.h.unit]
c.v.val = c.v.val_SI / self.v[c.v.unit]
fluid = hlp.single_fluid(c.fluid.val)
if isinstance(fluid, str) and not c.x.val_set:
c.x.val_SI = fp.Q_ph(c.p.val_SI, c.h.val_SI, fluid)
c.x.val = c.x.val_SI
c.T.val0 = c.T.val
c.m.val0 = c.m.val
c.p.val0 = c.p.val
c.h.val0 = c.h.val
c.fluid.val0 = c.fluid.val.copy()
msg = 'Postprocessing complete.'
logging.info(msg)
def process_components(cols):
cols.name.calc_parameters()
# %% printing and plotting
def print_results(self):
r"""Print the calculations results to prompt."""
cp_sort = self.comps.copy()
# sort components by component type alphabetically
cp_sort['cp'] = cp_sort.apply(network.get_class_base, axis=1)
cp_sort['label'] = cp_sort.apply(network.get_props, axis=1,
args=('label',))
cp_sort.drop('i', axis=1, inplace=True)
cp_sort.drop('o', axis=1, inplace=True)
pd.options.mode.chained_assignment = None
for c in cp_sort.cp.unique():
df = cp_sort[cp_sort['cp'] == c]
# gather parameters to print for components of type c
cols = []
for col, val in df.index[0].attr().items():
if isinstance(val, dc.dc_cp):
if val.get_attr('printout'):
cols += [col]
# are there any parameters to print?
if len(cols) > 0:
for col in cols:
df[col] = df.apply(network.print_components, axis=1,
args=(col,))
df.set_index('label', inplace=True)
df.drop('cp', axis=1, inplace=True)
df = df.dropna(how='all')
if len(df) > 0:
# printout with tabulate
print('##### RESULTS (' + c + ') #####')
print(tabulate(df, headers='keys', tablefmt='psql',
floatfmt='.2e'))
# connection properties
df = pd.DataFrame(columns=['m / (' + self.m_unit + ')',
'p / (' + self.p_unit + ')',
'h / (' + self.h_unit + ')',
'T / (' + self.T_unit + ')'])
for c in self.conns.index:
if c.printout is True:
row = (c.s.label + ':' + c.s_id + ' -> ' +
c.t.label + ':' + c.t_id)
df.loc[row] = (
[c.m.val_SI / self.m[self.m_unit],
c.p.val_SI / self.p[self.p_unit],
c.h.val_SI / self.h[self.h_unit],
c.T.val_SI / self.T[self.T_unit][1] -
self.T[self.T_unit][0]]
)
if len(df) > 0:
print('##### RESULTS (connections) #####')
print(tabulate(df, headers='keys', tablefmt='psql',
floatfmt='.3e'))
for b in self.busses.values():
df = pd.DataFrame(columns=['component', 'value'])
if b.printout is True:
df['cp'] = b.comps.index
df['ref'] = b.comps['P_ref'].values
df['component'] = df['cp'].apply(lambda x: x.label)
df['value'] = df['cp'].apply(
lambda x: x.bus_func(b.comps.loc[x]))
df.loc['total'] = df.sum()
df.loc['total', 'component'] = 'total'
df.set_index('component', inplace=True)
df.drop('cp', axis=1, inplace=True)
print('##### RESULTS (' + b.label + ') #####')
print(tabulate(df, headers='keys', tablefmt='psql',
floatfmt='.3e'))
def print_components(c, *args):
if c.name.printout is True:
return c.name.get_attr(args[0]).val
else:
return np.nan
# %% saving
def save(self, path, **kwargs):
r"""
Save the results to results files.
Parameters
----------
filename : str
Path for the results.
Note
----
Results will be saved to path. The results contain:
- netw.csv (network information)
- conn.csv (connection information)
- folder comps containing .csv files for busses and characteristics
as well as .csv files for all types of components within your
network.
"""
if path[-1] != '/' and path[-1] != '\\':
path += '/'
path = hlp.modify_path_os(path)
logging.debug('Saving network to path ' + path + '.')
# creat path, if non existent
if not os.path.exists(path):
os.makedirs(path)
# create path for component folder if non existent
path_comps = hlp.modify_path_os(path + 'comps/')
if not os.path.exists(path_comps):
os.makedirs(path_comps)
# save all network information
self.save_network(path + 'netw.csv')
self.save_connections(path + 'conn.csv')
self.save_components(path_comps)
self.save_busses(path_comps + 'bus.csv')
self.save_characteristics(path_comps)
def save_network(self, fn):
r"""
Save basic network configuration.
Parameters
----------
fn : str
Path/filename for the network configuration file.
"""
data = {}
data['m_unit'] = self.m_unit
data['p_unit'] = self.p_unit
data['p_min'] = self.p_range[0]
data['p_max'] = self.p_range[1]
data['h_unit'] = self.h_unit
data['h_min'] = self.h_range[0]
data['h_max'] = self.h_range[1]
data['T_unit'] = self.T_unit
data['T_min'] = self.T_range[0]
data['T_max'] = self.T_range[1]
data['fluids'] = [self.fluids]
df = pd.DataFrame(data=data)
df.to_csv(fn, sep=';', decimal='.', index=False, na_rep='nan')
logging.debug('Network information saved to ' + fn + '.')
def save_connections(self, fn):
r"""
Save the connection properties.
- Uses connections object id as row identifier and saves
* connections source and target as well as
* properties with references and
* fluid vector (including user specification if structure is True).
- Connections source and target are identified by its labels.
Parameters
----------
fn : str
Path/filename for the file.
"""
f = network.get_props
df = pd.DataFrame()
# connection id
df['id'] = self.conns.apply(network.get_id, axis=1)
# general connection parameters
# source
df['s'] = self.conns.apply(f, axis=1, args=('s', 'label'))
df['s_id'] = self.conns.apply(f, axis=1, args=('s_id',))
# target
df['t'] = self.conns.apply(f, axis=1, args=('t', 'label'))
df['t_id'] = self.conns.apply(f, axis=1, args=('t_id',))
# design and offdesign properties
cols = ['design', 'offdesign', 'design_path', 'local_design',
'local_offdesign']
for key in cols:
df[key] = self.conns.apply(f, axis=1, args=(key,))
# fluid properties
cols = ['m', 'p', 'h', 'T', 'x', 'v', 'Td_bp']
for key in cols:
# values and units
df[key] = self.conns.apply(f, axis=1, args=(key, 'val'))
df[key + '_unit'] = self.conns.apply(f, axis=1, args=(key, 'unit'))
# connection parametrisation
df[key + '_unit_set'] = self.conns.apply(f, axis=1,
args=(key, 'unit_set'))
df[key + '0'] = self.conns.apply(f, axis=1, args=(key, 'val0'))
df[key + '_set'] = self.conns.apply(f, axis=1,
args=(key, 'val_set'))
df[key + '_ref'] = self.conns.apply(f, axis=1,
args=(key, 'ref', 'obj',)
).astype(str)
df[key + '_ref'] = df[key + '_ref'].str.extract(r' at (.*?)>',
expand=False)
df[key + '_ref_f'] = self.conns.apply(f, axis=1,
args=(key, 'ref', 'f',))
df[key + '_ref_d'] = self.conns.apply(f, axis=1,
args=(key, 'ref', 'd',))
df[key + '_ref_set'] = self.conns.apply(f, axis=1,
args=(key, 'ref_set',))
# state property
key = 'state'
df[key] = self.conns.apply(f, axis=1, args=(key, 'val'))
df[key + '_set'] = self.conns.apply(f, axis=1, args=(key, 'is_set'))
# fluid composition
for val in self.fluids:
# fluid mass fraction
df[val] = self.conns.apply(f, axis=1, args=('fluid', 'val', val))
# fluid mass fraction parametrisation
df[val + '0'] = self.conns.apply(f, axis=1,
args=('fluid', 'val0', val))
df[val + '_set'] = self.conns.apply(f, axis=1,
args=('fluid', 'val_set', val))
# fluid balance
df['balance'] = self.conns.apply(f, axis=1, args=('fluid', 'balance'))
df.to_csv(fn, sep=';', decimal='.', index=False, na_rep='nan')
logging.debug('Connection information saved to ' + fn + '.')
def save_components(self, path):
r"""
Save the component properties.
- Uses components labels as row identifier.
- Writes:
- component's incomming and outgoing connections (object id) and
- component's parametrisation.
Parameters
----------
path : str
Path/filename for the file.
"""
busses = self.busses.values()
# create / overwrite csv file
cp_sort = self.comps.copy()
# component type
cp_sort['cp'] = cp_sort.apply(network.get_class_base, axis=1)
# busses
cp_sort['busses'] = cp_sort.apply(network.get_busses, axis=1,
args=(busses,))
for var in ['param', 'P_ref', 'char']:
cp_sort['bus_' + var] = cp_sort.apply(network.get_bus_data, axis=1,
args=(busses, var))
pd.options.mode.chained_assignment = None
f = network.get_props
for c in cp_sort.cp.unique():
df = cp_sort[cp_sort['cp'] == c]
# basic information
cols = ['label', 'design', 'offdesign', 'design_path',
'local_design', 'local_offdesign']
for col in cols:
df[col] = df.apply(f, axis=1, args=(col,))
# attributes
for col, data in df.index[0].attr().items():
# component characteristics container
if isinstance(data, dc.dc_cc):
df[col] = df.apply(f, axis=1,
args=(col, 'func')).astype(str)
df[col] = df[col].str.extract(r' at (.*?)>', expand=False)
df[col + '_set'] = df.apply(f, axis=1,
args=(col, 'is_set'))
df[col + '_param'] = df.apply(f, axis=1,
args=(col, 'param'))
# component characteristic map container
elif isinstance(data, dc.dc_cm):
df[col] = df.apply(f, axis=1,
args=(col, 'func')).astype(str)
df[col] = df[col].str.extract(r' at (.*?)>',
expand=False)
df[col + '_set'] = df.apply(f, axis=1,
args=(col, 'is_set'))
df[col + '_param'] = df.apply(f, axis=1,
args=(col, 'param'))
# component property container
elif isinstance(data, dc.dc_cp):
df[col] = df.apply(f, axis=1, args=(col, 'val'))
df[col + '_set'] = df.apply(f, axis=1,
args=(col, 'is_set'))
df[col + '_var'] = df.apply(f, axis=1,
args=(col, 'is_var'))
# component property container
elif isinstance(data, dc.dc_simple):
df[col] = df.apply(f, axis=1, args=(col, 'val'))
df[col + '_set'] = df.apply(f, axis=1,
args=(col, 'is_set'))
# component property container
elif isinstance(data, dc.dc_gcp):
df[col] = df.apply(f, axis=1, args=(col, 'method'))
df.set_index('label', inplace=True)
df.drop('i', axis=1, inplace=True)
df.drop('o', axis=1, inplace=True)
fn = path + c + '.csv'
df.to_csv(fn, sep=';', decimal='.', index=True, na_rep='nan')
logging.debug('Component information (' + c + ') saved to ' +
fn + '.')
def save_busses(self, fn):
r"""
Save the bus properties.
Parameters
----------
fn : str
Path/filename for the file.
"""
if len(self.busses) > 0:
df = pd.DataFrame({'id': self.busses.values()},
index=self.busses.values())
df['label'] = df.apply(network.get_props, axis=1, args=('label',))
df['P'] = df.apply(network.get_props, axis=1, args=('P', 'val'))
df['P_set'] = df.apply(network.get_props, axis=1,
args=('P', 'is_set'))
df.drop('id', axis=1, inplace=True)
df.set_index('label', inplace=True)
df.to_csv(fn, sep=';', decimal='.', index=True, na_rep='nan')
logging.debug('Bus information saved to ' + fn + '.')
def save_characteristics(self, path):
r"""
Save the characteristics.
Parameters
----------
fn : str
Path/filename for the file.
"""
# components
cp_sort = self.comps
cp_sort['cp'] = cp_sort.apply(network.get_class_base, axis=1)
# characteristic lines in components
chars = []
for c in cp_sort.cp.unique():
df = cp_sort[cp_sort['cp'] == c]
for col, data in df.index[0].attr().items():
if isinstance(data, dc.dc_cc):
chars += df.apply(network.get_props, axis=1,
args=(col, 'func')).tolist()
# characteristic lines in busses
for bus in self.busses.values():
for c in bus.comps.index:
ch = bus.comps.loc[c].char
if ch not in chars:
chars += [ch]
if len(chars) > 0:
# get id and data
df = | pd.DataFrame({'id': chars}, index=chars) | pandas.DataFrame |
'''
Author:<NAME>
<EMAIL>'''
# Import required libraries
import pathlib
import dash
import numpy as np
from dash.dependencies import Input, Output, State, ClientsideFunction
import dash_core_components as dcc
import dash_html_components as html
import plotly.figure_factory as ff
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import plotly.express as px
from dateutil.relativedelta import *
from datetime import datetime
from controls import TYPE_COLORS,PORTS_COLORS,FLEET
from choropleth_map_emission import choropleth_map, sum_by_hexagon
##DataFrames
from data_filtering import processed_data
import pandas as pd
import geopandas as gpd
import os
import requests
##Databases
##Databases
panama_ports=gpd.read_file("data/Panama_ports.geojson")
canal,ports=processed_data(FLEET)
gatun=pd.read_csv("data/draught_restr_data.csv")
em=pd.read_csv("data/emissions_type_monthly.csv")
em["dt_pos_utc"]=pd.to_datetime(em["dt_pos_utc"])
pol=gpd.read_file("data/Panama_Canal.geojson")[["Name","geometry"]]
pol=pol[pol.geometry.apply(lambda x: x.geom_type=="Polygon")]
##Transform to datetime. Preferred to read csv method which is less flexible.
canal["time_at_entrance"]=pd.to_datetime(canal["time_at_entrance"])
ports["initial_service"]=pd.to_datetime(ports["initial_service"])
gatun["Date"]=pd.to_datetime(gatun["Date"])
##Ports color
panama_ports=panama_ports.assign(color="#F9A054")
# get relative data folder
PATH = pathlib.Path(__file__).parent
DATA_PATH = PATH.joinpath("data").resolve()
app = dash.Dash(
__name__, meta_tags=[{"name": "viewport", "content": "width=device-width"}]
)
app.title = 'Panama Maritime Stats'
server = app.server
# Create global chart template
MAPBOX_TOKEN = os.environ.get('MAPBOX_TOKEN', None)
layout_map = dict(
autosize=True,
paper_bgcolor='#30333D',
plot_bgcolor='#30333D',
margin=dict(l=10, r=10, b=10, t=10),
hovermode="closest",
font=dict(family="HelveticaNeue",size=17,color="#B2B2B2"),
legend=dict(font=dict(size=10), orientation="h"),
mapbox=dict(
accesstoken=MAPBOX_TOKEN,
style='mapbox://styles/gabrielfuenmar/ckhs87tuj2rd41amvifhb26ad',
center=dict(lon=-79.55, lat=8.93),
zoom=9,
),
showlegend=False,
)
layout= dict(
legend=dict(bgcolor='rgba(0,0,0,0)',font=dict(size=14,family="HelveticaNeue")),
font_family="HelveticaNeue",
font_color="#B2B2B2",
title_font_family="HelveticaNeue",
title_font_color="#B2B2B2",
title_font_size=20,
paper_bgcolor='#21252C',
plot_bgcolor='#21252C',
xaxis=dict(gridcolor="rgba(178, 178, 178, 0.1)",title_font_size=15,
tickfont_size=14,title_font_family="HelveticaNeue",tickfont_family="HelveticaNeue"),
yaxis=dict(gridcolor="rgba(178, 178, 178, 0.1)",title_font_size=15,tickfont_size=14,
title_font_family="HelveticaNeue",tickfont_family="HelveticaNeue")
)
##Modebar on graphs
config={"displaylogo":False, 'modeBarButtonsToRemove': ['autoScale2d']}
##Annotation on graphs
annotation_layout=dict(
xref="x domain",
yref="y domain",
x=0.25,
y=-0.35)
# Create app layout
app.layout = html.Div(
[
dcc.Store(id="aggregate_data"),
# empty Div to trigger javascript file for graph resizing
html.Div(id="output-clientside"),
html.Div(
[
html.Div(
[
html.A(html.Img(
src=app.get_asset_url("mtcc_logo_v3.png"),
id="plotly-image",
style={
"height": "160px",
"width": "auto",
"margin-bottom": "0px",
"text-align": "center"
},
),
href="https://mtcclatinamerica.com/")
],
className="one-half column",
),
html.Div(
[
html.Div(
[
html.H3(
"Panama Maritime Statistics",
style={"margin-bottom": "0px"},
),
html.H5(
"Efficiency and Sustainability Indicators", style={"margin-top": "0px"}
),
]
)
],
className="one-half column",
id="title",
),
html.Div(
[
html.Button("Refresh", id="refresh-button"),
html.A(
html.Button("Developer", id="home-button"),
href="https://gabrielfuentes.org",
)
],
className="one-third column",
id="button",
style={
"text-align": "center"},
),
],
id="header",
className="row flex-display",
style={"margin-bottom": "15px"},
),
html.Div(
[
html.Div(
[
html.P("Date Filter",
className="control_label",
),
html.Div([html.P(id="date_from"),
html.P(id="date_to")],className="datecontainer")
,
dcc.RangeSlider(
id="year_slider",
min=0,
max=20,
value=[0, 20],
marks={
0:"Dec 2018",
5:"May 2019",
10:"Oct 2019",
15:"Mar 2020",
20:"Aug 2020"},
allowCross=False,
className="dcc_control",
),
html.P("Vessel Type:", className="control_label"),
dcc.Dropdown(
id='types-dropdown',
options=[{'label': row,'value': row} \
for row in sorted(FLEET)],
placeholder="All",multi=True,
className="dcc_control"),
html.P("Port:", className="control_label"),
dcc.Dropdown(
id='ports-dropdown',
options=[{'label': row,'value': row} \
for row in sorted(ports[~ports.port_name.isin(["Pacific - PATSA","Colon2000"])]\
.dropna(subset=["port_name"]).port_name.unique())+["Panama Canal South", "Panama Canal North"]],
placeholder="All",multi=True,
className="dcc_control"),
html.P(
"Vessel Size (GT)",
className="control_label",
),
html.Div([html.P(id="size_from"),
html.P(id="size_to")],className="datecontainer"),
dcc.RangeSlider(
id="size_slider",
min=400,
max=170000,
value=[400, 170000],
step=8500,
marks={
400:"400",
35000:"35k",
70000:"70k",
105000:"105k",
140000:"140k",
170000:"170k"},
allowCross=False,
className="dcc_control",
),
],
className="pretty_container four columns",
id="cross-filter-options",
),
html.Div(
[
html.Div(
[
html.Div(
[html.H6(id="waitingText"), html.P("Waiting Average")],
id="waiting",
className="mini_container",
),
html.Div(
[html.H6(id="opsText"), html.P("Operations")],
id="ops",
className="mini_container",
),
html.Div(
[html.H6(id="serviceText"), html.P("Service Average")],
id="service_m",
className="mini_container",
),
html.Div(#####Hardcoded for the time being. Build a scrapper.
[html.H6(["15.24 m"],id="draughtText"), html.P("Canal Max Draught TFW")],
id="draught",
className="mini_container",
),
],
id="info-container",
className="row container-display",
),
html.Div([
html.Div(
[
html.Div([html.H5("Emissions Review"),
html.H6(id="month_map",style={"color":"white"})],
style={"display": "flex", "flex-direction": "row","justify-content":"space-between"}),
dcc.Graph(animate=False,config=config,id="map_in"),
html.P(["Grid size"],id="grid_size",className="control_label"),
dcc.Slider(
id="zoom_slider",
min=4,
max=8,
value=8,
marks={
4:{'label': '1'},5:{'label': '2'},6:{'label': '3'},
7:{'label': '4'},8:{'label': '5'}},
className="dcc_control",
included=False),
dcc.RadioItems(
id='selector',options=[{'label': "CO2 emissions", 'value': "co2"},
{'label': "CH4 emissions", 'value': "ch4"}],
value="co2",labelStyle={'display': 'inline-block'}),
],
id="emissionsMapContainer",
className="pretty_container eight columns",
)
],
className="row flex-display",
),
],
id="right-column",
className="eight columns",
),
],
className="row flex-display",
),
html.Div(
[
html.Div(
[dcc.Graph(id="service_graph",config=config)],
className="pretty_container six columns",
),
html.Div(
[dcc.Graph(id="waiting_graph",config=config)],
className="pretty_container six columns",
)
],
className="row flex-display",
),
html.Div(
[
html.Div(
[dcc.Graph(id="draught_graph",config=config)],
className="pretty_container six columns",
),
html.Div(
[dcc.Graph(id="ratio_graph",config=config)],
className="pretty_container six columns",
),
],
className="row flex-display",
),
],
id="mainContainer",
style={"display": "flex", "flex-direction": "column"},
)
def upper_text_p1(fr="01-01-2019",to="18-11-2020",ports_sel=["All"],
type_vessel=["All"],size=["All"],text_bar=True,*args):
date_from= | pd.to_datetime(fr) | pandas.to_datetime |
import os
import pandas as pd
import numpy as np
import random
from human_ISH_config import *
import h5py
import time
from shutil import copyfile
import operator
import matplotlib.pyplot as plt
import math
import json
random.seed(1)
def get_stats(images_info_df):
"""
Uses the images_info_df and calculates some stats.
:param images_info_df: pandas dataframe that has the information of all image
:return: a dictionary containing stats.
"""
stats_dict = {'image_count':None, 'donor_count':None, 'female_donor_count':None, 'male_donor_count':None,
'unique_genes_count': None, 'unique_entrez_id_count' : None}
image_id_list = images_info_df['image_id']
gene_symbol_list = images_info_df['gene_symbol']
entrez_id_list = images_info_df['entrez_id']
experiment_id_list = images_info_df['experiment_id']
specimen_id_list = images_info_df['specimen_id']
donor_id_list = images_info_df['donor_id']
donor_sex_list = images_info_df['donor_sex']
female_donors = images_info_df[images_info_df['donor_sex'] == 'F']
male_donors = images_info_df[images_info_df['donor_sex'] == 'M']
# -----------
# How many donors does this study have? How many are female and how many are male?
donors_count = len(set(images_info_df['donor_id']))
print ("Total number of donors: {}".format(donors_count))
female_donors_count = len(set(female_donors['donor_id']))
print("Number of female donors: {}".format(female_donors_count))
male_donors_count = len(set(male_donors['donor_id']))
print("Number of male donors: {}".format(male_donors_count))
if female_donors_count + male_donors_count != donors_count:
print ("something is not right about the number of female and male donors ...")
# -----------
# How many unique genes does this study include?
gene_count = len(set(gene_symbol_list))
print ("Number of unique genes: {}".format(gene_count))
entrez_id_count = len(set(entrez_id_list))
print("Number of unique entrez IDs: {}".format(entrez_id_count))
if entrez_id_count != gene_count:
print ("something is not right. The number of unique genes should be equal to the number of unique entrez IDs")
# -----------
# How many genes have been tested from each donor.
# How many images do we have from each donor.
group_by_donor = images_info_df.groupby('donor_id')
unique_gene_count_per_donor_list = []
unique_image_count_per_donor_list = []
for key, item in group_by_donor:
this_group_genes = group_by_donor.get_group(key)['gene_symbol']
this_group_images = group_by_donor.get_group(key)['image_id']
unique_gene_count_per_donor_list.append(len(set(this_group_genes)))
unique_image_count_per_donor_list.append(len(set(this_group_images)))
print("Minimum number of unique genes from a donor: {}".format(min(unique_gene_count_per_donor_list)))
print("Maximum number of unique genes from a donor: {}".format(max(unique_gene_count_per_donor_list)))
print("Average number of unique genes from a donor: {}".format(np.mean(unique_gene_count_per_donor_list)))
print("Minimum number of images from a donor: {}".format(min(unique_image_count_per_donor_list)))
print("Maximum number of images from a donor: {}".format(max(unique_image_count_per_donor_list)))
print("Average number of images from a donor: {}".format(np.mean(unique_image_count_per_donor_list)))
# -----------
# How many images do we have from each gene.
# How many donors do we have from each gene.
group_by_gene = images_info_df.groupby('gene_symbol')
unique_donor_count_per_gene_list = []
unique_image_count_per_gene_list = []
for key, item in group_by_gene:
this_group_donors = group_by_gene.get_group(key)['donor_id']
this_group_images = group_by_gene.get_group(key)['image_id']
unique_donor_count_per_gene_list.append(len(set(this_group_donors)))
unique_image_count_per_gene_list.append(len(set(this_group_images)))
print("Minimum number of unique donors from a gene: {}".format(min(unique_donor_count_per_gene_list)))
print("Maximum number of unique donors from a gene: {}".format(max(unique_donor_count_per_gene_list)))
print("Average number of unique donors from a gene: {}".format(np.mean(unique_donor_count_per_gene_list)))
print("Minimum number of images from a gene: {}".format(min(unique_image_count_per_gene_list)))
print("Maximum number of images from a gene: {}".format(max(unique_image_count_per_gene_list)))
print("Average number of images from a gene: {}".format(np.mean(unique_image_count_per_gene_list)))
gene_on_all_donors_count = 0
gene_on_only_one_donor_count = 0
for item in unique_donor_count_per_gene_list:
if item == donors_count:
gene_on_all_donors_count +=1
if item == 1:
gene_on_only_one_donor_count += 1
print ("There are {} genes that have been sampled from all the {} donors.".format(gene_on_all_donors_count, donors_count))
print ("There are {} genes that have been sampled from only 1 donor.".format(gene_on_only_one_donor_count))
# -----------
stats_dict['image_count'] = len(image_id_list)
stats_dict['donor_count'] = donors_count
stats_dict['female_donor_count'] = female_donors_count
stats_dict['male_donor_count'] = male_donors_count
stats_dict['unique_genes_count'] = gene_count
stats_dict['unique_entrez_id_count'] = entrez_id_count
# -------------------
# I want to group by donor, in each donor, see on average, how many images there are per gene
# and then average over all the donors
group_by_donor = images_info_df.groupby('donor_id')
avg_num_of_imaes_per_gene_list = []
for key, item in group_by_donor:
# for each donor
this_group_genes = list(group_by_donor.get_group(key)['gene_symbol']) # get a list of its genes (has duplicates)
# for each unique genes, see how many times it appears in the list (== how many images we have of it in this donor)
this_group_genes_count_list = [[x,this_group_genes.count(x)] for x in set(this_group_genes)]
sum = 0
for item in this_group_genes_count_list:
sum += item[1]
# in this donor, on average, we have 'avg' number of images per each gene.
avg = sum / len(this_group_genes_count_list)
# append it to the list
avg_num_of_imaes_per_gene_list.append(avg)
avg_num_of_images_per_gene_in_each_donor_over_all = np.mean(avg_num_of_imaes_per_gene_list)
print ("Average number of images per each gene in each donor, Over all donors: ",avg_num_of_images_per_gene_in_each_donor_over_all)
return stats_dict
def define_sets_with_no_shared_genes(images_info_df):
"""
We want to create training, validation, and test set.
The condition is that the sets should not have any genes in common.
If INCLUDE_SZ_DATA flag is set to false, we want to make sure there are no schizophrenia genes in the training set.
if TRAIN_ON_ALL flag is set to True, then all the genes will be considered as training. We won't have a validation or test.
:param images_info_df: pandas dataframe that has the information of all image
:return: 3 pandas dataframes: training, validation, test
"""
unique_genes = list(np.unique(images_info_df['gene_symbol']))
total_unique_gene_count = len(unique_genes)
print(total_unique_gene_count)
if TRAIN_ON_ALL == False:
test_genes_count = int((TEST_SPLIT / 100.0) * total_unique_gene_count)
validation_gene_count = int((VALIDATION_SPLIT / 100.0) * total_unique_gene_count)
test_genes = random.sample(unique_genes, test_genes_count)
remaining_genes = [x for x in unique_genes if x not in test_genes]
validation_genes = random.sample(remaining_genes, validation_gene_count)
training_genes = [x for x in remaining_genes if x not in validation_genes]
# ------- filter SZ genes if necessary -------
if INCLUDE_SZ_DATA == False:
path_to_SZ_info = os.path.join(DATA_DIR, "schizophrenia", "human_ISH_info.csv")
sz_info_df = pd.read_csv(path_to_SZ_info)
sz_unique_genes = list(set(list(sz_info_df['gene_symbol'])))
print(
"There are {} genes in the training set. {} schizophrenia-associated genes will be removed"
.format(len(training_genes), len(sz_unique_genes)))
training_genes = [x for x in training_genes if x not in sz_unique_genes]
print ("Number of remaining genes: {}".format(len(training_genes)))
# --------------------------------------------
training_df = images_info_df[images_info_df['gene_symbol'].isin(training_genes)]
validation_df = images_info_df[images_info_df['gene_symbol'].isin(validation_genes)]
test_df = images_info_df[images_info_df['gene_symbol'].isin(test_genes)]
training_df = training_df.sort_values(by=['image_id'])
validation_df = validation_df.sort_values(by=['image_id'])
test_df = test_df.sort_values(by=['image_id'])
train_val_df = pd.concat([training_df, validation_df], ignore_index=True)
train_val_df = train_val_df.sort_values(by=['image_id'])
sets_path = os.path.join(DATA_DIR, STUDY, "sets_"+str(PATCH_COUNT_PER_IMAGE)+"_patches_"+str(SEGMENTATION_TRAINING_SAMPLES)+"_seg")
if (not os.path.exists(sets_path)):
os.mkdir(sets_path)
if INCLUDE_SZ_DATA == True:
training_df.to_csv(os.path.join(sets_path, "training.csv"), index=None)
train_val_df.to_csv(os.path.join(sets_path, "training_validation.csv"), index=None)
else:
training_df.to_csv(os.path.join(sets_path, "no_sz_training.csv"), index=None)
train_val_df.to_csv(os.path.join(sets_path, "no_sz_training_validation.csv"), index=None)
validation_df.to_csv(os.path.join(sets_path, "validation.csv"), index=None)
test_df.to_csv(os.path.join(sets_path, "test.csv"), index=None)
else:
print ("-" * 50)
print ('TRAINING ON ALL')
print("-" * 50)
training_genes = [x for x in unique_genes]
# ------- filter SZ genes if necessary -------
if INCLUDE_SZ_DATA == False:
path_to_SZ_info = os.path.join(DATA_DIR, "schizophrenia", "human_ISH_info.csv")
sz_info_df = pd.read_csv(path_to_SZ_info)
sz_unique_genes = list(set(list(sz_info_df['gene_symbol'])))
print(
"There are {} genes in the training set. {} schizophrenia-associated genes will be removed"
.format(len(training_genes), len(sz_unique_genes)))
training_genes = [x for x in training_genes if x not in sz_unique_genes]
print("Number of remaining genes: {}".format(len(training_genes)))
# --------------------------------------------
training_df = images_info_df[images_info_df['gene_symbol'].isin(training_genes)]
training_df = training_df.sort_values(by=['image_id'])
validation_df = None
test_df = None
train_val_df = None
sets_path = os.path.join(DATA_DIR, STUDY, "sets_" + str(PATCH_COUNT_PER_IMAGE) + "_patches_" + str(
SEGMENTATION_TRAINING_SAMPLES) + "_seg")
if (not os.path.exists(sets_path)):
os.mkdir(sets_path)
if INCLUDE_SZ_DATA == True:
training_df.to_csv(os.path.join(sets_path, "all_training.csv"), index=None)
else:
training_df.to_csv(os.path.join(sets_path, "no_sz_all_training.csv"), index=None)
return training_df, validation_df, test_df, train_val_df
def define_sets_with_no_shared_donors(images_info_df):
"""
We want to create training, validation, and test set.
The condition is that the sets should not have any donors in common.
:param images_info_df: pandas dataframe that has the information of all image
:return: 3 pandas dataframes: training, validation, test
"""
gene_count_threshold_for_test_set = 60 #70
gene_count_threshold_for_validation_set = 85 #90
group_by_donor = images_info_df.groupby('donor_id')
test_set_donor_list = []
validation_set_donor_list = []
training_set_donor_list = []
for key, item in group_by_donor:
this_group_genes = group_by_donor.get_group(key)['gene_symbol']
if len(set(this_group_genes)) < gene_count_threshold_for_test_set:
test_set_donor_list.append(key)
elif len(set(this_group_genes)) < gene_count_threshold_for_validation_set:
validation_set_donor_list.append(key)
else:
training_set_donor_list.append(key)
print ("\n---- test set ----")
#print (test_set_info_list)
test_set_image_count = 0
test_set_gene_list = []
test_set_donor_count = len(test_set_donor_list)
for item in test_set_donor_list:
this_group_images = group_by_donor.get_group(item)['image_id']
this_group_genes = group_by_donor.get_group(item)['gene_symbol']
test_set_image_count += len(set(this_group_images))
test_set_gene_list.extend(set(this_group_genes))
print ("number of donors in test set: ",test_set_donor_count)
print ("test set image count" , test_set_image_count)
print("test set unique gene count", len(set(test_set_gene_list)))
print("\n---- validation set ----")
#print(validation_set_info_list)
validation_set_image_count = 0
validation_set_gene_list= []
validation_set_donor_count = len(validation_set_donor_list)
for item in validation_set_donor_list:
this_group_images = group_by_donor.get_group(item)['image_id']
this_group_genes = group_by_donor.get_group(item)['gene_symbol']
validation_set_image_count += len(set(this_group_images))
validation_set_gene_list.extend(set(this_group_genes))
print("number of donors in validation set: ",validation_set_donor_count)
print("validation set image count", validation_set_image_count)
print("validation set unique gene count", len(set(validation_set_gene_list)))
print("\n---- training set ----")
#print(training_set_info_list)
training_set_image_count = 0
training_set_gene_list = []
training_set_donor_count = len(training_set_donor_list)
for item in training_set_donor_list:
this_group_images = group_by_donor.get_group(item)['image_id']
this_group_genes = group_by_donor.get_group(item)['gene_symbol']
training_set_image_count += len(set(this_group_images))
training_set_gene_list.extend(set(this_group_genes))
print("number of donors in training set: ",training_set_donor_count)
print("training set image count", training_set_image_count)
print("training set unique gene count", len(set(training_set_gene_list)))
print ("\n")
#----------
training_df = images_info_df[images_info_df['donor_id'].isin(training_set_donor_list)]
validation_df = images_info_df[images_info_df['donor_id'].isin(validation_set_donor_list)]
test_df = images_info_df[images_info_df['donor_id'].isin(test_set_donor_list)]
training_df = training_df.sort_values(by=['image_id'])
validation_df = validation_df.sort_values(by=['image_id'])
test_df = test_df.sort_values(by=['image_id'])
sets_path = os.path.join(DATA_DIR, STUDY, "sets_" + str(PATCH_COUNT_PER_IMAGE) + "_patches_"+str(SEGMENTATION_TRAINING_SAMPLES)+"_seg")
if (not os.path.exists(sets_path)):
os.mkdir(sets_path)
training_df.to_csv(os.path.join(sets_path, "training.csv"), index=None)
validation_df.to_csv(os.path.join(sets_path, "validation.csv"), index=None)
test_df.to_csv(os.path.join(sets_path, "test.csv"), index=None)
return training_df, validation_df, test_df
def compare_set_genes_list(training_df, validation_df, test_df):
"""
Compare the 3 sets to see how many genes they have in common.
:param training_df: pandas dataframe containing the training data
:param validation_df: pandas dataframe containing the validation data
:param test_df: pandas dataframe containing the test data
:return: 4 lists. Each list has the shared genes between different sets:
genes shared between train and validation
genes shared between train and test
genes shared between validation and test
genes shared between all 3 sets
"""
train_set_genes = set(training_df['gene_symbol'])
validation_set_genes = set(validation_df['gene_symbol'])
test_set_genes = set(test_df['gene_symbol'])
train_validation_shared_genes_list = list(set(train_set_genes) & set(validation_set_genes))
train_test_shared_genes_list = list(set(train_set_genes) & set(test_set_genes))
validation_test_shared_genes_list = list(set(test_set_genes) & set(validation_set_genes))
all_shared_genes_list = list(set(train_set_genes) & set(validation_set_genes) & set(test_set_genes))
print("Number of shared genes between train and validation: ", len(train_validation_shared_genes_list))
print("Number of shared genes between train and test: ", len(train_test_shared_genes_list))
print("Number of shared genes between validation and test: ", len(validation_test_shared_genes_list))
print("Number of shared genes between all 3 sets: ", len(all_shared_genes_list))
print ("\n")
return train_validation_shared_genes_list, train_test_shared_genes_list, validation_test_shared_genes_list, all_shared_genes_list
def create_new_sets_by_removing_shared_genes(images_info_df, training_df, validation_df, test_df, train_validation_shared_genes_list,
train_test_shared_genes_list, validation_test_shared_genes_list, all_shared_genes_list):
"""
This function gets the set dataframes and the list of genes that are shared between them.
It then modifies validation set so that it doesn't have any genes shared with test set.
And modifies training set so that it doesn't have any genes shared with the new validation set and the test set.
:param images_info_df: pandas dataframe that has the information of all image
:param training_df: pandas dataframe containing the training data
:param validation_df: pandas dataframe containing the validation data
:param test_df: pandas dataframe containing the test data
:param train_validation_shared_genes_list: list of genes shared between train and validation
:param train_test_shared_genes_list: list of genes shared between train and test
:param validation_test_shared_genes_list: list of genes shared between validation and test
:param all_shared_genes_list: list of genes shared between all 3 sets
:return: 3 dataframes: training, validation, test
"""
print ("Modifying the sets...")
# -----------
#print ("---- Handling validation")
validation_set_genes = set(validation_df['gene_symbol'])
genes_not_shared_between_val_test = set(validation_set_genes) - set(validation_test_shared_genes_list)
new_validation_df = validation_df[validation_df['gene_symbol'].isin(genes_not_shared_between_val_test)]
new_validation_images = set(new_validation_df['image_id'])
new_validation_genes = set(new_validation_df['gene_symbol'])
#print ("new_validation_set_image_count: ", len(new_validation_images))
#print("new_validation_set_gene_count: ",len(new_validation_genes))
#print ("\n")
# ----------
#print ("---- Handling training")
training_set_genes = set(training_df['gene_symbol'])
genes_not_shared_between_train_validation_test = set(training_set_genes) - set(train_test_shared_genes_list) - set(new_validation_genes)
new_training_df = training_df[training_df['gene_symbol'].isin(genes_not_shared_between_train_validation_test)]
new_training_genes = set(new_training_df['gene_symbol'])
new_training_images = set(new_training_df['image_id'])
#print("new_training_set_image_count: ", len(new_training_images))
#print("new_training_set_gene_count: ", len(new_training_genes))
#print("\n")
return new_training_df, new_validation_df, test_df
def get_stats_on_sets(stats_dict, training_df, validation_df, test_df):
"""
Calculates some stats on the sets.
:param images_info_df: pandas dataframe that has the information of all image
:param training_df: pandas dataframe containing the training data
:param validation_df: pandas dataframe containing the validation data
:param test_df: pandas dataframe containing the test data
:return: None
"""
original_image_count = stats_dict['image_count']
original_gene_count = stats_dict['unique_genes_count']
# ----- training info ------
training_genes_count = len(set(training_df['gene_symbol']))
training_images_count = len(set(training_df['image_id']))
training_donor_count = len(set(training_df['donor_id']))
print ("\n---- Train ----")
print ("image count: ", training_images_count)
print ("gene count: ", training_genes_count)
print ("donor count: ", training_donor_count)
# ----- validation info -----
if validation_df is not None:
validation_images_count = len(set(validation_df['image_id']))
validation_genes_count = len(set(validation_df['gene_symbol']))
validation_donor_count = len(set(validation_df['donor_id']))
else:
validation_images_count = 0
validation_genes_count = 0
validation_donor_count = 0
print("\n---- Validation ----")
print("image count: ", validation_images_count)
print("gene count: ", validation_genes_count)
print("donor count: ", validation_donor_count)
# ----- test info ------
if test_df is not None:
test_images_count = len(set(test_df['image_id']))
test_genes_count = len(set(test_df['gene_symbol']))
test_donor_count = len(set(test_df['donor_id']))
else:
test_images_count = 0
test_genes_count = 0
test_donor_count = 0
print("\n---- Test ----")
print("image count: ", test_images_count)
print("gene count: ", test_genes_count)
print("donor count: ", test_donor_count)
current_image_count = training_images_count + validation_images_count + test_images_count
current_gene_count = training_genes_count + validation_genes_count + test_genes_count
print ("original image count: ", original_image_count)
print ("original gene count: ", original_gene_count)
print("\n")
print("current image count: ", current_image_count)
print("current gene count: ", current_gene_count)
print("\n")
print (original_image_count - current_image_count , " images thrown away")
print (original_gene_count - current_gene_count, " genes thrown away")
print ("\n")
print ("Train image percentage: ", (training_images_count/current_image_count)*100)
print("Validation image percentage: ", (validation_images_count / current_image_count) * 100)
print("Test image percentage: ", (test_images_count / current_image_count) * 100)
def donor_info(my_set):
group_by_donor = my_set.groupby('donor_id')
unique_gene_count_per_donor_list = []
unique_image_count_per_donor_list = []
for key, item in group_by_donor:
this_group_genes = group_by_donor.get_group(key)['gene_symbol']
this_group_images = group_by_donor.get_group(key)['image_id']
unique_gene_count_per_donor_list.append((key,len(set(this_group_genes))))
unique_image_count_per_donor_list.append((key,len(set(this_group_images))))
print("\ngene count per donor: ")
print (unique_gene_count_per_donor_list)
print ("\nimage count per donor: ")
print (unique_image_count_per_donor_list)
def make_triplet_csv_no_segmentation(df, out_file):
"""
Use this function to create input suited for the triplet-reid training scripts
"""
if df is not None:
temp_df = df.assign(image=lambda df: df.image_id.apply(lambda row: "{}.jpg".format(row)))[['gene_symbol', 'image']]
new_image_info= []
total_number_of_circles = NUMBER_OF_CIRCLES_IN_HEIGHT * NUMBER_OF_CIRCLES_IN_WIDTH
for patch_index in range(1, total_number_of_circles+1):
patch_image_list = [(id.split(".")[0]+"_"+str(patch_index)+".jpg",gene) for id, gene in zip(temp_df['image'],temp_df['gene_symbol'])]
new_image_info += patch_image_list
new_df = pd.DataFrame(columns=['gene_symbol','image'])
new_df['image'] = [item[0] for item in new_image_info]
new_df['gene_symbol'] = [item[1] for item in new_image_info]
new_df = new_df.sort_values(by=['image'])
return (new_df.to_csv(out_file, index=False, header=False))
else:
return None
def make_triplet_csv_with_segmentation(df, out_file):
print ("_"*50)
print ("OUT FILE is: ", out_file)
if df is not None:
csv_file_name = "less_than_" + str(PATCH_COUNT_PER_IMAGE) + ".csv"
not_enough_patches_df = pd.read_csv(os.path.join(DATA_DIR, STUDY, "segmentation_data","trained_on_"+str(SEGMENTATION_TRAINING_SAMPLES) ,"outlier_images", csv_file_name))
not_enough_patches_dict = dict(zip(not_enough_patches_df["image_id"], not_enough_patches_df["count"]))
temp_df = df.assign(image=lambda df: df.image_id.apply(lambda row: "{}.jpg".format(row)))[['gene_symbol', 'image']]
new_image_info = []
for id, gene in zip(temp_df['image'],temp_df['gene_symbol']):
id_temp = int(id.split(".")[0])
if id_temp in not_enough_patches_dict:
count = not_enough_patches_dict[id_temp]
for patch_index in range(0, count):
patch_image_list = [(id.split(".")[0] + "_" + str(patch_index) + ".jpg", gene)]
new_image_info += patch_image_list
else:
for patch_index in range(0, PATCH_COUNT_PER_IMAGE):
patch_image_list = [(id.split(".")[0] + "_" + str(patch_index) + ".jpg", gene)]
new_image_info += patch_image_list
new_df = pd.DataFrame(columns=['gene_symbol', 'image'])
new_df['image'] = [item[0] for item in new_image_info]
new_df['gene_symbol'] = [item[1] for item in new_image_info]
new_df = new_df.sort_values(by=['image'])
return (new_df.to_csv(out_file, index=False, header=False))
else:
return None
def make_custom_triplet_csv(study, df, output_dir, output_name, patch_count_per_image = 50):
csv_file_name = "less_than_" + str(patch_count_per_image) + ".csv"
not_enough_patches_df = pd.read_csv(
os.path.join(DATA_DIR, study, "segmentation_data", "trained_on_" + str(SEGMENTATION_TRAINING_SAMPLES),
"outlier_images", csv_file_name))
not_enough_patches_dict = dict(zip(not_enough_patches_df["image_id"], not_enough_patches_df["count"]))
temp_df = df.assign(image=lambda df: df.image_id.apply(lambda row: "{}.jpg".format(row)))[['gene_symbol', 'image']]
new_image_info = []
for id, gene in zip(temp_df['image'], temp_df['gene_symbol']):
id_temp = int(id.split(".")[0])
if id_temp in not_enough_patches_dict:
count = not_enough_patches_dict[id_temp]
for patch_index in range(0, count):
patch_image_list = [(id.split(".")[0] + "_" + str(patch_index) + ".jpg", gene)]
new_image_info += patch_image_list
else:
for patch_index in range(0, PATCH_COUNT_PER_IMAGE):
patch_image_list = [(id.split(".")[0] + "_" + str(patch_index) + ".jpg", gene)]
new_image_info += patch_image_list
new_df = pd.DataFrame(columns=['gene_symbol', 'image'])
new_df['image'] = [item[0] for item in new_image_info]
new_df['gene_symbol'] = [item[1] for item in new_image_info]
new_df = new_df.sort_values(by=['image'])
out_file = os.path.join(output_dir, output_name)
new_df.to_csv(out_file, index=False, header=False)
def make_triplet_csvs(dfs):
sets_path = os.path.join(DATA_DIR, STUDY, "sets_" + str(PATCH_COUNT_PER_IMAGE) + "_patches_"+str(SEGMENTATION_TRAINING_SAMPLES)+"_seg")
out_base = sets_path + "/triplet"
if PATCH_TYPE=="segmentation":
if TRAIN_ON_ALL == True:
if INCLUDE_SZ_DATA == True:
# training on everything, and keep sz genes. Validation and test dfs will be None.
return tuple((make_triplet_csv_with_segmentation(df, "{}_{}.csv".format(out_base, ext)) and "{}_{}.csv".format(
out_base, ext))
for df, ext in zip(dfs, ("all_training", "validation", "test", "training_validation")))
else: # training on everything, but exclude sz genes. Validation and test dfs will be None.
return tuple(
(make_triplet_csv_with_segmentation(df, "{}_{}.csv".format(out_base, ext)) and "{}_{}.csv".format(
out_base, ext))
for df, ext in zip(dfs, ("no_sz_all_training", "validation", "test", "training_validation")))
else: # Not training on everything. So we have validation and test dfs as well.
if INCLUDE_SZ_DATA == True:
return tuple(
(make_triplet_csv_with_segmentation(df, "{}_{}.csv".format(out_base, ext)) and "{}_{}.csv".format(
out_base, ext))
for df, ext in zip(dfs, ("training", "validation", "test", "no_sz_training_validation")))
else: # not training on everything, So we have validation and test dfs. but exclude sz genes from training.
return tuple(
(make_triplet_csv_with_segmentation(df, "{}_{}.csv".format(out_base, ext)) and "{}_{}.csv".format(
out_base, ext))
for df, ext in zip(dfs, ("no_sz_training", "validation", "test", "no_sz_training_validation")))
else: # no segmentation
if INCLUDE_SZ_DATA == True:
return tuple((make_triplet_csv_no_segmentation(df, "{}_{}.csv".format(out_base,ext)) and "{}_{}.csv".format(out_base, ext))
for df, ext in zip(dfs, ("training", "validation", "test", "training_validation")))
else:
return tuple((make_triplet_csv_no_segmentation(df,
"{}_{}.csv".format(out_base, ext)) and "{}_{}.csv".format(
out_base, ext))
for df, ext in zip(dfs, ("no_sz_training", "validation", "test", "no_sz_training_validation")))
def convert_h5_to_csv(experiment_root =None):
if experiment_root == None:
experiment_root = EXPERIMENT_ROOT
exp_root_contents = os.listdir(experiment_root)
for item in exp_root_contents:
if item.endswith(".h5"):
embedding_csv_name = item.split(".")[0] + ".csv"
set_csv_file_name = embedding_csv_name.replace("_embeddings", "")
print ("set csv file name is: ", set_csv_file_name)
print ("item is: ", item)
sets_path = os.path.join(DATA_DIR, STUDY, "sets_" + str(PATCH_COUNT_PER_IMAGE) + "_patches_" + str(
SEGMENTATION_TRAINING_SAMPLES) + "_seg")
# ----
if "autism" in item:
sets_path = os.path.join(DATA_DIR, "autism", "sets_" + str(PATCH_COUNT_PER_IMAGE) + "_patches_" + str(
SEGMENTATION_TRAINING_SAMPLES) + "_seg")
elif "schizophrenia" in item:
sets_path = os.path.join(DATA_DIR, "schizophrenia", "sets_" + str(PATCH_COUNT_PER_IMAGE) + "_patches_" + str(
SEGMENTATION_TRAINING_SAMPLES) + "_seg")
# ----
set_csv_file = os.path.join(sets_path, set_csv_file_name)
df = pd.read_csv(set_csv_file, names=['gene', 'image_id'])
f = h5py.File(os.path.join(experiment_root, item), 'r')['emb']
df['image_id']= df.apply(lambda x: x['image_id'].split('.')[0], axis = 1)
pd.DataFrame(np.array(f), index=df.image_id).to_csv(os.path.join(experiment_root, embedding_csv_name))
def save_embedding_info_into_file(filename):
if (not os.path.exists(EMBEDDING_DEST)):
os.mkdir(EMBEDDING_DEST)
if (not os.path.exists(os.path.join(EMBEDDING_DEST, filename))):
os.mkdir(os.path.join(EMBEDDING_DEST, filename))
embed_info_dir = os.path.join(EMBEDDING_DEST, filename)
exp_root = os.path.join(DATA_DIR, STUDY, "experiment_files", "experiment_" + filename)
exp_root_contents = os.listdir(exp_root)
for item in exp_root_contents:
if item.endswith(".csv"):
copyfile(os.path.join(exp_root, item), os.path.join(embed_info_dir, item))
elif item.endswith(".json"):
copyfile(os.path.join(exp_root, item), os.path.join(embed_info_dir, item))
elif item.endswith(".log"):
copyfile(os.path.join(exp_root, item), os.path.join(embed_info_dir, item))
elif item.startswith("events."):
copyfile(os.path.join(exp_root, item), os.path.join(embed_info_dir, item))
return filename
def merge_embeddings_to_donor_level(filename):
"""
We have an embedding for every patch in the dataset. However, each donor may have more than one image associated to it.
This function will take all the images that correspond to a donor, and average over the values of the embedding vector to generate a final embedding for that gene.
"""
embed_file_contents = os.listdir(os.path.join(EMBEDDING_DEST, filename))
for item in embed_file_contents:
if item.endswith("embeddings.csv"):
# if item.endswith("_gene_level.csv") or item.endswith("_image_level.csv"):
# pass
# else:
embeddings_file = pd.read_csv(os.path.join(EMBEDDING_DEST, filename, item))
if "autism" in item:
image_root = os.path.join(DATA_DIR, "autism", "segmentation_data",
"trained_on_" + str(SEGMENTATION_TRAINING_SAMPLES), "results",
"final_patches_" + str(PATCH_COUNT_PER_IMAGE))
elif "schizophrenia" in item:
image_root = os.path.join(DATA_DIR, "schizophrenia", "segmentation_data",
"trained_on_" + str(SEGMENTATION_TRAINING_SAMPLES), "results",
"final_patches_" + str(PATCH_COUNT_PER_IMAGE))
else:
image_root = IMAGE_ROOT
patches_info = pd.read_csv(os.path.join(image_root, "valid_patches_info.csv"))
embeddings_file = embeddings_file.rename(columns={'image_id': 'patch_id'})
# perform left merge on the two dataframes to add gene_symbol to the embeddings.csv
merged_df = embeddings_file.merge(patches_info[["patch_id", "donor_id"]], how="left", on="patch_id")
# reorder the dataframe columns
merged_columns = list(merged_df)
merged_columns = [merged_columns[0]] + [merged_columns[-1]] + merged_columns[1:-1]
merged_df = merged_df[merged_columns]
# drop the patch_id column
merged_df = merged_df.drop(columns=["patch_id"])
# group by gene_symbol and average over the embedding values
grouped_df = merged_df.groupby(['donor_id']).mean()
print(grouped_df.head())
print("the number of donors is: {}".format(len(grouped_df)))
# and then I want to save this file as gene_embddings in the same folder.
item_name = item.split(".")[0]
save_to_path = os.path.join(EMBEDDING_DEST, filename, item_name + "_donor_level.csv")
grouped_df.to_csv(save_to_path)
def merge_embeddings_to_gene_level(filename):
"""
We have an embedding for every patch in the dataset. However, each gene may have more than one image associated to it.
This function will take all the images that correspond to an image, and average over the values of the embedding vector to generate a final embedding for that gene.
"""
embed_file_contents = os.listdir(os.path.join(EMBEDDING_DEST, filename))
for item in embed_file_contents:
if item.endswith("embeddings.csv"):
#if item.endswith("_gene_level.csv") or item.endswith("_image_level.csv"):
#pass
#else:
embeddings_file = pd.read_csv(os.path.join(EMBEDDING_DEST, filename, item))
if "autism" in item:
image_root = os.path.join(DATA_DIR, "autism", "segmentation_data",
"trained_on_" + str(SEGMENTATION_TRAINING_SAMPLES), "results",
"final_patches_" + str(PATCH_COUNT_PER_IMAGE))
elif "schizophrenia" in item:
image_root = os.path.join(DATA_DIR, "schizophrenia", "segmentation_data",
"trained_on_" + str(SEGMENTATION_TRAINING_SAMPLES), "results",
"final_patches_" + str(PATCH_COUNT_PER_IMAGE))
else:
image_root = IMAGE_ROOT
patches_info = pd.read_csv(os.path.join(image_root, "valid_patches_info.csv"))
embeddings_file = embeddings_file.rename(columns={'image_id': 'patch_id'})
# perform left merge on the two dataframes to add gene_symbol to the embeddings.csv
merged_df = embeddings_file.merge(patches_info[["patch_id", "gene_symbol"]], how = "left" , on = "patch_id")
# reorder the dataframe columns
merged_columns = list(merged_df)
merged_columns = [merged_columns[0]] + [merged_columns [-1]] + merged_columns[1:-1]
merged_df = merged_df[merged_columns]
# drop the patch_id column
merged_df = merged_df.drop(columns=["patch_id"])
# group by gene_symbol and average over the embedding values
grouped_df = merged_df.groupby(['gene_symbol']).mean()
print (grouped_df.head())
print ("the number of genes is: {}".format(len(grouped_df)))
# and then I want to save this file as gene_embddings in the same folder.
item_name = item.split(".")[0]
save_to_path = os.path.join(EMBEDDING_DEST, filename, item_name+"_gene_level.csv")
grouped_df.to_csv(save_to_path)
def merge_embeddings_to_image_level(filename):
"""
We have an embedding for every patch in the dataset.
This function will take all the patches that correspond to an image, and average over the values of the
embedding vector to generate a final embedding for that image.
"""
embed_file_contents = os.listdir(os.path.join(EMBEDDING_DEST, filename))
for item in embed_file_contents:
if item.endswith("embeddings.csv"):
#if item.endswith("_gene_level.csv") or item.endswith("_image_level.csv"):
#pass
#else:
print ("staaaaaaart: ", item)
embeddings_file = pd.read_csv(os.path.join(EMBEDDING_DEST, filename, item))
if "autism" in item:
image_root = os.path.join(DATA_DIR, "autism", "segmentation_data",
"trained_on_" + str(SEGMENTATION_TRAINING_SAMPLES), "results",
"final_patches_" + str(PATCH_COUNT_PER_IMAGE))
elif "schizophrenia" in item:
image_root = os.path.join(DATA_DIR, "schizophrenia", "segmentation_data",
"trained_on_" + str(SEGMENTATION_TRAINING_SAMPLES), "results",
"final_patches_" + str(PATCH_COUNT_PER_IMAGE))
else:
image_root = IMAGE_ROOT
patches_info = pd.read_csv(os.path.join(image_root, "valid_patches_info.csv"))
print (embeddings_file.head())
print ("---")
print (patches_info.head())
im_id_list = patches_info['image_id']
im_id_ex = im_id_list[10]
print (im_id_ex)
print (type(im_id_ex))
if filename == "random":
embeddings_file = embeddings_file.rename(columns={'id': 'patch_id'})
else:
embeddings_file = embeddings_file.rename(columns={'image_id': 'patch_id'})
p_id_list =embeddings_file['patch_id']
p_id_ex = p_id_list[10]
print (p_id_ex)
print (type(p_id_ex))
print ("~~~~~")
# perform left merge on the two dataframes to add gene_symbol to the embeddings.csv
merged_df = embeddings_file.merge(patches_info[["patch_id", "image_id"]], how="left", on="patch_id")
print ("_---")
print (merged_df.head())
# reorder the dataframe columns
merged_columns = list(merged_df)
merged_columns = [merged_columns[0]] + [merged_columns[-1]] + merged_columns[1:-1]
merged_df = merged_df[merged_columns]
print (merged_df.head())
print ("///")
im_id_list = merged_df['image_id']
im_id_ex = im_id_list[10]
print (im_id_ex)
print (type(im_id_ex))
# drop the patch_id column
merged_df = merged_df.drop(columns=["patch_id"])
merged_df = merged_df.astype({'image_id': 'int'})
print ("_____")
print (merged_df.head())
# group by gene_symbol and average over the embedding values
grouped_df = merged_df.groupby(['image_id']).mean()
print ("[[[[")
print(grouped_df.head())
print("the number of images is: {}".format(len(grouped_df)))
# and then I want to save this file as gene_embddings in the same folder.
item_name = item.split(".")[0]
save_to_path = os.path.join(EMBEDDING_DEST, filename, item_name + "_image_level.csv")
grouped_df.to_csv(save_to_path)
def filter_out_common_genes(df_file_name,threshold = 3):
sets_path = os.path.join(DATA_DIR, STUDY, "sets_" + str(PATCH_COUNT_PER_IMAGE) + "_patches_"+str(SEGMENTATION_TRAINING_SAMPLES)+"_seg")
df = pd.read_csv(os.path.join(sets_path, df_file_name))
print(len(df))
genes = df.iloc[:, 0]
unique_gene_count_dict = {}
genes_unique, counts = np.unique(genes, return_counts=True)
for i in range(len(genes_unique)):
unique_gene_count_dict[genes_unique[i]] = counts[i]
sorted_dict = sorted(unique_gene_count_dict.items(), key=operator.itemgetter(1))
print (sorted_dict)
most_common = []
for i in range(threshold):
most_common.append(sorted_dict[-1-i][0])
# ----------
new_df = df[~df.iloc[:,0].isin(most_common)]
print(len(new_df))
genes = new_df.iloc[:, 0]
unique_gene_count_dict = {}
genes_unique, counts = np.unique(genes, return_counts=True)
for i in range(len(genes_unique)):
unique_gene_count_dict[genes_unique[i]] = counts[i]
sorted_dict = sorted(unique_gene_count_dict.items(), key=operator.itemgetter(1))
print(sorted_dict)
new_df_file_name = df_file_name.split(".")[0] + "_filtered.csv"
new_df.to_csv(os.path.join(sets_path, new_df_file_name), index=None)
def filter_out_genes_out_of_mean_and_std(df_file_name):
sets_path = os.path.join(DATA_DIR, STUDY, "sets_" + str(PATCH_COUNT_PER_IMAGE) + "_patches_"+str(SEGMENTATION_TRAINING_SAMPLES)+"_seg")
in_range = []
df = pd.read_csv(os.path.join(sets_path, df_file_name))
print(len(df))
genes = df.iloc[:, 0]
unique_gene_count_dict = {}
genes_unique, counts = np.unique(genes, return_counts=True)
for i in range(len(genes_unique)):
unique_gene_count_dict[genes_unique[i]] = counts[i]
sorted_dict = sorted(unique_gene_count_dict.items(), key=operator.itemgetter(1))
print (sorted_dict)
ordered_genes = [item[0] for item in sorted_dict]
ordered_unique_gene_count = [item[1] for item in sorted_dict]
avg =np.mean(ordered_unique_gene_count)
sd = np.std(ordered_unique_gene_count)
max_lim = int(avg) + int(sd)
min_lim = int(avg) - int(sd)
print ("avg is: ", avg)
print ("sd is: ", sd)
print ("max lim is: ", max_lim)
print ("min lim is: ",min_lim)
num_of_out_of_range_genes = 0
num_of_out_of_range_images = 0
for item in sorted_dict:
if item[1]> min_lim and item[1] < max_lim:
in_range.append(item[0])
else:
num_of_out_of_range_genes +=1
num_of_out_of_range_images += item[1]
print ("num of out of range genes: ", num_of_out_of_range_genes)
print ("num of out of range images: ", num_of_out_of_range_images)
# ----------
new_df = df[df.iloc[:, 0].isin(in_range)]
print(len(new_df))
genes = new_df.iloc[:, 0]
unique_gene_count_dict = {}
genes_unique, counts = np.unique(genes, return_counts=True)
for i in range(len(genes_unique)):
unique_gene_count_dict[genes_unique[i]] = counts[i]
sorted_dict = sorted(unique_gene_count_dict.items(), key=operator.itemgetter(1))
print(sorted_dict)
new_df_file_name = df_file_name.split(".")[0] + "_in_range.csv"
new_df.to_csv(os.path.join(sets_path, new_df_file_name), index=None)
def draw_hist(df_file_name):
sets_path = os.path.join(DATA_DIR, STUDY, "sets_" + str(PATCH_COUNT_PER_IMAGE) + "_patches_"+str(SEGMENTATION_TRAINING_SAMPLES)+"_seg")
df = pd.read_csv(os.path.join(sets_path, df_file_name))
print(len(df))
genes = df.iloc[:, 0]
unique_gene_count_dict = {}
genes_unique, counts = np.unique(genes, return_counts=True)
for i in range(len(genes_unique)):
unique_gene_count_dict[genes_unique[i]] = counts[i]
sorted_dict = sorted(unique_gene_count_dict.items(), key=operator.itemgetter(1))
ordered_genes = [item[0] for item in sorted_dict]
ordered_unique_gene_count = [item[1] for item in sorted_dict]
print(ordered_genes)
print(ordered_unique_gene_count)
print(np.mean(ordered_unique_gene_count))
print(np.std(ordered_unique_gene_count))
plt.hist(ordered_unique_gene_count, normed=False, bins=100)
plt.ylabel('unique gene count')
plt.show()
def images_wiht_no_valid_patches():
path_to_outliers = os.path.join(DATA_DIR,STUDY,"segmentation_data","trained_on_"+str(SEGMENTATION_TRAINING_SAMPLES),"outlier_images")
less_than_thresh_df = pd.read_csv(os.path.join(path_to_outliers, "less_than_" + str(PATCH_COUNT_PER_IMAGE) + ".csv"))
no_valid_patch_list = list(less_than_thresh_df[less_than_thresh_df["count"] == 0]["image_id"])
no_valid_patch_list = [str(item) for item in no_valid_patch_list]
return no_valid_patch_list
def make_sets():
images_info_df = pd.read_csv(os.path.join(DATA_DIR, STUDY, "human_ISH_info.csv"))
no_valid_patch_list = images_wiht_no_valid_patches()
images_info_df = images_info_df[~images_info_df["image_id"].isin(no_valid_patch_list)]
stats_dict = get_stats(images_info_df)
# if TRAIN_ON_ALL is set to True, then validation_df, test_df, train_val_df will all be None
training_df, validation_df, test_df, train_val_df = define_sets_with_no_shared_genes(images_info_df)
get_stats_on_sets(stats_dict, training_df, validation_df, test_df)
make_triplet_csvs((training_df, validation_df, test_df, train_val_df))
filter_out_common_genes("triplet_training.csv")
filter_out_genes_out_of_mean_and_std("triplet_training.csv")
"""
training_df, validation_df, test_df = define_sets_with_no_shared_donors(images_info_df)
train_validation_shared_genes_list, train_test_shared_genes_list, validation_test_shared_genes_list, all_shared_genes_list = \
compare_set_genes_list(training_df, validation_df, test_df)
new_training_df, new_validation_df, test_df = create_new_sets_by_removing_shared_genes(images_info_df, training_df, validation_df, test_df,
train_validation_shared_genes_list, train_test_shared_genes_list,
validation_test_shared_genes_list, all_shared_genes_list)
get_stats_on_sets(stats_dict, new_training_df, new_validation_df, test_df)
"""
def generate_random_embeddings( embeddings_length):
"""
this function generates random embeddings for the images. The result will be a csv files that has the embedding vector of every image.
:param embeddings_length: the length of the embedding vector which also determines the number of columns in the final csv file.
:return: None
"""
#set_name_list = ["training.csv", "training_validation.csv", "validation.csv"]
#set_name_list = ["all_training.csv", "no_sz_all_training.csv"]
set_name_list = ["test.csv"]
for set_name in set_name_list:
print ("set: ", set_name)
path_to_info_csv = os.path.join(DATA_DIR,STUDY, "sets_50_patches_40_seg/" + set_name)
#path_to_info_csv = os.path.join(IMAGE_ROOT,info_csv_file)
info_csv = pd.read_csv(path_to_info_csv)
columns = list(info_csv)
id_column = info_csv[columns[0]]
n_images = len(info_csv)
cols = np.arange(0, embeddings_length)
cols = list(map(str, cols))
cols = ['id'] + cols
random_embed_file = pd.DataFrame(columns=cols)
random_embed_file['id'] = id_column
for i in range(embeddings_length):
sample = np.random.uniform(size=(n_images,))
random_embed_file[str(i)] = sample
path_to_random = os.path.join(EMBEDDING_DEST, "random")
if (not os.path.exists(path_to_random)):
os.mkdir(path_to_random)
random_embed_file.to_csv(os.path.join(path_to_random, "random_" + set_name.split(".")[0] +"_embeddings_image_level.csv"),index=None)
print ("finished generating random embeddings...")
def generate_random_embeddings_for_disease_dataset(embeddings_length, study=None):
"""
this function generates random embeddings for the images of a certain dataser. The result will be a csv files that has the embedding vector of every image.
:param study: the specific study (=disease) dataset. Could be schizophrenia or autism.
:param embeddings_length: the length of the embedding vector which also determines the number of columns in the final csv file.
:return: None
"""
if study == None:
study = STUDY
path_to_info_csv = os.path.join(DATA_DIR, study, "human_ISH_info.csv")
info_csv = pd.read_csv(path_to_info_csv,)
columns = list(info_csv)
id_column = info_csv[columns[0]]
n_images = len(info_csv)
cols = np.arange(0, embeddings_length)
cols = list(map(str, cols))
cols = ['id'] + cols
random_embed_file = pd.DataFrame(columns=cols)
random_embed_file['id'] = id_column
for i in range(embeddings_length):
sample = np.random.uniform(size=(n_images,))
random_embed_file[str(i)] = sample
path_to_random = os.path.join(DATA_DIR, study, "segmentation_embeddings", "random")
if (not os.path.exists(path_to_random)):
os.mkdir(path_to_random)
random_embed_file.to_csv(os.path.join(path_to_random, "random_embeddings_image_level.csv"),index=None)
print ("finished generating random embeddings...")
def get_embeddings_from_pre_trained_model_for_each_set(model_name ="resnet50"):
mode_folder_name = model_name + "_" + str(PATCH_COUNT_PER_IMAGE) + "_patches"
path_to_pre_trained_embeddings = os.path.join(EMBEDDING_DEST, mode_folder_name, model_name+"_embeddings_image_level.csv")
pre_trained_embeddings =pd.read_csv(path_to_pre_trained_embeddings)
print (len(pre_trained_embeddings))
#set_name_list = ["training.csv", "training_validation.csv", "validation.csv"]
#set_name_list = ["all_training.csv", "no_sz_all_training.csv"]
set_name_list = ["test.csv"]
for set_name in set_name_list:
print("set: ", set_name)
path_to_info_csv = os.path.join(DATA_DIR, STUDY, "sets_50_patches_40_seg/" + set_name)
info_csv = pd.read_csv(path_to_info_csv )
set_id_column = list(info_csv['image_id'])
print (len(set_id_column))
this_set_pre_trained_embeds = pre_trained_embeddings[pre_trained_embeddings['image_id'].isin(set_id_column)]
set_pre_trained_embed_file_name = model_name + "_" + set_name.split(".")[0] + "_embeddings_image_level.csv"
this_set_pre_trained_embeds.to_csv(os.path.join(EMBEDDING_DEST, mode_folder_name, set_pre_trained_embed_file_name), index=None)
print ("finished generating {} embeddings for this set.".format(model_name))
def get_embeddings_from_pre_trained_model(model_name="resnet50", trained_on="imagenet", dim=128, standardize=False,
chunk_range=None, chunk_ID=None):
"""
Generates embeddings from a pre-trained model without further training.
The function uses 'valid_patches_info.csv' to take the list of images to perform on.
But, if the number of images is too high, there might be OOM errors. In that case, the function will perform on chunks
of images at each time. There is another function, 'get_embeddings_from_pre_trained_model_in_chunks', which will be
called first and will generate the chunk. That function will then call this function.
:param model_name: string, the pre-trained model to be used
:param trained_on: string, the dataset on which the pre-trained model has been trained
:param dim: int, the dimensionality of the output embeddings
:param standardize: bool, flag to linearly scale each image to have mean 0 and variance 1
:param chunk_range: tuple, if the function is supposed to perform on chunks, this tuple indicates the start and end index
:param chunk_ID: int, if the function is supposed to perform on chunks, this value indicates the chunk ID
:return: None. It creates the embeddings and stores them in a csv file.
"""
print("Generating embeddings from a plain ", model_name)
# ---- imports libraries ---------
import tensorflow as tf
from tensorflow.keras import layers
from tensorflow.keras import Model
from tensorflow.keras.preprocessing import image
# --------------------------------
if standardize:
embed_folder_name = model_name + "_" + str(PATCH_COUNT_PER_IMAGE) + "_patches_standardized_2"
if chunk_ID:
embeddings_csv_file_name = model_name + "_standardized_embeddings_" + str(chunk_ID) +".csv"
else:
embeddings_csv_file_name = model_name + "_standardized_embeddings.csv"
else:
embed_folder_name = model_name + "_" + str(PATCH_COUNT_PER_IMAGE) + "_patches"
if chunk_ID:
embeddings_csv_file_name = model_name + "_embeddings_" + str(chunk_ID)+".csv"
else:
embeddings_csv_file_name = model_name + "_embeddings.csv"
if (not os.path.exists(os.path.join(EMBEDDING_DEST, embed_folder_name))):
os.mkdir(os.path.join(EMBEDDING_DEST, embed_folder_name))
valid_patches_info_path = os.path.join(IMAGE_ROOT, "valid_patches_info.csv")
valid_patches_info = pd.read_csv(valid_patches_info_path)
patch_id_list = valid_patches_info['patch_id']
image_dir = IMAGE_ROOT
print("image dir is: ", image_dir)
height = PATCH_HEIGHT
width = PATCH_WIDTH
image_list = [item + ".jpg" for item in patch_id_list]
image_list.sort()
if chunk_range:
chunk_start = chunk_range[0]
chunk_end = chunk_range[1]
image_list = image_list[chunk_start:chunk_end]
loaded_images = []
print("started loading images ...")
for i in range(len(image_list)):
print (i , " loading", " chunk_ID: ", chunk_ID)
image_to_embed = image_list[i]
image_id = image_to_embed.split(".")[0]
img_path = os.path.join(image_dir, image_to_embed)
img = image.load_img(img_path, target_size=(height, width))
loaded_images.append(img)
print("finished loading images ...\n")
if standardize:
print("started standardizing images ...")
for i in range(len(loaded_images)):
print(i, " standardizing", " chunk_ID: ", chunk_ID)
img = loaded_images[i]
img = tf.keras.preprocessing.image.img_to_array(img)
img = tf.image.per_image_standardization(img)
img_data = tf.keras.backend.eval(img)
tf.keras.backend.clear_session()
loaded_images[i] = img_data
print("finished standardizing images ...")
embeddings_list = []
if model_name == "resnet50":
from tensorflow.keras.applications.resnet50 import ResNet50
from tensorflow.keras.applications.resnet50 import preprocess_input
pre_trained_model = ResNet50(input_shape=(height, width, 3),
include_top=False,
pooling=max,
weights=trained_on)
# freeze all the layers
for layer in pre_trained_model.layers:
layer.trainable = False
# print (pre_trained_model.summary())
last_layer = pre_trained_model.get_layer(index=-1)
print("last layer output shape is: ", last_layer.output_shape)
last_output = last_layer.output
# x = layers.AveragePooling2D((8,8))(last_output)
# x = layers.Flatten()(x)
x = layers.Flatten()(last_output)
x = layers.Dense(dim, activation='relu')(x)
model = Model(pre_trained_model.input, x)
# model = Model(pre_trained_model.input, last_output)
print("total number of images: ", len(image_list))
print("\n started passing images through the model ...")
for i in range(len(loaded_images)):
print(i, " passing through", " chunk_ID: ", chunk_ID)
image_id = image_list[i].split(".")[0]
img = loaded_images[i]
img_data = image.img_to_array(img)
img_data = np.expand_dims(img_data, axis=0)
img_data = preprocess_input(img_data)
# img_data = np.vstack([x])
resnet50_feature = model.predict(img_data)
resnet50_feature = resnet50_feature.squeeze().tolist()
resnet50_feature = [image_id] + resnet50_feature
embeddings_list.append(resnet50_feature)
tf.keras.backend.clear_session()
column_names = np.arange(0, dim)
column_names = [str(name) for name in column_names]
column_names = ['image_id'] + column_names
embedding_df = pd.DataFrame(embeddings_list, columns=column_names)
embeddings_path = os.path.join(EMBEDDING_DEST, embed_folder_name, embeddings_csv_file_name)
embedding_df.to_csv(embeddings_path, index=None)
def get_embeddings_from_pre_trained_model_in_chunks(number_of_chunks=10, model_name="resnet50", trained_on="imagenet", dim=128, standardize=True):
"""
This function is used when the number of images is too high for the system to handle them all at once and it could cause
OOM problems.
This function will group them in chunks and call the 'get_embeddings_from_pre_trained_model' function on each chunk.
:param number_of_chunks: int
:param model_name: string, the pre-trained model to be used
:param trained_on: string, the dataset on which the pre-trained model has been trained
:param dim: int, the dimensionality of the output embeddings
:param standardize: bool, flag to linearly scale each image to have mean 0 and variance 1
:return: None
"""
valid_patches_info_path = os.path.join(IMAGE_ROOT, "valid_patches_info.csv")
valid_patches_info = pd.read_csv(valid_patches_info_path)
patch_id_list = valid_patches_info['patch_id']
image_dir = IMAGE_ROOT
print("image dir is: ", image_dir)
image_list = [item + ".jpg" for item in patch_id_list]
image_list.sort()
number_of_images = len(image_list)
print ("there are {} images in this directory".format(number_of_images))
# minimum number of images in each chunk. There might be more in the last chunk.
min_in_each_chunk = number_of_images // number_of_chunks
start = 0
for i in range(1, number_of_chunks):
this_chunk_start_ind = start
this_chunk_end_ind = start+min_in_each_chunk
print ("this chunk start and end indices are {} , {}".format(this_chunk_start_ind, this_chunk_end_ind))
chunk_ID = i
print ("chunk ID: {}".format(chunk_ID))
start = this_chunk_end_ind
print ('calling get embed function ...')
get_embeddings_from_pre_trained_model(model_name=model_name, trained_on=trained_on, dim=dim, standardize=standardize,
chunk_range=(this_chunk_start_ind, this_chunk_end_ind), chunk_ID=chunk_ID)
# handling the last chunk
this_chunk_start_ind = start
this_chunk_end_ind= number_of_images
print ("last chunk's start and end indices are {} , {}".format(this_chunk_start_ind, this_chunk_end_ind))
chunk_ID = number_of_chunks
print("chunk ID: {}".format(chunk_ID))
print('calling get embed function ...')
get_embeddings_from_pre_trained_model(model_name="resnet50", trained_on="imagenet", dim=128,
standardize=standardize,
chunk_range=(this_chunk_start_ind, this_chunk_end_ind), chunk_ID=chunk_ID)
def concatenate_embedding_chunks(embed_folder_name, number_of_chunks =10):
print ("started concatenating embedding chunks ...")
embed_folder_path = os.path.join(EMBEDDING_DEST, embed_folder_name)
embed_folder_content = os.listdir(embed_folder_path)
general_csv_name = ""
embed_csv_files = []
for i in range(1, number_of_chunks+1):
embed_csv_name = ""
for item in embed_folder_content:
if item.endswith("_"+str(i)+".csv"):
general_csv_name = item.split("_"+str(i)+".csv")[0]
embed_csv_name = item
break
print ("embedding csv file name: {}".format(embed_csv_name))
embed_csv_file = pd.read_csv(os.path.join(embed_folder_path, embed_csv_name))
embed_csv_files.append(embed_csv_file)
print ("finished reading all the embedding files ... ")
print ("general csv name: {}".format(general_csv_name))
general_csv_name = general_csv_name +".csv"
final_embed_csv = pd.concat(embed_csv_files, ignore_index=True)
final_embed_csv.to_csv(os.path.join(embed_folder_path, general_csv_name),index=None)
# ------
check_concatenated_embeddings(embed_folder_name, general_csv_name)
def check_each_chunk(embed_folder_name, first_file_index, second_file_index, number_of_chunks =10):
embed_folder_path = os.path.join(EMBEDDING_DEST, embed_folder_name)
embed_folder_content = os.listdir(embed_folder_path)
def check_concatenated_embeddings(embed_folder_name, general_csv_name, number_of_chunks =10):
valid_patches_info_path = os.path.join(IMAGE_ROOT, "valid_patches_info.csv")
valid_patches_info = pd.read_csv(valid_patches_info_path)
patch_id_list = valid_patches_info['patch_id'] # the type is actually pandas series. Not python list
concat_embed_path = os.path.join(EMBEDDING_DEST, embed_folder_name, general_csv_name)
concat_embed_file = pd.read_csv(concat_embed_path)
image_id_list = concat_embed_file['image_id'] # the type is actually pandas series. Not python list
print ("patch count in valid patch info: {} ".format(len(patch_id_list)))
print ("patch count in concatenated embed file: {}".format(len(image_id_list)))
dif_count = 0
# I have to use .values because it is pandas series. Otherwise it will check the indices and return False.
for item in patch_id_list[:10].values:
if item not in image_id_list[:10].values:
dif_count +=1
print ("difference is: {} ".format(dif_count))
def run():
#pass
embed_file_name = "triplet_training_validation_embeddings.csv"
embed_dir = os.path.join(DATA_DIR, STUDY, "segmentation_embeddings")
#ts_list = os.listdir(embed_dir)
ts_list =["1584025762"]
for ts in ts_list:
print ("ts:", ts)
filename = os.path.join(embed_dir, ts, embed_file_name)
merge_embeddings_to_gene_level(ts)
merge_embeddings_to_image_level(ts)
def specific_donor_embeddings(donor_id, embed_folder_name, convert_to_tsv = True, study =None):
if study == None:
images_info_df = pd.read_csv(os.path.join(DATA_DIR, STUDY, "human_ISH_info.csv"))
else:
images_info_df = pd.read_csv(os.path.join(DATA_DIR, study, "human_ISH_info.csv"))
this_donor = images_info_df[images_info_df['donor_id']==donor_id]
this_donor_image_id_gene = this_donor[['image_id', 'donor_id', 'gene_symbol']]
embed_dir = os.path.join(EMBEDDING_DEST, embed_folder_name)
embed_file_name = ""
for item in os.listdir(embed_dir):
if study == None:
if item.endswith("embeddings_image_level.csv"):
embed_file_name = item
else:
if item.endswith("embeddings_image_level.csv") and study in item:
embed_file_name = item
embed_df = pd.read_csv(os.path.join(EMBEDDING_DEST, embed_folder_name, embed_file_name))
merged_df = pd.merge(this_donor_image_id_gene, embed_df, on='image_id')
merged_df_no_meta = merged_df.drop(columns=['gene_symbol'])
merged_df_no_meta = merged_df_no_meta.drop(columns=['image_id'])
merged_df_no_meta = merged_df_no_meta.drop(columns=['donor_id'])
if study == None:
donor_file_name = donor_id
else:
donor_file_name = study+ "_" + donor_id
if convert_to_tsv:
merged_df.to_csv(os.path.join(EMBEDDING_DEST, embed_folder_name,donor_file_name+".csv"), index=None)
convert_to_tsv(os.path.join(EMBEDDING_DEST, embed_folder_name,donor_file_name+".csv"))
merged_df_no_meta.to_csv(os.path.join(EMBEDDING_DEST, embed_folder_name, donor_file_name+"_no_meta.csv"), header=False, index=None)
convert_to_tsv(os.path.join(EMBEDDING_DEST, embed_folder_name, donor_file_name+"_no_meta.csv"))
return merged_df, merged_df_no_meta
def convert_to_tsv(path_to_csv):
path_to_tsv = path_to_csv.split(".")[0] + ".tsv"
csv_read = pd.read_csv(path_to_csv)
with open(path_to_tsv, 'w') as write_tsv:
write_tsv.write(csv_read.to_csv(sep='\t', index=False))
def convert_to_tsv_meta_and_without_meta(path_to_csv):
#cols = ['gene_symbol', 'Cortical.marker..human.', 'Expression.level']
#cols = ['image_id', 'gene_symbol', 'entrez_id', 'region']
#cols = ['image_id', 'gene_symbol', 'donor_id', 'region' ]
cols = ['image_id', 'gene_symbol_x', 'donor_id', 'region', "entrez_id", "V1_pattern", "V2_pattern", "Temporal_pattern",
"marker_annotation","expression_level", "gene_symbol_y"]
# With meta
path_to_tsv = path_to_csv.split(".")[0] + ".tsv"
csv_read = pd.read_csv(path_to_csv)
with open(path_to_tsv, 'w') as write_tsv:
write_tsv.write(csv_read.to_csv(sep='\t', index=False))
# Without meta data
path_to_tsv = path_to_csv.split(".")[0] + "_no_meta.tsv"
csv_read = pd.read_csv(path_to_csv)
csv_read = csv_read.drop(columns=cols)
with open(path_to_tsv, 'w') as write_tsv:
write_tsv.write(csv_read.to_csv(sep='\t', index=False, header=False))
def get_image_level_embeddings_of_a_target_set(path_to_sets, ts, target_sets=["training", "validation"]):
embeddings_path = os.path.join(EMBEDDING_DEST, ts)
contents = os.listdir(embeddings_path)
image_level_embeddings_file_name = ""
for item in contents:
if item.endswith("training_validation_embeddings_image_level.csv"):
image_level_embeddings_file_name = item
break
image_level_embeddings = pd.read_csv(os.path.join(embeddings_path, image_level_embeddings_file_name))
for target in target_sets:
print ("Getting embeddings of the " + target + " set...")
path_to_target_set = os.path.join(path_to_sets, target +".csv")
target_df = pd.read_csv(path_to_target_set)
target_image_id = list(target_df['image_id'])
target_embeddings = image_level_embeddings[image_level_embeddings['image_id'].isin(target_image_id)]
target_embeddings_file_name = target +"_embeddings_image_level.csv"
target_embeddings.to_csv(os.path.join(embeddings_path, target_embeddings_file_name), index=None)
print ("Finished getting embeddings of target sets.")
def get_gene_level_embeddings_of_a_target_set(path_to_sets, ts, target_sets=["training", "validation"]):
embeddings_path = os.path.join(EMBEDDING_DEST, ts)
contents = os.listdir(embeddings_path)
gene_level_embeddings_file_name = ""
for item in contents:
if item.endswith("training_validation_embeddings_gene_level.csv"):
gene_level_embeddings_file_name = item
break
gene_level_embeddings = pd.read_csv(os.path.join(embeddings_path, gene_level_embeddings_file_name))
for target in target_sets:
print ("Getting embeddings of the " + target + " set...")
path_to_target_set = os.path.join(path_to_sets, target +".csv")
target_df = | pd.read_csv(path_to_target_set) | pandas.read_csv |
from __future__ import absolute_import
import pandas as pd
import numpy as np
import csv
from scipy.stats import multivariate_normal
import warnings
def read_csvv(csvv_path):
'''
Returns the estimator object from a CSVV file
Parameters
----------
path: str_or_buffer
path to csvv file
Returns
-------
estimator : MultivariateNormalEstimator
:py:class:`Gamma` object with median and VCV matrix indexed by
prednames, covarnames, and outcomes
'''
data = {}
with open(csvv_path, 'r') as fp:
reader = csv.reader(fp)
for row in reader:
if row[0] == 'gamma':
data['gamma'] = np.array([float(i) for i in next(reader)])
if row[0] == 'gammavcv':
data['gammavcv'] = np.array([float(i) for i in next(reader)])
if row[0] == 'residvcv':
data['residvcv'] = np.array([float(i) for i in next(reader)])
if row[0] == 'prednames':
data['prednames'] = [i.strip() for i in next(reader)]
if row[0] == 'covarnames':
data['covarnames'] = [i.strip() for i in next(reader)]
if row[0] == 'outcome':
data['outcome'] = [cv.strip() for cv in next(reader)]
index = pd.MultiIndex.from_tuples(
list(zip(data['outcome'], data['prednames'], data['covarnames'])),
names=['outcome', 'prednames', 'covarnames'])
g = MultivariateNormalEstimator(data['gamma'], data['gammavcv'], index)
return g
def get_gammas(*args, **kwargs):
warnings.warn(
'get_gammas has been deprecated, and has been replaced with read_csvv',
DeprecationWarning)
return read_csvv(*args, **kwargs)
class MultivariateNormalEstimator(object):
'''
Stores a median and residual VCV matrix for multidimensional variables with
named indices and provides multivariate sampling and statistical analysis
functions
Parameters
----------
coefficients: array
length :math:`(m_1*m_2*\cdots*m_n)` 1-d :py:class:`numpy.ndarray` with
regression coefficients
vcv: array
:math:`(m_1*m_2*\cdots*m_n) x (m_1*m_2*\cdots*m_n)`
:py:class:`numpy.ndarray` with variance-covariance matrix for
multivariate distribution
index: Index
:py:class:`~pandas.Index` or :math:`(m_1*m_2*\cdots*m_n)` 1-d
:py:class:`~pandas.MultiIndex` describing the multivariate space
'''
def __init__(self, coefficients, vcv, index):
self.coefficients = coefficients
self.vcv = vcv
self.index = index
def median(self):
'''
Returns the median values (regression coefficients)
Returns
-------
median : DataArray
:py:class:`~xarray.DataArray` of coefficients
'''
return | pd.Series(self.coefficients, index=self.index) | pandas.Series |
#pylint disable=C0301
from struct import Struct, pack
from abc import abstractmethod
import inspect
from typing import List
import numpy as np
from numpy import zeros, searchsorted, allclose
from pyNastran.utils.numpy_utils import integer_types, float_types
from pyNastran.op2.result_objects.op2_objects import BaseElement, get_times_dtype
from pyNastran.f06.f06_formatting import (
write_floats_13e, write_floats_12e,
write_float_13e, # write_float_12e,
_eigenvalue_header,
)
from pyNastran.op2.op2_interface.write_utils import set_table3_field
SORT2_TABLE_NAME_MAP = {
'OEF2' : 'OEF1',
'OEFATO2' : 'OEFATO1',
'OEFCRM2' : 'OEFCRM1',
'OEFPSD2' : 'OEFPSD1',
'OEFRMS2' : 'OEFRMS1',
'OEFNO2' : 'OEFNO1',
}
TABLE_NAME_TO_TABLE_CODE = {
'OEF1' : 4,
}
class ForceObject(BaseElement):
def __init__(self, data_code, isubcase, apply_data_code=True):
self.element_type = None
self.element_name = None
self.nonlinear_factor = np.nan
self.element = None
self._times = None
BaseElement.__init__(self, data_code, isubcase, apply_data_code=apply_data_code)
def finalize(self):
"""it's required that the object be in SORT1"""
self.set_as_sort1()
def set_as_sort1(self):
"""the data is in SORT1, but the flags are wrong"""
if self.is_sort1:
return
self.table_name = SORT2_TABLE_NAME_MAP[self.table_name]
self.sort_bits[1] = 0 # sort1
self.sort_method = 1
assert self.is_sort1 is True, self.is_sort1
def _reset_indices(self):
self.itotal = 0
self.ielement = 0
def get_headers(self):
raise NotImplementedError()
def get_element_index(self, eids):
# elements are always sorted; nodes are not
itot = searchsorted(eids, self.element) #[0]
return itot
def eid_to_element_node_index(self, eids):
#ind = ravel([searchsorted(self.element == eid) for eid in eids])
ind = searchsorted(eids, self.element)
#ind = ind.reshape(ind.size)
#ind.sort()
return ind
def _write_table_3(self, op2, op2_ascii, new_result, itable, itime): #itable=-3, itime=0):
import inspect
from struct import pack
frame = inspect.currentframe()
call_frame = inspect.getouterframes(frame, 2)
op2_ascii.write('%s.write_table_3: %s\n' % (self.__class__.__name__, call_frame[1][3]))
#print('new_result=%s itable=%s' % (new_result, itable))
if new_result and itable != -3:
header = [
4, 146, 4,
]
else:
header = [
4, itable, 4,
4, 1, 4,
4, 0, 4,
4, 146, 4,
]
op2.write(pack(b'%ii' % len(header), *header))
op2_ascii.write('table_3_header = %s\n' % header)
approach_code = self.approach_code
table_code = self.table_code
isubcase = self.isubcase
element_type = self.element_type
assert isinstance(self.element_type, int), self.element_type
#[
#'aCode', 'tCode', 'element_type', 'isubcase',
#'???', '???', '???', 'load_set'
#'format_code', 'num_wide', 's_code', '???',
#'???', '???', '???', '???',
#'???', '???', '???', '???',
#'???', '???', '???', '???',
#'???', 'Title', 'subtitle', 'label']
#random_code = self.random_code
format_code = self.format_code
s_code = 0 # self.s_code
num_wide = self.num_wide
acoustic_flag = 0
thermal = 0
title = b'%-128s' % self.title.encode('ascii')
subtitle = b'%-128s' % self.subtitle.encode('ascii')
label = b'%-128s' % self.label.encode('ascii')
ftable3 = b'50i 128s 128s 128s'
#oCode = 0
load_set = 0
#print(self.code_information())
ftable3 = b'i' * 50 + b'128s 128s 128s'
field6 = 0
field7 = 0
if self.analysis_code == 1:
field5 = self.loadIDs[itime]
elif self.analysis_code == 2:
field5 = self.modes[itime]
field6 = self.eigns[itime]
field7 = self.cycles[itime]
assert isinstance(field6, float), type(field6)
assert isinstance(field7, float), type(field7)
ftable3 = set_table3_field(ftable3, 6, b'f') # field 6
ftable3 = set_table3_field(ftable3, 7, b'f') # field 7
elif self.analysis_code == 5:
try:
field5 = self.freqs[itime]
except AttributeError: # pragma: no cover
print(self)
raise
ftable3 = set_table3_field(ftable3, 5, b'f') # field 5
elif self.analysis_code == 6:
if hasattr(self, 'times'):
field5 = self.times[itime]
#elif hasattr(self, 'dts'):
#field5 = self.times[itime]
else: # pragma: no cover
print(self.get_stats())
raise NotImplementedError('cant find times or dts on analysis_code=8')
ftable3 = set_table3_field(ftable3, 5, b'f') # field 5
elif self.analysis_code == 7: # pre-buckling
field5 = self.loadIDs[itime] # load set number
elif self.analysis_code == 8: # post-buckling
if hasattr(self, 'lsdvmns'):
field5 = self.lsdvmns[itime] # load set number
elif hasattr(self, 'loadIDs'):
field5 = self.loadIDs[itime]
else: # pragma: no cover
print(self.get_stats())
raise NotImplementedError('cant find lsdvmns or loadIDs on analysis_code=8')
if hasattr(self, 'eigns'):
field6 = self.eigns[itime]
elif hasattr(self, 'eigrs'):
field6 = self.eigrs[itime]
else: # pragma: no cover
print(self.get_stats())
raise NotImplementedError('cant find eigns or eigrs on analysis_code=8')
assert isinstance(field6, float_types), type(field6)
ftable3 = set_table3_field(ftable3, 6, b'f') # field 6
elif self.analysis_code == 9: # complex eigenvalues
field5 = self.modes[itime]
if hasattr(self, 'eigns'):
field6 = self.eigns[itime]
elif hasattr(self, 'eigrs'):
field6 = self.eigrs[itime]
else: # pragma: no cover
print(self.get_stats())
raise NotImplementedError('cant find eigns or eigrs on analysis_code=8')
ftable3 = set_table3_field(ftable3, 6, b'f') # field 6
field7 = self.eigis[itime]
ftable3 = set_table3_field(ftable3, 7, b'f') # field 7
elif self.analysis_code == 10: # nonlinear statics
field5 = self.load_steps[itime]
ftable3 = set_table3_field(ftable3, 5, b'f') # field 5; load step
elif self.analysis_code == 11: # old geometric nonlinear statics
field5 = self.loadIDs[itime] # load set number
else:
raise NotImplementedError(self.analysis_code)
table3 = [
approach_code, table_code, element_type, isubcase, field5,
field6, field7, load_set, format_code, num_wide,
s_code, acoustic_flag, 0, 0, 0,
0, 0, 0, 0, 0,
0, 0, thermal, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0,
title, subtitle, label,
]
assert table3[22] == thermal
n = 0
for v in table3:
if isinstance(v, (int, float, np.float32)):
n += 4
elif isinstance(v, str):
#print(len(v), v)
n += len(v)
else:
#print('write_table_3', v)
n += len(v)
assert n == 584, n
data = [584] + table3 + [584]
fmt = b'i' + ftable3 + b'i'
#print(fmt)
#print(data)
#f.write(pack(fascii, '%s header 3c' % self.table_name, fmt, data))
op2_ascii.write('%s header 3c = %s\n' % (self.table_name, data))
op2.write(pack(fmt, *data))
class RealForceObject(ForceObject):
def __init__(self, data_code, isubcase, apply_data_code=True):
ForceObject.__init__(self, data_code, isubcase, apply_data_code=apply_data_code)
@property
def is_real(self):
return True
@property
def is_complex(self):
return False
"""
F A I L U R E I N D I C E S F O R L A Y E R E D C O M P O S I T E E L E M E N T S ( T R I A 3 )
ELEMENT FAILURE PLY FP=FAILURE INDEX FOR PLY FB=FAILURE INDEX FOR BONDING FAILURE INDEX FOR ELEMENT FLAG
ID THEORY ID (DIRECT STRESSES/STRAINS) (INTER-LAMINAR STRESSES) MAX OF FP,FB FOR ALL PLIES
3 STRAIN 1 20345.4805 -2
7.1402
2 0.9025 -12
7.1402
3 20342.2461 -2
20345.4805 ***
4 STRAIN 1 16806.9277 -2
38.8327
2 0.9865 -2
38.8327
3 16804.4199 -2
F A I L U R E I N D I C E S F O R L A Y E R E D C O M P O S I T E E L E M E N T S ( T R I A 6 )
ELEMENT FAILURE PLY FP=FAILURE INDEX FOR PLY FB=FAILURE INDEX FOR BONDING FAILURE INDEX FOR ELEMENT FLAG
ID THEORY ID (DIRECT STRESSES/STRAINS) (INTER-LAMINAR STRESSES) MAX OF FP,FB FOR ALL PLIES
5 STRAIN 1 21850.3184 -2
166984.4219
2 0.7301 -2
166984.4219
3 21847.9902 -2
166984.4219 ***
6 STRAIN 1 18939.8340 -2
130371.3828
2 0.7599 -1
130371.3828
3 18937.7734 -2
F A I L U R E I N D I C E S F O R L A Y E R E D C O M P O S I T E E L E M E N T S ( Q U A D 4 )
ELEMENT FAILURE PLY FP=FAILURE INDEX FOR PLY FB=FAILURE INDEX FOR BONDING FAILURE INDEX FOR ELEMENT FLAG
ID THEORY ID (DIRECT STRESSES/STRAINS) (INTER-LAMINAR STRESSES) MAX OF FP,FB FOR ALL PLIES
1 STRAIN 1 18869.6621 -2
16.2471
2 1.0418 -2
16.2471
3 18866.6074 -2
18869.6621 ***
1 CC227: CANTILEVERED COMPOSITE PLATE 3 LAYER SYMM PLY CC227 DECEMBER 5, 2011 MSC.NASTRAN 6/17/05 PAGE 15
FAILURE CRITERION IS STRAIN, STRESS ALLOWABLES, LIST STRESSES
0
F A I L U R E I N D I C E S F O R L A Y E R E D C O M P O S I T E E L E M E N T S ( Q U A D 8 )
ELEMENT FAILURE PLY FP=FAILURE INDEX FOR PLY FB=FAILURE INDEX FOR BONDING FAILURE INDEX FOR ELEMENT FLAG
ID THEORY ID (DIRECT STRESSES/STRAINS) (INTER-LAMINAR STRESSES) MAX OF FP,FB FOR ALL PLIES
2 STRAIN 1 14123.7451 -2
31.4861
2 1.0430 -2
31.4861
3 14122.1221 -2
"""
class FailureIndicesArray(RealForceObject):
def __init__(self, data_code, is_sort1, isubcase, dt):
RealForceObject.__init__(self, data_code, isubcase)
self.nelements = 0 # result specific
def build(self):
"""sizes the vectorized attributes of the FailureIndices"""
if self.is_built:
return
#print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))
assert self.ntimes > 0, 'ntimes=%s' % self.ntimes
assert self.nelements > 0, 'nelements=%s' % self.nelements
assert self.ntotal > 0, 'ntotal=%s' % self.ntotal
#self.names = []
self.nelements //= self.ntimes
self.itime = 0
self.ielement = 0
self.itotal = 0
#self.ntimes = 0
#self.nelements = 0
self.is_built = True
#print("ntimes=%s nelements=%s ntotal=%s" % (self.ntimes, self.nelements, self.ntotal))
dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size)
self._times = zeros(self.ntimes, dtype=dtype)
self.failure_theory = np.full(self.nelements, '', dtype='U8')
self.element_layer = zeros((self.nelements, 2), dtype=idtype)
#[failure_stress_for_ply, interlaminar_stress, max_value]
self.data = zeros((self.ntimes, self.nelements, 3), dtype=fdtype)
def build_dataframe(self):
"""creates a pandas dataframe"""
import pandas as pd
headers = self.get_headers()
element_layer = [self.element_layer[:, 0], self.element_layer[:, 1]]
if self.nonlinear_factor not in (None, np.nan):
# Time 0.00 0.05
# ElementID NodeID Item
# 2 1 failure_index_for_ply (direct stress/strain) 0.0 5.431871e-14
# 2 failure_index_for_bonding (interlaminar stresss) 0.0 3.271738e-16
# 3 max_value NaN NaN
# 1 failure_index_for_ply (direct stress/strain) 0.0 5.484873e-30
# 2 failure_index_for_bonding (interlaminar stresss) 0.0 3.271738e-16
# 3 max_value NaN NaN
# 1 failure_index_for_ply (direct stress/strain) 0.0 5.431871e-14
# 2 failure_index_for_bonding (interlaminar stresss) NaN NaN
# 3 max_value 0.0 5.431871e-14
column_names, column_values = self._build_dataframe_transient_header()
names = ['ElementID', 'Layer', 'Item']
data_frame = self._build_pandas_transient_element_node(
column_values, column_names, headers,
element_layer, self.data, names=names,
from_tuples=False, from_array=True)
#column_names, column_values = self._build_dataframe_transient_header()
#data_frame = pd.Panel(self.data, items=column_values,
#major_axis=element_layer, minor_axis=headers).to_frame()
#data_frame.columns.names = column_names
#data_frame.index.names = ['ElementID', 'Layer', 'Item']
else:
#Static failure_index_for_ply (direct stress/strain) failure_index_for_bonding (interlaminar stresss) max_value
#ElementID Layer
#101 1 7.153059e-07 0.0 NaN
# 2 1.276696e-07 0.0 NaN
# 3 7.153059e-07 NaN 7.153059e-07
element_layer = [self.element_layer[:, 0], self.element_layer[:, 1]]
index = pd.MultiIndex.from_arrays(element_layer, names=['ElementID', 'Layer'])
data_frame = pd.DataFrame(self.data[0], columns=headers, index=index)
data_frame.columns.names = ['Static']
self.data_frame = data_frame
def get_headers(self) -> List[str]:
#headers = ['eid', 'failure_theory', 'ply', 'failure_index_for_ply (direct stress/strain)',
#'failure_index_for_bonding (interlaminar stresss)', 'failure_index_for_element', 'flag']
headers = ['failure_index_for_ply (direct stress/strain)',
'failure_index_for_bonding (interlaminar stresss)', 'max_value']
return headers
def __eq__(self, table): # pragma: no cover
return True
def add_sort1(self, dt, eid, failure_theory, ply_id, failure_stress_for_ply, flag,
interlaminar_stress, max_value, nine):
"""unvectorized method for adding SORT1 transient data"""
assert isinstance(eid, integer_types) and eid > 0, 'dt=%s eid=%s' % (dt, eid)
self._times[self.itime] = dt
self.element_layer[self.ielement] = [eid, ply_id]
self.failure_theory[self.ielement] = failure_theory
self.data[self.itime, self.ielement, :] = [failure_stress_for_ply, interlaminar_stress, max_value]
self.ielement += 1
def get_stats(self, short=False) -> List[str]:
if not self.is_built:
return [
'<%s>\n' % self.__class__.__name__,
' ntimes: %i\n' % self.ntimes,
' ntotal: %i\n' % self.ntotal,
]
ntimes = self.data.shape[0]
nelements = self.data.shape[1]
assert self.ntimes == ntimes, 'ntimes=%s expected=%s' % (self.ntimes, ntimes)
assert self.nelements == nelements, 'nelements=%s expected=%s' % (self.nelements, nelements)
msg = []
if self.nonlinear_factor not in (None, np.nan): # transient
msg.append(' type=%s ntimes=%i nelements=%i; table_name=%r\n'
% (self.__class__.__name__, ntimes, nelements, self.table_name))
ntimes_word = 'ntimes'
else:
msg.append(' type=%s nelements=%i; table_name=%r\n'
% (self.__class__.__name__, nelements, self.table_name))
ntimes_word = '1'
headers = self.get_headers()
n = len(headers)
msg.append(' data: [%s, nelements, %i] where %i=[%s]\n' % (ntimes_word, n, n, str(', '.join(headers))))
msg.append(' data.shape = %s\n' % str(self.data.shape).replace('L', ''))
msg.append(' element type: %s\n' % self.element_name)
msg += self.get_data_code()
return msg
def get_f06_header(self, is_mag_phase=True, is_sort1=True):
return [] # raise NotImplementedError('this should be overwritten by %s' % (self.__class__.__name__))
def write_f06(self, f06_file, header=None, page_stamp='PAGE %s',
page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
msg_temp = self.get_f06_header(is_mag_phase=is_mag_phase, is_sort1=is_sort1)
f06_file.write('skipping FailureIndices f06\n')
return page_num
#NotImplementedError(self.code_information())
#asd
#if self.is_sort1:
#page_num = self._write_sort1_as_sort1(header, page_stamp, page_num, f06_file, msg_temp)
#else:
#raise NotImplementedError(self.code_information())
#page_num = self._write_sort2_as_sort2(header, page_stamp, page_num, f06_file, msg_temp)
#' F A I L U R E I N D I C E S F O R L A Y E R E D C O M P O S I T E E L E M E N T S ( T R I A 3 )\n'
#' ELEMENT FAILURE PLY FP=FAILURE INDEX FOR PLY FB=FAILURE INDEX FOR BONDING FAILURE INDEX FOR ELEMENT FLAG\n'
#' ID THEORY ID (DIRECT STRESSES/STRAINS) (INTER-LAMINAR STRESSES) MAX OF FP,FB FOR ALL PLIES\n'
#' 1 HOFFMAN 101 6.987186E-02 \n'
#' 1.687182E-02 \n'
#' 102 9.048269E-02 \n'
#' 1.721401E-02 \n'
#return page_num
class RealSpringDamperForceArray(RealForceObject):
def __init__(self, data_code, is_sort1, isubcase, dt):
RealForceObject.__init__(self, data_code, isubcase)
self.nelements = 0 # result specific
#if not is_sort1:
#raise NotImplementedError('SORT2')
@classmethod
def add_static_case(cls, table_name, element_name, element, data, isubcase,
is_sort1=True, is_random=False, is_msc=True,
random_code=0, title='', subtitle='', label=''):
analysis_code = 1 # static
data_code = oef_data_code(table_name, analysis_code,
is_sort1=is_sort1, is_random=is_random,
random_code=random_code,
title=title, subtitle=subtitle, label=label,
is_msc=is_msc)
data_code['loadIDs'] = [0] # TODO: ???
data_code['data_names'] = []
# I'm only sure about the 1s in the strains and the
# corresponding 0s in the stresses.
#if is_stress:
#data_code['stress_bits'] = [0, 0, 0, 0]
#data_code['s_code'] = 0
#else:
#data_code['stress_bits'] = [0, 1, 0, 1]
#data_code['s_code'] = 1 # strain?
element_name_to_element_type = {
'CELAS1' : 11,
'CELAS2' : 12,
'CELAS3' : 13,
'CELAS4' : 14,
}
element_type = element_name_to_element_type[element_name]
data_code['element_name'] = element_name
data_code['element_type'] = element_type
#data_code['load_set'] = 1
ntimes = data.shape[0]
nnodes = data.shape[1]
dt = None
obj = cls(data_code, is_sort1, isubcase, dt)
obj.element = element
obj.data = data
obj.ntimes = ntimes
obj.ntotal = nnodes
obj._times = [None]
obj.is_built = True
return obj
def build(self):
"""sizes the vectorized attributes of the RealSpringDamperForceArray"""
#print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))
assert self.ntimes > 0, 'ntimes=%s' % self.ntimes
assert self.nelements > 0, 'nelements=%s' % self.nelements
assert self.ntotal > 0, 'ntotal=%s' % self.ntotal
#self.names = []
self.nelements //= self.ntimes
self.itime = 0
self.ielement = 0
self.itotal = 0
#self.ntimes = 0
#self.nelements = 0
self.is_built = True
#print("ntimes=%s nelements=%s ntotal=%s" % (self.ntimes, self.nelements, self.ntotal))
dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size)
self.build_data(self.ntimes, self.nelements, dtype, idtype, fdtype)
def build_data(self, ntimes, nelements, dtype, idtype, fdtype):
"""actually performs the build step"""
self.ntimes = ntimes
self.nelements = nelements
self._times = zeros(ntimes, dtype=dtype)
self.element = zeros(nelements, dtype=idtype)
#[force]
self.data = zeros((ntimes, nelements, 1), dtype=fdtype)
def build_dataframe(self):
"""creates a pandas dataframe"""
import pandas as pd
headers = self.get_headers()
if self.nonlinear_factor not in (None, np.nan):
#Mode 1 2 3
#Freq 1.482246e-10 3.353940e-09 1.482246e-10
#Eigenvalue -8.673617e-19 4.440892e-16 8.673617e-19
#Radians 9.313226e-10 2.107342e-08 9.313226e-10
#ElementID Item
#30 spring_force 2.388744e-19 -1.268392e-10 -3.341473e-19
#31 spring_force 2.781767e-19 -3.034770e-11 -4.433221e-19
#32 spring_force 0.000000e+00 0.000000e+00 0.000000e+00
#33 spring_force 0.000000e+00 0.000000e+00 0.000000e+00
column_names, column_values = self._build_dataframe_transient_header()
data_frame = self._build_pandas_transient_elements(
column_values, column_names,
headers, self.element, self.data)
else:
#Static spring_force
#ElementID
#30 0.0
#31 0.0
#32 0.0
#33 0.0
data_frame = pd.DataFrame(self.data[0], columns=headers, index=self.element)
data_frame.index.name = 'ElementID'
data_frame.columns.names = ['Static']
self.data_frame = data_frame
def __eq__(self, table): # pragma: no cover
assert self.is_sort1 == table.is_sort1
is_nan = (
self.nonlinear_factor is not None and
np.isnan(self.nonlinear_factor) and
np.isnan(table.nonlinear_factor)
)
if not is_nan:
assert self.nonlinear_factor == table.nonlinear_factor
assert self.ntotal == table.ntotal
assert self.table_name == table.table_name, 'table_name=%r table.table_name=%r' % (self.table_name, table.table_name)
assert self.approach_code == table.approach_code
if self.nonlinear_factor not in (None, np.nan):
assert np.array_equal(self._times, table._times), 'ename=%s-%s times=%s table.times=%s' % (
self.element_name, self.element_type, self._times, table._times)
if not np.array_equal(self.element, table.element):
assert self.element.shape == table.element.shape, 'shape=%s element.shape=%s' % (self.element.shape, table.element.shape)
msg = 'table_name=%r class_name=%s\n' % (self.table_name, self.__class__.__name__)
msg += '%s\nEid1, Eid2\n' % str(self.code_information())
for eid, eid2 in zip(self.element, table.element):
msg += '%s, %s\n' % (eid, eid2)
print(msg)
raise ValueError(msg)
if not np.array_equal(self.data, table.data):
msg = 'table_name=%r class_name=%s\n' % (self.table_name, self.__class__.__name__)
msg += '%s\n' % str(self.code_information())
ntimes = self.data.shape[0]
i = 0
if self.is_sort1:
for itime in range(ntimes):
for ieid, eid, in enumerate(self.element):
t1 = self.data[itime, ieid, :]
t2 = table.data[itime, ieid, :]
(force1, stress1) = t1
(force2, stress2) = t2
if not allclose(t1, t2):
#if not np.array_equal(t1, t2):
msg += '%s\n (%s, %s)\n (%s, %s)\n' % (
eid,
force1, stress1,
force2, stress2)
i += 1
if i > 10:
print(msg)
raise ValueError(msg)
else:
raise NotImplementedError(self.is_sort2)
if i > 0:
print(msg)
raise ValueError(msg)
return True
def add_sort1(self, dt, eid, force):
"""unvectorized method for adding SORT1 transient data"""
assert isinstance(eid, integer_types) and eid > 0, 'dt=%s eid=%s' % (dt, eid)
#print('dt=%s eid=%s' % (dt, eid))
self._times[self.itime] = dt
self.element[self.ielement] = eid
self.data[self.itime, self.ielement, :] = [force]
self.ielement += 1
def get_stats(self, short=False) -> List[str]:
if not self.is_built:
return [
'<%s>\n' % self.__class__.__name__,
' ntimes: %i\n' % self.ntimes,
' ntotal: %i\n' % self.ntotal,
]
ntimes = self.data.shape[0]
nelements = self.data.shape[1]
assert self.ntimes == ntimes, 'ntimes=%s expected=%s' % (self.ntimes, ntimes)
assert self.nelements == nelements, 'nelements=%s expected=%s' % (self.nelements, nelements)
msg = []
if self.nonlinear_factor not in (None, np.nan): # transient
msg.append(' type=%s ntimes=%i nelements=%i; table_name=%r\n'
% (self.__class__.__name__, ntimes, nelements, self.table_name))
ntimes_word = 'ntimes'
else:
msg.append(' type=%s nelements=%i; table_name=%r\n'
% (self.__class__.__name__, nelements, self.table_name))
ntimes_word = '1'
headers = self.get_headers()
n = len(headers)
msg.append(' data: [%s, nelements, %i] where %i=[%s]\n' % (
ntimes_word, n, n, str(', '.join(headers))))
msg.append(' data.shape = %s\n' % str(self.data.shape).replace('L', ''))
msg.append(' element.shape = %s\n' % str(self.element.shape).replace('L', ''))
msg.append(' element type: %s\n' % self.element_name)
msg += self.get_data_code()
return msg
def get_f06_header(self, is_mag_phase=True, is_sort1=True):
raise NotImplementedError('this should be overwritten by %s' % (self.__class__.__name__))
def write_f06(self, f06_file, header=None, page_stamp='PAGE %s',
page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
msg_temp = self.get_f06_header(is_mag_phase=is_mag_phase, is_sort1=is_sort1)
if self.is_sort1:
page_num = self._write_sort1_as_sort1(header, page_stamp, page_num, f06_file, msg_temp)
else:
raise NotImplementedError(self.code_information())
#page_num = self._write_sort2_as_sort2(header, page_stamp, page_num, f06_file, msg_temp)
return page_num
def _write_sort1_as_sort1(self, header, page_stamp, page_num, f06_file, msg_temp):
ntimes = self.data.shape[0]
eids = self.element
nwrite = len(eids)
nrows = nwrite // 4
nleftover = nwrite - nrows * 4
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f06_file.write(''.join(header + msg_temp))
stress = self.data[itime, :, 0]
out = []
for eid, stressi in zip(eids, stress):
out.append([eid, write_float_13e(stressi)])
for i in range(0, nrows * 4, 4):
f06_file.write(' %10i %13s %10i %13s %10i %13s %10i %13s\n' % (
tuple(out[i] + out[i + 1] + out[i + 2] + out[i + 3])))
i = nrows * 4
if nleftover == 3:
f06_file.write(' %10i %13s %10i %13s %10i %13s\n' % (
tuple(out[i] + out[i + 1] + out[i + 2])))
elif nleftover == 2:
f06_file.write(' %10i %13s %10i %13s\n' % (
tuple(out[i] + out[i + 1])))
elif nleftover == 1:
f06_file.write(' %10i %13s\n' % tuple(out[i]))
f06_file.write(page_stamp % page_num)
page_num += 1
return page_num - 1
def write_op2(self, op2, op2_ascii, itable, new_result,
date, is_mag_phase=False, endian='>'):
"""writes an OP2"""
import inspect
from struct import Struct, pack
frame = inspect.currentframe()
call_frame = inspect.getouterframes(frame, 2)
op2_ascii.write('%s.write_op2: %s\n' % (self.__class__.__name__, call_frame[1][3]))
if itable == -1:
self._write_table_header(op2, op2_ascii, date)
itable = -3
#eids = self.element
# table 4 info
#ntimes = self.data.shape[0]
#nnodes = self.data.shape[1]
nelements = self.data.shape[1]
# 21 = 1 node, 3 principal, 6 components, 9 vectors, 2 p/ovm
#ntotal = ((nnodes * 21) + 1) + (nelements * 4)
ntotali = self.num_wide
ntotal = ntotali * nelements
#print('shape = %s' % str(self.data.shape))
#assert self.ntimes == 1, self.ntimes
#device_code = self.device_code
op2_ascii.write(' ntimes = %s\n' % self.ntimes)
eids_device = self.element * 10 + self.device_code
#print('ntotal=%s' % (ntotal))
#assert ntotal == 193, ntotal
if self.is_sort1:
struct1 = Struct(endian + b'if')
else:
raise NotImplementedError('SORT2')
op2_ascii.write('%s-nelements=%i\n' % (self.element_name, nelements))
for itime in range(self.ntimes):
self._write_table_3(op2, op2_ascii, new_result, itable, itime)
# record 4
itable -= 1
header = [4, itable, 4,
4, 1, 4,
4, 0, 4,
4, ntotal, 4,
4 * ntotal]
op2.write(pack('%ii' % len(header), *header))
op2_ascii.write('r4 [4, 0, 4]\n')
op2_ascii.write('r4 [4, %s, 4]\n' % (itable))
op2_ascii.write('r4 [4, %i, 4]\n' % (4 * ntotal))
force = self.data[itime, :, 0]
for eid, forcei in zip(eids_device, force):
data = [eid, forcei]
op2_ascii.write(' eid=%s force=%s\n' % tuple(data))
op2.write(struct1.pack(*data))
itable -= 1
header = [4 * ntotal,]
op2.write(pack('i', *header))
op2_ascii.write('footer = %s\n' % header)
new_result = False
return itable
class RealSpringForceArray(RealSpringDamperForceArray):
def __init__(self, data_code, is_sort1, isubcase, dt):
RealSpringDamperForceArray.__init__(self, data_code, is_sort1, isubcase, dt)
@property
def nnodes_per_element(self) -> int:
return 1
def get_headers(self) -> List[str]:
headers = ['spring_force']
return headers
def get_f06_header(self, is_mag_phase=True, is_sort1=True):
if self.element_type == 11: # CELAS1
msg = [' F O R C E S I N S C A L A R S P R I N G S ( C E L A S 1 )\n']
elif self.element_type == 12: # CELAS2
msg = [' F O R C E S I N S C A L A R S P R I N G S ( C E L A S 2 )\n']
elif self.element_type == 13: # CELAS3
msg = [' F O R C E S I N S C A L A R S P R I N G S ( C E L A S 3 )\n']
elif self.element_type == 14: # CELAS4
msg = [' F O R C E S I N S C A L A R S P R I N G S ( C E L A S 4 )\n']
else: # pragma: no cover
msg = 'element_name=%s element_type=%s' % (self.element_name, self.element_type)
raise NotImplementedError(msg)
msg += [
' ELEMENT FORCE ELEMENT FORCE ELEMENT FORCE ELEMENT FORCE\n'
' ID. ID. ID. ID.\n'
]
return msg
class RealDamperForceArray(RealSpringDamperForceArray):
def __init__(self, data_code, is_sort1, isubcase, dt):
RealSpringDamperForceArray.__init__(self, data_code, is_sort1, isubcase, dt)
@property
def nnodes_per_element(self) -> int:
return 1
def get_headers(self) -> List[str]:
headers = ['damper_force']
return headers
def get_f06_header(self, is_mag_phase=True, is_sort1=True):
if self.element_type == 20: # CDAMP1
msg = [' F O R C E S I N S C A L A R D A M P E R S ( C D A M P 1 )\n']
elif self.element_type == 21: # CDAMP2
msg = [' F O R C E S I N S C A L A R D A M P E R S ( C D A M P 2 )\n']
elif self.element_type == 22: # CDAMP3
msg = [' F O R C E S I N S C A L A R D A M P E R S ( C D A M P 3 )\n']
elif self.element_type == 23: # CDAMP4
msg = [' F O R C E S I N S C A L A R D A M P E R S ( C D A M P 4 )\n']
else: # pragma: no cover
msg = 'element_name=%s element_type=%s' % (self.element_name, self.element_type)
raise NotImplementedError(msg)
if is_sort1:
msg += [
' ELEMENT FORCE ELEMENT FORCE ELEMENT FORCE ELEMENT FORCE\n'
' ID. ID. ID. ID.\n'
]
else:
msg += [
' AXIAL AXIAL\n'
' TIME FORCE TORQUE TIME FORCE TORQUE\n'
]
return msg
class RealRodForceArray(RealForceObject):
def __init__(self, data_code, is_sort1, isubcase, dt):
RealForceObject.__init__(self, data_code, isubcase)
self.nelements = 0 # result specific
@classmethod
def add_static_case(cls, table_name, element_name, element, data, isubcase,
is_sort1=True, is_random=False, is_msc=True,
random_code=0, title='', subtitle='', label=''):
analysis_code = 1 # static
data_code = oef_data_code(table_name, analysis_code,
is_sort1=is_sort1, is_random=is_random,
random_code=random_code,
title=title, subtitle=subtitle, label=label,
is_msc=is_msc)
data_code['loadIDs'] = [0] # TODO: ???
data_code['data_names'] = []
# I'm only sure about the 1s in the strains and the
# corresponding 0s in the stresses.
#if is_stress:
#data_code['stress_bits'] = [0, 0, 0, 0]
#data_code['s_code'] = 0
#else:
#data_code['stress_bits'] = [0, 1, 0, 1]
#data_code['s_code'] = 1 # strain?
element_name_to_element_type = {
'CROD' : 1,
'CTUBE' : 3,
'CONROD' : 10,
}
element_type = element_name_to_element_type[element_name]
data_code['element_name'] = element_name
data_code['element_type'] = element_type
#data_code['load_set'] = 1
ntimes = data.shape[0]
nnodes = data.shape[1]
dt = None
obj = cls(data_code, is_sort1, isubcase, dt)
obj.element = element
obj.data = data
obj.ntimes = ntimes
obj.ntotal = nnodes
obj._times = [None]
obj.is_built = True
return obj
@property
def nnodes_per_element(self) -> int:
return 1
def get_headers(self) -> List[str]:
headers = ['axial', 'torsion']
return headers
#def get_headers(self):
#headers = ['axial', 'torque']
#return headers
def _get_msgs(self):
base_msg = [' ELEMENT AXIAL TORSIONAL ELEMENT AXIAL TORSIONAL\n',
' ID. FORCE MOMENT ID. FORCE MOMENT\n']
crod_msg = [' F O R C E S I N R O D E L E M E N T S ( C R O D )\n', ]
conrod_msg = [' F O R C E S I N R O D E L E M E N T S ( C O N R O D )\n', ]
ctube_msg = [' F O R C E S I N R O D E L E M E N T S ( C T U B E )\n', ]
crod_msg += base_msg
conrod_msg += base_msg
ctube_msg += base_msg
return crod_msg, conrod_msg, ctube_msg
def build(self):
"""sizes the vectorized attributes of the RealRodForceArray"""
assert self.ntimes > 0, 'ntimes=%s' % self.ntimes
assert self.nelements > 0, 'nelements=%s' % self.nelements
assert self.ntotal > 0, 'ntotal=%s' % self.ntotal
#self.names = []
self.nelements //= self.ntimes
#print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))
self.itime = 0
self.ielement = 0
self.itotal = 0
#self.ntimes = 0
#self.nelements = 0
self.is_built = True
#print("ntimes=%s nelements=%s ntotal=%s" % (self.ntimes, self.nelements, self.ntotal))
self.build_data(self.ntimes, self.nelements, float_fmt='float32')
def build_data(self, ntimes, nelements, float_fmt='float32'):
"""actually performs the build step"""
self.ntimes = ntimes
self.nelements = nelements
#self.ntotal = ntimes * nelements
dtype = 'float32'
if isinstance(self.nonlinear_factor, integer_types):
dtype = 'int32'
self._times = zeros(ntimes, dtype=dtype)
self.element = zeros(nelements, dtype='int32')
#[axial_force, torque]
self.data = zeros((ntimes, nelements, 2), dtype='float32')
def build_dataframe(self):
"""creates a pandas dataframe"""
import pandas as pd
headers = self.get_headers()
if self.nonlinear_factor not in (None, np.nan):
column_names, column_values = self._build_dataframe_transient_header()
data_frame = self._build_pandas_transient_elements(
column_values, column_names,
headers, self.element, self.data)
else:
#Static axial SMa torsion SMt
#ElementID
#14 0.0 1.401298e-45 0.0 1.401298e-45
#15 0.0 1.401298e-45 0.0 1.401298e-45
data_frame = pd.DataFrame(self.data[0], columns=headers, index=self.element)
data_frame.index.name = 'ElementID'
data_frame.columns.names = ['Static']
self.data_frame = data_frame
def add_sort1(self, dt, eid, axial, torque):
"""unvectorized method for adding SORT1 transient data"""
assert isinstance(eid, integer_types) and eid > 0, 'dt=%s eid=%s' % (dt, eid)
self._times[self.itime] = dt
self.element[self.ielement] = eid
self.data[self.itime, self.ielement, :] = [axial, torque]
self.ielement += 1
if self.ielement == self.nelements:
self.ielement = 0
def get_stats(self, short=False) -> List[str]:
if not self.is_built:
return [
'<%s>\n' % self.__class__.__name__,
' ntimes: %i\n' % self.ntimes,
' ntotal: %i\n' % self.ntotal,
]
nelements = self.nelements
ntimes = self.ntimes
#ntotal = self.ntotal
msg = []
if self.nonlinear_factor not in (None, np.nan): # transient
msg.append(' type=%s ntimes=%i nelements=%i; table_name=%r\n'
% (self.__class__.__name__, ntimes, nelements, self.table_name))
ntimes_word = 'ntimes'
else:
msg.append(' type=%s nelements=%i; table_name=%r\n'
% (self.__class__.__name__, nelements, self.table_name))
ntimes_word = '1'
headers = self.get_headers()
n = len(headers)
msg.append(' data: [%s, nnodes, %i] where %i=[%s]\n' % (
ntimes_word, n, n, str(', '.join(headers))))
msg.append(' data.shape = %s\n' % str(self.data.shape).replace('L', ''))
msg.append(' element.shape = %s\n' % str(self.element.shape).replace('L', ''))
#msg.append(' element type: %s\n' % self.element_type)
msg.append(' element name: %s\n' % self.element_name)
msg += self.get_data_code()
return msg
def get_f06_header(self, is_mag_phase=True):
crod_msg, conrod_msg, ctube_msg = self._get_msgs()
if 'CROD' in self.element_name:
msg = crod_msg
elif 'CONROD' in self.element_name:
msg = conrod_msg
elif 'CTUBE' in self.element_name:
msg = ctube_msg
return self.element_name, msg
def write_f06(self, f06_file, header=None, page_stamp='PAGE %s',
page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
(elem_name, msg_temp) = self.get_f06_header(is_mag_phase)
# write the f06
#(ntimes, ntotal, two) = self.data.shape
ntimes = self.data.shape[0]
eids = self.element
is_odd = False
nwrite = len(eids)
if len(eids) % 2 == 1:
nwrite -= 1
is_odd = True
#print('len(eids)=%s nwrite=%s is_odd=%s' % (len(eids), nwrite, is_odd))
for itime in range(ntimes):
dt = self._times[itime] # TODO: rename this...
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f06_file.write(''.join(header + msg_temp))
#print("self.data.shape=%s itime=%s ieids=%s" % (str(self.data.shape), itime, str(ieids)))
axial = self.data[itime, :, 0]
torsion = self.data[itime, :, 1]
out = []
for eid, axiali, torsioni in zip(eids, axial, torsion):
[axiali, torsioni] = write_floats_13e([axiali, torsioni])
out.append([eid, axiali, torsioni])
for i in range(0, nwrite, 2):
out_line = ' %8i %-13s %-13s %8i %-13s %s\n' % tuple(out[i] + out[i + 1])
f06_file.write(out_line)
if is_odd:
out_line = ' %8i %-13s %s\n' % tuple(out[-1])
f06_file.write(out_line)
f06_file.write(page_stamp % page_num)
page_num += 1
return page_num - 1
def __eq__(self, table): # pragma: no cover
assert self.is_sort1 == table.is_sort1
is_nan = (
self.nonlinear_factor is not None and
np.isnan(self.nonlinear_factor) and
np.isnan(table.nonlinear_factor)
)
if not is_nan:
assert self.nonlinear_factor == table.nonlinear_factor
assert self.ntotal == table.ntotal
assert self.table_name == table.table_name, 'table_name=%r table.table_name=%r' % (self.table_name, table.table_name)
assert self.approach_code == table.approach_code
if self.nonlinear_factor not in (None, np.nan):
assert np.array_equal(self._times, table._times), 'ename=%s-%s times=%s table.times=%s' % (
self.element_name, self.element_type, self._times, table._times)
if not np.array_equal(self.element, table.element):
assert self.element.shape == table.element.shape, 'element shape=%s table.shape=%s' % (self.element.shape, table.element.shape)
msg = 'table_name=%r class_name=%s\n' % (self.table_name, self.__class__.__name__)
msg += '%s\n' % str(self.code_information())
msg += 'Eid\n'
for eid, eid2 in zip(self.element, table.element):
msg += '%s, %s\n' % (eid, eid2)
print(msg)
raise ValueError(msg)
if not np.array_equal(self.data, table.data):
msg = 'table_name=%r class_name=%s\n' % (self.table_name, self.__class__.__name__)
msg += '%s\n' % str(self.code_information())
i = 0
for itime in range(self.ntimes):
for ie, eid in enumerate(self.element):
t1 = self.data[itime, ie, :]
t2 = table.data[itime, ie, :]
(axial1, torque1) = t1
(axial2, torque2) = t2
if not np.array_equal(t1, t2):
msg += '(%s) (%s, %s) (%s, %s)\n' % (
eid,
axial1, torque1,
axial2, torque2)
i += 1
if i > 10:
print(msg)
raise ValueError(msg)
#print(msg)
if i > 0:
raise ValueError(msg)
return True
def write_op2(self, op2, op2_ascii, itable, new_result,
date, is_mag_phase=False, endian='>'):
"""writes an OP2"""
frame = inspect.currentframe()
call_frame = inspect.getouterframes(frame, 2)
op2_ascii.write('%s.write_op2: %s\n' % (self.__class__.__name__, call_frame[1][3]))
if itable == -1:
self._write_table_header(op2, op2_ascii, date)
itable = -3
#if isinstance(self.nonlinear_factor, float):
#op2_format = '%sif' % (7 * self.ntimes)
#raise NotImplementedError()
#else:
#op2_format = 'i21f'
#s = Struct(op2_format)
#eids = self.element
# table 4 info
#ntimes = self.data.shape[0]
#nnodes = self.data.shape[1]
nelements = self.data.shape[1]
# 21 = 1 node, 3 principal, 6 components, 9 vectors, 2 p/ovm
#ntotal = ((nnodes * 21) + 1) + (nelements * 4)
ntotali = self.num_wide
ntotal = ntotali * nelements
#print('shape = %s' % str(self.data.shape))
#assert self.ntimes == 1, self.ntimes
#device_code = self.device_code
op2_ascii.write(' ntimes = %s\n' % self.ntimes)
eids_device = self.element * 10 + self.device_code
#fmt = '%2i %6f'
#print('ntotal=%s' % (ntotal))
#assert ntotal == 193, ntotal
if self.is_sort1:
struct1 = Struct(endian + b'i2f')
else:
raise NotImplementedError('SORT2')
op2_ascii.write('%s-nelements=%i\n' % (self.element_name, nelements))
for itime in range(self.ntimes):
self._write_table_3(op2, op2_ascii, new_result, itable, itime)
# record 4
#print('stress itable = %s' % itable)
itable -= 1
header = [4, itable, 4,
4, 1, 4,
4, 0, 4,
4, ntotal, 4,
4 * ntotal]
op2.write(pack('%ii' % len(header), *header))
op2_ascii.write('r4 [4, 0, 4]\n')
op2_ascii.write('r4 [4, %s, 4]\n' % (itable))
op2_ascii.write('r4 [4, %i, 4]\n' % (4 * ntotal))
axial = self.data[itime, :, 0]
torsion = self.data[itime, :, 1]
#print('eids3', eids3)
for eid, axiali, torsioni in zip(eids_device, axial, torsion):
data = [eid, axiali, torsioni]
op2_ascii.write(' eid=%s axial=%s torsion=%s\n' % tuple(data))
op2.write(struct1.pack(*data))
itable -= 1
header = [4 * ntotal,]
op2.write(pack('i', *header))
op2_ascii.write('footer = %s\n' % header)
new_result = False
return itable
class RealCBeamForceArray(RealForceObject):
def __init__(self, data_code, is_sort1, isubcase, dt):
#ForceObject.__init__(self, data_code, isubcase)
RealForceObject.__init__(self, data_code, isubcase)
self.result_flag = 0
self.itime = 0
self.nelements = 0 # result specific
#if is_sort1:
##sort1
#pass
#else:
#raise NotImplementedError('SORT2')
def build(self):
"""sizes the vectorized attributes of the RealCBeamForceArray"""
#print('ntimes=%s nelements=%s ntotal=%s subtitle=%s' % (self.ntimes, self.nelements, self.ntotal, self.subtitle))
if self.is_built:
return
nnodes = 11
#self.names = []
#self.nelements //= nnodes
self.nelements //= self.ntimes
#self.ntotal //= self.ntimes
self.itime = 0
self.ielement = 0
self.itotal = 0
self.is_built = True
#print('ntotal=%s ntimes=%s nelements=%s' % (self.ntotal, self.ntimes, self.nelements))
#print("ntimes=%s nelements=%s ntotal=%s" % (self.ntimes, self.nelements, self.ntotal))
dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size)
self._times = zeros(self.ntimes, dtype)
self.element = zeros(self.ntotal, idtype)
self.element_node = zeros((self.ntotal, 2), idtype)
# the number is messed up because of the offset for the element's properties
if not (self.nelements * nnodes) == self.ntotal:
msg = 'ntimes=%s nelements=%s nnodes=%s ne*nn=%s ntotal=%s' % (self.ntimes,
self.nelements, nnodes,
self.nelements * nnodes,
self.ntotal)
raise RuntimeError(msg)
#[sd, bm1, bm2, ts1, ts2, af, ttrq, wtrq]
self.data = zeros((self.ntimes, self.ntotal, 8), fdtype)
def finalize(self):
sd = self.data[0, :, 0]
i_sd_zero = np.where(sd != 0.0)[0]
i_node_zero = np.where(self.element_node[:, 1] != 0)[0]
assert i_node_zero.max() > 0, 'CBEAM element_node hasnt been filled'
i = np.union1d(i_sd_zero, i_node_zero)
#self.nelements = len(self.element) // 11
self.element = self.element[i]
self.element_node = self.element_node[i, :]
self.data = self.data[:, i, :]
def build_dataframe(self):
"""creates a pandas dataframe"""
import pandas as pd
headers = self.get_headers()
element_location = [
self.element_node[:, 0],
self.data[0, :, 0],
]
if self.nonlinear_factor not in (None, np.nan):
#Mode 1 2 3
#Freq 1.482246e-10 3.353940e-09 1.482246e-10
#Eigenvalue -8.673617e-19 4.440892e-16 8.673617e-19
#Radians 9.313226e-10 2.107342e-08 9.313226e-10
#ElementID Location Item
#12 0.0 bending_moment1 1.505494e-13 -2.554764e-07 -5.272747e-13
# bending_moment2 -2.215085e-13 -2.532377e-07 3.462328e-13
# shear1 1.505494e-13 -2.554763e-07 -5.272747e-13
# shear2 -2.215085e-13 -2.532379e-07 3.462328e-13
# axial_force 1.294136e-15 -1.670896e-09 4.759476e-16
# total_torque -4.240346e-16 2.742446e-09 1.522254e-15
# warping_torque 0.000000e+00 0.000000e+00 0.000000e+00
# 1.0 bending_moment1 0.000000e+00 -1.076669e-13 1.009742e-28
# bending_moment2 -5.048710e-29 1.704975e-13 0.000000e+00
# shear1 1.505494e-13 -2.554763e-07 -5.272747e-13
# shear2 -2.215085e-13 -2.532379e-07 3.462328e-13
# axial_force 1.294136e-15 -1.670896e-09 4.759476e-16
# total_torque -4.240346e-16 2.742446e-09 1.522254e-15
# warping_torque 0.000000e+00 0.000000e+00 0.000000e+00
column_names, column_values = self._build_dataframe_transient_header()
data_frame = self._build_pandas_transient_element_node(
column_values, column_names,
headers[1:], element_location, self.data[:, :, 1:], from_tuples=False, from_array=True)
data_frame.index.names = ['ElementID', 'Location', 'Item']
else:
df1 = pd.DataFrame(element_location).T
df1.columns = ['ElementID', 'Location']
df2 = pd.DataFrame(self.data[0])
df2.columns = headers
data_frame = df1.join([df2])
#self.data_frame = data_frame.reset_index().replace({'NodeID': {0:'CEN'}}).set_index(['ElementID', 'NodeID'])
self.data_frame = data_frame
def __eq__(self, table): # pragma: no cover
self._eq_header(table)
assert self.is_sort1 == table.is_sort1
if not np.array_equal(self.data, table.data):
msg = 'table_name=%r class_name=%s\n' % (self.table_name, self.__class__.__name__)
msg += '%s\n' % str(self.code_information())
ntimes = self.data.shape[0]
i = 0
if self.is_sort1:
for itime in range(ntimes):
for ieid, eid, in enumerate(self.element):
t1 = self.data[itime, ieid, :]
t2 = table.data[itime, ieid, :]
(axial_stress1, equiv_stress1, total_strain1, effective_plastic_creep_strain1, effective_creep_strain1, linear_torsional_stress1) = t1
(axial_stress2, equiv_stress2, total_strain2, effective_plastic_creep_strain2, effective_creep_strain2, linear_torsional_stress2) = t2
if not np.allclose(t1, t2):
#if not np.array_equal(t1, t2):
msg += '%s\n (%s, %s, %s, %s, %s, %s)\n (%s, %s, %s, %s, %s, %s)\n' % (
eid,
axial_stress1, equiv_stress1, total_strain1, effective_plastic_creep_strain1, effective_creep_strain1, linear_torsional_stress1,
axial_stress2, equiv_stress2, total_strain2, effective_plastic_creep_strain2, effective_creep_strain2, linear_torsional_stress2)
i += 1
if i > 10:
print(msg)
raise ValueError(msg)
else:
raise NotImplementedError(self.is_sort2)
if i > 0:
print(msg)
raise ValueError(msg)
return True
def add_new_element_sort1(self, dt, eid, nid, sd, bm1, bm2, ts1, ts2, af, ttrq, wtrq):
return self.add_sort1(dt, eid, nid, sd, bm1, bm2, ts1, ts2, af, ttrq, wtrq)
def add_sort1(self, dt, eid, nid, sd, bm1, bm2, ts1, ts2, af, ttrq, wtrq):
"""unvectorized method for adding SORT1 transient data"""
assert isinstance(eid, integer_types) and eid > 0, 'dt=%s eid=%s' % (dt, eid)
self._times[self.itime] = dt
self.data[self.itime, self.itotal, :] = [sd, bm1, bm2, ts1, ts2, af, ttrq, wtrq]
self.element[self.itotal] = eid
self.element_node[self.itotal, :] = [eid, nid]
self.itotal += 1
def get_stats(self, short=False) -> List[str]:
if not self.is_built:
return [
'<%s>\n' % self.__class__.__name__,
' ntimes: %i\n' % self.ntimes,
' ntotal: %i\n' % self.ntotal,
]
nelements = self.nelements
ntimes = self.ntimes
msg = []
if self.nonlinear_factor not in (None, np.nan): # transient
msg.append(' type=%s ntimes=%i nelements=%i; table_name=%r\n'
% (self.__class__.__name__, ntimes, nelements, self.table_name))
else:
msg.append(' type=%s nelements=%i; table_name=%r\n' % (
self.__class__.__name__, nelements, self.table_name))
#msg.append(' eType, cid\n')
msg.append(' data: [ntimes, nelements, 8] where 8=[%s]\n' % str(', '.join(self.get_headers())))
msg.append(' data.shape = %s\n' % str(self.data.shape).replace('L', ''))
msg.append(' element.shape = %s\n' % str(self.element.shape).replace('L', ''))
msg.append(' element_node.shape = %s\n' % str(self.element_node.shape).replace('L', ''))
msg.append(' is_sort1=%s is_sort2=%s\n' % (self.is_sort1, self.is_sort2))
msg.append(' CBEAM\n')
msg += self.get_data_code()
return msg
def write_f06(self, f06_file, header=None, page_stamp='PAGE %s',
page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
#name = self.data_code['name']
#if name == 'freq':
#name = 'FREQUENCY'
#else: # mode
#raise RuntimeError(name)
#if is_sort1:
msg_temp = [
' F O R C E S I N B E A M E L E M E N T S ( C B E A M )\n',
' STAT DIST/ - BENDING MOMENTS - - WEB SHEARS - AXIAL TOTAL WARPING\n',
' ELEMENT-ID GRID LENGTH PLANE 1 PLANE 2 PLANE 1 PLANE 2 FORCE TORQUE TORQUE\n']
#else:
#raise NotImplementedError('CBEAM-SORT2')
if self.is_sort1:
#assert self.is_sort1 is True, str(self)
#if is_sort1:
page_num = self._write_sort1_as_sort1(f06_file, page_num, page_stamp, header, msg_temp)
#else:
#self._write_sort1_as_sort2(f06_file, page_num, page_stamp, header, msg_temp)
else:
print('skipping %s because its sort2' % self.__class__.__name__)
#assert self.is_sort1 is True, str(self)
return page_num - 1
def get_headers(self) -> List[str]:
headers = [
'sd', 'bending_moment1', 'bending_moment2', 'shear1', 'shear2',
'axial_force', 'total_torque', 'warping_torque', ]
return headers
def _write_sort1_as_sort1(self, f06_file, page_num, page_stamp, header, msg_temp):
eids = self.element_node[:, 0]
nids = self.element_node[:, 1]
long_form = False
if nids.min() == 0:
msg = header + [
' F O R C E S I N B E A M E L E M E N T S ( C B E A M )\n',
' STAT DIST/ - BENDING MOMENTS - - WEB SHEARS - AXIAL TOTAL WARPING\n',
' ELEMENT-ID GRID LENGTH PLANE 1 PLANE 2 PLANE 1 PLANE 2 FORCE TORQUE TORQUE\n']
long_form = True
#times = self._times
ntimes = self.data.shape[0]
for itime in range(ntimes):
if self.nonlinear_factor not in (None, np.nan):
dt = self._times[itime]
dt_line = ' %14s = %12.5E\n' % (self.data_code['name'], dt)
header[1] = dt_line
msg = header + msg_temp
f06_file.write(''.join(msg))
#sd, bm1, bm2, ts1, ts2, af, ttrq, wtrq
assert self.is_sort1 is True, str(self)
sd = self.data[itime, :, 0]
bm1 = self.data[itime, :, 1]
bm2 = self.data[itime, :, 2]
ts1 = self.data[itime, :, 3]
ts2 = self.data[itime, :, 4]
af = self.data[itime, :, 5]
ttrq = self.data[itime, :, 6]
wtrq = self.data[itime, :, 7]
for eid, nid, sdi, bm1i, bm2i, ts1i, ts2i, afi, ttrqi, wtrqi in zip(eids, nids, sd, bm1, bm2, ts1, ts2, af, ttrq, wtrq):
vals = (bm1i, bm2i, ts1i, ts2i, afi, ttrqi, wtrqi)
vals2 = write_floats_13e(vals)
(sbm1i, sbm2i, sts1i, sts2i, safi, sttrqi, swtrq) = vals2
if long_form:
f06_file.write(' %8i %.3f %-13s %-13s %-13s %-13s %-13s %-13s %s\n' % (
eid, sdi, sbm1i, sbm2i, sts1i, sts2i, safi, sttrqi, swtrq))
else:
if sdi == 0.:
f06_file.write('0 %8i\n' % eid)
f06_file.write(' %8i %.3f %-13s %-13s %-13s %-13s %-13s %-13s %s\n' % (
nid, sdi, sbm1i, sbm2i, sts1i, sts2i, safi, sttrqi, swtrq))
f06_file.write(page_stamp % page_num)
page_num += 1
return page_num
def write_op2(self, op2, op2_ascii, itable, new_result,
date, is_mag_phase=False, endian='>'):
"""writes an OP2"""
frame = inspect.currentframe()
call_frame = inspect.getouterframes(frame, 2)
op2_ascii.write('%s.write_op2: %s\n' % (self.__class__.__name__, call_frame[1][3]))
if itable == -1:
self._write_table_header(op2, op2_ascii, date)
itable = -3
eids = self.element_node[:, 0]
nids = self.element_node[:, 1]
#long_form = False
#if nids.min() == 0:
#long_form = True
#if isinstance(self.nonlinear_factor, float):
#op2_format = '%sif' % (7 * self.ntimes)
#raise NotImplementedError()
#else:
#op2_format = 'i21f'
#s = Struct(op2_format)
#xxbs = self.xxb
#print(xxbs)
eids_device = eids * 10 + self.device_code
ueids = np.unique(eids)
#ieid = np.searchsorted(eids, ueids)
# table 4 info
#ntimes = self.data.shape[0]
#nnodes = self.data.shape[1]
nelements = len(ueids)
# 21 = 1 node, 3 principal, 6 components, 9 vectors, 2 p/ovm
#ntotal = ((nnodes * 21) + 1) + (nelements * 4)
ntotali = self.num_wide
ntotal = ntotali * nelements
op2_ascii.write(' ntimes = %s\n' % self.ntimes)
if self.is_sort1:
struct1 = Struct(endian + b'2i 8f')
struct2 = Struct(endian + b'i 8f')
else:
raise NotImplementedError('SORT2')
op2_ascii.write('nelements=%i\n' % nelements)
for itime in range(self.ntimes):
self._write_table_3(op2, op2_ascii, new_result, itable, itime)
# record 4
itable -= 1
header = [4, itable, 4,
4, 1, 4,
4, 0, 4,
4, ntotal, 4,
4 * ntotal]
op2.write(pack('%ii' % len(header), *header))
op2_ascii.write('r4 [4, 0, 4]\n')
op2_ascii.write('r4 [4, %s, 4]\n' % (itable))
op2_ascii.write('r4 [4, %i, 4]\n' % (4 * ntotal))
sd = self.data[itime, :, 0]
bm1 = self.data[itime, :, 1]
bm2 = self.data[itime, :, 2]
ts1 = self.data[itime, :, 3]
ts2 = self.data[itime, :, 4]
af = self.data[itime, :, 5]
ttrq = self.data[itime, :, 6]
wtrq = self.data[itime, :, 7]
icount = 0
nwide = 0
ielement = 0
assert len(eids) == len(sd)
for eid, nid, sdi, bm1i, bm2i, ts1i, ts2i, afi, ttrqi, wtrqi in zip(eids, nids, sd, bm1, bm2, ts1, ts2, af, ttrq, wtrq):
if icount == 0:
eid_device = eids_device[ielement]
nid = nids[ielement]
data = [eid_device, nid, sdi, bm1i, bm2i, ts1i, ts2i, afi, ttrqi, wtrqi] # 10
op2.write(struct1.pack(*data))
ielement += 1
icount = 1
elif nid > 0 and icount > 0:
# 11 total nodes, with 1, 11 getting an nid; the other 9 being
# xxb sections
data = [0, 0., 0., 0., 0., 0., 0., 0., 0.]
#print('***adding %s\n' % (10-icount))
for unused_i in range(10 - icount):
op2.write(struct2.pack(*data))
nwide += len(data)
eid_device2 = eids_device[ielement]
assert eid_device == eid_device2
nid = nids[ielement]
data = [nid, sdi, bm1i, bm2i, ts1i, ts2i, afi, ttrqi, wtrqi] # 9
op2.write(struct2.pack(*data))
ielement += 1
icount = 0
else:
raise RuntimeError('CBEAM op2 writer')
#data = [0, xxb, sxc, sxd, sxe, sxf, smax, smin, smt, smc] # 10
#op2.write(struct2.pack(*data))
#icount += 1
op2_ascii.write(' eid_device=%s data=%s\n' % (eid_device, str(data)))
nwide += len(data)
assert ntotal == nwide, 'ntotal=%s nwide=%s' % (ntotal, nwide)
itable -= 1
header = [4 * ntotal,]
op2.write(pack('i', *header))
op2_ascii.write('footer = %s\n' % header)
new_result = False
return itable
class RealCShearForceArray(RealForceObject):
def __init__(self, data_code, is_sort1, isubcase, dt):
self.element_type = None
self.element_name = None
RealForceObject.__init__(self, data_code, isubcase)
#self.code = [self.format_code, self.sort_code, self.s_code]
#self.ntimes = 0 # or frequency/mode
#self.ntotal = 0
self.nelements = 0 # result specific
#if not is_sort1:
#raise NotImplementedError('SORT2')
@property
def nnodes_per_element(self) -> int:
return 1
def _reset_indices(self):
self.itotal = 0
self.ielement = 0
def get_headers(self) -> List[str]:
headers = [
'force41', 'force21', 'force12', 'force32', 'force23', 'force43',
'force34', 'force14',
'kick_force1', 'shear12', 'kick_force2', 'shear23',
'kick_force3', 'shear34', 'kick_force4', 'shear41',
]
return headers
#def get_headers(self):
#headers = ['axial', 'torque']
#return headers
def build(self):
"""sizes the vectorized attributes of the RealCShearForceArray"""
#print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))
assert self.ntimes > 0, 'ntimes=%s' % self.ntimes
assert self.nelements > 0, 'nelements=%s' % self.nelements
assert self.ntotal > 0, 'ntotal=%s' % self.ntotal
#self.names = []
self.nelements //= self.ntimes
self.itime = 0
self.ielement = 0
self.itotal = 0
#self.ntimes = 0
#self.nelements = 0
self.is_built = True
#print("ntimes=%s nelements=%s ntotal=%s" % (self.ntimes, self.nelements, self.ntotal))
dtype = 'float32'
if isinstance(self.nonlinear_factor, integer_types):
dtype = 'int32'
self._times = zeros(self.ntimes, dtype=dtype)
self.element = zeros(self.nelements, dtype='int32')
#[force41, force21, force12, force32, force23, force43,
# force34, force14,
# kick_force1, shear12, kick_force2, shear23,
# kick_force3, shear34, kick_force4, shear41]
self.data = zeros((self.ntimes, self.ntotal, 16), dtype='float32')
def build_dataframe(self):
"""creates a pandas dataframe"""
import pandas as pd
headers = self.get_headers()
if self.nonlinear_factor not in (None, np.nan):
#Mode 1 2 3
#Freq 1.482246e-10 3.353940e-09 1.482246e-10
#Eigenvalue -8.673617e-19 4.440892e-16 8.673617e-19
#Radians 9.313226e-10 2.107342e-08 9.313226e-10
#ElementID Item
#22 force41 -4.025374e-14 2.935730e-08 1.017620e-13
# force21 -4.025374e-14 2.935730e-08 1.017620e-13
# force12 4.025374e-14 -2.935730e-08 -1.017620e-13
# force32 4.025374e-14 -2.935730e-08 -1.017620e-13
# force23 -4.025374e-14 2.935730e-08 1.017620e-13
# force43 -4.025374e-14 2.935730e-08 1.017620e-13
# force34 4.025374e-14 -2.935730e-08 -1.017620e-13
# force14 4.025374e-14 -2.935730e-08 -1.017620e-13
# kick_force1 -0.000000e+00 0.000000e+00 0.000000e+00
# shear12 -8.050749e-14 5.871460e-08 2.035239e-13
# kick_force2 -0.000000e+00 0.000000e+00 0.000000e+00
# shear23 -8.050749e-14 5.871460e-08 2.035239e-13
# kick_force3 -0.000000e+00 0.000000e+00 0.000000e+00
# shear34 -8.050749e-14 5.871460e-08 2.035239e-13
# kick_force4 -0.000000e+00 0.000000e+00 0.000000e+00
# shear41 -8.050749e-14 5.871460e-08 2.035239e-13
column_names, column_values = self._build_dataframe_transient_header()
data_frame = self._build_pandas_transient_elements(
column_values, column_names,
headers, self.element, self.data)
else:
#Static axial SMa torsion SMt
#ElementID
#14 0.0 1.401298e-45 0.0 1.401298e-45
#15 0.0 1.401298e-45 0.0 1.401298e-45
data_frame = pd.DataFrame(self.data[0], columns=headers, index=self.element)
data_frame.index.name = 'ElementID'
data_frame.columns.names = ['Static']
self.data_frame = data_frame
def __eq__(self, table): # pragma: no cover
assert self.is_sort1 == table.is_sort1
is_nan = (
self.nonlinear_factor is not None and
np.isnan(self.nonlinear_factor) and
np.isnan(table.nonlinear_factor)
)
if not is_nan:
assert self.nonlinear_factor == table.nonlinear_factor
assert self.ntotal == table.ntotal
assert self.table_name == table.table_name, 'table_name=%r table.table_name=%r' % (self.table_name, table.table_name)
assert self.approach_code == table.approach_code
if self.nonlinear_factor not in (None, np.nan):
assert np.array_equal(self._times, table._times), 'ename=%s-%s times=%s table.times=%s' % (
self.element_name, self.element_type, self._times, table._times)
if not np.array_equal(self.element, table.element):
assert self.element.shape == table.element.shape, 'element shape=%s table.shape=%s' % (self.element.shape, table.element.shape)
msg = 'table_name=%r class_name=%s\n' % (self.table_name, self.__class__.__name__)
msg += '%s\n' % str(self.code_information())
msg += 'Eid\n'
for eid1, eid2 in zip(self.element, table.element):
msg += '%s, %s\n' % (eid1, eid2)
print(msg)
raise ValueError(msg)
if not np.array_equal(self.data, table.data):
msg = 'table_name=%r class_name=%s\n' % (self.table_name, self.__class__.__name__)
msg += '%s\n' % str(self.code_information())
i = 0
for itime in range(self.ntimes):
for ie, eid in enumerate(self.element):
t1 = self.data[itime, ie, :]
t2 = table.data[itime, ie, :]
(force41a, force14a, force21a, force12a, force32a, force23a, force43a, force34a, kick_force1a, kick_force2a, kick_force3a, kick_force4a, shear12a, shear23a, shear34a, shear41a) = t1
(force41b, force14b, force21b, force12b, force32b, force23b, force43b, force34b, kick_force1b, kick_force2b, kick_force3b, kick_force4b, shear12b, shear23b, shear34b, shear41b) = t2
if not np.array_equal(t1, t2):
msg += (
'%s (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)\n'
' (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)\n' % (
eid,
force41a, force14a, force21a, force12a, force32a, force23a, force43a, force34a, kick_force1a, kick_force2a, kick_force3a, kick_force4a, shear12a, shear23a, shear34a, shear41a,
force41b, force14b, force21b, force12b, force32b, force23b, force43b, force34b, kick_force1b, kick_force2b, kick_force3b, kick_force4b, shear12b, shear23b, shear34b, shear41b
))
i += 1
if i > 10:
print(msg)
raise ValueError(msg)
#print(msg)
if i > 0:
raise ValueError(msg)
return True
def add_sort1(self, dt, eid,
force41, force14, force21, force12, force32, force23, force43, force34,
kick_force1, kick_force2, kick_force3, kick_force4,
shear12, shear23, shear34, shear41):
"""unvectorized method for adding SORT1 transient data"""
assert isinstance(eid, integer_types) and eid > 0, 'dt=%s eid=%s' % (dt, eid)
self._times[self.itime] = dt
self.element[self.ielement] = eid
self.data[self.itime, self.ielement, :] = [
force41, force14, force21, force12, force32, force23, force43, force34,
kick_force1, kick_force2, kick_force3, kick_force4,
shear12, shear23, shear34, shear41]
self.ielement += 1
def get_stats(self, short=False) -> List[str]:
if not self.is_built:
return [
'<%s>\n' % self.__class__.__name__,
' ntimes: %i\n' % self.ntimes,
' ntotal: %i\n' % self.ntotal,
]
nelements = self.nelements
ntimes = self.ntimes
#ntotal = self.ntotal
msg = []
if self.nonlinear_factor not in (None, np.nan): # transient
msg.append(' type=%s ntimes=%i nelements=%i; table_name=%r\n'
% (self.__class__.__name__, ntimes, nelements, self.table_name))
ntimes_word = 'ntimes'
else:
msg.append(' type=%s nelements=%i; table_name=%r\n'
% (self.__class__.__name__, nelements, self.table_name))
ntimes_word = '1'
headers = self.get_headers()
n = len(headers)
msg.append(' data: [%s, nelements, %i] where %i=[%s]\n' % (ntimes_word, n, n, str(', '.join(headers))))
msg.append(' data.shape = %s\n' % str(self.data.shape).replace('L', ''))
msg.append(' element.shape = %s\n' % str(self.element.shape).replace('L', ''))
#msg.append(' element type: %s\n' % self.element_type)
msg.append(' element name: %s\n' % self.element_name)
msg += self.get_data_code()
return msg
def write_f06(self, f06_file, header=None, page_stamp='PAGE %s',
page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
msg_temp = [
' F O R C E S A C T I N G O N S H E A R P A N E L E L E M E N T S (CSHEAR)\n'
' \n'
' ====== POINT 1 ====== ====== POINT 2 ====== ====== POINT 3 ====== ====== POINT 4 ======\n'
' ELEMENT F-FROM-4 F-FROM-2 F-FROM-1 F-FROM-3 F-FROM-2 F-FROM-4 F-FROM-3 F-FROM-1\n'
' ID KICK-1 SHEAR-12 KICK-2 SHEAR-23 KICK-3 SHEAR-34 KICK-4 SHEAR-41\n'
]
#(elem_name, msg_temp) = self.get_f06_header(is_mag_phase=is_mag_phase, is_sort1=is_sort1)
#(ntimes, ntotal, two) = self.data.shape
ntimes = self.data.shape[0]
eids = self.element
for itime in range(ntimes):
dt = self._times[itime] # TODO: rename this...
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f06_file.write(''.join(header + msg_temp))
f14 = self.data[itime, :, 0]
f12 = self.data[itime, :, 1]
f21 = self.data[itime, :, 2]
f23 = self.data[itime, :, 3]
f32 = self.data[itime, :, 4]
f34 = self.data[itime, :, 5]
f43 = self.data[itime, :, 6]
f41 = self.data[itime, :, 7]
kick1 = self.data[itime, :, 8]
tau12 = self.data[itime, :, 9]
kick2 = self.data[itime, :, 10]
tau23 = self.data[itime, :, 11]
kick3 = self.data[itime, :, 12]
tau34 = self.data[itime, :, 13]
kick4 = self.data[itime, :, 14]
tau41 = self.data[itime, :, 15]
#zip_in = [
#f14, f12, f21, f23, f32, f34, f43, f41,
#kick1, tau12, kick2, tau23, kick3, tau34, kick4, tau41,
#]
for (eid, f14i, f12i, f21i, f23i, f32i, f34i, f43i, f41i,
kick1i, tau12i, kick2i, tau23i, kick3i, tau34i, kick4i, tau41i) in zip(
eids, f14, f12, f21, f23, f32, f34, f43, f41,
kick1, tau12, kick2, tau23, kick3, tau34, kick4, tau41):
vals2 = write_floats_12e([
f14i, f12i, f21i, f23i, f32i, f34i, f43i, f41i,
kick1i, tau12i, kick2i, tau23i, kick3i, tau34i, kick4i, tau41i])
[
f14i, f12i,
f21i, f23i,
f32i, f34i,
f43i, f41i,
kick1i, tau12i, kick2i, tau23i,
kick3i, tau34i, kick4i, tau41i
] = vals2
f06_file.write(
'0%13i%-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n'
' %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n' % (
eid, f14i, f12i, f21i, f23i, f32i, f34i, f43i, f41i,
kick1i, tau12i, kick2i, tau23i, kick3i, tau34i, kick4i, tau41i))
f06_file.write(page_stamp % page_num)
page_num += 1
return page_num - 1
def write_op2(self, op2, op2_ascii, itable, new_result, date,
is_mag_phase=False, endian='>'):
"""writes an OP2"""
frame = inspect.currentframe()
call_frame = inspect.getouterframes(frame, 2)
op2_ascii.write('%s.write_op2: %s\n' % (self.__class__.__name__, call_frame[1][3]))
if itable == -1:
self._write_table_header(op2, op2_ascii, date)
itable = -3
#if isinstance(self.nonlinear_factor, float):
#op2_format = '%sif' % (7 * self.ntimes)
#raise NotImplementedError()
#else:
#op2_format = 'i21f'
#s = Struct(op2_format)
unused_eids = self.element
# table 4 info
#ntimes = self.data.shape[0]
#nnodes = self.data.shape[1]
nelements = self.data.shape[1]
# 21 = 1 node, 3 principal, 6 components, 9 vectors, 2 p/ovm
#ntotal = ((nnodes * 21) + 1) + (nelements * 4)
ntotali = self.num_wide
ntotal = ntotali * nelements
#print('shape = %s' % str(self.data.shape))
#assert self.ntimes == 1, self.ntimes
op2_ascii.write(' ntimes = %s\n' % self.ntimes)
eids = self.element
eids_device = self.element * 10 + self.device_code
#fmt = '%2i %6f'
#print('ntotal=%s' % (ntotal))
#assert ntotal == 193, ntotal
if self.is_sort1:
struct1 = Struct(endian + b'i 16f')
else:
raise NotImplementedError('SORT2')
op2_ascii.write('nelements=%i\n' % nelements)
for itime in range(self.ntimes):
#print('3, %s' % itable)
self._write_table_3(op2, op2_ascii, new_result, itable, itime)
# record 4
#print('stress itable = %s' % itable)
itable -= 1
#print('4, %s' % itable)
header = [4, itable, 4,
4, 1, 4,
4, 0, 4,
4, ntotal, 4,
4 * ntotal]
op2.write(pack('%ii' % len(header), *header))
op2_ascii.write('r4 [4, 0, 4]\n')
op2_ascii.write('r4 [4, %s, 4]\n' % (itable))
op2_ascii.write('r4 [4, %i, 4]\n' % (4 * ntotal))
f14 = self.data[itime, :, 0]
f12 = self.data[itime, :, 1]
f21 = self.data[itime, :, 2]
f23 = self.data[itime, :, 3]
f32 = self.data[itime, :, 4]
f34 = self.data[itime, :, 5]
f43 = self.data[itime, :, 6]
f41 = self.data[itime, :, 7]
kick1 = self.data[itime, :, 8]
tau12 = self.data[itime, :, 9]
kick2 = self.data[itime, :, 10]
tau23 = self.data[itime, :, 11]
kick3 = self.data[itime, :, 12]
tau34 = self.data[itime, :, 13]
kick4 = self.data[itime, :, 14]
tau41 = self.data[itime, :, 15]
for (eid, eid_device, f14i, f12i, f21i, f23i, f32i, f34i, f43i, f41i,
kick1i, tau12i, kick2i, tau23i, kick3i, tau34i, kick4i, tau41i) in zip(
eids, eids_device, f14, f12, f21, f23, f32, f34, f43, f41,
kick1, tau12, kick2, tau23, kick3, tau34, kick4, tau41):
op2.write(struct1.pack(
eid_device, f14i, f12i, f21i, f23i, f32i, f34i, f43i, f41i,
kick1i, tau12i, kick2i, tau23i, kick3i, tau34i, kick4i, tau41i))
vals2 = write_floats_12e([
f14i, f12i, f21i, f23i, f32i, f34i, f43i, f41i,
kick1i, tau12i, kick2i, tau23i, kick3i, tau34i, kick4i, tau41i])
[
f14i, f12i,
f21i, f23i,
f32i, f34i,
f43i, f41i,
kick1i, tau12i, kick2i, tau23i,
kick3i, tau34i, kick4i, tau41i
] = vals2
op2_ascii.write(
'0%13i%-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n'
' %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n' % (
eid, f14i, f12i, f21i, f23i, f32i, f34i, f43i, f41i,
kick1i, tau12i, kick2i, tau23i, kick3i, tau34i, kick4i, tau41i))
itable -= 1
header = [4 * ntotal,]
op2.write(pack('i', *header))
op2_ascii.write('footer = %s\n' % header)
new_result = False
return itable
class RealViscForceArray(RealForceObject): # 24-CVISC
def __init__(self, data_code, is_sort1, isubcase, dt):
RealForceObject.__init__(self, data_code, isubcase)
#self.ntimes = 0 # or frequency/mode
#self.ntotal = 0
self.nelements = 0 # result specific
#if not is_sort1:
#raise NotImplementedError('SORT2')
@property
def nnodes_per_element(self) -> int:
return 1
def get_headers(self) -> List[str]:
headers = ['axial', 'torsion']
return headers
#def get_headers(self):
#headers = ['axial', 'torque']
#return headers
def build(self):
"""sizes the vectorized attributes of the RealViscForceArray"""
#print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))
if self.is_built:
return
assert self.ntimes > 0, 'ntimes=%s' % self.ntimes
assert self.nelements > 0, 'nelements=%s' % self.nelements
assert self.ntotal > 0, 'ntotal=%s' % self.ntotal
#self.names = []
self.nelements //= self.ntimes
self.itime = 0
self.ielement = 0
self.itotal = 0
#self.ntimes = 0
#self.nelements = 0
self.is_built = True
#print("ntimes=%s nelements=%s ntotal=%s" % (self.ntimes, self.nelements, self.ntotal))
dtype = 'float32'
if isinstance(self.nonlinear_factor, integer_types):
dtype = 'int32'
self._times = zeros(self.ntimes, dtype=dtype)
self.element = zeros(self.nelements, dtype='int32')
#[axial_force, torque]
self.data = zeros((self.ntimes, self.ntotal, 2), dtype='float32')
def build_dataframe(self):
"""creates a pandas dataframe"""
import pandas as pd
headers = self.get_headers()
if self.nonlinear_factor not in (None, np.nan):
#Mode 1 2 3
#Freq 1.482246e-10 3.353940e-09 1.482246e-10
#Eigenvalue -8.673617e-19 4.440892e-16 8.673617e-19
#Radians 9.313226e-10 2.107342e-08 9.313226e-10
#ElementID Item
#50 axial -0.0 -0.0 0.0
# torsion 0.0 0.0 -0.0
#51 axial 0.0 -0.0 -0.0
# torsion -0.0 0.0 0.0
column_names, column_values = self._build_dataframe_transient_header()
data_frame = self._build_pandas_transient_elements(
column_values, column_names,
headers, self.element, self.data)
else:
#Static axial torsion
#ElementID
#14 0.0 0.0
#15 0.0 0.0
data_frame = pd.DataFrame(self.data[0], columns=headers, index=self.element)
data_frame.index.name = 'ElementID'
data_frame.columns.names = ['Static']
self.data_frame = data_frame
def add_sort1(self, dt, eid, axial, torque):
"""unvectorized method for adding SORT1 transient data"""
assert isinstance(eid, integer_types) and eid > 0, 'dt=%s eid=%s' % (dt, eid)
self._times[self.itime] = dt
self.element[self.ielement] = eid
self.data[self.itime, self.ielement, :] = [axial, torque]
self.ielement += 1
def get_stats(self, short=False) -> List[str]:
if not self.is_built:
return [
'<%s>\n' % self.__class__.__name__,
' ntimes: %i\n' % self.ntimes,
' ntotal: %i\n' % self.ntotal,
]
nelements = self.nelements
ntimes = self.ntimes
#ntotal = self.ntotal
msg = []
if self.nonlinear_factor not in (None, np.nan): # transient
msg.append(' type=%s ntimes=%i nelements=%i\n'
% (self.__class__.__name__, ntimes, nelements))
ntimes_word = 'ntimes'
else:
msg.append(' type=%s nelements=%i\n'
% (self.__class__.__name__, nelements))
ntimes_word = '1'
headers = self.get_headers()
n = len(headers)
msg.append(' data: [%s, nnodes, %i] where %i=[%s]\n' % (ntimes_word, n, n, str(', '.join(headers))))
msg.append(' data.shape = %s\n' % str(self.data.shape).replace('L', ''))
msg.append(' element.shape = %s\n' % str(self.element.shape).replace('L', ''))
#msg.append(' element type: %s\n' % self.element_type)
msg.append(' element name: %s\n' % self.element_name)
msg += self.get_data_code()
return msg
def get_f06_header(self, is_mag_phase=True, is_sort1=True):
if is_sort1:
msg = [
' F O R C E S I N V I S C E L E M E N T S ( C V I S C )\n'
' \n'
' ELEMENT AXIAL TORSIONAL ELEMENT AXIAL TORSIONAL\n'
' ID. FORCE MOMENT ID. FORCE MOMENT\n'
]
else:
msg = [
' F O R C E S I N V I S C E L E M E N T S ( C V I S C )\n'
' \n'
' AXIAL AXIAL\n'
' TIME FORCE TORQUE TIME FORCE TORQUE\n'
#' 0.0 0.0 0.0 1.000000E+00 -5.642718E-04 0.0\n'
#' 2.000000E+00 -1.905584E-06 0.0 3.000000E+00 9.472010E-07 0.0\n'
]
return msg
def write_f06(self, f06_file, header=None, page_stamp='PAGE %s',
page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
msg_temp = self.get_f06_header(is_mag_phase)
# write the f06
#(ntimes, ntotal, two) = self.data.shape
ntimes = self.data.shape[0]
eids = self.element
is_odd = False
nwrite = len(eids)
if len(eids) % 2 == 1:
nwrite -= 1
is_odd = True
#print('len(eids)=%s nwrite=%s is_odd=%s' % (len(eids), nwrite, is_odd))
for itime in range(ntimes):
dt = self._times[itime] # TODO: rename this...
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f06_file.write(''.join(header + msg_temp))
#print("self.data.shape=%s itime=%s ieids=%s" % (str(self.data.shape), itime, str(ieids)))
axial = self.data[itime, :, 0]
torsion = self.data[itime, :, 1]
out = []
for eid, axiali, torsioni in zip(eids, axial, torsion):
[axiali, torsioni] = write_floats_13e([axiali, torsioni])
out.append([eid, axiali, torsioni])
for i in range(0, nwrite, 2):
out_line = ' %8i %-13s %-13s %8i %-13s %s\n' % tuple(out[i] + out[i + 1])
f06_file.write(out_line)
if is_odd:
out_line = ' %8i %-13s %s\n' % tuple(out[-1])
f06_file.write(out_line)
f06_file.write(page_stamp % page_num)
page_num += 1
return page_num - 1
def __eq__(self, table): # pragma: no cover
assert self.is_sort1 == table.is_sort1
is_nan = (
self.nonlinear_factor is not None and
np.isnan(self.nonlinear_factor) and
np.isnan(table.nonlinear_factor)
)
if not is_nan:
assert self.nonlinear_factor == table.nonlinear_factor
assert self.ntotal == table.ntotal
assert self.table_name == table.table_name, 'table_name=%r table.table_name=%r' % (self.table_name, table.table_name)
assert self.approach_code == table.approach_code
if not np.array_equal(self.element, table.element):
assert self.element.shape == table.element.shape, 'element shape=%s table.shape=%s' % (self.element.shape, table.element.shape)
msg = 'table_name=%r class_name=%s\n' % (self.table_name, self.__class__.__name__)
msg += '%s\n' % str(self.code_information())
msg += 'Eid\n'
for eid1, eid2 in zip(self.element, table.element):
msg += '%s, %s\n' % (eid1, eid2)
print(msg)
raise ValueError(msg)
if not np.array_equal(self.data, table.data):
msg = 'table_name=%r class_name=%s\n' % (self.table_name, self.__class__.__name__)
msg += '%s\n' % str(self.code_information())
i = 0
for itime in range(self.ntimes):
for ie, eid in enumerate(self.element):
t1 = self.data[itime, ie, :]
t2 = table.data[itime, ie, :]
(axial1, torque1) = t1
(axial2, torque2) = t2
if not np.array_equal(t1, t2):
msg += '(%s) (%s, %s) (%s, %s)\n' % (
eid,
axial1, torque1,
axial2, torque2)
i += 1
if i > 10:
print(msg)
raise ValueError(msg)
#print(msg)
if i > 0:
raise ValueError(msg)
return True
class RealPlateForceArray(RealForceObject): # 33-CQUAD4, 74-CTRIA3
def __init__(self, data_code, is_sort1, isubcase, dt):
RealForceObject.__init__(self, data_code, isubcase)
self.dt = dt
self.nelements = 0
assert self.element_name != 'RBAR', self.data_code
#if is_sort1:
#if dt is not None:
#self.add = self.add_sort1
#else:
#assert dt is not None
#self.add = self.add_sort2
def _get_msgs(self):
raise NotImplementedError()
def get_headers(self) -> List[str]:
return ['mx', 'my', 'mxy', 'bmx', 'bmy', 'bmxy', 'tx', 'ty']
def build(self):
"""sizes the vectorized attributes of the RealPlateForceArray"""
#print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))
if self.is_built:
return
assert self.ntimes > 0, 'ntimes=%s' % self.ntimes
assert self.nelements > 0, 'nelements=%s' % self.nelements
assert self.ntotal > 0, 'ntotal=%s' % self.ntotal
#self.names = []
#self.nelements //= self.ntimes
self.itime = 0
self.ielement = 0
self.itotal = 0
#self.ntimes = 0
#self.nelements = 0
self.is_built = True
#print("ntimes=%s nelements=%s ntotal=%s" % (self.ntimes, self.nelements, self.ntotal))
dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size)
self._times = zeros(self.ntimes, dtype=dtype)
self.element = zeros(self.ntotal, dtype=idtype)
#[mx, my, mxy, bmx, bmy, bmxy, tx, ty]
self.data = zeros((self.ntimes, self.ntotal, 8), dtype=fdtype)
def build_dataframe(self):
"""creates a pandas dataframe"""
import pandas as pd
headers = self.get_headers()
assert 0 not in self.element
if self.nonlinear_factor not in (None, np.nan):
#Mode 1 2 3
#Freq 1.482246e-10 3.353940e-09 1.482246e-10
#Eigenvalue -8.673617e-19 4.440892e-16 8.673617e-19
#Radians 9.313226e-10 2.107342e-08 9.313226e-10
#ElementID Item
#8 mx -5.467631e-14 -1.406068e-07 1.351960e-13
# my -8.983144e-14 -3.912936e-07 9.707208e-14
# mxy 2.767353e-13 -4.950616e-08 -5.985472e-13
# bmx 7.616284e-14 -2.809588e-08 -1.051987e-13
# bmy 4.245138e-14 -6.567249e-09 -6.066584e-14
# bmxy -1.233790e-14 3.561397e-09 1.840837e-14
# tx 2.601638e-13 -9.601510e-08 -3.611116e-13
# ty -5.825233e-14 -7.382687e-09 9.038553e-14
#9 mx 5.444685e-15 -1.014145e-07 -4.500100e-14
column_names, column_values = self._build_dataframe_transient_header()
data_frame = self._build_pandas_transient_elements(
column_values, column_names,
headers, self.element, self.data)
else:
#Static axial SMa torsion SMt
#ElementID
#14 0.0 1.401298e-45 0.0 1.401298e-45
#15 0.0 1.401298e-45 0.0 1.401298e-45
data_frame = pd.DataFrame(self.data[0], columns=headers, index=self.element)
data_frame.index.name = 'ElementID'
data_frame.columns.names = ['Static']
self.data_frame = data_frame
def __eq__(self, table): # pragma: no cover
assert self.is_sort1 == table.is_sort1
self._eq_header(table)
if not np.array_equal(self.data, table.data):
msg = 'table_name=%r class_name=%s\n' % (self.table_name, self.__class__.__name__)
msg += '%s\n' % str(self.code_information())
i = 0
for itime in range(self.ntimes):
for ie, e in enumerate(self.element_node):
(eid, nid) = e
t1 = self.data[itime, ie, :]
t2 = table.data[itime, ie, :]
(fiber_dist1, oxx1, oyy1, txy1, angle1, majorP1, minorP1, ovm1) = t1
(fiber_dist2, oxx2, oyy2, txy2, angle2, majorP2, minorP2, ovm2) = t2
# vm stress can be NaN for some reason...
if not np.array_equal(t1[:-1], t2[:-1]):
msg += '(%s, %s) (%s, %s, %s, %s, %s, %s, %s, %s) (%s, %s, %s, %s, %s, %s, %s, %s)\n' % (
eid, nid,
fiber_dist1, oxx1, oyy1, txy1, angle1, majorP1, minorP1, ovm1,
fiber_dist2, oxx2, oyy2, txy2, angle2, majorP2, minorP2, ovm2)
i += 1
if i > 10:
print(msg)
raise ValueError(msg)
#print(msg)
if i > 0:
raise ValueError(msg)
return True
#def add_new_eid_sort1(self, dt, eid, axial, SMa, torsion, SMt):
#self._times[self.itime] = dt
#self.element[self.ielement] = eid
#self.data[self.itime, self.ielement, :] = [axial, SMa, torsion, SMt]
#self.ielement += 1
def add_sort1(self, dt, eid, mx, my, mxy, bmx, bmy, bmxy, tx, ty):
"""unvectorized method for adding SORT1 transient data"""
assert isinstance(eid, integer_types) and eid > 0, 'dt=%s eid=%s' % (dt, eid)
self._times[self.itime] = dt
self.element[self.itotal] = eid
self.data[self.itime, self.itotal, :] = [mx, my, mxy, bmx, bmy, bmxy, tx, ty]
self.itotal += 1
def add_sort2(self, eid, mx, my, mxy, bmx, bmy, bmxy, tx, ty):
raise NotImplementedError('SORT2')
#if dt not in self.mx:
#self.add_new_transient(dt)
#self.data[self.itime, self.itotal, :] = [mx, my, mxy, bmx, bmy, bmxy, tx, ty]
@property
def nnodes_per_element(self):
return 1
def get_stats(self, short=False) -> List[str]:
if not self.is_built:
return [
'<%s>\n' % self.__class__.__name__,
' ntimes: %i\n' % self.ntimes,
' ntotal: %i\n' % self.ntotal,
]
nelements = self.nelements
ntimes = self.ntimes
#ntotal = self.ntotal
msg = []
if self.nonlinear_factor not in (None, np.nan): # transient
msg.append(' type=%s ntimes=%i nelements=%i\n'
% (self.__class__.__name__, ntimes, nelements))
ntimes_word = 'ntimes'
else:
msg.append(' type=%s nelements=%i\n'
% (self.__class__.__name__, nelements))
ntimes_word = '1'
headers = self.get_headers()
n = len(headers)
msg.append(' data: [%s, nelements, %i] where %i=[%s]\n' % (ntimes_word, n, n, str(', '.join(headers))))
msg.append(' data.shape = %s\n' % str(self.data.shape).replace('L', ''))
msg.append(' element.shape = %s\n' % str(self.element.shape).replace('L', ''))
msg.append(' element type: %s\n' % self.element_name)
msg += self.get_data_code()
return msg
def get_f06_header(self, is_mag_phase=True):
if 'CTRIA3' in self.element_name:
msg = [
' F O R C E S I N T R I A N G U L A R E L E M E N T S ( T R I A 3 )\n'
' \n'
' ELEMENT - MEMBRANE FORCES - - BENDING MOMENTS - - TRANSVERSE SHEAR FORCES -\n'
' ID FX FY FXY MX MY MXY QX QY\n'
]
nnodes = 3
elif 'CQUAD4' in self.element_name:
msg = [
' F O R C E S I N Q U A D R I L A T E R A L E L E M E N T S ( Q U A D 4 )\n'
' \n'
' ELEMENT - MEMBRANE FORCES - - BENDING MOMENTS - - TRANSVERSE SHEAR FORCES -\n'
' ID GRID-ID FX FY FXY MX MY MXY QX QY\n'
]
nnodes = 4
elif 'CTRIAR' in self.element_name:
msg = [
' F O R C E S I N T R I A N G U L A R E L E M E N T S ( T R I A R )\n'
' \n'
' ELEMENT - MEMBRANE FORCES - - BENDING MOMENTS - - TRANSVERSE SHEAR FORCES -\n'
' ID FX FY FXY MX MY MXY QX QY\n'
]
nnodes = 3
elif 'CQUADR' in self.element_name:
msg = [
' F O R C E S I N Q U A D R I L A T E R A L E L E M E N T S ( Q U A D R )\n'
' \n'
' ELEMENT - MEMBRANE FORCES - - BENDING MOMENTS - - TRANSVERSE SHEAR FORCES -\n'
' ID GRID-ID FX FY FXY MX MY MXY QX QY\n'
]
nnodes = 4
else:
msg = f'element_name={self.element_name} self.element_type={self.element_type}'
raise NotImplementedError(msg)
return self.element_name, nnodes, msg
def write_f06(self, f06_file, header=None, page_stamp='PAGE %s',
page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
(elem_name, nnodes, msg_temp) = self.get_f06_header(is_mag_phase)
# write the f06
ntimes = self.data.shape[0]
eids = self.element
cen_word = 'CEN/%i' % nnodes
for itime in range(ntimes):
dt = self._times[itime] # TODO: rename this...
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f06_file.write(''.join(header + msg_temp))
#print("self.data.shape=%s itime=%s ieids=%s" % (str(self.data.shape), itime, str(ieids)))
#[mx, my, mxy, bmx, bmy, bmxy, tx, ty]
mx = self.data[itime, :, 0]
my = self.data[itime, :, 1]
mxy = self.data[itime, :, 2]
bmx = self.data[itime, :, 3]
bmy = self.data[itime, :, 4]
bmxy = self.data[itime, :, 5]
tx = self.data[itime, :, 6]
ty = self.data[itime, :, 7]
if self.element_type in [74, 83, 227, 228]:
# 74, 83 CTRIA3
# 227 CTRIAR linear
# 228 CQUADR linear
for eid, mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi in zip(eids, mx, my, mxy, bmx, bmy, bmxy, tx, ty):
[mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi] = write_floats_13e(
[mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi])
# ctria3
# 8 -7.954568E+01 2.560061E+03 -4.476376E+01 1.925648E+00 1.914048E+00 3.593237E-01 8.491534E+00 5.596094E-01 #
f06_file.write(' %8i %18s %13s %13s %13s %13s %13s %13s %s\n' % (
eid, mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi))
elif self.element_type == 33:
for eid, mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi in zip(eids, mx, my, mxy, bmx, bmy, bmxy, tx, ty):
[mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi] = write_floats_13e(
[mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi])
# cquad4
#0 6 CEN/4 1.072685E+01 2.504399E+03 -2.455727E+01 -5.017930E+00 -2.081427E+01 -5.902618E-01 -9.126162E+00 4.194400E+01#
#Fmt = '% 8i ' + '%27.20E ' * 8 + '\n'
#f06_file.write(Fmt % (eid, mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi))
#
f06_file.write('0 %8i %8s %13s %13s %13s %13s %13s %13s %13s %s\n' % (
eid, cen_word, mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi))
else:
raise NotImplementedError(f'element_name={self.element_name} element_type={self.element_type}')
f06_file.write(page_stamp % page_num)
page_num += 1
return page_num - 1
def write_op2(self, op2, op2_ascii, itable, new_result,
date, is_mag_phase=False, endian='>'):
"""writes an OP2"""
frame = inspect.currentframe()
call_frame = inspect.getouterframes(frame, 2)
op2_ascii.write('%s.write_op2: %s\n' % (self.__class__.__name__, call_frame[1][3]))
if itable == -1:
self._write_table_header(op2, op2_ascii, date)
itable = -3
print(self.get_stats())
#if 'CTRIA3' in self.element_name:
#nnodes = 3
#elif 'CQUAD4' in self.element_name:
#nnodes = 4
#elif 'CTRIAR' in self.element_name:
#nnodes = 4 # ???
#elif 'CQUADR' in self.element_name:
#nnodes = 5 # ???
#else: # pragma: no cover
#raise NotImplementedError(self.code_information())
#print("nnodes_all =", nnodes_all)
#cen_word_ascii = 'CEN/%i' % nnodes
#cen_word = b'CEN/%i' % nnodes
eids = self.element
#cen_word = 'CEN/%i' % nnodes
#msg.append(' element_node.shape = %s\n' % str(self.element_node.shape).replace('L', ''))
#msg.append(' data.shape=%s\n' % str(self.data.shape).replace('L', ''))
eids = self.element
eids_device = eids * 10 + self.device_code
nelements = len(eids)
assert nelements > 0, eids
#print('nelements =', nelements)
# 21 = 1 node, 3 principal, 6 components, 9 vectors, 2 p/ovm
#ntotal = ((nnodes * 21) + 1) + (nelements * 4)
ntotali = self.num_wide
ntotal = ntotali * nelements
#print('shape = %s' % str(self.data.shape))
#assert nnodes > 1, nnodes
#assert self.ntimes == 1, self.ntimes
#device_code = self.device_code
op2_ascii.write(' ntimes = %s\n' % self.ntimes)
#fmt = '%2i %6f'
#print('ntotal=%s' % (ntotal))
#assert ntotal == 193, ntotal
#[fiber_dist, oxx, oyy, txy, angle, majorP, minorP, ovm]
if self.is_sort1:
structi = Struct(endian + b'i 8f')
else:
raise NotImplementedError('SORT2')
op2_ascii.write('nelements=%i\n' % nelements)
for itime in range(self.ntimes):
self._write_table_3(op2, op2_ascii, new_result, itable, itime)
# record 4
#print('stress itable = %s' % itable)
itable -= 1
header = [4, itable, 4,
4, 1, 4,
4, 0, 4,
4, ntotal, 4,
4 * ntotal]
op2.write(pack('%ii' % len(header), *header))
op2_ascii.write('r4 [4, 0, 4]\n')
op2_ascii.write('r4 [4, %s, 4]\n' % (itable))
op2_ascii.write('r4 [4, %i, 4]\n' % (4 * ntotal))
mx = self.data[itime, :, 0]
my = self.data[itime, :, 1]
mxy = self.data[itime, :, 2]
bmx = self.data[itime, :, 3]
bmy = self.data[itime, :, 4]
bmxy = self.data[itime, :, 5]
tx = self.data[itime, :, 6]
ty = self.data[itime, :, 7]
nwide = 0
for eid_device, mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi in zip(eids_device, mx, my, mxy, bmx, bmy, bmxy, tx, ty):
data = [eid_device, mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi]
#[mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi] = write_floats_13e(
# [mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi])
op2.write(structi.pack(*data))
op2_ascii.write(' eid_device=%s data=%s\n' % (eid_device, str(data[1:])))
nwide += len(data)
assert nwide == ntotal, "nwide=%s ntotal=%s" % (nwide, ntotal)
itable -= 1
header = [4 * ntotal,]
op2.write(pack('i', *header))
op2_ascii.write('footer = %s\n' % header)
new_result = False
return itable
class RealPlateBilinearForceArray(RealForceObject): # 144-CQUAD4
def __init__(self, data_code, is_sort1, isubcase, dt):
RealForceObject.__init__(self, data_code, isubcase)
self.dt = dt
self.nelements = 0
#if is_sort1:
#if dt is not None:
#self.add = self.add_sort1
#else:
#assert dt is not None
#self.add = self.add_sort2
def _get_msgs(self):
raise NotImplementedError()
def get_headers(self) -> List[str]:
return ['mx', 'my', 'mxy', 'bmx', 'bmy', 'bmxy', 'tx', 'ty']
def build(self):
"""sizes the vectorized attributes of the RealPlateBilinearForceArray"""
#print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))
assert self.ntimes > 0, 'ntimes=%s' % self.ntimes
assert self.nelements > 0, 'nelements=%s' % self.nelements
assert self.ntotal > 0, 'ntotal=%s' % self.ntotal
#self.names = []
#self.nelements //= self.ntimes
self.itime = 0
self.ielement = 0
self.itotal = 0
#self.ntimes = 0
#self.nelements = 0
self.is_built = True
#print("ntimes=%s nelements=%s ntotal=%s" % (self.ntimes, self.nelements, self.ntotal))
dtype = 'float32'
if isinstance(self.nonlinear_factor, integer_types):
dtype = 'int32'
self._times = zeros(self.ntimes, dtype=dtype)
self.element_node = zeros((self.ntotal, 2), dtype='int32')
# -MEMBRANE FORCES- -BENDING MOMENTS- -TRANSVERSE SHEAR FORCES -
# FX FY FXY MX MY MXY QX QY
#[fx, fy, fxy, mx, my, mxy, qx, qy]
#[mx, my, mxy, bmx, bmy, bmxy, tx, ty]
self.data = zeros((self.ntimes, self.ntotal, 8), dtype='float32')
def build_dataframe(self):
"""creates a pandas dataframe"""
import pandas as pd
headers = self.get_headers()
node = pd.Series(self.element_node[:, 1])
node.replace({'NodeID': {0:'CEN'}}, inplace=True)
element_node = [self.element_node[:, 0], node]
if self.nonlinear_factor not in (None, np.nan):
# Mode 1 2 3
# Freq 1.482246e-10 3.353940e-09 1.482246e-10
# Eigenvalue -8.673617e-19 4.440892e-16 8.673617e-19
# Radians 9.313226e-10 2.107342e-08 9.313226e-10
# ElementID NodeID Item
# 6 0 mx 2.515537e-13 -2.294306e-07 -3.626725e-13
# my 2.916815e-13 -7.220319e-08 -5.030049e-13
# mxy -2.356622e-14 4.391171e-07 -5.960345e-14
# bmx 4.138377e-14 -1.861012e-08 -5.586283e-14
# bmy 5.991298e-15 -2.471926e-09 -5.400710e-15
# bmxy 4.511364e-15 -1.190845e-09 -5.546569e-15
# tx 1.122732e-13 -5.563460e-08 -1.523176e-13
# ty -1.164320e-14 4.813929e-09 1.023404e-14
# 4 mx 3.839208e-13 -4.580973e-07 -4.949736e-13
column_names, column_values = self._build_dataframe_transient_header()
data_frame = self._build_pandas_transient_element_node(
column_values, column_names,
headers, element_node, self.data, from_tuples=False, from_array=True)
else:
df1 = pd.DataFrame(element_node).T
df1.columns = ['ElementID', 'NodeID']
df2 = pd.DataFrame(self.data[0])
df2.columns = headers
data_frame = df1.join(df2)
data_frame = data_frame.reset_index().set_index(['ElementID', 'NodeID'])
self.data_frame = data_frame
def __eq__(self, table): # pragma: no cover
self._eq_header(table)
assert self.is_sort1 == table.is_sort1
if not np.array_equal(self.data, table.data):
msg = 'table_name=%r class_name=%s\n' % (self.table_name, self.__class__.__name__)
msg += '%s\n' % str(self.code_information())
i = 0
for itime in range(self.ntimes):
for ie, e in enumerate(self.element_node):
(eid, nid) = e
t1 = self.data[itime, ie, :]
t2 = table.data[itime, ie, :]
(mx1, my1, mxy1, bmx1, bmy1, bmxy1, tx1, ty1) = t1
(mx2, my2, mxy2, bmx2, bmy2, bmxy2, tx2, ty2) = t2
if not np.array_equal(t1, t2):
msg += '(%s, %s) (%s, %s, %s, %s, %s, %s, %s, %s) (%s, %s, %s, %s, %s, %s, %s, %s)\n' % (
eid, nid,
mx1, my1, mxy1, bmx1, bmy1, bmxy1, tx1, ty1,
mx2, my2, mxy2, bmx2, bmy2, bmxy2, tx2, ty2)
i += 1
if i > 10:
print(msg)
raise ValueError(msg)
#print(msg)
if i > 0:
raise ValueError(msg)
return True
def add_sort1(self, dt, eid, term, nid, mx, my, mxy, bmx, bmy, bmxy, tx, ty):
"""unvectorized method for adding SORT1 transient data"""
assert isinstance(eid, integer_types) and eid > 0, 'dt=%s eid=%s' % (dt, eid)
self._times[self.itime] = dt
self.element_node[self.itotal] = [eid, nid]
self.data[self.itime, self.itotal, :] = [mx, my, mxy, bmx, bmy, bmxy, tx, ty]
self.itotal += 1
def add_sort2(self, eid, mx, my, mxy, bmx, bmy, bmxy, tx, ty):
raise NotImplementedError('SORT2')
#if dt not in self.mx:
#self.add_new_transient(dt)
#self.data[self.itime, self.itotal, :] = [mx, my, mxy, bmx, bmy, bmxy, tx, ty]
@property
def nnodes_per_element(self):
if self.element_type == 144: # CQUAD4
nnodes_element = 5
elif self.element_type == 64: # CQUAD8
nnodes_element = 5
elif self.element_type == 82: # CQUADR
nnodes_element = 5
elif self.element_type == 75: # CTRIA6
nnodes_element = 4
elif self.element_type == 70: # CTRIAR
nnodes_element = 4
else:
raise NotImplementedError('element_type=%s element_name=%s' % (self.element_type, self.element_name))
return nnodes_element
def get_stats(self, short=False) -> List[str]:
if not self.is_built:
return [
'<%s>\n' % self.__class__.__name__,
' ntimes: %i\n' % self.ntimes,
' ntotal: %i\n' % self.ntotal,
]
nelements = self.nelements
ntimes = self.ntimes
ntotal = self.ntotal
msg = []
if self.nonlinear_factor not in (None, np.nan): # transient
msg.append(' type=%s ntimes=%i nelements=%i ntotal=%i nnodes/element=%i\n'
% (self.__class__.__name__, ntimes, nelements, ntotal, self.nnodes_per_element))
ntimes_word = 'ntimes'
else:
msg.append(' type=%s nelements=%i ntotal=%i nnodes/element=%i\n'
% (self.__class__.__name__, nelements, ntotal, self.nnodes_per_element))
ntimes_word = '1'
headers = self.get_headers()
n = len(headers)
msg.append(' data: [%s, ntotal, %i] where %i=[%s]\n' % (ntimes_word, n, n, str(', '.join(headers))))
msg.append(' data.shape = %s\n' % str(self.data.shape).replace('L', ''))
msg.append(' element_node.shape = %s\n' % str(self.element_node.shape).replace('L', ''))
msg.append(' element type: %s\n' % self.element_name)
msg += self.get_data_code()
return msg
def get_f06_header(self, is_mag_phase=True):
# if 'CTRIA3' in self.element_name:
# msg = [
# ' F O R C E S I N T R I A N G U L A R E L E M E N T S ( T R I A 3 )\n'
# ' \n'
# ' ELEMENT - MEMBRANE FORCES - - BENDING MOMENTS - - TRANSVERSE SHEAR FORCES -\n'
# ' ID FX FY FXY MX MY MXY QX QY\n'
# ]
# nnodes = 3
if self.element_type == 70:
# CQUAD4
element_name = 'CTRIAR'
msg = [
' F O R C E S I N T R I A N G U L A R E L E M E N T S ( T R I A R )\n'
' \n'
' ELEMENT - MEMBRANE FORCES - - BENDING MOMENTS - - TRANSVERSE SHEAR FORCES -\n'
' ID GRID-ID FX FY FXY MX MY MXY QX QY\n'
]
nnodes = 6
elif self.element_type == 75:
# CQUAD4
element_name = 'CTRIA6'
msg = [
' F O R C E S I N T R I A N G U L A R E L E M E N T S ( T R I A 6 )\n'
' \n'
' ELEMENT - MEMBRANE FORCES - - BENDING MOMENTS - - TRANSVERSE SHEAR FORCES -\n'
' ID GRID-ID FX FY FXY MX MY MXY QX QY\n'
]
nnodes = 6
elif self.element_type == 64:
# CQUAD4
element_name = 'CQUAD8'
msg = [
' F O R C E S I N Q U A D R I L A T E R A L E L E M E N T S ( Q U A D 8 )\n'
' \n'
' ELEMENT - MEMBRANE FORCES - - BENDING MOMENTS - - TRANSVERSE SHEAR FORCES -\n'
' ID GRID-ID FX FY FXY MX MY MXY QX QY\n'
]
nnodes = 8
elif self.element_type == 82:
# CQUAD4
element_name = 'CQUADR'
msg = [
' F O R C E S I N Q U A D R I L A T E R A L E L E M E N T S ( Q U A D R )\n'
' \n'
' ELEMENT - MEMBRANE FORCES - - BENDING MOMENTS - - TRANSVERSE SHEAR FORCES -\n'
' ID GRID-ID FX FY FXY MX MY MXY QX QY\n'
]
nnodes = 4
elif self.element_type == 144:
# CQUAD4
element_name = 'CQUAD4'
msg = [
' F O R C E S I N Q U A D R I L A T E R A L E L E M E N T S ( Q U A D 4 ) OPTION = BILIN \n'
' \n'
' ELEMENT - MEMBRANE FORCES - - BENDING MOMENTS - - TRANSVERSE SHEAR FORCES -\n'
' ID GRID-ID FX FY FXY MX MY MXY QX QY\n'
]
nnodes = 4
else:
raise NotImplementedError('element_name=%s element_type=%s' % (self.element_name, self.element_type))
return element_name, nnodes, msg
def write_f06(self, f06_file, header=None, page_stamp='PAGE %s',
page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
(elem_name, nnodes, msg_temp) = self.get_f06_header(is_mag_phase)
# write the f06
ntimes = self.data.shape[0]
eids = self.element_node[:, 0]
nids = self.element_node[:, 1]
cen_word = 'CEN/%i' % nnodes
if self.element_type in [64, 82, 144]: # CQUAD8, CQUADR, CQUAD4
cyci = [0, 1, 2, 3, 4]
#cyc = cycle([0, 1, 2, 3, 4]) # TODO: this is totally broken...
nnodes_per_eid = 5
elif self.element_type in [70, 75]: # CTRIAR, CTRIA6
cyci = [0, 1, 2, 3]
#cyc = cycle([0, 1, 2, 3]) # TODO: this is totally broken...
nnodes_per_eid = 4
else:
raise NotImplementedError(self.element_type)
# TODO: this shouldn't be neccessary
cyc = cyci * (len(eids) // nnodes_per_eid)
assert len(eids) % nnodes_per_eid == 0
for itime in range(ntimes):
dt = self._times[itime] # TODO: rename this...
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f06_file.write(''.join(header + msg_temp))
#print("self.data.shape=%s itime=%s ieids=%s" % (str(self.data.shape), itime, str(ieids)))
#[mx, my, mxy, bmx, bmy, bmxy, tx, ty]
mx = self.data[itime, :, 0]
my = self.data[itime, :, 1]
mxy = self.data[itime, :, 2]
bmx = self.data[itime, :, 3]
bmy = self.data[itime, :, 4]
bmxy = self.data[itime, :, 5]
tx = self.data[itime, :, 6]
ty = self.data[itime, :, 7]
for i, eid, nid, mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi in zip(cyc, eids, nids, mx, my, mxy, bmx, bmy, bmxy, tx, ty):
[mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi] = write_floats_13e(
[mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi])
# ctria3
# 8 -7.954568E+01 2.560061E+03 -4.476376E+01 1.925648E+00 1.914048E+00 3.593237E-01 8.491534E+00 5.596094E-01 #
if i == 0:
f06_file.write(
'0 %8i %s %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n' % (
eid, cen_word, mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi))
else:
f06_file.write(
' %8i %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n' % (
nid, mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi))
# else:
# raise NotImplementedError(self.element_type)
f06_file.write(page_stamp % page_num)
page_num += 1
return page_num - 1
def write_op2(self, op2, op2_ascii, itable, new_result,
date, is_mag_phase=False, endian='>'):
"""writes an OP2"""
frame = inspect.currentframe()
call_frame = inspect.getouterframes(frame, 2)
op2_ascii.write('%s.write_op2: %s\n' % (self.__class__.__name__, call_frame[1][3]))
if itable == -1:
self._write_table_header(op2, op2_ascii, date)
itable = -3
(unused_elem_name, nnodes, unused_msg_temp) = self.get_f06_header(is_mag_phase)
# write the f06
#ntimes = self.data.shape[0]
eids = self.element_node[:, 0]
nids = self.element_node[:, 1]
if self.element_type in [64, 82, 144]: # CQUAD8, CQUADR, CQUAD4
cyci = [0, 1, 2, 3, 4]
#cyc = cycle([0, 1, 2, 3, 4]) # TODO: this is totally broken...
nnodes_per_eid = 5
elif self.element_type in [70, 75]: # CTRIAR, CTRIA6
cyci = [0, 1, 2, 3]
#cyc = cycle([0, 1, 2, 3]) # TODO: this is totally broken...
nnodes_per_eid = 4
else:
raise NotImplementedError(self.element_type)
# TODO: this shouldn't be neccessary
cyc = cyci * (len(eids) // nnodes_per_eid)
assert len(eids) % nnodes_per_eid == 0
#print("nnodes_all =", nnodes_all)
#cen_word_ascii = 'CEN/%i' % nnodes
cen_word = b'CEN/'
#msg.append(' element_node.shape = %s\n' % str(self.element_node.shape).replace('L', ''))
#msg.append(' data.shape=%s\n' % str(self.data.shape).replace('L', ''))
eids = self.element_node[:, 0]
nids = self.element_node[:, 1]
eids_device = eids * 10 + self.device_code
nelements = len(np.unique(eids))
#print('nelements =', nelements)
# 21 = 1 node, 3 principal, 6 components, 9 vectors, 2 p/ovm
#ntotal = ((nnodes * 21) + 1) + (nelements * 4)
ntotali = self.num_wide
ntotal = ntotali * nelements
#print('shape = %s' % str(self.data.shape))
assert nnodes > 1, nnodes
#assert self.ntimes == 1, self.ntimes
#device_code = self.device_code
op2_ascii.write(' ntimes = %s\n' % self.ntimes)
#fmt = '%2i %6f'
#print('ntotal=%s' % (ntotal))
#assert ntotal == 193, ntotal
#[fiber_dist, oxx, oyy, txy, angle, majorP, minorP, ovm]
if self.is_sort1:
struct1 = Struct(endian + b'i4s i 8f')
struct2 = Struct(endian + b'i 8f')
else:
raise NotImplementedError('SORT2')
op2_ascii.write('nelements=%i\n' % nelements)
for itime in range(self.ntimes):
self._write_table_3(op2, op2_ascii, new_result, itable, itime)
# record 4
#print('stress itable = %s' % itable)
itable -= 1
header = [4, itable, 4,
4, 1, 4,
4, 0, 4,
4, ntotal, 4,
4 * ntotal]
op2.write(pack('%ii' % len(header), *header))
op2_ascii.write('r4 [4, 0, 4]\n')
op2_ascii.write('r4 [4, %s, 4]\n' % (itable))
op2_ascii.write('r4 [4, %i, 4]\n' % (4 * ntotal))
mx = self.data[itime, :, 0]
my = self.data[itime, :, 1]
mxy = self.data[itime, :, 2]
bmx = self.data[itime, :, 3]
bmy = self.data[itime, :, 4]
bmxy = self.data[itime, :, 5]
tx = self.data[itime, :, 6]
ty = self.data[itime, :, 7]
nwide = 0
for i, eid, eid_device, nid, mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi in zip(cyc, eids, eids_device, nids, mx, my, mxy, bmx, bmy, bmxy, tx, ty):
#[mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi] = write_floats_13e(
# [mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi])
if i == 0:
data = [eid_device, cen_word, nnodes, mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi]
op2.write(struct1.pack(*data))
op2_ascii.write(
'0 %8i %s %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n' % (
eid, cen_word, mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi))
else:
data = [nid, mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi]
op2.write(struct2.pack(*data))
op2_ascii.write(
' %8i %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n' % (
nid, mxi, myi, mxyi, bmxi, bmyi, bmxyi, txi, tyi))
op2_ascii.write(' eid_device=%s data=%s\n' % (eid_device, str(data)))
nwide += len(data)
assert nwide == ntotal, "nwide=%s ntotal=%s" % (nwide, ntotal)
itable -= 1
header = [4 * ntotal,]
op2.write(pack('i', *header))
op2_ascii.write('footer = %s\n' % header)
new_result = False
return itable
class RealCBarFastForceArray(RealForceObject):
"""
34-CBAR
119-CFAST
"""
def __init__(self, data_code, is_sort1, isubcase, dt):
self.element_type = None
self.element_name = None
RealForceObject.__init__(self, data_code, isubcase)
#self.code = [self.format_code, self.sort_code, self.s_code]
#self.ntimes = 0 # or frequency/mode
#self.ntotal = 0
self.nelements = 0 # result specific
@property
def nnodes_per_element(self) -> int:
return 1
def get_headers(self) -> List[str]:
headers = [
'bending_moment_a1', 'bending_moment_a2',
'bending_moment_b1', 'bending_moment_b2',
'shear1', 'shear2',
'axial', 'torque']
return headers
def build(self):
"""sizes the vectorized attributes of the RealCBarForceArray"""
#print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))
assert self.ntimes > 0, 'ntimes=%s' % self.ntimes
assert self.nelements > 0, 'nelements=%s' % self.nelements
assert self.ntotal > 0, 'ntotal=%s' % self.ntotal
#self.names = []
self.nelements //= self.ntimes
self.itime = 0
self.ielement = 0
self.itotal = 0
#self.ntimes = 0
#self.nelements = 0
self.is_built = True
#print("ntimes=%s nelements=%s ntotal=%s" % (self.ntimes, self.nelements, self.ntotal))
if self.is_sort1: # or self.table_name in ['OEFRMS2']
ntimes = self.ntimes
nelements = self.nelements
ntotal = self.ntotal
self._build(ntimes, nelements, ntotal, self._times_dtype)
else:
ntimes = self.nelements
nelements = self.ntimes
ntotal = nelements * 2
name = self.analysis_method + 's'
self._build(ntimes, nelements, ntotal, self._times_dtype)
setattr(self, name, self._times)
self.data_code['name'] = self.analysis_method
self.data_names[0] = self.analysis_method
#print(f'data_names -> {self.data_names}')
def _build(self, ntimes, nelements, ntotal, dtype):
self.ntimes = ntimes
self.nelements = nelements
self.ntotal = ntotal
#print(f"*ntimes={ntimes} nelements={nelements} ntotal={ntotal} data_names={self.data_names}")
unused_dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size)
self._times = zeros(ntimes, dtype=dtype)
self.element = zeros(nelements, dtype=idtype)
#[bending_moment_a1, bending_moment_a2, bending_moment_b1, bending_moment_b2, shear1, shear2, axial, torque]
self.data = zeros((ntimes, ntotal, 8), dtype=fdtype)
def build_dataframe(self):
"""creates a pandas dataframe"""
import pandas as pd
headers = self.get_headers()
if self.nonlinear_factor not in (None, np.nan):
column_names, column_values = self._build_dataframe_transient_header()
data_frame = self._build_pandas_transient_elements(
column_values, column_names,
headers, self.element, self.data)
else:
data_frame = | pd.DataFrame(self.data[0], columns=headers, index=self.element) | pandas.DataFrame |
DEBUGGING_R = False
FIXED_SPECIES = ["H2O", "H+", "O2(g)", "water", "Cl-", "e-", "OH-", "O2", "H2O(g)"]
import os
import re
import sys
import shutil
import copy
import collections
import dill
import math
from urllib.request import urlopen
import warnings
import subprocess
import pkg_resources
import pandas as pd
import numpy as np
from chemparse import parse_formula
from IPython.core.display import display, HTML
import periodictable
from .HKF_cgl import OBIGT2eos, calc_logK
# matplotlib for static plots
import matplotlib
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import plotly.express as px
import plotly.io as pio
from plotly.subplots import make_subplots
import plotly.graph_objects as go
# rpy2 for Python and R integration
import rpy2.rinterface_lib.callbacks
import logging
rpy2.rinterface_lib.callbacks.logger.setLevel(logging.ERROR) # will display errors, but not warnings
import rpy2.robjects as ro
from rpy2.robjects import pandas2ri
pandas2ri.activate()
class Error_Handler:
"""
Handles how errors are printed in Jupyter notebooks. By default, errors that
are handled by AqEquil are printed with an error message, but no traceback.
Errors that are not handled by AqEquil, such as those thrown if the user
encounters a bug, will display a full traceback.
If the error handler prints an error message without traceback, all future
errors regardless of origin will be shown without traceback until the
notebook kernel is restarted.
Attributes
----------
clean : bool
Report exceptions without traceback? If True, only the error message is
shown. If False, the entire error message, including traceback, is
shown. Ignored if AqEquil is not being run in a Jupyter notebook.
"""
def __init__(self, clean=True):
self.clean = clean # bool: hide traceback?
pass
@staticmethod
def hide_traceback(exc_tuple=None, filename=None, tb_offset=None,
exception_only=False, running_compiled_code=False):
"""
Return a modified ipython showtraceback function that does not display
traceback when encountering an error.
"""
ipython = get_ipython()
etype, value, tb = sys.exc_info()
value.__cause__ = None # suppress chained exceptions
return ipython._showtraceback(etype, value, ipython.InteractiveTB.get_exception_only(etype, value))
def raise_exception(self, msg):
"""
Raise an exception that displays the error message without traceback. This
happens only when the exception is predicted by the AqEquil package
(e.g., for common user errors).
"""
if self.clean and isnotebook():
ipython = get_ipython()
ipython.showtraceback = self.hide_traceback
raise Exception(msg)
def load(filename, messages=True, hide_traceback=True):
"""
Load a speciation file.
Parameters
----------
filename : str
Name of the speciation file.
Returns
----------
An object of class `Speciation`.
"""
err_handler = Error_Handler(clean=hide_traceback)
if len(filename) <= 12:
print("Attempting to load "+str(filename)+".speciation ...")
filename = filename+".speciation"
if 'speciation' in filename[-11:]:
if os.path.exists(filename) and os.path.isfile(filename):
pass
else:
err = "Cannot locate input file {}/{}".format(os.getcwd(), filename)
err_handler.raise_exception(err)
else:
err = ("Input file {}".format(filename) + " "
"must be in {} format.".format(ext_dict[ext]))
err_handler.raise_exception(err)
if os.path.getsize(filename) > 0:
with open(filename, 'rb') as handle:
speciation = dill.load(handle)
if messages:
print("Loaded '{}'".format(filename))
return speciation
else:
msg = "Cannot open " + str(filename) + " because the file is empty."
err_handler.raise_exception(msg)
def isnotebook():
"""
Check if this code is running in a Jupyter notebook
"""
try:
shell = get_ipython().__class__.__name__
if shell == 'ZMQInteractiveShell':
return True # Jupyter notebook or qtconsole
elif shell == 'TerminalInteractiveShell':
return False # Terminal running IPython
else:
return False # Other type (?)
except NameError:
return False # Probably standard Python interpreter
def float_to_fraction (x, error=0.000001):
"""
Convert a float into a fraction. Works with floats like 2.66666666.
Solution from https://stackoverflow.com/a/5128558/8406195
"""
n = int(math.floor(x))
x -= n
if x < error:
return (n, 1)
elif 1 - error < x:
return (n+1, 1)
# The lower fraction is 0/1
lower_n = 0
lower_d = 1
# The upper fraction is 1/1
upper_n = 1
upper_d = 1
while True:
# The middle fraction is (lower_n + upper_n) / (lower_d + upper_d)
middle_n = lower_n + upper_n
middle_d = lower_d + upper_d
# If x + error < middle
if middle_d * (x + error) < middle_n:
# middle is our new upper
upper_n = middle_n
upper_d = middle_d
# Else If middle < x - error
elif middle_n < (x - error) * middle_d:
# middle is our new lower
lower_n = middle_n
lower_d = middle_d
# Else middle is our best fraction
else:
return (n * middle_d + middle_n, middle_d)
def float_to_formatted_fraction(x, error=0.000001):
"""
Format a fraction for html.
"""
f = float_to_fraction(x, error=error)
whole_number_float = int((f[0]-(f[0]%f[1]))/f[1])
remainder_tuple = (f[0]%f[1], f[1])
if remainder_tuple[0] == 0:
return str(whole_number_float)
else:
if whole_number_float == 0:
whole_number_float = ""
return "{0}<sup>{1}</sup>⁄<sub>{2}</sub>".format(whole_number_float, remainder_tuple[0], remainder_tuple[1])
def format_coeff(coeff):
"""
Format a reaction coefficient for html.
"""
if coeff == 1 or coeff == -1:
coeff = ""
elif coeff.is_integer() and coeff < 0:
coeff = str(-int(coeff))
elif coeff.is_integer() and coeff > 0:
coeff = str(int(coeff))
else:
if coeff < 0:
coeff = float_to_formatted_fraction(-coeff)
else:
coeff = float_to_formatted_fraction(coeff)
if coeff != "":
coeff = coeff + " "
return coeff
def flatten_list(_2d_list):
"""
Flatten a list of lists.
Code from: https://stackabuse.com/python-how-to-flatten-list-of-lists/
"""
flat_list = []
# Iterate through the outer list
for element in _2d_list:
if type(element) is list:
# If the element is of type list, iterate through the sublist
for item in element:
flat_list.append(item)
else:
flat_list.append(element)
return flat_list
def convert_to_RVector(value, force_Rvec=True):
"""
Convert a value or list into an R vector of the appropriate type.
Parameters
----------
value : numeric or str, or list of numeric or str
Value to be converted.
force_Rvec : bool, default True
If `value` is not a list, force conversion into a R vector?
False will return an int, float, or str if value is non-list.
True will always return an R vector.
Returns
-------
int, float, str, or an rpy2 R vector
A value or R vector of an appropriate data type.
"""
if not isinstance(value, list) and not force_Rvec:
return value
elif not isinstance(value, list) and force_Rvec:
value = [value]
else:
pass
if all(isinstance(x, bool) for x in value):
return ro.BoolVector(value)
elif all(isinstance(x, int) for x in value):
return ro.IntVector(value)
elif all(isinstance(x, float) or isinstance(x, int) for x in value):
return ro.FloatVector(value)
else:
return ro.StrVector([str(v) for v in value])
def get_colors(colormap, ncol, alpha=1.0, hide_traceback=True):
"""
Get a list of rgb values for a matplotlib colormap
Parameters
----------
colormap : str, default "WORM"
Name of the colormap to color the scatterpoints. Accepts "WORM",
"colorblind", or matplotlib colormaps.
See https://matplotlib.org/stable/tutorials/colors/colormaps.html
The "colorblind" colormap is referenced from <NAME>. Points of view:
Color blindness. Nat Methods 8, 441 (2011).
https://doi.org/10.1038/nmeth.1618
ncol : int
Number of colors to return in the list.
alpha : float, default 1.0
An alpha value between 0.0 (transparent) and 1.0 (opaque).
Returns
-------
colors : list
A list of rgb color tuples
"""
err_handler = Error_Handler(clean=hide_traceback)
qualitative_cmaps = ['Pastel1', 'Pastel2', 'Paired', 'Accent',
'Dark2', 'Set1', 'Set2', 'Set3',
'tab10', 'tab20', 'tab20b', 'tab20c']
if colormap == "colorblind":
# colors from Wong B. 2011, https://doi.org/10.1038/nmeth.1618
colors = [(0, 0, 0, alpha), # black
(230/255, 159/255, 0, alpha), # orange
(86/255, 180/255, 233/255, alpha), # sky blue
(0, 158/255, 115/255, alpha), # bluish green
(240/255, 228/255, 66/255, alpha), # yellow
(0, 114/255, 178/255, alpha), # blue
(213/255, 94/255, 0, alpha), # vermillion
(204/255, 121/255, 167/255, alpha)] # reddish purple
if ncol <= len(colors):
return colors[:ncol]
else:
print("Switching from 'colorblind' colormap to 'viridis' because there are {} variables to plot.".format(ncol))
colormap = "viridis"
elif colormap == "WORM":
colors = [(0, 0, 0, alpha), # black
(22/255, 153/255, 211/255, alpha), # blue
(232/255, 86/255, 66/255, alpha), # red
(245/255, 171/255, 80/255, alpha), # orange
(115/255, 108/255, 168/255, alpha), # purple
(151/255, 208/255, 119/255, alpha), # green
(47/255, 91/255, 124/255, alpha), # dark blue
(119/255, 119/255, 119/255, alpha)] # gray
if ncol <= len(colors):
return colors[:ncol]
else:
print("Switching from 'WORM' colormap to 'viridis' because there are {} variables to plot.".format(ncol))
colormap = "viridis"
if colormap in qualitative_cmaps:
# handle qualitative (non-continuous) colormaps
colors = [plt.cm.__getattribute__(colormap).colors[i] for i in range(ncol)]
colors = [(c[0], c[1], c[2], alpha) for c in colors]
else:
# handle sequential (continuous) colormaps
norm = matplotlib.colors.Normalize(vmin=0, vmax=ncol-1)
try:
cmap = cm.__getattribute__(colormap)
except:
valid_colormaps = [cmap for cmap in dir(cm) if "_" not in cmap and cmap not in ["LUTSIZE", "MutableMapping", "ScalarMappable", "functools", "datad", "revcmap"]]
err_handler.raise_exception("'{}'".format(colormap)+" is not a recognized matplotlib colormap. "
"Try one of these: {}".format(valid_colormaps))
m = cm.ScalarMappable(norm=norm, cmap=cmap)
colors = [m.to_rgba(i) for i in range(ncol)]
colors = [(c[0], c[1], c[2], alpha) for c in colors]
return colors
def html_chemname_format_AqEquil(name, charge_sign_at_end=False):
"""
AqEquil-specific formatting of chemical names for html. Takes "_(input)"
into account when formatting names.
Parameters
----------
name : str
A chemical formula.
Returns
-------
A formatted chemical formula string.
"""
# format only the first part of the name if it has "_(input)"
if len(name.split("_(input)"))==2:
if name.split("_(input)")[1] == '':
name = name.split("_(input)")[0]
input_flag=True
else:
input_flag = False
name = html_chemname_format(name, charge_sign_at_end=charge_sign_at_end)
# add " (input)" to the end of the name
if input_flag:
name = name+" (input)"
return(name)
def html_chemname_format(name, charge_sign_at_end=False):
"""
Format a chemical formula to display subscripts and superscripts in HTML
(e.g., Plotly plots)
Example, "CH3COO-" becomes "CH<sub>3</sub>COO<sup>-</sup>"
Parameters
----------
name : str
A chemical formula.
charge_sign_at_end : bool, default False
Display charge with sign after the number (e.g. SO4 2-)?
Returns
-------
A formatted chemical formula string.
"""
p = re.compile(r'(?P<sp>[-+]\d*?$)')
name = p.sub(r'<sup>\g<sp></sup>', name)
charge = re.search(r'<.*$', name)
name_no_charge = re.match(r'(?:(?!<|$).)*', name).group(0)
mapping = {"0": "<sub>0</sub>", "1": "<sub>1</sub>", "2": "<sub>2</sub>", "3": "<sub>3</sub>", "4": "<sub>4</sub>",
"5": "<sub>5</sub>", "6": "<sub>6</sub>", "7": "<sub>7</sub>", "8": "<sub>8</sub>", "9": "<sub>9</sub>",
".":"<sub>.</sub>"}
name_no_charge_formatted = "".join([mapping.get(x) or x for x in list(name_no_charge)])
if charge != None:
name = name_no_charge_formatted + charge.group(0)
else:
name = name_no_charge_formatted
if charge_sign_at_end:
if "<sup>-" in name:
name = name.replace("<sup>-", "<sup>")
name = name.replace("</sup>", "-</sup>")
if "<sup>+" in name:
name = name.replace("<sup>+", "<sup>")
name = name.replace("</sup>", "+</sup>")
return(name)
class Speciation(object):
"""
Stores the output of a speciation calculation.
Attributes
----------
input : pd.DataFrame
Pandas dataframe containing user-supplied sample chemistry data.
mass_contribution : pd.DataFrame
Pandas dataframe containing basis species contributions to mass balance
of aqueous species.
batch_3o : rpy2 ListVector
An rpy2 ListVector (R object) containing speciation results, in case
analysis in R is preferred.
report : pd.DataFrame
Pandas dataframe reporting major results of speciation calculation in
across all samples.
report_divs : rpy2 ListVector
An rpy2 ListVector of column names within the different sections of the
speciation report.
sample_data : dict
Dictionary with sample names as keys and speciation results as values.
"""
def __init__(self, args, hide_traceback=True):
self.err_handler = Error_Handler(clean=hide_traceback)
self.reactions_for_plotting = None # stores formatted reactions for plotting results of affinity and energy supply calculations
for k in args:
setattr(self, k, args[k])
def __getitem__(self, item):
return getattr(self, item)
@staticmethod
def __unique(seq):
"""
Provide a sequence, get a list of non-repeating elements in the same order.
"""
seen = set()
seen_add = seen.add
return [x for x in seq if not (x in seen or seen_add(x))]
def save(self, filename, messages=True):
"""
Save the speciation as a '.speciation' file to your current working
directory. This file can be loaded with `AqEquil.load(filename)`.
Parameters
----------
filename : str
The desired name of the file.
messages : str
Print a message confirming the save?
"""
if filename[-11:] != '.speciation':
filename = filename + '.speciation'
with open(filename, 'wb') as handle:
dill.dump(self, handle, protocol=dill.HIGHEST_PROTOCOL)
if messages:
print("Saved as '{}'".format(filename))
@staticmethod
def __save_figure(fig, save_as, save_format, save_scale, plot_width, plot_height, ppi):
if isinstance(save_format, str) and save_format not in ['png', 'jpg', 'jpeg', 'webp', 'svg', 'pdf', 'eps', 'json', 'html']:
self.err_handler.raise_exception("{}".format(save_format)+" is an unrecognized "
"save format. Supported formats include 'png', "
"'jpg', 'jpeg', 'webp', 'svg', 'pdf', 'eps', "
"'json', or 'html'")
if isinstance(save_format, str):
if not isinstance(save_as, str):
save_as = "newplot"
if save_format=="html":
fig.write_html(save_as+".html")
print("Saved figure as {}".format(save_as)+".html")
save_format = 'png'
elif save_format in ['pdf', 'eps', 'json']:
pio.write_image(fig, save_as+"."+save_format, format=save_format, scale=save_scale,
width=plot_width*ppi, height=plot_height*ppi)
print("Saved figure as {}".format(save_as)+"."+save_format)
save_format = "png"
else:
pio.write_image(fig, save_as+"."+save_format, format=save_format, scale=save_scale,
width=plot_width*ppi, height=plot_height*ppi)
print("Saved figure as {}".format(save_as)+"."+save_format)
else:
save_format = "png"
return save_as, save_format
@staticmethod
def __get_unit_info(subheader):
unit_name_dict = {
"pH" : ("", "pH"),
"ppm" : ("", "ppm"),
"ppb" : ("", "ppb"),
"mg/L" : ("", "mg/L"),
"degC" : ("temperature", "°C"),
"log_molality" : ("log molality", "log(mol/kg)"),
"Molality" : ("molality", "mol/kg"),
"molality" : ("molality", "mol/kg"),
"molal" : ("molality", "mol/kg"),
"log_activity" : ("log activity", ""),
"Log activity" : ("log activity", ""),
"mg/kg.sol" : ("", "mg solute per kg solution"),
"Alk., eq/kg.H2O" : ("alkalinity", "eq/kg"),
"Alk., eq/L" : ("alkalinity", "eq/L"),
"Alk., eq/kg.sol" : ("alkalinity", "eq/kg solution"),
"Alk., mg/L CaCO3" : ("alkalinity", "mg/L CaCO3"),
"Alk., mg/L HCO3-" : ("alkalinity", "mg/L HCO3-"),
"pX" : ("-(log activity)", "-log(mol/kg)"),
"activity" : ("activity", ""),
"log_gamma" : ("log gamma", "log(kg/mol)"),
"gamma" : ("gamma", "kg/mol"),
"affinity_kcal" : ("affinity", "kcal/mol"),
"%" : ("", "%"),
"Eh_volts" : ("Eh", "volts"),
"eq/kg.H2O" : ("charge", "eq/kg"),
"logfO2" : ("", ""),
"cal/mol e-" : ("affinity", "cal/mol e-"),
"cal/kg.H2O" : ("energy supply", "cal/kg H2O"),
"Log ion-H+ activity ratio" : ("Log ion-H+ activity ratio", ""),
"log_fugacity" : ("log fugacity", "log(bar)"),
"fugacity" : ("fugacity", "bar"),
"bar" : ("", "bar"),
}
out = unit_name_dict.get(subheader)
return out[0], out[1]
def lookup(self, col=None):
"""
Look up desired columns in the speciation report.
Parameters
----------
col : str or list of str
Leave blank to get a list of section names in the report:
```speciation.lookup()```
Provide the name of a section to look up the names of columns in
that section of the report:
```speciation.lookup("aq_distribution")```
Provide a column name (or a list of column names) to retrieve the
column from the report:
```speciation.lookup(["Temperature", "O2"])```
Returns
----------
Pandas dataframe or list of str
If a column name (or list of column names) is provided, returns the
speciation report with only the desired column(s). Otherwise returns
a list of section names (if no arguments are provided), or a list of
columns in a section (if a section name is provided).
"""
names_length = len(self.report_divs.names)
if col==None and names_length>0:
return list(self.report_divs.names)
if names_length>0:
if col in list(self.report_divs.names):
return list(self.report_divs.rx2(col))
if isinstance(col, str):
col = [col]
return self.report.iloc[:, self.report.columns.get_level_values(0).isin(set(col))]
def __convert_aq_units_to_log_friendly(self, species, rows):
col_data = self.lookup(species)
col_data = col_data.loc[rows]
if col_data.columns.get_level_values(1) == 'log_activity':
y = [10**float(s[0]) if s[0] != 'NA' else float("nan") for s in col_data.values.tolist()]
out_unit = 'activity'
elif col_data.columns.get_level_values(1) == 'log_molality':
y = [10**float(s[0]) if s[0] != 'NA' else float("nan") for s in col_data.values.tolist()]
out_unit = 'molality'
elif col_data.columns.get_level_values(1) == 'log_gamma':
y = [10**float(s[0]) if s[0] != 'NA' else float("nan") for s in col_data.values.tolist()]
out_unit = 'gamma'
elif col_data.columns.get_level_values(1) == 'log_fugacity':
y = [10**float(s[0]) if s[0] != 'NA' else float("nan") for s in col_data.values.tolist()]
out_unit = 'fugacity'
else:
y = [float(s[0]) if s[0] != 'NA' else float("nan") for s in col_data.values.tolist()]
out_unit = col_data.columns.get_level_values(1)[0]
return y, out_unit
def plot_mineral_saturation(self, sample_name, title=None,
mineral_sat_type="affinity",
plot_width=4, plot_height=3, ppi=122,
colors=["blue", "orange"],
save_as=None, save_format=None, save_scale=1,
interactive=True, plot_out=False):
"""
Vizualize mineral saturation states in a sample as a bar plot.
Parameters
----------
sample_name : str
Name of the sample to plot.
title : str, optional
Title of the plot.
mineral_sat_type : str, default "affinity"
Metric for mineral saturation state to plot. Can be "affinity" or
"logQoverK".
colors : list of two str, default ["blue", "orange"]
Sets the color of the bars representing supersaturated
and undersaturated states, respectively.
save_as : str, optional
Provide a filename to save this figure. Filetype of saved figure is
determined by `save_format`.
Note: interactive plots can be saved by clicking the 'Download plot'
button in the plot's toolbar.
save_format : str, default "png"
Desired format of saved or downloaded figure. Can be 'png', 'jpg',
'jpeg', 'webp', 'svg', 'pdf', 'eps', 'json', or 'html'. If 'html',
an interactive plot will be saved. Only 'png', 'svg', 'jpeg',
and 'webp' can be downloaded with the 'download as' button in the
toolbar of an interactive plot.
save_scale : numeric, default 1
Multiply title/legend/axis/canvas sizes by this factor when saving
the figure.
interactive : bool, default True
Return an interactive plot if True or a static plot if False.
plot_out : bool, default False
Return a plotly figure object? If True, a plot is not displayed as
it is generated.
"""
if sample_name not in self.report.index:
msg = ("Could not find '{}'".format(sample_name)+" among sample "
"names in the speciation report. Sample names include "
"{}".format(list(self.report.index)))
self.err_handler.raise_exception(msg)
if isinstance(self.sample_data[sample_name].get('mineral_sat', None), pd.DataFrame):
mineral_data = self.sample_data[sample_name]['mineral_sat'][mineral_sat_type].astype(float).sort_values(ascending=False)
x = mineral_data.index
else:
msg = ("This sample does not have mineral saturation state data."
"To generate this data, ensure get_mineral_sat=True when "
"running speciate(), or ensure this sample has "
"mineral-forming basis species.")
self.err_handler.raise_exception(msg)
color_list = [colors[0] if m >= 0 else colors[1] for m in mineral_data]
if mineral_sat_type == "affinity":
ylabel = 'affinity, kcal/mol'
if mineral_sat_type == "logQoverK":
ylabel = 'logQ/K'
if title==None:
title = sample_name + " mineral saturation index"
df = pd.DataFrame(mineral_data)
fig = px.bar(df, x=df.index, y="affinity",
height=plot_height*ppi, width=plot_width*ppi,
labels={'affinity': ylabel}, template="simple_white")
fig.update_traces(hovertemplate = "%{x} <br>"+ylabel+": %{y}",
marker_color=color_list)
fig.update_layout(xaxis_tickangle=-45, xaxis_title=None,
title={'text':title, 'x':0.5, 'xanchor':'center'},
margin={"t":40},
xaxis={'fixedrange':True},
yaxis={'fixedrange':True, 'exponentformat':'power'})
save_as, save_format = self.__save_figure(fig, save_as, save_format,
save_scale, plot_width,
plot_height, ppi)
config = {'displaylogo': False,
'modeBarButtonsToRemove': ['zoom2d', 'pan2d', 'select2d',
'lasso2d', 'zoomIn2d', 'zoomOut2d',
'autoScale2d', 'resetScale2d',
'toggleSpikelines'],
'toImageButtonOptions': {
'format': save_format, # one of png, svg, jpeg, webp
'filename': save_as,
'height': plot_height*ppi,
'width': plot_width*ppi,
'scale': save_scale,
},
}
if not interactive:
config['staticPlot'] = True
if plot_out:
return fig
else:
fig.show(config=config)
def barplot(self, y="pH", title=None, convert_log=True, show_missing=True,
plot_width=4, plot_height=3, ppi=122, colormap="WORM",
save_as=None, save_format=None, save_scale=1,
interactive=True, plot_out=False):
"""
Show a bar plot to vizualize one or more variables across all samples.
Parameters
----------
y : str or list of str, default "pH"
Name (or list of names) of the variables to plot. Valid variables
are columns in the speciation report.
title : str, optional
Title of the plot.
convert_log : bool, default True
Convert units "log_activity", "log_molality", "log_gamma", and
"log_fugacity" to "activity", "molality", "gamma", and "fugacity",
respectively?
show_missing : bool, default True
Show samples that do not have bars?
plot_width, plot_height : numeric, default 4 by 3
Width and height of the plot, in inches.
ppi : numeric, default 122
Pixels per inch. Along with `plot_width` and `plot_height`,
determines the size of interactive plots.
colormap : str, default "WORM"
Name of the colormap to color the scatterpoints. Accepts "WORM",
"colorblind", or matplotlib colormaps.
See https://matplotlib.org/stable/tutorials/colors/colormaps.html
The "colorblind" colormap is referenced from <NAME>. Points of view:
Color blindness. Nat Methods 8, 441 (2011).
https://doi.org/10.1038/nmeth.1618
save_as : str, optional
Provide a filename to save this figure. Filetype of saved figure is
determined by `save_format`.
Note: interactive plots can be saved by clicking the 'Download plot'
button in the plot's toolbar.
save_format : str, default "png"
Desired format of saved or downloaded figure. Can be 'png', 'jpg',
'jpeg', 'webp', 'svg', 'pdf', 'eps', 'json', or 'html'. If 'html',
an interactive plot will be saved. Only 'png', 'svg', 'jpeg',
and 'webp' can be downloaded with the 'download as' button in the
toolbar of an interactive plot.
save_scale : numeric, default 1
Multiply title/legend/axis/canvas sizes by this factor when saving
the figure.
interactive : bool, default True
Return an interactive plot if True or a static plot if False.
plot_out : bool, default False
Return a plotly figure object? If True, a plot is not displayed as
it is generated.
"""
if not isinstance(y, list):
y = [y]
colors = get_colors(colormap, len(y))
# convert rgba to hex
colors = [matplotlib.colors.rgb2hex(c) for c in colors]
# map each species to its color, e.g.,
# {'CO2': '#000000', 'HCO3-': '#1699d3', 'Other': '#736ca8'}
dict_species_color = {sp:color for sp,color in zip(y, colors)}
# html format color dict key names
dict_species_color = {html_chemname_format_AqEquil(k):v for k,v in dict_species_color.items()}
y_cols = self.lookup(y)
if not show_missing:
y_cols = y_cols.dropna(how='all') # this df will keep subheaders
x = y_cols.index # names of samples
df = self.lookup(["name"]+y).copy()
if not show_missing:
df = df.dropna(how='all') # this df will lose subheaders (flattened)
df.loc[:, "name"] = df.index
df.columns = df.columns.get_level_values(0)
for i, yi in enumerate(y):
y_col = y_cols.iloc[:, y_cols.columns.get_level_values(0)==yi]
try:
subheader = y_col.columns.get_level_values(1)[0]
except:
msg = ("Could not find '{}' ".format(yi)+"in the speciation "
"report. Available variables include "
"{}".format(list(set(self.report.columns.get_level_values(0)))))
self.err_handler.raise_exception(msg)
try:
unit_type, unit = self.__get_unit_info(subheader)
except:
unit_type = ""
unit = ""
try:
y_vals = [float(y0[0]) if y0[0] != 'NA' else float("nan") for y0 in y_col.values.tolist()]
except:
msg = ("One or more the values belonging to "
"'{}' are non-numeric and cannot be plotted.".format(y_col.columns.get_level_values(0)[0]))
self.err_handler.raise_exception(msg)
if convert_log and [abs(y0) for y0 in y_vals] != y_vals: # convert to bar-friendly units if possible
if subheader in ["log_activity", "log_molality", "log_gamma", "log_fugacity"]:
y_plot, out_unit = self.__convert_aq_units_to_log_friendly(yi, rows=x)
unit_type, unit = self.__get_unit_info(out_unit)
else:
y_plot = y_vals
else:
y_plot = y_vals
if i == 0:
subheader_previous = subheader
unit_type_previous = unit_type
if unit_type != unit_type_previous and i != 0:
msg = ("{} has a different unit of measurement ".format(yi)+""
"({}) than {} ({}). ".format(unit, yi_previous, unit_type_previous)+""
"Plotted variables must share units.")
self.err_handler.raise_exception(msg)
elif "activity" in subheader.lower() and "molality" in subheader_previous.lower():
msg = ("{} has a different unit of measurement ".format(yi)+""
"({}) than {} ({}). ".format("activity", yi_previous, "molality")+""
"Plotted variables must share units.")
self.err_handler.raise_exception(msg)
elif "molality" in subheader.lower() and "activity" in subheader_previous.lower():
msg = ("{} has a different unit of measurement ".format(yi)+""
"({}) than {} ({}). ".format("molality", yi_previous, "activity")+""
"Plotted variables must share units.")
self.err_handler.raise_exception(msg)
yi_previous = copy.deepcopy(yi)
unit_type_previous = copy.deepcopy(unit_type)
subheader_previous = copy.deepcopy(subheader)
df.loc[:, yi] = y_plot
if len(y) > 1:
if unit != "":
ylabel = "{} [{}]".format(unit_type, unit)
else:
ylabel = unit_type
else:
if 'pH' in y:
ylabel = 'pH'
elif 'Temperature' in y:
ylabel = 'Temperature [°C]'
else:
if unit != "":
ylabel = "{} {} [{}]".format(html_chemname_format_AqEquil(y[0]), unit_type, unit)
else:
ylabel = "{} {}".format(html_chemname_format_AqEquil(y[0]), unit_type)
df = pd.melt(df, id_vars=["name"], value_vars=y)
df = df.rename(columns={"Sample": "y_variable", "value": "y_value"})
df['y_variable'] = df['y_variable'].apply(html_chemname_format_AqEquil)
if unit_type == "energy supply" or unit_type == "affinity":
# get formatted reactions to display
if not isinstance(self.reactions_for_plotting, pd.DataFrame):
self.reactions_for_plotting = self.show_redox_reactions(formatted=True,
charge_sign_at_end=False,
show=False, simplify=True)
y_find = [yi.replace("_energy", "").replace("_affinity", "") for yi in y]
rxns = self.reactions_for_plotting.loc[y_find, :]["reaction"].tolist()*len(x)
if len(y) == 1:
ylabel = "{}<br>{} [{}]".format(html_chemname_format_AqEquil(y_find[0]), unit_type, unit)
# customdata for displaying reactions has to be here instead of in update_traces
fig = px.bar(df, x="name", y="y_value",
height=plot_height*ppi, width=plot_width*ppi,
color='y_variable', barmode='group',
labels={'y_value': ylabel}, template="simple_white",
color_discrete_map=dict_species_color, custom_data=[rxns])
fig.update_traces(hovertemplate = "%{x} <br>"+ylabel+": %{y}<br>%{customdata[0]}")
else:
fig = px.bar(df, x="name", y="y_value",
height=plot_height*ppi, width=plot_width*ppi,
color='y_variable', barmode='group',
labels={'y_value': ylabel}, template="simple_white",
color_discrete_map=dict_species_color)
fig.update_traces(hovertemplate = "%{x} <br>"+ylabel+": %{y}")
fig.update_layout(xaxis_tickangle=-45, xaxis_title=None,
title={'text':title, 'x':0.5, 'xanchor':'center'},
legend_title=None, margin={"t": 40},
xaxis={'fixedrange':True},
yaxis={'fixedrange':True, 'exponentformat':'power'})
if len(y) == 1:
fig.update_layout(showlegend=False)
save_as, save_format = self.__save_figure(fig, save_as, save_format,
save_scale, plot_width,
plot_height, ppi)
config = {'displaylogo': False,
'modeBarButtonsToRemove': ['zoom2d', 'pan2d', 'select2d',
'lasso2d', 'zoomIn2d', 'zoomOut2d',
'autoScale2d', 'resetScale2d',
'toggleSpikelines'],
'toImageButtonOptions': {
'format': save_format,
'filename': save_as,
'height': plot_height*ppi,
'width': plot_width*ppi,
'scale': save_scale,
},
}
if not interactive:
config['staticPlot'] = True
if plot_out:
return fig
else:
fig.show(config=config)
def scatterplot(self, x="pH", y="Temperature", title=None,
plot_width=4, plot_height=3, ppi=122,
fill_alpha=0.7, point_size=10,
colormap="WORM", save_as=None, save_format=None,
save_scale=1, interactive=True, plot_out=False):
"""
Vizualize two or more sample variables with a scatterplot.
Parameters
----------
x, y : str, default for x is "pH", default for y is "Temperature"
Names of the variables to plot against each other. Valid variables
are columns in the speciation report. `y` can be a list of
of variable names for a multi-series scatterplot.
title : str, optional
Title of the plot.
plot_width, plot_height : numeric, default 4 by 3
Width and height of the plot, in inches. Size of interactive plots
is also determined by pixels per inch, set by the parameter `ppi`.
ppi : numeric, default 122
Pixels per inch. Along with `plot_width` and `plot_height`,
determines the size of interactive plots.
fill_alpha : numeric, default 0.7
Transparency of scatterpoint area fill.
point_size : numeric, default 10
Size of scatterpoints.
colormap : str, default "WORM"
Name of the colormap to color the scatterpoints. Accepts "WORM",
"colorblind", or matplotlib colormaps.
See https://matplotlib.org/stable/tutorials/colors/colormaps.html
The "colorblind" colormap is referenced from <NAME>. Points of view:
Color blindness. Nat Methods 8, 441 (2011).
https://doi.org/10.1038/nmeth.1618
save_as : str, optional
Provide a filename to save this figure. Filetype of saved figure is
determined by `save_format`.
Note: interactive plots can be saved by clicking the 'Download plot'
button in the plot's toolbar.
save_format : str, default "png"
Desired format of saved or downloaded figure. Can be 'png', 'jpg',
'jpeg', 'webp', 'svg', 'pdf', 'eps', 'json', or 'html'. If 'html',
an interactive plot will be saved. Only 'png', 'svg', 'jpeg',
and 'webp' can be downloaded with the 'download as' button in the
toolbar of an interactive plot.
save_scale : numeric, default 1
Multiply title/legend/axis/canvas sizes by this factor when saving
the figure.
interactive : bool, default True
Return an interactive plot if True or a static plot if False.
plot_out : bool, default False
Return a plotly figure object? If True, a plot is not displayed as
it is generated.
"""
if not isinstance(y, list):
y = [y]
if not isinstance(x, str):
self.err_handler.raise_exception("x must be a string.")
x_col = self.lookup(x)
try:
xsubheader = x_col.columns.get_level_values(1)[0]
except:
msg = ("Could not find '{}' ".format(x)+"in the speciation "
"report. Available variables include "
"{}".format(list(set(self.report.columns.get_level_values(0)))))
self.err_handler.raise_exception(msg)
try:
x_plot = [float(x0[0]) if x0[0] != 'NA' else float("nan") for x0 in x_col.values.tolist()]
except:
msg = ("One or more the values belonging to "
"'{}' are non-numeric and cannot be plotted.".format(x_col.columns.get_level_values(0)[0]))
self.err_handler.raise_exception(msg)
try:
xunit_type, xunit = self.__get_unit_info(xsubheader)
except:
xunit_type = ""
xunit = ""
colors = get_colors(colormap, len(y), alpha=fill_alpha)
for i, yi in enumerate(y):
y_col = self.lookup(yi)
try:
subheader = y_col.columns.get_level_values(1)[0]
except:
msg = ("Could not find '{}' ".format(yi)+"in the speciation "
"report. Available variables include "
"{}".format(list(set(self.report.columns.get_level_values(0)))))
self.err_handler.raise_exception(msg)
try:
unit_type, unit = self.__get_unit_info(subheader)
except:
unit_type = ""
unit = ""
try:
y_plot = [float(y0[0]) if y0[0] != 'NA' else float("nan") for y0 in y_col.values.tolist()]
except:
msg = ("One or more the values belonging to "
"'{}' are non-numeric and cannot be plotted.".format(y_col.columns.get_level_values(0)[0]))
self.err_handler.raise_exception(msg)
if i == 0:
subheader_previous = subheader
unit_type_previous = unit_type
if unit_type != unit_type_previous and i != 0:
msg = ("{} has a different unit of measurement ".format(yi)+""
"({}) than {} ({}). ".format(unit_type, yi_previous, unit_type_previous)+""
"Plotted variables must share units.")
self.err_handler.raise_exception(msg)
elif "activity" in subheader.lower() and "molality" in subheader_previous.lower():
msg = ("{} has a different unit of measurement ".format(yi)+""
"({}) than {} ({}). ".format("activity", yi_previous, "molality")+""
"Plotted variables must share units.")
self.err_handler.raise_exception(msg)
elif "molality" in subheader.lower() and "activity" in subheader_previous.lower():
msg = ("{} has a different unit of measurement ".format(yi)+""
"({}) than {} ({}). ".format("molality", yi_previous, "activity")+""
"Plotted variables must share units.")
self.err_handler.raise_exception(msg)
yi_previous = copy.deepcopy(yi)
unit_type_previous = copy.deepcopy(unit_type)
subheader_previous = copy.deepcopy(subheader)
if len(y) > 1:
if unit != "":
ylabel = "{} [{}]".format(unit_type, unit)
else:
ylabel = unit_type
else:
if 'pH' in y:
ylabel = 'pH'
elif 'Temperature' in y:
ylabel = 'Temperature [°C]'
else:
y_formatted = html_chemname_format_AqEquil(y[0])
if unit != "":
ylabel = "{} {} [{}]".format(y_formatted, unit_type, unit)
else:
ylabel = "{} {}".format(y_formatted, unit_type)
if x == 'pH':
xlabel = 'pH'
elif x == 'Temperature':
xlabel = 'Temperature [°C]'
else:
x_formatted = html_chemname_format_AqEquil(x)
if xunit != "":
xlabel = "{} {} [{}]".format(x_formatted, xunit_type, xunit)
else:
xlabel = "{} {}".format(x_formatted, xunit_type)
# convert rgba to hex
colors = [matplotlib.colors.rgb2hex(c) for c in colors]
# map each species to its color, e.g.,
# {'CO2': '#000000', 'HCO3-': '#1699d3', 'Other': '#736ca8'}
dict_species_color = {sp:color for sp,color in zip(y, colors)}
# html format color dict key names
dict_species_color = {html_chemname_format_AqEquil(k):v for k,v in dict_species_color.items()}
df = self.lookup(["name", x]+y).copy()
df.loc[:, "name"] = df.index
df.columns = df.columns.get_level_values(0)
df = pd.melt(df, id_vars=["name", x], value_vars=y)
df = df.rename(columns={"Sample": "y_variable", "value": "y_value"})
if (unit_type == "energy supply" or unit_type == "affinity") and isinstance(self.reactions_for_plotting, pd.DataFrame):
# get formatted reactions to display
if not isinstance(self.reactions_for_plotting, pd.DataFrame):
self.reactions_for_plotting = self.show_redox_reactions(formatted=True,
charge_sign_at_end=False,
show=False, simplify=True)
y_find = [yi.replace("_energy", "").replace("_affinity", "") for yi in y]
rxns = self.reactions_for_plotting.loc[y_find, :]["reaction"].tolist()
rxn_dict = {rxn_name:rxn for rxn_name,rxn in zip(y, rxns)}
if len(y) == 1:
ylabel = "{}<br>{} [{}]".format(html_chemname_format_AqEquil(y_find[0]), unit_type, unit)
df["formatted_rxn"] = df["y_variable"].map(rxn_dict)
else:
df["formatted_rxn"] = ""
df['y_variable'] = df['y_variable'].apply(html_chemname_format_AqEquil)
fig = px.scatter(df, x=x, y="y_value", color="y_variable",
hover_data=[x, "y_value", "y_variable", "name", "formatted_rxn"],
width=plot_width*ppi, height=plot_height*ppi,
labels={x: xlabel, "y_value": ylabel},
category_orders={"species": y},
color_discrete_map=dict_species_color,
opacity=fill_alpha,
custom_data=['name', 'formatted_rxn'],
template="simple_white")
fig.update_traces(marker=dict(size=point_size),
hovertemplate = "%{customdata[0]}<br>"+xlabel+": %{x} <br>"+ylabel+": %{y}<br>%{customdata[1]}")
fig.update_layout(legend_title=None,
title={'text':title, 'x':0.5, 'xanchor':'center'},
margin={"t": 40},
yaxis={'exponentformat':'power'})
if len(y) == 1:
fig.update_layout(showlegend=False)
save_as, save_format = self.__save_figure(fig, save_as, save_format,
save_scale, plot_width,
plot_height, ppi)
config = {'displaylogo': False, 'scrollZoom': True,
'modeBarButtonsToRemove': ['select2d', 'lasso2d', 'toggleSpikelines', 'resetScale2d'],
'toImageButtonOptions': {
'format': save_format, # one of png, svg, jpeg, webp
'filename': save_as,
'height': plot_height*ppi,
'width': plot_width*ppi,
'scale': save_scale,
},
}
if not interactive:
config['staticPlot'] = True
if plot_out:
return fig
else:
fig.show(config=config)
def plot_mass_contribution(self, basis, title=None, sort_by=None,
ascending=True, sort_y_by=None, width=0.9,
colormap="WORM",
plot_width=4, plot_height=3, ppi=122,
save_as=None, save_format=None,
save_scale=1, interactive=True,
plot_out=False):
"""
Plot basis species contributions to mass balance of aqueous species
across all samples.
Parameters
----------
basis : str
Name of the basis species.
title : str, optional
Title of the plot.
sort_by : str, optional
Name of the variable used to sort samples. Variable names must be
taken from the speciation report column names. No sorting is done by
default.
ascending : bool, default True
Should sample sorting be in ascending order? Descending if False.
Ignored unless `sort_by` is defined.
sort_y_by : list of str or 'alphabetical', optional
List of species names in the order that they should be stacked, from
the bottom of the plot to the top. 'alphabetical' will sort species
alphabetically.
width : float, default 0.9
Width of bars. No space between bars if width=1.0.
colormap : str, default "WORM"
Name of the colormap to color the scatterpoints. Accepts "WORM",
"colorblind", or matplotlib colormaps.
See https://matplotlib.org/stable/tutorials/colors/colormaps.html
The "colorblind" colormap is referenced from Wong, B. Points of view:
Color blindness. Nat Methods 8, 441 (2011).
https://doi.org/10.1038/nmeth.1618
plot_width, plot_height : numeric, default 4 by 3
Width and height of the plot, in inches. Size of interactive plots
is also determined by pixels per inch, set by the parameter `ppi`.
ppi : numeric, default 122
Pixels per inch. Along with `plot_width` and `plot_height`,
determines the size of interactive plots.
save_as : str, optional
Provide a filename to save this figure. Filetype of saved figure is
determined by `save_format`.
Note: interactive plots can be saved by clicking the 'Download plot'
button in the plot's toolbar.
save_format : str, default "png"
Desired format of saved or downloaded figure. Can be 'png', 'jpg',
'jpeg', 'webp', 'svg', 'pdf', 'eps', 'json', or 'html'. If 'html',
an interactive plot will be saved. Only 'png', 'svg', 'jpeg',
and 'webp' can be downloaded with the 'download as' button in the
toolbar of an interactive plot.
save_scale : numeric, default 1
Multiply title/legend/axis/canvas sizes by this factor when saving
the figure.
interactive : bool, default True
Return an interactive plot if True or a static plot if False.
plot_out : bool, default False
Return a plotly figure object? If True, a plot is not displayed as
it is generated.
"""
try:
self.mass_contribution
except:
msg = ("Results for basis species contributions to aqueous mass "
"balance could not be found. Ensure that "
"get_mass_contribution = True when running speciate().")
self.err_handler.raise_exception(msg)
if basis not in set(self.mass_contribution['basis']):
msg = ("The basis species {} ".format(basis)+"could not be found "
"among available basis species: "
"{}".format(str(list(set(self.mass_contribution['basis'])))))
self.err_handler.raise_exception(msg)
df_sp = copy.deepcopy(self.mass_contribution.loc[self.mass_contribution['basis'] == basis])
if isinstance(sort_y_by, list):
for species in sort_y_by:
if species not in df_sp["species"]:
for sample in set(df_sp["sample"]):
df2 = {'sample':sample, 'basis':basis, 'species':species, 'factor':None, 'molality':None, 'percent':0}
df_sp = df_sp.append(df2, ignore_index=True)
if sort_by != None:
if sort_by in self.report.columns.get_level_values(0):
sort_col = self.lookup(sort_by)
sort_by_unit = sort_col.columns.get_level_values(1)[0]
sort_index = sort_col.sort_values([(sort_by, sort_by_unit)], ascending=ascending).index
df_list = []
for i in sort_index:
df_list.append(df_sp[df_sp['sample']==i])
df_sp = | pd.concat(df_list) | pandas.concat |
# -*- coding: utf-8 -*-
"""
Created on Wed Dec 30 18:07:56 2020
@author: Fabio
"""
import pandas as pd
import matplotlib.pyplot as plt
def df_filterbydate(df, dataLB, dataUB):
df['Data_Registrazione'] = pd.to_datetime(df['Data_Registrazione'], infer_datetime_format=True).dt.date
df = df[(df['Data_Registrazione'] >= dataLB) & (df['Data_Registrazione'] <= dataUB)]
return df
def get_df_classi(df, soglia=180):
# creo df delle classi non prof == 0/ prof == 1/ molto prof == 2 """
df0 = df[df['profitto'] <= 0]
df1 = df[(df['profitto'] > 0) & (df['profitto'] <= soglia)]
df2 = df[df['profitto'] > soglia]
return df0, df1, df2
def get_classi_cliente(cliente, df, soglia):
# estraggo il df del singolo cliente considerando tutti i suoi produttori
df_cliente = df[df['Produttore'] == cliente]
visit_num = len(df_cliente.index)
df0, df1, df2 = get_df_classi(df_cliente,soglia)
class_0c = len(df0.index) # conto il totale degli ordini non prof
class_1c = len(df1.index) # conto il totale degli ordini prof
class_2c = len(df2.index) # conto il totale degli ordini max prof
class_c = [class_0c, class_1c, class_2c]
class_0p = class_0c / visit_num
class_1p = class_1c / visit_num
class_2p = class_2c / visit_num
class_p = [class_0p, class_1p, class_2p]
class_0s = df0['profitto'].sum() # sommo il totale degli ordini non prof
class_1s = df1['profitto'].sum() # sommo il totale degli ordini prof
class_2s = df2['profitto'].sum() # sommo il totale degli ordini max prof
class_s = [class_0s, class_1s, class_2s]
if (class_0s >= class_1s + class_2s) or (class_0p > class_1p and class_0p > class_2p):
color = 'red' # se non profittevole
classe = 0
elif (class_1p >= class_0p) and (class_1p >= class_2p):
color = 'lightblue' # se profittevole
classe = 1
elif (class_2p >= class_0p) and (class_2p >= class_1p):
color = 'blue' # se ottimo profitto
classe = 2
return class_c, class_p, class_s, color, classe
def get_classi_produttore(cliente, lat, long, df, soglia):
# creo un df per singolo cliente con le coordinate di tutti i suoi produttori
df_produttore = df[(df['Produttore'] == cliente) & (df['lat_P'] == lat) & (df['long_P'] == long)]
visit_num = len(df_produttore.index)
df0, df1, df2 = get_df_classi(df_produttore, soglia)
class_0c = df0['profitto'].count() # conto il totale degli ordini non prof
class_1c = df1['profitto'].count() # conto il totale degli ordini prof
class_2c = df2['profitto'].count() # conto il totale degli ordini max prof
class_c = [class_0c, class_1c, class_2c]
class_0p = class_0c / visit_num
class_1p = class_1c / visit_num
class_2p = class_2c / visit_num
class_p = [class_0p, class_1p, class_2p]
class_0s = df0['profitto'].sum() # sommo il totale degli ordini non prof
class_1s = df1['profitto'].sum() # sommo il totale degli ordini prof
class_2s = df2['profitto'].sum() # sommo il totale degli ordini max prof
class_s = [class_0s, class_1s, class_2s]
if (class_0s >= class_1s + class_2s) or (class_0p > class_1p and class_0p > class_2p):
color = 'red' # se non profittevole
classe = 0
elif (class_1p >= class_0p) and (class_1p >= class_2p):
color = 'blue' # se profittevole
classe = 1
elif (class_2p >= class_0p) and (class_2p >= class_1p):
color = 'darkblue' # se ottimo profitto
classe = 2
return class_c, class_p, class_s, color, classe
def filtro_ordine_peggiore(df,df2): # restituisce i peggiori ordini dei singoli clienti nella classe specificata dal df in input, df2 è il df totale
produttori = df['Produttore'].drop_duplicates().tolist()
ordini_peggiori = []
for produttore in produttori:
""" seleziono i peggiori ordini del produttore sulla base del profitto"""
peggiore = min(df[df['Produttore'] == produttore]['profitto'])
""" estraggo gli indici dei peggiori ordini"""
peggiore_index = df[df['profitto'] == peggiore].index
""" ne estraggo il num fiscale"""
num_ordine = df2.iloc[peggiore_index]['NumFiscale'].values
""" creo una lista con produttore, num ficale e profitto dei peggiori ordini"""
ordini_peggiori.append([produttore, num_ordine, peggiore])
""" creo un df dalla lista"""
df_ordini = pd.DataFrame(data=ordini_peggiori, columns=['Produttore', 'NumFiscale', 'profitto'])
return df_ordini
def filtro_classifica(
df): # da usare con i dataframe df_non_prof\df_prof\df_max_prof, restituisce la classifica dei clienti sulla base del profitto totale
""" creo un df ordinato in modo decrescente sulla base del profitto"""
classifica = df.sort_values(by='profitto', ascending=False)
profitto = classifica['profitto']
produttori = classifica['Produttore']
df_classifica = pd.DataFrame()
df_classifica['Produttore'] = produttori
df_classifica['profitto'] = profitto
return df_classifica
def best_n(df, n):
df_best = df.nlargest(n, 'profitto')
produttori_list = df_best['Produttore'].tolist()
return df_best, produttori_list
def worst_n(df, n):
df_worst = df.nsmallest(n, 'profitto')
produttori_list = df_worst['Produttore'].tolist()
return df_worst, produttori_list
def grafici(df, df2, dfn, dfp, dfo, hist, pie, best,
worst): # dare in input df, dfpneg, dfp, dfpmax e df2 è il df_produttori
""" per scegliere il tipo di grafico inserire un valore al posto di hist/pie (o entrambi) e None su quello non richiesto, stessa cosa per scegliere se peggiori o migliori, ma non entrambi"""
ax_i = []
ax_t = []
"""blocco di if/elif per verificare la scelta del tipo di grafico """
if (pd.isna(hist) == False) & (pd.isna(pie) == False):
"""blocco di if/elif per verificare la scelta tra peggiori e migliori """
if pd.isna(best) == False:
produttori = best_n(df2, 10)
elif pd.isna(worst) == False:
produttori = worst_n(df2, 10)
else:
produttori = []
"""blocco di if/elif per verificare la scelta del tipo di grafico """
for produttore in produttori:
""" per l'istogramma seleziono il produttore e estraggo la serie delle commesse nel df ed eseguo il plot"""
serie = df[df['Produttore'] == produttore]['profitto']
figure, axes = plt.subplots(1, 1)
plt.title(produttore)
ax = serie.plot.hist()
plt.ylabel('numero commesse')
ax_i.append([produttore, ax])
""" per la torta seleziono il produttore ed estraggo la serie delle commesse in df_pneg, df_p e df_pmax"""
serie_neg = dfn[dfn['Produttore'] == produttore]['profitto']
serie_prof = dfp[dfp['Produttore'] == produttore]['profitto']
serie_max = dfo[dfo['Produttore'] == produttore]['profitto']
""" eseguo il plot sul numero di volte che il produttore compare nelle singole classi """
y = [len(serie_neg), len(serie_prof), len(serie_max)]
label = ['non profittevoli', 'profittevoli', 'ottimo profitto']
figure, ax = plt.subplots()
plt.title(produttore)
ax.pie(y)
plt.legend(label, loc="best")
ax_t.append([produttore, ax])
elif | pd.isna(hist) | pandas.isna |
# -*- coding:utf-8 -*-
"""CI/CD for vega."""
import vega
import os
from vega.core.common.utils import update_dict
from vega.core.common import Config
import pandas as pd
import time
import subprocess
import traceback
import datetime
def main():
"""Execute main."""
algs = Config("./ci.yml")
run_status = | pd.DataFrame({"algorithms": [], "run_time(min)": [], "status": [], "error_info": []}) | pandas.DataFrame |
from django.db import models
from django.utils import timezone
from django.db.models import Q
import asyncio
from ib_insync import IB, Stock, MarketOrder, util
from core.common import empty_append
from core.indicators import rel_dif
import vectorbtpro as vbt
import sys
import math
import pandas as pd
import numpy as np
from trading_bot.settings import (PERFORM_ORDER, USE_IB_FOR_DATA,DIC_PERFORM_ORDER,
IB_LOCALHOST, IB_PORT)
### Interactive brockers and data retrieval ###
'''
Contains:
- Communication with Interactive brokers
- Retrieval of live data (Interactive brokers or YFinance)
- Performing order
- Models for financial products, stock exchanges...
Note: for some reasons, it does not work if myIB class is not in models
'''
## All symbols must be from same stock exchange
def retrieve_data(symbols,period,**kwargs):
try:
IBok=True
for symbol in symbols:
if kwargs.get("index",False):
action=Index.objects.get(symbol=symbol)
else:
action=Action.objects.get(symbol=symbol)
if action.stock_ex.ib_ticker in ["BVME.ETF"]:
IBok=False
break
index_symbol=exchange_to_symbol(action)
if (USE_IB_FOR_DATA and IBok) or kwargs.get("useIB",False):
fig= ''.join(x for x in period if x.isdigit())
if period.find("d")!=-1:
period_ib=fig +" D"
elif period.find("mo")!=-1:
period_ib=fig +" M"
elif period.find("y")!=-1:
period_ib=fig +" Y"
#Time period of one bar. Must be one of: ‘1 secs’, ‘5 secs’, ‘10 secs’ 15 secs’, ‘30 secs’, ‘1 min’, ‘2 mins’, ‘3 mins’, ‘5 mins’, ‘10 mins’, ‘15 mins’, ‘20 mins’, ‘30 mins’, ‘1 hour’, ‘2 hours’, ‘3 hours’, ‘4 hours’, ‘8 hours’, ‘1 day’, ‘1 week’, ‘1 month’.
if kwargs.get("interval",False):
fig= ''.join(x for x in kwargs.get("interval") if x.isdigit())
if period.find("m")!=-1:
interval=fig +" mins"
elif period.find("h")!=-1:
interval=fig +" hours"
elif period.find("d")!=-1:
interval=fig +" day"
else:
interval='1 day'
open_=[]
close=[]
low=[]
high=[]
myIB=MyIB()
for symbol in symbols:
action=Action.objects.get(symbol=symbol)
contract = Stock(action.ib_ticker(),action.stock_ex.ib_ticker, action.currency.symbol)
bars = myIB.ib.reqHistoricalData(
contract,
endDateTime='',
durationStr=period_ib, #"10 D","1 M"
barSizeSetting=interval, #"1 day", "1 min"
whatToShow='TRADES',
useRTH=True,
formatDate=1)
df=util.df(bars)
open_=empty_append(open_,df["open"].values,axis=1)
close=empty_append(close,df["close"].values,axis=1)
high=empty_append(high,df["high"].values,axis=1)
low=empty_append(low,df["low"].values,axis=1)
volume=empty_append(low,df["volume"].values,axis=1)
cours_open=pd.DataFrame(data=open_,index=df["date"],columns=symbols)
cours_close= | pd.DataFrame(data=close,index=df["date"],columns=symbols) | pandas.DataFrame |
import numpy as np
import pandas as pd
# Classifier used
from sklearn.ensemble import RandomForestClassifier
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE
# Best Feature selection
from sklearn.feature_selection import RFE
# Input Matrix
dataframe_trn = pd.read_csv("../input/train.csv")
dataframe_tst = pd.read_csv("../input/test.csv")
#Target Vector
labels_trn = dataframe_trn[["target","id"]]
#Dropping columns
dataframe_trn = dataframe_trn.drop(["target","id"],axis=1)
ids = pd.DataFrame(dataframe_tst["id"].values,columns= ["id"])
dataframe_tst = dataframe_tst.drop("id",axis=1)
headers = dataframe_trn.columns.values
# String to numeric Mapping
dict_mapping = {"Class_1":1,"Class_2":2,"Class_3":3,"Class_4":4,"Class_5":5,"Class_6":6,"Class_7":7,"Class_8":8,"Class_9":9}
labels_trn_numeric = labels_trn["target"].apply(lambda x: dict_mapping[x])
# Reducing Dimensions
#trn_embedded = TSNE(n_components=2).fit_transform(dataframe_trn)
#Plotting the Dataset
#plt.scatter(trn_embedded[:, 0], trn_embedded[:, 1],c=labels_trn_numeric)
#plt.show()
clf = RandomForestClassifier( n_estimators=500,n_jobs=4)
rfe = RFE(clf, 85)
fit = rfe.fit(dataframe_trn, labels_trn_numeric)
features = []
for i , j in zip(dataframe_trn.columns,fit.support_):
if j == True:
features.append(str(i))
array = pd.DataFrame(fit.predict_proba(dataframe_tst),columns=["Class_1","Class_2","Class_3","Class_4","Class_5","Class_6","Class_7","Class_8","Class_9"])
complete_array = | pd.concat([ids,array],axis=1) | pandas.concat |
"""
Daily Class
Meteorological data provided by Meteostat (https://dev.meteostat.net)
under the terms of the Creative Commons Attribution-NonCommercial
4.0 International Public License.
The code is licensed under the MIT license.
"""
import os
from copy import copy
from datetime import datetime
from typing import Union
from numpy import NaN
import numpy as np
import pandas as pd
from meteostat.core import Core
from meteostat.point import Point
class Daily(Core):
"""
Retrieve daily weather observations for one or multiple weather stations or
a single geographical point
"""
# The cache subdirectory
cache_subdir: str = 'daily'
# The list of weather Stations
stations = None
# The start date
start: datetime = None
# The end date
end: datetime = None
# Include model data?
model: bool = True
# The data frame
data = | pd.DataFrame() | pandas.DataFrame |
import pandas as pd
from datetime import timedelta, date, datetime
import os.path
import numpy as np
class covid:
def create_df(self, url):
# to check if file exists
# self is local path, url is online location
if os.path.exists(self):
df = pd.read_csv(self)
max_date = df["dateRep"].max()
max_date = datetime.strptime(max_date, '%Y-%m-%d').date()
if max_date + timedelta(days=1) == date.today():
print("Existing file already updated.")
return covid.get_data(self)
else:
df = covid.get_data(url)
df = covid.adjust_column_names(df)
df.to_csv('data.csv', index=False)
print('File exists but is not updated. Updating file.')
return df
else:
df = covid.get_data(url)
df = covid.adjust_column_names(df)
df.to_csv('data.csv', index=False)
print('File does not exists. Downloading and creating file.')
return df
def download_data(self):
df = pd.read_csv(self, parse_dates=['date'], dayfirst=True)
return df.to_csv('data.csv', index=False)
def get_data(self):
df = | pd.read_csv(self, parse_dates=[3], dayfirst=False) | pandas.read_csv |
# import pandas, numpy, and matplotlib
import pandas as pd
from feature_engine.encoding import OneHotEncoder
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.feature_selection import SelectKBest, f_regression,\
mutual_info_regression
pd.set_option('display.width', 75)
pd.set_option('display.max_columns', 20)
pd.set_option('display.max_rows', 100)
pd.options.display.float_format = '{:,.3f}'.format
# load the NLS data
nls97wages = | pd.read_csv("data/nls97wages.csv") | pandas.read_csv |
# -*- coding: utf-8 -*-
from __future__ import print_function
from datetime import datetime, timedelta
import functools
import itertools
import numpy as np
import numpy.ma as ma
import numpy.ma.mrecords as mrecords
from numpy.random import randn
import pytest
from pandas.compat import (
PY3, PY36, OrderedDict, is_platform_little_endian, lmap, long, lrange,
lzip, range, zip)
from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
from pandas.core.dtypes.common import is_integer_dtype
import pandas as pd
from pandas import (
Categorical, DataFrame, Index, MultiIndex, Series, Timedelta, Timestamp,
compat, date_range, isna)
from pandas.tests.frame.common import TestData
import pandas.util.testing as tm
MIXED_FLOAT_DTYPES = ['float16', 'float32', 'float64']
MIXED_INT_DTYPES = ['uint8', 'uint16', 'uint32', 'uint64', 'int8', 'int16',
'int32', 'int64']
class TestDataFrameConstructors(TestData):
def test_constructor(self):
df = DataFrame()
assert len(df.index) == 0
df = DataFrame(data={})
assert len(df.index) == 0
def test_constructor_mixed(self):
index, data = tm.getMixedTypeDict()
# TODO(wesm), incomplete test?
indexed_frame = DataFrame(data, index=index) # noqa
unindexed_frame = DataFrame(data) # noqa
assert self.mixed_frame['foo'].dtype == np.object_
def test_constructor_cast_failure(self):
foo = DataFrame({'a': ['a', 'b', 'c']}, dtype=np.float64)
assert foo['a'].dtype == object
# GH 3010, constructing with odd arrays
df = DataFrame(np.ones((4, 2)))
# this is ok
df['foo'] = np.ones((4, 2)).tolist()
# this is not ok
pytest.raises(ValueError, df.__setitem__, tuple(['test']),
np.ones((4, 2)))
# this is ok
df['foo2'] = np.ones((4, 2)).tolist()
def test_constructor_dtype_copy(self):
orig_df = DataFrame({
'col1': [1.],
'col2': [2.],
'col3': [3.]})
new_df = pd.DataFrame(orig_df, dtype=float, copy=True)
new_df['col1'] = 200.
assert orig_df['col1'][0] == 1.
def test_constructor_dtype_nocast_view(self):
df = DataFrame([[1, 2]])
should_be_view = DataFrame(df, dtype=df[0].dtype)
should_be_view[0][0] = 99
assert df.values[0, 0] == 99
should_be_view = DataFrame(df.values, dtype=df[0].dtype)
should_be_view[0][0] = 97
assert df.values[0, 0] == 97
def test_constructor_dtype_list_data(self):
df = DataFrame([[1, '2'],
[None, 'a']], dtype=object)
assert df.loc[1, 0] is None
assert df.loc[0, 1] == '2'
def test_constructor_list_frames(self):
# see gh-3243
result = DataFrame([DataFrame([])])
assert result.shape == (1, 0)
result = DataFrame([DataFrame(dict(A=lrange(5)))])
assert isinstance(result.iloc[0, 0], DataFrame)
def test_constructor_mixed_dtypes(self):
def _make_mixed_dtypes_df(typ, ad=None):
if typ == 'int':
dtypes = MIXED_INT_DTYPES
arrays = [np.array(np.random.rand(10), dtype=d)
for d in dtypes]
elif typ == 'float':
dtypes = MIXED_FLOAT_DTYPES
arrays = [np.array(np.random.randint(
10, size=10), dtype=d) for d in dtypes]
zipper = lzip(dtypes, arrays)
for d, a in zipper:
assert(a.dtype == d)
if ad is None:
ad = dict()
ad.update({d: a for d, a in zipper})
return DataFrame(ad)
def _check_mixed_dtypes(df, dtypes=None):
if dtypes is None:
dtypes = MIXED_FLOAT_DTYPES + MIXED_INT_DTYPES
for d in dtypes:
if d in df:
assert(df.dtypes[d] == d)
# mixed floating and integer coexinst in the same frame
df = _make_mixed_dtypes_df('float')
_check_mixed_dtypes(df)
# add lots of types
df = _make_mixed_dtypes_df('float', dict(A=1, B='foo', C='bar'))
_check_mixed_dtypes(df)
# GH 622
df = _make_mixed_dtypes_df('int')
_check_mixed_dtypes(df)
def test_constructor_complex_dtypes(self):
# GH10952
a = np.random.rand(10).astype(np.complex64)
b = np.random.rand(10).astype(np.complex128)
df = DataFrame({'a': a, 'b': b})
assert a.dtype == df.a.dtype
assert b.dtype == df.b.dtype
def test_constructor_dtype_str_na_values(self, string_dtype):
# https://github.com/pandas-dev/pandas/issues/21083
df = DataFrame({'A': ['x', None]}, dtype=string_dtype)
result = df.isna()
expected = DataFrame({"A": [False, True]})
tm.assert_frame_equal(result, expected)
assert df.iloc[1, 0] is None
df = DataFrame({'A': ['x', np.nan]}, dtype=string_dtype)
assert np.isnan(df.iloc[1, 0])
def test_constructor_rec(self):
rec = self.frame.to_records(index=False)
if PY3:
# unicode error under PY2
rec.dtype.names = list(rec.dtype.names)[::-1]
index = self.frame.index
df = DataFrame(rec)
tm.assert_index_equal(df.columns, pd.Index(rec.dtype.names))
df2 = DataFrame(rec, index=index)
tm.assert_index_equal(df2.columns, pd.Index(rec.dtype.names))
tm.assert_index_equal(df2.index, index)
rng = np.arange(len(rec))[::-1]
df3 = DataFrame(rec, index=rng, columns=['C', 'B'])
expected = DataFrame(rec, index=rng).reindex(columns=['C', 'B'])
tm.assert_frame_equal(df3, expected)
def test_constructor_bool(self):
df = DataFrame({0: np.ones(10, dtype=bool),
1: np.zeros(10, dtype=bool)})
assert df.values.dtype == np.bool_
def test_constructor_overflow_int64(self):
# see gh-14881
values = np.array([2 ** 64 - i for i in range(1, 10)],
dtype=np.uint64)
result = DataFrame({'a': values})
assert result['a'].dtype == np.uint64
# see gh-2355
data_scores = [(6311132704823138710, 273), (2685045978526272070, 23),
(8921811264899370420, 45),
(long(17019687244989530680), 270),
(long(9930107427299601010), 273)]
dtype = [('uid', 'u8'), ('score', 'u8')]
data = np.zeros((len(data_scores),), dtype=dtype)
data[:] = data_scores
df_crawls = DataFrame(data)
assert df_crawls['uid'].dtype == np.uint64
@pytest.mark.parametrize("values", [np.array([2**64], dtype=object),
np.array([2**65]), [2**64 + 1],
np.array([-2**63 - 4], dtype=object),
np.array([-2**64 - 1]), [-2**65 - 2]])
def test_constructor_int_overflow(self, values):
# see gh-18584
value = values[0]
result = DataFrame(values)
assert result[0].dtype == object
assert result[0][0] == value
def test_constructor_ordereddict(self):
import random
nitems = 100
nums = lrange(nitems)
random.shuffle(nums)
expected = ['A%d' % i for i in nums]
df = DataFrame(OrderedDict(zip(expected, [[0]] * nitems)))
assert expected == list(df.columns)
def test_constructor_dict(self):
frame = DataFrame({'col1': self.ts1,
'col2': self.ts2})
# col2 is padded with NaN
assert len(self.ts1) == 30
assert len(self.ts2) == 25
tm.assert_series_equal(self.ts1, frame['col1'], check_names=False)
exp = pd.Series(np.concatenate([[np.nan] * 5, self.ts2.values]),
index=self.ts1.index, name='col2')
tm.assert_series_equal(exp, frame['col2'])
frame = DataFrame({'col1': self.ts1,
'col2': self.ts2},
columns=['col2', 'col3', 'col4'])
assert len(frame) == len(self.ts2)
assert 'col1' not in frame
assert isna(frame['col3']).all()
# Corner cases
assert len(DataFrame({})) == 0
# mix dict and array, wrong size - no spec for which error should raise
# first
with pytest.raises(ValueError):
DataFrame({'A': {'a': 'a', 'b': 'b'}, 'B': ['a', 'b', 'c']})
# Length-one dict micro-optimization
frame = DataFrame({'A': {'1': 1, '2': 2}})
tm.assert_index_equal(frame.index, pd.Index(['1', '2']))
# empty dict plus index
idx = Index([0, 1, 2])
frame = DataFrame({}, index=idx)
assert frame.index is idx
# empty with index and columns
idx = Index([0, 1, 2])
frame = DataFrame({}, index=idx, columns=idx)
assert frame.index is idx
assert frame.columns is idx
assert len(frame._series) == 3
# with dict of empty list and Series
frame = DataFrame({'A': [], 'B': []}, columns=['A', 'B'])
tm.assert_index_equal(frame.index, Index([], dtype=np.int64))
# GH 14381
# Dict with None value
frame_none = DataFrame(dict(a=None), index=[0])
frame_none_list = DataFrame(dict(a=[None]), index=[0])
with tm.assert_produces_warning(FutureWarning,
check_stacklevel=False):
assert frame_none.get_value(0, 'a') is None
with tm.assert_produces_warning(FutureWarning,
check_stacklevel=False):
assert frame_none_list.get_value(0, 'a') is None
tm.assert_frame_equal(frame_none, frame_none_list)
# GH10856
# dict with scalar values should raise error, even if columns passed
msg = 'If using all scalar values, you must pass an index'
with pytest.raises(ValueError, match=msg):
DataFrame({'a': 0.7})
with pytest.raises(ValueError, match=msg):
DataFrame({'a': 0.7}, columns=['a'])
@pytest.mark.parametrize("scalar", [2, np.nan, None, 'D'])
def test_constructor_invalid_items_unused(self, scalar):
# No error if invalid (scalar) value is in fact not used:
result = DataFrame({'a': scalar}, columns=['b'])
expected = DataFrame(columns=['b'])
tm.assert_frame_equal(result, expected)
@pytest.mark.parametrize("value", [2, np.nan, None, float('nan')])
def test_constructor_dict_nan_key(self, value):
# GH 18455
cols = [1, value, 3]
idx = ['a', value]
values = [[0, 3], [1, 4], [2, 5]]
data = {cols[c]: Series(values[c], index=idx) for c in range(3)}
result = DataFrame(data).sort_values(1).sort_values('a', axis=1)
expected = DataFrame(np.arange(6, dtype='int64').reshape(2, 3),
index=idx, columns=cols)
tm.assert_frame_equal(result, expected)
result = DataFrame(data, index=idx).sort_values('a', axis=1)
tm.assert_frame_equal(result, expected)
result = DataFrame(data, index=idx, columns=cols)
tm.assert_frame_equal(result, expected)
@pytest.mark.parametrize("value", [np.nan, None, float('nan')])
def test_constructor_dict_nan_tuple_key(self, value):
# GH 18455
cols = Index([(11, 21), (value, 22), (13, value)])
idx = Index([('a', value), (value, 2)])
values = [[0, 3], [1, 4], [2, 5]]
data = {cols[c]: Series(values[c], index=idx) for c in range(3)}
result = (DataFrame(data)
.sort_values((11, 21))
.sort_values(('a', value), axis=1))
expected = DataFrame(np.arange(6, dtype='int64').reshape(2, 3),
index=idx, columns=cols)
tm.assert_frame_equal(result, expected)
result = DataFrame(data, index=idx).sort_values(('a', value), axis=1)
tm.assert_frame_equal(result, expected)
result = DataFrame(data, index=idx, columns=cols)
tm.assert_frame_equal(result, expected)
@pytest.mark.skipif(not PY36, reason='Insertion order for Python>=3.6')
def test_constructor_dict_order_insertion(self):
# GH19018
# initialization ordering: by insertion order if python>= 3.6
d = {'b': self.ts2, 'a': self.ts1}
frame = DataFrame(data=d)
expected = DataFrame(data=d, columns=list('ba'))
tm.assert_frame_equal(frame, expected)
@pytest.mark.skipif(PY36, reason='order by value for Python<3.6')
def test_constructor_dict_order_by_values(self):
# GH19018
# initialization ordering: by value if python<3.6
d = {'b': self.ts2, 'a': self.ts1}
frame = DataFrame(data=d)
expected = DataFrame(data=d, columns=list('ab'))
tm.assert_frame_equal(frame, expected)
def test_constructor_multi_index(self):
# GH 4078
# construction error with mi and all-nan frame
tuples = [(2, 3), (3, 3), (3, 3)]
mi = MultiIndex.from_tuples(tuples)
df = DataFrame(index=mi, columns=mi)
assert pd.isna(df).values.ravel().all()
tuples = [(3, 3), (2, 3), (3, 3)]
mi = MultiIndex.from_tuples(tuples)
df = DataFrame(index=mi, columns=mi)
assert pd.isna(df).values.ravel().all()
def test_constructor_error_msgs(self):
msg = "Empty data passed with indices specified."
# passing an empty array with columns specified.
with pytest.raises(ValueError, match=msg):
DataFrame(np.empty(0), columns=list('abc'))
msg = "Mixing dicts with non-Series may lead to ambiguous ordering."
# mix dict and array, wrong size
with pytest.raises(ValueError, match=msg):
DataFrame({'A': {'a': 'a', 'b': 'b'},
'B': ['a', 'b', 'c']})
# wrong size ndarray, GH 3105
msg = r"Shape of passed values is \(3, 4\), indices imply \(3, 3\)"
with pytest.raises(ValueError, match=msg):
DataFrame(np.arange(12).reshape((4, 3)),
columns=['foo', 'bar', 'baz'],
index=pd.date_range('2000-01-01', periods=3))
# higher dim raise exception
with pytest.raises(ValueError, match='Must pass 2-d input'):
DataFrame(np.zeros((3, 3, 3)), columns=['A', 'B', 'C'], index=[1])
# wrong size axis labels
msg = ("Shape of passed values "
r"is \(3, 2\), indices "
r"imply \(3, 1\)")
with pytest.raises(ValueError, match=msg):
DataFrame(np.random.rand(2, 3), columns=['A', 'B', 'C'], index=[1])
msg = ("Shape of passed values "
r"is \(3, 2\), indices "
r"imply \(2, 2\)")
with pytest.raises(ValueError, match=msg):
DataFrame(np.random.rand(2, 3), columns=['A', 'B'], index=[1, 2])
msg = ("If using all scalar "
"values, you must pass "
"an index")
with pytest.raises(ValueError, match=msg):
DataFrame({'a': False, 'b': True})
def test_constructor_with_embedded_frames(self):
# embedded data frames
df1 = DataFrame({'a': [1, 2, 3], 'b': [3, 4, 5]})
df2 = DataFrame([df1, df1 + 10])
df2.dtypes
str(df2)
result = df2.loc[0, 0]
tm.assert_frame_equal(result, df1)
result = df2.loc[1, 0]
tm.assert_frame_equal(result, df1 + 10)
def test_constructor_subclass_dict(self):
# Test for passing dict subclass to constructor
data = {'col1': tm.TestSubDict((x, 10.0 * x) for x in range(10)),
'col2': tm.TestSubDict((x, 20.0 * x) for x in range(10))}
df = DataFrame(data)
refdf = DataFrame({col: dict(compat.iteritems(val))
for col, val in compat.iteritems(data)})
tm.assert_frame_equal(refdf, df)
data = tm.TestSubDict(compat.iteritems(data))
df = DataFrame(data)
tm.assert_frame_equal(refdf, df)
# try with defaultdict
from collections import defaultdict
data = {}
self.frame['B'][:10] = np.nan
for k, v in compat.iteritems(self.frame):
dct = defaultdict(dict)
dct.update(v.to_dict())
data[k] = dct
frame = DataFrame(data)
tm.assert_frame_equal(self.frame.sort_index(), frame)
def test_constructor_dict_block(self):
expected = np.array([[4., 3., 2., 1.]])
df = DataFrame({'d': [4.], 'c': [3.], 'b': [2.], 'a': [1.]},
columns=['d', 'c', 'b', 'a'])
tm.assert_numpy_array_equal(df.values, expected)
def test_constructor_dict_cast(self):
# cast float tests
test_data = {
'A': {'1': 1, '2': 2},
'B': {'1': '1', '2': '2', '3': '3'},
}
frame = DataFrame(test_data, dtype=float)
assert len(frame) == 3
assert frame['B'].dtype == np.float64
assert frame['A'].dtype == np.float64
frame = DataFrame(test_data)
assert len(frame) == 3
assert frame['B'].dtype == np.object_
assert frame['A'].dtype == np.float64
# can't cast to float
test_data = {
'A': dict(zip(range(20), tm.makeStringIndex(20))),
'B': dict(zip(range(15), randn(15)))
}
frame = DataFrame(test_data, dtype=float)
assert len(frame) == 20
assert frame['A'].dtype == np.object_
assert frame['B'].dtype == np.float64
def test_constructor_dict_dont_upcast(self):
d = {'Col1': {'Row1': 'A String', 'Row2': np.nan}}
df = DataFrame(d)
assert isinstance(df['Col1']['Row2'], float)
dm = DataFrame([[1, 2], ['a', 'b']], index=[1, 2], columns=[1, 2])
assert isinstance(dm[1][1], int)
def test_constructor_dict_of_tuples(self):
# GH #1491
data = {'a': (1, 2, 3), 'b': (4, 5, 6)}
result = DataFrame(data)
expected = DataFrame({k: list(v) for k, v in compat.iteritems(data)})
tm.assert_frame_equal(result, expected, check_dtype=False)
def test_constructor_dict_multiindex(self):
def check(result, expected):
return tm.assert_frame_equal(result, expected, check_dtype=True,
check_index_type=True,
check_column_type=True,
check_names=True)
d = {('a', 'a'): {('i', 'i'): 0, ('i', 'j'): 1, ('j', 'i'): 2},
('b', 'a'): {('i', 'i'): 6, ('i', 'j'): 5, ('j', 'i'): 4},
('b', 'c'): {('i', 'i'): 7, ('i', 'j'): 8, ('j', 'i'): 9}}
_d = sorted(d.items())
df = DataFrame(d)
expected = DataFrame(
[x[1] for x in _d],
index=MultiIndex.from_tuples([x[0] for x in _d])).T
expected.index = MultiIndex.from_tuples(expected.index)
check(df, expected)
d['z'] = {'y': 123., ('i', 'i'): 111, ('i', 'j'): 111, ('j', 'i'): 111}
_d.insert(0, ('z', d['z']))
expected = DataFrame(
[x[1] for x in _d],
index=Index([x[0] for x in _d], tupleize_cols=False)).T
expected.index = Index(expected.index, tupleize_cols=False)
df = DataFrame(d)
df = df.reindex(columns=expected.columns, index=expected.index)
check(df, expected)
def test_constructor_dict_datetime64_index(self):
# GH 10160
dates_as_str = ['1984-02-19', '1988-11-06', '1989-12-03', '1990-03-15']
def create_data(constructor):
return {i: {constructor(s): 2 * i}
for i, s in enumerate(dates_as_str)}
data_datetime64 = create_data(np.datetime64)
data_datetime = create_data(lambda x: datetime.strptime(x, '%Y-%m-%d'))
data_Timestamp = create_data(Timestamp)
expected = DataFrame([{0: 0, 1: None, 2: None, 3: None},
{0: None, 1: 2, 2: None, 3: None},
{0: None, 1: None, 2: 4, 3: None},
{0: None, 1: None, 2: None, 3: 6}],
index=[Timestamp(dt) for dt in dates_as_str])
result_datetime64 = DataFrame(data_datetime64)
result_datetime = DataFrame(data_datetime)
result_Timestamp = DataFrame(data_Timestamp)
tm.assert_frame_equal(result_datetime64, expected)
tm.assert_frame_equal(result_datetime, expected)
tm.assert_frame_equal(result_Timestamp, expected)
def test_constructor_dict_timedelta64_index(self):
# GH 10160
td_as_int = [1, 2, 3, 4]
def create_data(constructor):
return {i: {constructor(s): 2 * i}
for i, s in enumerate(td_as_int)}
data_timedelta64 = create_data(lambda x: np.timedelta64(x, 'D'))
data_timedelta = create_data(lambda x: timedelta(days=x))
data_Timedelta = create_data(lambda x: Timedelta(x, 'D'))
expected = DataFrame([{0: 0, 1: None, 2: None, 3: None},
{0: None, 1: 2, 2: None, 3: None},
{0: None, 1: None, 2: 4, 3: None},
{0: None, 1: None, 2: None, 3: 6}],
index=[Timedelta(td, 'D') for td in td_as_int])
result_timedelta64 = DataFrame(data_timedelta64)
result_timedelta = DataFrame(data_timedelta)
result_Timedelta = DataFrame(data_Timedelta)
tm.assert_frame_equal(result_timedelta64, expected)
tm.assert_frame_equal(result_timedelta, expected)
tm.assert_frame_equal(result_Timedelta, expected)
def test_constructor_period(self):
# PeriodIndex
a = pd.PeriodIndex(['2012-01', 'NaT', '2012-04'], freq='M')
b = pd.PeriodIndex(['2012-02-01', '2012-03-01', 'NaT'], freq='D')
df = pd.DataFrame({'a': a, 'b': b})
assert df['a'].dtype == a.dtype
assert df['b'].dtype == b.dtype
# list of periods
df = pd.DataFrame({'a': a.astype(object).tolist(),
'b': b.astype(object).tolist()})
assert df['a'].dtype == a.dtype
assert df['b'].dtype == b.dtype
def test_nested_dict_frame_constructor(self):
rng = pd.period_range('1/1/2000', periods=5)
df = DataFrame(randn(10, 5), columns=rng)
data = {}
for col in df.columns:
for row in df.index:
with tm.assert_produces_warning(FutureWarning,
check_stacklevel=False):
data.setdefault(col, {})[row] = df.get_value(row, col)
result = DataFrame(data, columns=rng)
tm.assert_frame_equal(result, df)
data = {}
for col in df.columns:
for row in df.index:
with tm.assert_produces_warning(FutureWarning,
check_stacklevel=False):
data.setdefault(row, {})[col] = df.get_value(row, col)
result = DataFrame(data, index=rng).T
tm.assert_frame_equal(result, df)
def _check_basic_constructor(self, empty):
# mat: 2d matrix with shape (3, 2) to input. empty - makes sized
# objects
mat = empty((2, 3), dtype=float)
# 2-D input
frame = DataFrame(mat, columns=['A', 'B', 'C'], index=[1, 2])
assert len(frame.index) == 2
assert len(frame.columns) == 3
# 1-D input
frame = DataFrame(empty((3,)), columns=['A'], index=[1, 2, 3])
assert len(frame.index) == 3
assert len(frame.columns) == 1
# cast type
frame = DataFrame(mat, columns=['A', 'B', 'C'],
index=[1, 2], dtype=np.int64)
assert frame.values.dtype == np.int64
# wrong size axis labels
msg = r'Shape of passed values is \(3, 2\), indices imply \(3, 1\)'
with pytest.raises(ValueError, match=msg):
DataFrame(mat, columns=['A', 'B', 'C'], index=[1])
msg = r'Shape of passed values is \(3, 2\), indices imply \(2, 2\)'
with pytest.raises(ValueError, match=msg):
DataFrame(mat, columns=['A', 'B'], index=[1, 2])
# higher dim raise exception
with pytest.raises(ValueError, match='Must pass 2-d input'):
DataFrame(empty((3, 3, 3)), columns=['A', 'B', 'C'],
index=[1])
# automatic labeling
frame = DataFrame(mat)
tm.assert_index_equal(frame.index, pd.Index(lrange(2)))
tm.assert_index_equal(frame.columns, pd.Index(lrange(3)))
frame = DataFrame(mat, index=[1, 2])
tm.assert_index_equal(frame.columns, pd.Index(lrange(3)))
frame = DataFrame(mat, columns=['A', 'B', 'C'])
tm.assert_index_equal(frame.index, pd.Index(lrange(2)))
# 0-length axis
frame = DataFrame(empty((0, 3)))
assert len(frame.index) == 0
frame = DataFrame(empty((3, 0)))
assert len(frame.columns) == 0
def test_constructor_ndarray(self):
self._check_basic_constructor(np.ones)
frame = DataFrame(['foo', 'bar'], index=[0, 1], columns=['A'])
assert len(frame) == 2
def test_constructor_maskedarray(self):
self._check_basic_constructor(ma.masked_all)
# Check non-masked values
mat = ma.masked_all((2, 3), dtype=float)
mat[0, 0] = 1.0
mat[1, 2] = 2.0
frame = DataFrame(mat, columns=['A', 'B', 'C'], index=[1, 2])
assert 1.0 == frame['A'][1]
assert 2.0 == frame['C'][2]
# what is this even checking??
mat = ma.masked_all((2, 3), dtype=float)
frame = DataFrame(mat, columns=['A', 'B', 'C'], index=[1, 2])
assert np.all(~np.asarray(frame == frame))
def test_constructor_maskedarray_nonfloat(self):
# masked int promoted to float
mat = ma.masked_all((2, 3), dtype=int)
# 2-D input
frame = DataFrame(mat, columns=['A', 'B', 'C'], index=[1, 2])
assert len(frame.index) == 2
assert len(frame.columns) == 3
assert np.all(~np.asarray(frame == frame))
# cast type
frame = DataFrame(mat, columns=['A', 'B', 'C'],
index=[1, 2], dtype=np.float64)
assert frame.values.dtype == np.float64
# Check non-masked values
mat2 = ma.copy(mat)
mat2[0, 0] = 1
mat2[1, 2] = 2
frame = DataFrame(mat2, columns=['A', 'B', 'C'], index=[1, 2])
assert 1 == frame['A'][1]
assert 2 == frame['C'][2]
# masked np.datetime64 stays (use NaT as null)
mat = ma.masked_all((2, 3), dtype='M8[ns]')
# 2-D input
frame = DataFrame(mat, columns=['A', 'B', 'C'], index=[1, 2])
assert len(frame.index) == 2
assert len(frame.columns) == 3
assert isna(frame).values.all()
# cast type
frame = DataFrame(mat, columns=['A', 'B', 'C'],
index=[1, 2], dtype=np.int64)
assert frame.values.dtype == np.int64
# Check non-masked values
mat2 = ma.copy(mat)
mat2[0, 0] = 1
mat2[1, 2] = 2
frame = DataFrame(mat2, columns=['A', 'B', 'C'], index=[1, 2])
assert 1 == frame['A'].view('i8')[1]
assert 2 == frame['C'].view('i8')[2]
# masked bool promoted to object
mat = ma.masked_all((2, 3), dtype=bool)
# 2-D input
frame = DataFrame(mat, columns=['A', 'B', 'C'], index=[1, 2])
assert len(frame.index) == 2
assert len(frame.columns) == 3
assert np.all(~np.asarray(frame == frame))
# cast type
frame = DataFrame(mat, columns=['A', 'B', 'C'],
index=[1, 2], dtype=object)
assert frame.values.dtype == object
# Check non-masked values
mat2 = ma.copy(mat)
mat2[0, 0] = True
mat2[1, 2] = False
frame = DataFrame(mat2, columns=['A', 'B', 'C'], index=[1, 2])
assert frame['A'][1] is True
assert frame['C'][2] is False
def test_constructor_mrecarray(self):
# Ensure mrecarray produces frame identical to dict of masked arrays
# from GH3479
assert_fr_equal = functools.partial(tm.assert_frame_equal,
check_index_type=True,
check_column_type=True,
check_frame_type=True)
arrays = [
('float', np.array([1.5, 2.0])),
('int', np.array([1, 2])),
('str', np.array(['abc', 'def'])),
]
for name, arr in arrays[:]:
arrays.append(('masked1_' + name,
np.ma.masked_array(arr, mask=[False, True])))
arrays.append(('masked_all', np.ma.masked_all((2,))))
arrays.append(('masked_none',
np.ma.masked_array([1.0, 2.5], mask=False)))
# call assert_frame_equal for all selections of 3 arrays
for comb in itertools.combinations(arrays, 3):
names, data = zip(*comb)
mrecs = mrecords.fromarrays(data, names=names)
# fill the comb
comb = {k: (v.filled() if hasattr(v, 'filled') else v)
for k, v in comb}
expected = DataFrame(comb, columns=names)
result = DataFrame(mrecs)
assert_fr_equal(result, expected)
# specify columns
expected = DataFrame(comb, columns=names[::-1])
result = DataFrame(mrecs, columns=names[::-1])
assert_fr_equal(result, expected)
# specify index
expected = DataFrame(comb, columns=names, index=[1, 2])
result = DataFrame(mrecs, index=[1, 2])
assert_fr_equal(result, expected)
def test_constructor_corner_shape(self):
df = DataFrame(index=[])
assert df.values.shape == (0, 0)
@pytest.mark.parametrize("data, index, columns, dtype, expected", [
(None, lrange(10), ['a', 'b'], object, np.object_),
(None, None, ['a', 'b'], 'int64', np.dtype('int64')),
(None, lrange(10), ['a', 'b'], int, np.dtype('float64')),
({}, None, ['foo', 'bar'], None, np.object_),
({'b': 1}, lrange(10), list('abc'), int, np.dtype('float64'))
])
def test_constructor_dtype(self, data, index, columns, dtype, expected):
df = DataFrame(data, index, columns, dtype)
assert df.values.dtype == expected
def test_constructor_scalar_inference(self):
data = {'int': 1, 'bool': True,
'float': 3., 'complex': 4j, 'object': 'foo'}
df = DataFrame(data, index=np.arange(10))
assert df['int'].dtype == np.int64
assert df['bool'].dtype == np.bool_
assert df['float'].dtype == np.float64
assert df['complex'].dtype == np.complex128
assert df['object'].dtype == np.object_
def test_constructor_arrays_and_scalars(self):
df = DataFrame({'a': randn(10), 'b': True})
exp = DataFrame({'a': df['a'].values, 'b': [True] * 10})
tm.assert_frame_equal(df, exp)
with pytest.raises(ValueError, match='must pass an index'):
DataFrame({'a': False, 'b': True})
def test_constructor_DataFrame(self):
df = DataFrame(self.frame)
tm.assert_frame_equal(df, self.frame)
df_casted = DataFrame(self.frame, dtype=np.int64)
assert df_casted.values.dtype == np.int64
def test_constructor_more(self):
# used to be in test_matrix.py
arr = randn(10)
dm = DataFrame(arr, columns=['A'], index=np.arange(10))
assert dm.values.ndim == 2
arr = randn(0)
dm = DataFrame(arr)
assert dm.values.ndim == 2
assert dm.values.ndim == 2
# no data specified
dm = DataFrame(columns=['A', 'B'], index=np.arange(10))
assert dm.values.shape == (10, 2)
dm = DataFrame(columns=['A', 'B'])
assert dm.values.shape == (0, 2)
dm = DataFrame(index=np.arange(10))
assert dm.values.shape == (10, 0)
# can't cast
mat = np.array(['foo', 'bar'], dtype=object).reshape(2, 1)
with pytest.raises(ValueError, match='cast'):
DataFrame(mat, index=[0, 1], columns=[0], dtype=float)
dm = DataFrame(DataFrame(self.frame._series))
tm.assert_frame_equal(dm, self.frame)
# int cast
dm = DataFrame({'A': np.ones(10, dtype=int),
'B': np.ones(10, dtype=np.float64)},
index=np.arange(10))
assert len(dm.columns) == 2
assert dm.values.dtype == np.float64
def test_constructor_empty_list(self):
df = DataFrame([], index=[])
expected = DataFrame(index=[])
tm.assert_frame_equal(df, expected)
# GH 9939
df = DataFrame([], columns=['A', 'B'])
expected = DataFrame({}, columns=['A', 'B'])
tm.assert_frame_equal(df, expected)
# Empty generator: list(empty_gen()) == []
def empty_gen():
return
yield
df = DataFrame(empty_gen(), columns=['A', 'B'])
tm.assert_frame_equal(df, expected)
def test_constructor_list_of_lists(self):
# GH #484
df = DataFrame(data=[[1, 'a'], [2, 'b']], columns=["num", "str"])
assert is_integer_dtype(df['num'])
assert df['str'].dtype == np.object_
# GH 4851
# list of 0-dim ndarrays
expected = DataFrame({0: np.arange(10)})
data = [np.array(x) for x in range(10)]
result = DataFrame(data)
tm.assert_frame_equal(result, expected)
def test_constructor_sequence_like(self):
# GH 3783
# collections.Squence like
class DummyContainer(compat.Sequence):
def __init__(self, lst):
self._lst = lst
def __getitem__(self, n):
return self._lst.__getitem__(n)
def __len__(self, n):
return self._lst.__len__()
lst_containers = [DummyContainer([1, 'a']), DummyContainer([2, 'b'])]
columns = ["num", "str"]
result = DataFrame(lst_containers, columns=columns)
expected = DataFrame([[1, 'a'], [2, 'b']], columns=columns)
tm.assert_frame_equal(result, expected, check_dtype=False)
# GH 4297
# support Array
import array
result = DataFrame({'A': array.array('i', range(10))})
expected = DataFrame({'A': list(range(10))})
tm.assert_frame_equal(result, expected, check_dtype=False)
expected = DataFrame([list(range(10)), list(range(10))])
result = DataFrame([array.array('i', range(10)),
array.array('i', range(10))])
tm.assert_frame_equal(result, expected, check_dtype=False)
def test_constructor_iterable(self):
# GH 21987
class Iter():
def __iter__(self):
for i in range(10):
yield [1, 2, 3]
expected = DataFrame([[1, 2, 3]] * 10)
result = DataFrame(Iter())
tm.assert_frame_equal(result, expected)
def test_constructor_iterator(self):
expected = DataFrame([list(range(10)), list(range(10))])
result = DataFrame([range(10), range(10)])
tm.assert_frame_equal(result, expected)
def test_constructor_generator(self):
# related #2305
gen1 = (i for i in range(10))
gen2 = (i for i in range(10))
expected = DataFrame([list(range(10)), list(range(10))])
result = DataFrame([gen1, gen2])
tm.assert_frame_equal(result, expected)
gen = ([i, 'a'] for i in range(10))
result = DataFrame(gen)
expected = DataFrame({0: range(10), 1: 'a'})
tm.assert_frame_equal(result, expected, check_dtype=False)
def test_constructor_list_of_dicts(self):
data = [OrderedDict([['a', 1.5], ['b', 3], ['c', 4], ['d', 6]]),
OrderedDict([['a', 1.5], ['b', 3], ['d', 6]]),
OrderedDict([['a', 1.5], ['d', 6]]),
OrderedDict(),
OrderedDict([['a', 1.5], ['b', 3], ['c', 4]]),
OrderedDict([['b', 3], ['c', 4], ['d', 6]])]
result = DataFrame(data)
expected = DataFrame.from_dict(dict(zip(range(len(data)), data)),
orient='index')
tm.assert_frame_equal(result, expected.reindex(result.index))
result = DataFrame([{}])
expected = DataFrame(index=[0])
tm.assert_frame_equal(result, expected)
def test_constructor_ordered_dict_preserve_order(self):
# see gh-13304
expected = | DataFrame([[2, 1]], columns=['b', 'a']) | pandas.DataFrame |
# gsheets_data.py
from dotenv import load_dotenv
import os
import gspread
from oauth2client.service_account import ServiceAccountCredentials
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import io
import sys
from wordcloud import WordCloud, STOPWORDS
import nltk
from nltk.sentiment.vader import SentimentIntensityAnalyzer
import sendgrid
from sendgrid.helpers.mail import *
def send_email(text, sub):
load_dotenv()
SENDGRID_API_KEY = os.environ.get("SENDGRID_API_KEY", "OOPS, please set env var called 'SENDGRID_API_KEY'")
MY_EMAIL_ADDRESS = os.environ.get("MY_EMAIL_ADDRESS", "OOPS, please set env var called 'MY_EMAIL_ADDRESS'")
CLIENT_EMAIL_ADDRESS = os.environ.get("MY_EMAIL_ADDRESS", "OOPS, please set env var called 'CLIENT_EMAIL_ADDRESS'")
sg = sendgrid.SendGridAPIClient(apikey=SENDGRID_API_KEY)
### load email variables
from_email = Email(MY_EMAIL_ADDRESS)
to_email = Email(CLIENT_EMAIL_ADDRESS)
subject = sub
sub_text = text
message_text = f"Dear User, \nThis is an automated email response. \n {sub_text}"
content = Content("text/plain", message_text)
mail = Mail(from_email, subject, to_email, content)
response = sg.client.mail.send.post(request_body=mail.get())
return response
def google_sheets_data(gsheet):
load_dotenv()
DOCUMENT_ID = os.environ.get("GOOGLE_SHEET_ID", "OOPS")
SHEET_NAME = gsheet
scope = ["https://spreadsheets.google.com/feeds",'https://www.googleapis.com/auth/spreadsheets',"https://www.googleapis.com/auth/drive.file","https://www.googleapis.com/auth/drive"]
file_name = os.path.join(os.getcwd(), "google_credentials", "gcreds.json")
creds = ServiceAccountCredentials.from_json_keyfile_name(file_name, scope)
client = gspread.authorize(creds)
doc = client.open_by_key(DOCUMENT_ID)
sheet = doc.worksheet(SHEET_NAME)
data = sheet.get_all_records()
return data
def quality(x):
if x == 5:
return 'Exceptional'
elif x==4.5 or x==4:
return 'Very Good'
elif x==3.5 or x==3:
return 'Average'
else:
return 'Poor'
def savefile(fileandext):
file_name = os.path.join(os.getcwd(), "plot_images", fileandext)
if os.path.exists(file_name):
os.remove(file_name)
return file_name
def float_format(data):
x = "{0:.2f}".format(data)
return x
if __name__ == "__main__":
### Defining the initial datasets. THey will be used for the plots created below
business_search = google_sheets_data('business_search')
business_reviews = google_sheets_data('business_reviews')
bs_data = pd.DataFrame(business_search)
br_data = pd.DataFrame(business_reviews)
cumm_bs_br = bs_data.merge(br_data, on = 'restaurant_id', how = 'inner')
bs_review = bs_data[['category','restaurant_id', 'review_count']]
bs_rating = bs_data[['category', 'restaurant_id', 'rating']]
bs_review_agg = bs_review.groupby(['category']).sum().reset_index()
bs_rating_agg = bs_rating.groupby(['category']).mean().reset_index()
colors = ['blue', 'crimson', 'deeppink', 'violet', 'c', 'olive', 'grey', 'plum', 'palegreen', 'sienna', 'navy', 'darkcyan', 'hotpink', 'pink', 'indianred', 'magenta', 'purple', 'brown', 'dimgrey', 'g']
cuisine_types = bs_data.category.unique().tolist()
#setting size of the canvas
plt.figure(figsize=(12,12))
###################################################################################
### Bar Chart - How good are restaurants in general?
# creates a bar chart based on user input
category_count = bs_data.groupby(['rating']).size().reset_index(name='counts')
category_count['quality'] = category_count['rating'].apply(quality)
del(category_count['rating'])
category_agg = category_count.groupby(['quality']).sum().reset_index()
category_agg['quality'] = | pd.Categorical(category_agg['quality'], ['Exceptional', 'Very Good', 'Average', 'Poor']) | pandas.Categorical |
import xml.etree.ElementTree as ET
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
import calendar
import time
from datetime import datetime
import pytz
from scipy import stats
from os.path import exists
# an instance of apple Health
# fname is the name of data file to be parsed must be an XML files
# flags for cache
class AppleHealth:
def __init__(self, fname = 'export.xml', pivotIndex = 'endDate', readCache = False, writeCache = False):
#check cache flag and cache accordingly
if readCache:
a = time.time()
self.readCache(fname)
e = time.time()
self.runtime = e-a
print("Cache parsing Time = {}".format(e-a))
if writeCache:
self.cacheAll(fname)
return
# create element tree object
a = time.time()
s = time.time()
tree = ET.parse(fname)
e = time.time()
print("Tree parsing Time = {}".format(e-s))
# for every health record, extract the attributes into a dictionary (columns). Then create a list (rows).
s = time.time()
root = tree.getroot()
record_list = [x.attrib for x in root.iter('Record')]
workout_list = [x.attrib for x in root.iter('Workout')]
e = time.time()
print("record list Time = {}".format(e-s))
# create DataFrame from a list (rows) of dictionaries (columns)
s = time.time()
self.record_data = pd.DataFrame(record_list)
self.workout_data = pd.DataFrame(workout_list)
e = time.time()
print("creating DF Time = {}".format(e-s))
format = '%Y-%m-%d %H:%M:%S'
# proper type to dates
def get_split_date(strdt):
split_date = strdt.split()
str_date = split_date[1] + ' ' + split_date[2] + ' ' + split_date[5] + ' ' + split_date[3]
return str_date
s = time.time()
for col in ['creationDate', 'startDate', 'endDate']:
self.record_data[col] = pd.to_datetime(self.record_data[col], format=format)
if not self.workout_data.empty:
self.workout_data[col] = pd.to_datetime(self.workout_data[col], format=format)
e = time.time()
print("date conv Time = {}".format(e-s))
s = time.time()
# value is numeric, NaN if fails]
self.record_data['value'] = pd.to_numeric(self.record_data['value'], errors='coerce')
if not self.workout_data.empty:
self.workout_data['duration'] = pd.to_numeric(self.workout_data['duration'], errors='coerce')
self.workout_data['totalDistance'] = pd.to_numeric(self.workout_data['totalDistance'], errors='coerce')
self.workout_data['totalEnergyBurned'] = | pd.to_numeric(self.workout_data['totalEnergyBurned'], errors='coerce') | pandas.to_numeric |
import pandas as pd
from bs4 import BeautifulSoup
import urllib.request
from StatusMsg import StatusMsg
import json
import os
import io
import datetime
from ExtractStateMyGov import ExtractStateMyGov
import requests
from tqdm import tqdm
import tabula
import tabulate
def combine_listItems(list):
combined_items = ' '.join([str(item) for item in list])
return combined_items
def getAPData(state, date, path):
try:
# file_path1 = tabula.read_pdf('../INPUT/{}/{}/'.format(date,state),pages=1,stream = True)
file_path = tabula.read_pdf(path,pages=1,stream = True)
table = tabulate(file_path1)
# print(table)
df_districts = pd.read_fwf(io.StringIO(table))
# remove junk on top and reset the index
df_districts.drop(df_districts.head(4).index, inplace=True)
df_districts = df_districts.reset_index()
# remove bottom junk
df_districts.drop(df_districts.tail(2).index, inplace=True)
df_other_cols = df_districts
# print(df_districts)
# remove unnecessary columns
cols = [0, 4, 6]
df_districts.drop(df_districts.columns[cols], axis=1, inplace=True)
# add column names
df_districts.columns = ['S.No','District', 'cumulativeConfirmedNumberForDistrict', 'District_1', 'Cases_2']
df_districts.drop('S.No', axis=1, inplace=True)
new_df = df_districts
# splitting the dataframe
N = 2
splitted_list_df = np.split(df_districts, np.arange(N, len(df_districts.columns), N), axis=1)
part_A = splitted_list_df[0]
part_B = splitted_list_df[1]
# print(type(part_B))
part_B_cols = {"District_1": "District", "Cases_2": "cumulativeConfirmedNumberForDistrict"}
part_B.rename(columns=part_B_cols, inplace=True)
# concatenate two splitted DF's
df_districts = | pd.concat([part_A, part_B], ignore_index=True, sort=False) | pandas.concat |
from collections import defaultdict
from zipfile import ZipFile
import pandas as pd
from sklearn.preprocessing import (
LabelEncoder,
MultiLabelBinarizer,
)
from .base import get_data, get_data_dir, get_quantized_data_path
from ..preprocess import delta, quantize_mfccs
CAL10K_DIR = 'cal10k'
CAL10K_ZIP = 'cal10k.zip'
DATA_URL = ('http://calab1.ucsd.edu/~datasets/cal10k/cal10kdata/'
'cal10k_mfcc_22050Hz_win2048_hop1024.zip')
TAGS_ZIP = 'tags.zip'
TAGS_URL = ('http://acsweb.ucsd.edu/~yvaizman/metadata/'
'cal10k_tagsFrom30SongsOrMore_5folds.zip')
def fetch_cal10k(data_home=None, download_if_missing=True,
codebook_size=512, fold=1):
r"""Loader for the CAL10k dataset [2]_.
This dataset consists of 10,870 western pop songs, performed by 4,597
unique artists. Each song is weakly annotated with 2 to 25 tags from a tag
vocabulary of 153 genre tags and 475 acoustic tags but only tags
associated with at least 30 songs are kept for the final tag vocabulary.
The CAL10k dataset has predefined train-test-splits for a 5-fold
cross-validation
.. warning::
This utility downloads a ~2GB file to your home directory. This might
take a few minutes, depending on your bandwidth.
Parameters
----------
data_home : optional
Specify a download and cache folder for the datasets. By default
(``None``) all data is stored in subfolders of ``~/cbar_data``.
download_if_missing: bool, optional
If ``False``, raise a ``IOError`` if the data is not locally available
instead of trying to download the data from the source site.
Defaults to ``True``.
codebook_size : int, optional
The codebook size. Defaults to 512.
fold : int, :math:`\in \{1, ..., 5\}`
The specific train-test-split to load. Defaults to 1.
Returns
-------
X_train : array-like, shape = [n_train_samples, codebook_size]
Training set songs. Each row corresponds to a preprocessed song,
represented as a sparse codebook vector.
X_test : array-like, shape = [n_test_samples, codebook_size]
Test set songs. Each row corresponds to a preprocessed song,
represented as a sparse codebook vector.
Y_train : array-like, shape = [n_train_samples, 581]
Training set tags associated with each training set song in
binary indicator format.
Y_test : array-like, shape = [n_test_samples, 581]
Test set tags associated with each test set song in
binary indicator format.
Notes
------
The CAL10k dataset is downloaded from UCSD's `Computer Audition
Laboratory's datasets page <http://calab1.ucsd.edu/~datasets/cal10k/>`_.
The annotations are the "corrected" annotations from [3]_, downloaded from
the `CAL10k corrected metadata page
<http://calab1.ucsd.edu/~datasets/cal10k/>`_.
The raw dataset consists of the 13 mel-frequency cepstral coefficients
for each frame of each song. The acoustic data is preprocessed similar to
the acoustic data in the CAL500 dataset (see notes in
:func:`cbar.datasets.fetch_cal500`).
References
----------
.. [2] <NAME>, <NAME>, and <NAME>, `Exploring automatic music
annotation with acoustically-objective tags.
<http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.306.9746&rep=
rep1&type=pdf>`_
in Proceedings of the international conference on Multimedia
information retrieval, 2010, pp. 55-62.
.. [3] <NAME>, <NAME>, and <NAME>, `Codebook-based audio
feature representation for music information retrieval.
<http://acsweb.ucsd.edu/~yvaizman/papers/taslp_2014_accepted.pdf>`_
Audio, Speech, and Language Processing, IEEE/ACM Transactions on, vol.
22, no. 10, pp. 1483-1493, 2014.
"""
data_dir = get_data_dir(data_home, CAL10K_DIR)
data_path = get_data(DATA_URL, data_dir, CAL10K_ZIP, download_if_missing)
tags_path = get_data(TAGS_URL, data_dir, TAGS_ZIP, download_if_missing)
file_path = get_quantized_data_path(data_dir, codebook_size)
le = LabelEncoder()
with ZipFile(data_path) as data:
le.fit([_clean(filename) for filename in data.namelist()[1:]])
try:
X = | pd.read_pickle(file_path) | pandas.read_pickle |
"""Create hydraulic systems dataset"""
import os
import zipfile
# call on members Union, List
import typing
# call on members data.CustomData, systemutils_more.download, systemutils.config
import h2oaicore
import datatable as dt
import numpy as np
import pandas as pd
class HydraulicSystemsData(h2oaicore.data.CustomData):
@staticmethod
def create_data(X: dt.Frame = None) -> typing.Union[str, typing.List[str],
dt.Frame, typing.List[dt.Frame],
np.ndarray, typing.List[np.ndarray],
pd.DataFrame, typing.List[pd.DataFrame]]:
def mean_conversion(pd_frame: pd.DataFrame) -> pd.Series:
"""Means are computed along columns to average the cycle sensor data
Each row in frame is data collected over a cycle of 60 seconds
Keyword arguments:
pd_frame -- pandas dataframe representation of hydraulic system sensor data
"""
return pd_frame.mean(axis = 1) # axis=1 means along column
def convert_to_frame(file_bytes_object: bytes) -> pd.DataFrame:
"""Convert bytes data to pandas dataframe
Keyword arguments:
file_bytes_object -- bytes representation of hydraulic system sensor file data read using zip
"""
data_file_str = str(file_bytes_object,"utf-8")
dt_frame = dt.Frame(data_file_str)
pd_frame = dt_frame.to_pandas()
return pd_frame
def import_data_field(zip: zipfile.ZipFile, filename: str, fieldname: str) -> pd.DataFrame:
"""Loads pandas dataframe with average cycle sensor data
Keyword arguments:
zip -- zip file object for reading filename
filename -- name of file to read hydraulic system sensor data from
fieldname -- name of hydraulic system sensor
"""
pd_frame = pd.DataFrame( mean_conversion(convert_to_frame(zip.read(filename))) )
pd_frame.columns = [fieldname]
return pd_frame
def import_target_label(zip: zipfile.ZipFile, filename: str, target_label: str) -> pd.DataFrame:
"""Loads pandas dataframe with target label field
Keyword arguments:
zip -- zip file object for reading filename
filename -- name of file to read prediction labels from
target_label -- chosen hydraulic system condition monitoring label for supervised learning
"""
pd_frame = convert_to_frame(zip.read(filename))
pd_target_labels_y = {
# store hydraulic cooler condition label data from column 0 into pd frame
"cool_cond_y": pd.DataFrame(pd_frame.iloc[:,0]),
# store hydraulic valve condition label data from column 1 into pd frame
"valve_cond_y": pd.DataFrame(pd_frame.iloc[:,1]),
# store hydraulic internal pump leakage label data from column 2 into pd frame
"pump_leak_y": | pd.DataFrame(pd_frame.iloc[:,2]) | pandas.DataFrame |
"""launcher/wrapper for executing CLI"""
import collections
from datetime import datetime
import logging
from os import path
import platform
from plumbum import cli
import pandas as pd
import prosper.common.prosper_cli as p_cli
import prosper.datareader.news as p_news
from vincent import _version, exceptions
HERE = path.abspath(path.dirname(__file__))
PROGNAME = 'GetNews'
IntrinioAuth = collections.namedtuple('IntrinioAuth', ['username', 'password'])
def fetch_news(
ticker_list,
source,
intrinio_auth,
logger=logging.getLogger(PROGNAME),
):
"""fetch news from desired source
Args:
ticker_list (list): list of tickers to fetch
source (str): name of service to fetch news from
intrinio_auth (:obj:`IntrinioAuth`): username/password container
logger (:obj:`logging.logger`): logging handle
Returns:
pandas.DataFrame: news for all tickers
Raises:
MissingAuthentication: lacking credentials for `intrinio` endpoints
NotImplementedError: unsupported source type
"""
now = pd.Timestamp.now('UTC')
if source == 'intrinio' and not intrinio_auth:
raise exceptions.MissingAuthentication(
'Need `intrinio_username` and `intrinio_password'
)
logger.info('fetching news from: %s', source)
results_df = pd.DataFrame()
for ticker in cli.terminal.Progress(ticker_list.split(',')):
logger.debug('fetching: %s', ticker)
news_df = pd.DataFrame()
if source == 'intrinio':
news_df = p_news.company_news_intrinio(
ticker,
intrinio_auth.username,
intrinio_auth.password,
logger=logger,
)
elif source == 'robinhood':
news_df = p_news.company_news_rh(ticker, logger=logger)
elif source == 'yahoo':
news_df = p_news.company_headlines_yahoo(ticker, logger=logger)
else:
raise NotImplementedError(f'Unexpected source type `{source}`')
news_df['gen_ticker'] = ticker
news_df['gen_time'] = now
news_df['gen_source'] = source
# append news into master dataframe
results_df = | pd.concat([results_df, news_df], ignore_index=True) | pandas.concat |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Oct 14 21:31:56 2017
@author: Franz
"""
import scipy.signal
import numpy as np
import scipy.io as so
import os.path
import re
import matplotlib.pylab as plt
import h5py
import matplotlib.patches as patches
import numpy.random as rand
import seaborn as sns
import pandas as pd
from functools import reduce
import random
import pdb
class Mouse :
def __init__(self, idf, list=None, typ='') :
self.recordings = []
self.recordings.append(list)
self.typ = typ
self.idf = idf
def add(self, rec) :
self.recordings.append(rec)
def __len__(self) :
return len(self.recordings)
def __repr__(self) :
return ", ".join(self.recordings)
### PROCESSING OF RECORDING DATA ##############################################
def load_stateidx(ppath, name, ann_name=''):
""" load the sleep state file of recording (folder) $ppath/$name
@Return:
M,K sequence of sleep states, sequence of
0'1 and 1's indicating non- and annotated states
"""
ddir = os.path.join(ppath, name)
ppath, name = os.path.split(ddir)
if ann_name == '':
ann_name = name
sfile = os.path.join(ppath, name, 'remidx_' + ann_name + '.txt')
f = open(sfile, 'r')
lines = f.readlines()
f.close()
n = 0
for l in lines:
if re.match('\d', l):
n += 1
M = np.zeros(n, dtype='int')
K = np.zeros(n, dtype='int')
i = 0
for l in lines :
if re.search('^\s+$', l) :
continue
if re.search('\s*#', l) :
continue
if re.match('\d+\s+-?\d+', l) :
a = re.split('\s+', l)
M[i] = int(a[0])
K[i] = int(a[1])
i += 1
return M,K
def load_recordings(ppath, rec_file) :
"""
load_recordings(ppath, rec_file)
load recording listing with syntax:
[E|C] \s+ recording_name
#COMMENT
@RETURN:
(list of controls, lis of experiments)
"""
exp_list = []
ctr_list = []
rfile = os.path.join(ppath, rec_file)
f = open(rfile, newline=None)
lines = f.readlines()
f.close()
for l in lines :
if re.search('^\s+$', l) :
continue
if re.search('^\s*#', l) :
continue
a = re.split('\s+', l)
if re.search('E', a[0]) :
exp_list.append(a[1])
if re.search('C', a[0]) :
ctr_list.append(a[1])
return ctr_list, exp_list
def load_dose_recordings(ppath, rec_file):
"""
load recording list with following syntax:
A line is either control or experiments; Control recordings look like:
C \s recording_name
Experimental recordings also come with an additional dose parameter
(allowing for comparison of multiple doses with controls)
E \s recording_name \s dose_1
E \s recording_name \s dose_2
"""
rfile = os.path.join(ppath, rec_file)
f = open(rfile, newline=None)
lines = f.readlines()
f.close()
# first get all potential doses
doses = {}
ctr_list = []
for l in lines :
if re.search('^\s+$', l):
continue
if re.search('^\s*#', l):
continue
a = re.split('\s+', l)
if re.search('E', a[0]):
if a[2] in doses:
doses[a[2]].append(a[1])
else:
doses[a[2]] = [a[1]]
if re.search('C', a[0]):
ctr_list.append(a[1])
return ctr_list, doses
def get_snr(ppath, name):
"""
read and return sampling rate (SR) from file $ppath/$name/info.txt
"""
fid = open(os.path.join(ppath, name, 'info.txt'), newline=None)
lines = fid.readlines()
fid.close()
values = []
for l in lines :
a = re.search("^" + 'SR' + ":" + "\s+(.*)", l)
if a :
values.append(a.group(1))
return float(values[0])
def get_infoparam(ifile, field):
"""
NOTE: field is a single string
and the function does not check for the type
of the values for field.
In fact, it just returns the string following field
"""
fid = open(ifile, newline=None)
lines = fid.readlines()
fid.close()
values = []
for l in lines :
a = re.search("^" + field + ":" + "\s+(.*)", l)
if a :
values.append(a.group(1))
return values
def add_infoparam(ifile, field, vals):
"""
:param ifile: info file
:param field: Parameters specifier, e.g. 'SR'
:param vals: list with parameters
"""
fid = open(ifile, 'a')
vals = [str(s) for s in vals]
param = " ".join(vals)
fid.write('%s:\t%s' % (field, param))
fid.write(os.linesep)
fid.close()
def laser_start_end(laser, SR=1525.88, intval=5):
"""laser_start_end(ppath, name)
print start and end index of laser stimulation trains: For example,
if you was stimulated for 2min every 20 min with 20 Hz, return the
start and end index of the each 2min stimulation period (train)
returns the tuple (istart, iend), both indices are inclusive,
i.e. part of the sequence
@Param:
laser - laser, vector of 0s and 1s
intval - minimum time separation [s] between two laser trains
@Return:
(istart, iend) - tuple of two np.arrays with laser start and end indices
"""
idx = np.where(laser > 0.5)[0]
if len(idx) == 0 :
return ([], [])
idx2 = np.nonzero(np.diff(idx)*(1./SR) > intval)[0]
istart = np.hstack([idx[0], idx[idx2+1]])
iend = np.hstack([idx[idx2], idx[-1]])
return (istart, iend)
def load_laser(ppath, name):
"""
load laser from recording ppath/name
@RETURN:
@laser, vector of 0's and 1's
"""
# laser might be .mat or h5py file
# perhaps we could find a better way of testing that
file = os.path.join(ppath, name, 'laser_'+name+'.mat')
try:
laser = np.array(h5py.File(file,'r').get('laser'))
except:
laser = so.loadmat(file)['laser']
return np.squeeze(laser)
def laser_protocol(ppath, name):
"""
What was the stimulation frequency and the inter-stimulation interval for recording
$ppath/$name?
@Return:
iinter-stimulation intervals, avg. inter-stimulation interval, frequency
"""
laser = load_laser(ppath, name)
SR = get_snr(ppath, name)
# first get inter-stimulation interval
(istart, iend) = laser_start_end(laser, SR)
intv = np.diff(np.array(istart/float(SR)))
d = intv/60.0
print("The laser was turned on in average every %.2f min," % (np.mean(d)))
print("with a min. interval of %.2f min and max. interval of %.2f min." % (np.min(d), np.max(d)))
print("Laser stimulation lasted for %f s." % (np.mean(np.array(iend/float(SR)-istart/float(SR)).mean())))
# print laser start times
print("Start time of each laser trial:")
j=1
for t in istart:
print("trial %d: %.2f" % (j, (t / float(SR)) / 60))
j += 1
# for each laser stimulation interval, check laser stimulation frequency
dt = 1/float(SR)
freq = []
laser_up = []
laser_down = []
for (i,j) in zip(istart, iend):
part = laser[i:j+1]
(a,b) = laser_start_end(part, SR, 0.005)
dur = (j-i+1)*dt
freq.append(len(a) / dur)
up_dur = (b-a+1)*dt*1000
down_dur = (a[1:]-b[0:-1]-1)*dt*1000
laser_up.append(np.mean(up_dur))
laser_down.append(np.mean(down_dur))
print(os.linesep + "Laser stimulation freq. was %.2f Hz," % np.mean(np.array(freq)))
print("with laser up and down duration of %.2f and %.2f ms." % (np.mean(np.array(laser_up)), np.mean(np.array(laser_down))))
return d, np.mean(d), np.mean(np.array(freq))
def swap_eeg(ppath, rec, ch='EEG'):
"""
swap EEG and EEG2 or EMG with EMG2 if $ch='EMG'
"""
if ch == 'EEG':
name = 'EEG'
else:
name = ch
EEG = so.loadmat(os.path.join(ppath, rec, name+'.mat'))[name]
EEG2 = so.loadmat(os.path.join(ppath, rec, name+'2.mat'))[name + '2']
tmp = EEG
EEG = EEG2
EEG2 = tmp
file_eeg1 = os.path.join(ppath, rec, '%s.mat' % name)
file_eeg2 = os.path.join(ppath, rec, '%s2.mat' % name)
so.savemat(file_eeg1, {name : EEG})
so.savemat(file_eeg2, {name+'2' : EEG2})
def eeg_conversion(ppath, rec, conv_factor=0.195):
"""
multiply all EEG and EMG channels with the given
conversion factor and write the conversion factor
as parameter (conversion:) into the info file.
Only if there's no conversion factor in the info file
specified, the conversion will be executed
:param ppath: base filder
:param rec: recording
:param conv_factor: conversion factor
:return: n/s
"""
ifile = os.path.join(ppath, rec, 'info.txt')
conv = get_infoparam(ifile, 'conversion')
if len(conv) > 0:
print("found conversion: parameter in info file")
print("returning: no conversion necessary!!!")
return
else:
files = os.listdir(os.path.join(ppath, rec))
files = [f for f in files if re.match('^EEG', f)]
for f in files:
name = re.split('\.', f)[0]
EEG = so.loadmat(os.path.join(ppath, rec, name+'.mat'), squeeze_me=True)[name]
if EEG[0].dtype == 'int16':
EEG = EEG * conv_factor
file_eeg = os.path.join(ppath, rec, '%s.mat' % name)
print(file_eeg)
so.savemat(file_eeg, {name: EEG})
else:
print('Wrong datatype! probably already converted; returning...')
return
files = os.listdir(os.path.join(ppath, rec))
files = [f for f in files if re.match('^EMG', f)]
for f in files:
name = re.split('\.', f)[0]
EMG = so.loadmat(os.path.join(ppath, rec, name+'.mat'), squeeze_me=True)[name]
if EMG[0].dtype == 'int16':
EMG = EMG * conv_factor
file_emg = os.path.join(ppath, rec, '%s.mat' % name)
print(file_emg)
so.savemat(file_emg, {name: EMG})
else:
print('Wrong datatype! probably already converted; returning...')
return
add_infoparam(ifile, 'conversion', [conv_factor])
calculate_spectrum(ppath, rec)
### DEPRICATED ############################################
def video_pulse_detection(ppath, rec, SR=1000, iv = 0.01):
"""
return index of each video frame onset
ppath/rec - recording
@Optional
SR - sampling rate of EEG(!) recording
iv - minimum time inverval (in seconds) between two frames
@Return
index of each video frame onset
"""
V = np.squeeze(so.loadmat(os.path.join(ppath, rec, 'videotime_' + rec + '.mat'))['video'])
TS = np.arange(0, len(V))
# indices where there's a jump in the signal
t = TS[np.where(V<0.5)];
if len(t) == 0:
idx = []
return idx
# time points where the interval between jumps is longer than iv
t2 = np.where(np.diff(t)*(1.0/SR)>=iv)[0]
idx = np.concatenate(([t[0]],t[t2+1]))
return idx
# SIGNAL PROCESSING ###########################################################
def my_lpfilter(x, w0, N=4):
"""
create a lowpass Butterworth filter with a cutoff of w0 * the Nyquist rate.
The nice thing about this filter is that is has zero-phase distortion.
A conventional lowpass filter would introduce a phase lag.
w0 - filter cutoff; value between 0 and 1, where 1 corresponds to nyquist frequency.
So if you want a filter with cutoff at x Hz, the corresponding w0 value is given by
w0 = 2 * x / sampling_rate
N - order of filter
@Return:
low-pass filtered signal
See also my hp_filter, or my_bpfilter
"""
from scipy import signal
b,a = signal.butter(N, w0)
y = signal.filtfilt(b,a, x)
return y
def my_hpfilter(x, w0, N=4):
"""
create an N-th order highpass Butterworth filter with cutoff frequency w0 * sampling_rate/2
"""
from scipy import signal
# use scipy.signal.firwin to generate filter
#taps = signal.firwin(numtaps, w0, pass_zero=False)
#y = signal.lfilter(taps, 1.0, x)
b,a = signal.butter(N, w0, 'high')
y = signal.filtfilt(b,a, x, padlen = x.shape[0]-1)
return y
def my_bpfilter(x, w0, w1, N=4,bf=True):
"""
create N-th order bandpass Butterworth filter with corner frequencies
w0*sampling_rate/2 and w1*sampling_rate/2
"""
#from scipy import signal
#taps = signal.firwin(numtaps, w0, pass_zero=False)
#y = signal.lfilter(taps, 1.0, x)
#return y
from scipy import signal
b,a = signal.butter(N, [w0, w1], 'bandpass')
if bf:
y = signal.filtfilt(b,a, x)
else:
y = signal.lfilter(b,a, x)
return y
def my_notchfilter(x, sr=1000, band=5, freq=60, ripple=10, order=3, filter_type='butter'):
from scipy.signal import iirfilter,lfilter
fs = sr
nyq = fs/2.0
low = freq - band/2.0
high = freq + band/2.0
low = low/nyq
high = high/nyq
b, a = iirfilter(order, [low, high], rp=ripple, btype='bandstop',
analog=False, ftype=filter_type)
filtered_data = lfilter(b, a, x)
return filtered_data
def downsample_vec(x, nbin):
"""
y = downsample_vec(x, nbin)
downsample the vector x by replacing nbin consecutive \
bin by their mean \
@RETURN: the downsampled vector
"""
n_down = int(np.floor(len(x) / nbin))
x = x[0:n_down*nbin]
x_down = np.zeros((n_down,))
# 0 1 2 | 3 4 5 | 6 7 8
for i in range(nbin) :
idx = list(range(i, int(n_down*nbin), int(nbin)))
x_down += x[idx]
return x_down / nbin
def smooth_data(x, sig):
"""
y = smooth_data(x, sig)
smooth data vector @x with gaussian kernel
with standard deviation $sig
"""
sig = float(sig)
if sig == 0.0:
return x
# gaussian:
gauss = lambda x, sig : (1/(sig*np.sqrt(2.*np.pi)))*np.exp(-(x*x)/(2.*sig*sig))
bound = 1.0/10000
L = 10.
p = gauss(L, sig)
while (p > bound):
L = L+10
p = gauss(L, sig)
#F = map(lambda x: gauss((x, sig)), np.arange(-L, L+1.))
# py3:
F = [gauss(x, sig) for x in np.arange(-L, L+1.)]
F = F / np.sum(F)
return scipy.signal.fftconvolve(x, F, 'same')
def power_spectrum(data, length, dt):
"""
scipy's implementation of Welch's method using hanning window to estimate
the power spectrum
The function returns power density with units V**2/Hz
see also https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.signal.welch.html
The label on the y-axis should say PSD [V**2/Hz]
@Parameters
data - time series; float vector!
length - length of hanning window, even integer!
@Return:
power density, frequencies
The function returns power density in units V^2 / Hz
Note that
np.var(data) ~ np.sum(power density) * (frequencies[1]-frequencies[0])
"""
f, pxx = scipy.signal.welch(data, fs=1.0/dt, window='hanning', nperseg=int(length), noverlap=int(length/2))
return pxx, f
def spectral_density(data, length, nfft, dt):
"""
calculate the spectrogram for the time series given by data with time resolution dt
The powerspectrum for each window of length $length is computed using
Welch's method.
The windows for the powerspectrum calculation are half-overlapping. If length contains 5s of data,
then the first windows goes from 0s to 5s, the second window from 2.5 to 7.5s, ...
The last window ends at ceil(len(data)/length)*5s
Another example, assume we have 13 s of data, with 5 s windows, the the powerdensity is calculated for the following
time windows:
0 -- 5, 2.5 -- 7.5, 5 -- 10, 7.5 -- 12.5, 10 -- 15
In total there are thus 2*ceil(13/5)-1 = 5 windows
The last window starts at 2*3-2 * (5/2) = 10 s
Note: the returned time axis starts at time point goes from 0 to 10s in 2.5s steps
@Parameters:
data - time series
length - window length of data used to calculate powerspectrum.
Note that the time resolution of the spectrogram is length/2
nfft - size of the window used to calculate the powerspectrum.
determines the frequency resolution.
@Return:
Powspectrum, frequencies, time axis
"""
n = len(data)
k = int(np.ceil((1.0*n)/length))
data = np.concatenate((data, np.zeros((length*k-n,))))
fdt = length*dt/2 # time step for spectrogram
t = np.arange(0, fdt*(2*k-2)+fdt/2.0, fdt)
# frequency axis of spectrogram
f = np.linspace(0, 1, int(np.ceil(nfft/2.0))+1) * (0.5/dt)
# the power spectrum is calculated for 2*k-1 time points
Pow = np.zeros((len(f), k*2-1))
j = 0
for i in range(0, k-2+1):
w1=data[(length*i):(i+1)*length]
w2=data[length*i+int(length/2):(i+1)*length+int(length/2)]
Pow[:,j] = power_spectrum(w1, nfft, dt)[0]
Pow[:,j+1] = power_spectrum(w2, nfft, dt)[0]
j += 2
# last time point
Pow[:,j],f = power_spectrum(data[length*(k-1):k*length], nfft, dt)
return Pow, f, t
def calculate_spectrum(ppath, name, fres=0.5):
"""
calculate EEG and EMG spectrogram used for sleep stage detection.
Function assumes that data vectors EEG.mat and EMG.mat exist in recording
folder ppath/name; these are used to calculate the powerspectrum
fres - resolution of frequency axis
all data saved in "true" mat files
:return EEG Spectrogram, EMG Spectrogram, frequency axis, time axis
"""
SR = get_snr(ppath, name)
swin = round(SR)*5
fft_win = round(swin/5) # approximate number of data points per second
if (fres == 1.0) or (fres == 1):
fft_win = int(fft_win)
elif fres == 0.5:
fft_win = 2*int(fft_win)
else:
print("Resolution %f not allowed; please use either 1 or 0.5" % fres)
(peeg2, pemg2) = (False, False)
# Calculate EEG spectrogram
EEG = np.squeeze(so.loadmat(os.path.join(ppath, name, 'EEG.mat'))['EEG'])
Pxx, f, t = spectral_density(EEG, int(swin), int(fft_win), 1/SR)
if os.path.isfile(os.path.join(ppath, name, 'EEG2.mat')):
peeg2 = True
EEG = np.squeeze(so.loadmat(os.path.join(ppath, name, 'EEG2.mat'))['EEG2'])
Pxx2, f, t = spectral_density(EEG, int(swin), int(fft_win), 1/SR)
#save the stuff to a .mat file
spfile = os.path.join(ppath, name, 'sp_' + name + '.mat')
if peeg2 == True:
so.savemat(spfile, {'SP':Pxx, 'SP2':Pxx2, 'freq':f, 'dt':t[1]-t[0],'t':t})
else:
so.savemat(spfile, {'SP':Pxx, 'freq':f, 'dt':t[1]-t[0],'t':t})
# Calculate EMG spectrogram
EMG = np.squeeze(so.loadmat(os.path.join(ppath, name, 'EMG.mat'))['EMG'])
Qxx, f, t = spectral_density(EMG, int(swin), int(fft_win), 1/SR)
if os.path.isfile(os.path.join(ppath, name, 'EMG2.mat')):
pemg2 = True
EMG = np.squeeze(so.loadmat(os.path.join(ppath, name, 'EMG2.mat'))['EMG2'])
Qxx2, f, t = spectral_density(EMG, int(swin), int(fft_win), 1/SR)
# save the stuff to .mat file
spfile = os.path.join(ppath, name, 'msp_' + name + '.mat')
if pemg2 == True:
so.savemat(spfile, {'mSP':Qxx, 'mSP2':Qxx2, 'freq':f, 'dt':t[1]-t[0],'t':t})
else:
so.savemat(spfile, {'mSP':Qxx, 'freq':f, 'dt':t[1]-t[0],'t':t})
return Pxx, Qxx, f, t
def whiten_spectrogram(ppath, name, fmax=50):
"""
experimental
:param ppath:
:param name:
:param fmax:
:return:
"""
P = so.loadmat(os.path.join(ppath, name, 'sp_' + name + '.mat'), squeeze_me=True)
SPE = P['SP']
freq = P['freq']
ifreq = np.where(freq <= fmax)[0]
SPE = SPE[ifreq,:]
nfilt = 5
filt = np.ones((nfilt, nfilt))
filt = np.divide(filt, filt.sum())
#SPE = scipy.signal.convolve2d(SPE, filt, boundary='symm', mode='same')
m = np.mean(SPE,axis=1)
SPE -= np.tile(m, (SPE.shape[1], 1)).T
SPE = SPE.T
C = np.dot(SPE.T, SPE)
[evals, L] = np.linalg.eigh(C)
idx = np.argsort(evals)
D = np.diag(np.sqrt(evals[idx]))
L = L[:,idx]
W = np.dot(L, np.dot(np.linalg.inv(D),np.dot(L.T,SPE.T)))
nfilt = 2
filt = np.ones((nfilt,nfilt))
filt = np.divide(filt, filt.sum())
W = scipy.signal.convolve2d(W, filt, boundary='symm', mode='same')
return W, D, L
def normalize_spectrogram(ppath, name, fmax=0, band=[], vm=5, pplot=True, sptype='', filt_dim=[]):
"""
Normalize EEG spectrogram by deviding each frequency band by its average value.
:param ppath, name: base folder, recording name
:param fmax: maximum frequency; frequency axis of spectrogram goes from 0 to fmax
if fmax=0, use complete frequency axis
:param band: list or tuple, define lower and upper range of a frequency band,
if pplot=True, plot band, along with spectrogram;
if band=[], disregard
:param vm: color range for plotting spectrogram
:pplot: if True, plot spectrogram along with power band
:sptype: if sptype='fine' plot 'special' spectrogram, save under sp_fine_$name.mat;
otherwise plot 'normal' spectrogram sp_$name.mat
:filt_dim: list or tuple; the two values define the dimensions of box filter
used to filter the normalized spectrogram; if filt_dim=[], then no filtering
:return SPE, t, freq: normalized spectrogram (np.array), time axis, frequency axis
"""
if (len(sptype) == 0) or (sptype=='std'):
P = so.loadmat(os.path.join(ppath, name, 'sp_' + name + '.mat'), squeeze_me=True)
elif sptype == 'fine':
P = so.loadmat(os.path.join(ppath, name, 'sp_fine_' + name + '.mat'), squeeze_me=True)
SPE = P['SP']
freq = P['freq']
t = P['t']
if fmax > 0:
ifreq = np.where(freq <= fmax)[0]
else:
ifreq = np.arange(0, len(freq))
freq = freq[ifreq]
nfilt = 4
filt = np.ones((nfilt,nfilt))
filt = np.divide(filt, filt.sum())
SPE = SPE[ifreq,:]
# before
#SPE = SPE[ifreq]
#W = scipy.signal.convolve2d(SPE, filt, boundary='symm', mode='same')
#sp_mean = W.mean(axis=1)
sp_mean = SPE.mean(axis=1)
SPE = np.divide(SPE, np.tile(sp_mean, (SPE.shape[1], 1)).T)
if len(filt_dim) > 0:
filt = np.ones(filt_dim)
filt = np.divide(filt, filt.sum())
SPE = scipy.signal.convolve2d(SPE, filt, boundary='symm', mode='same')
# get high gamma peaks
if len(band) > 0:
iband = np.where((freq >= band[0]) & (freq <= band[-1]))[0]
pow_band = SPE[iband,:].mean(axis=0)
thr = pow_band.mean() + pow_band.std()
idx = np.where(pow_band > thr)[0]
# plot normalized spectrogram, along with band
if pplot:
plt.ion()
plt.figure()
if len(band) > 0:
med = np.median(SPE.mean(axis=0))
ax1 = plt.subplot(211)
plt.pcolormesh(t, freq, SPE, vmin=0, vmax=vm*med, cmap='jet')
plt.subplot(212, sharex=ax1)
plt.plot(t,SPE[iband,:].mean(axis=0))
plt.plot(t[idx], pow_band[idx], '.')
plt.draw()
return SPE, t, freq[ifreq]
def recursive_spectrogram(ppath, name, sf=0.3, alpha=0.3, pplot=True):
"""
calculate EEG/EMG spectrogram in a way that can be implemented by a closed-loop system.
The spectrogram is temporally filtered using a recursive implementation of a lowpass filter
@Parameters:
ppath/name - mouse EEG recording
sf - smoothing factor along frequency axis
alpha - temporal lowpass filter time constant
pplot - if pplot==True, plot figure
@Return:
SE, SM - EEG, EMG spectrogram
"""
EEG = np.squeeze(so.loadmat(os.path.join(ppath, name, 'EEG.mat'))['EEG'])
EMG = np.squeeze(so.loadmat(os.path.join(ppath, name, 'EMG.mat'))['EMG'])
len_eeg = len(EEG)
fdt = 2.5
SR = get_snr(ppath, name)
# we calculate the powerspectrum for 5s windows
swin = int(np.round(SR) * 5.0)
# but we sample new data each 2.5 s
swinh = int(swin/2.0)
fft_win = int(swin / 5.0)
# number of 2.5s long samples
spoints = int(np.floor(len_eeg / swinh))
SE = np.zeros((int(fft_win/2+1), spoints))
SM = np.zeros((int(fft_win/2+1), spoints))
print("Starting calculating spectrogram for %s..." % name)
for i in range(2, spoints):
# we take the last two swinh windows (the new 2.5 s long sample and the one from
# the last iteration)
x = EEG[(i-2)*swinh:i*swinh]
[p, f] = power_spectrum(x.astype('float'), fft_win, 1.0/SR)
p = smooth_data(p, sf)
# recursive low pass filtering of spectrogram:
# the current state is an estimate of the current sample and the previous state
SE[:,i] = alpha*p + (1-alpha) * SE[:,i-1]
# and the same of EMG
x = EMG[(i-2)*swinh:i*swinh]
[p, f] = power_spectrum(x.astype('float'), fft_win, 1.0/SR)
p = smooth_data(p, sf)
SM[:,i] = alpha*p + (1-alpha) * SM[:,i-1]
if pplot:
# plot EEG spectrogram
t = np.arange(0, SM.shape[1])*fdt
plt.figure()
ax1 = plt.subplot(211)
im = np.where((f>=0) & (f<=30))[0]
med = np.median(SE.max(axis=0))
ax1.imshow(np.flipud(SE[im,:]), vmin=0, vmax=med*2)
plt.xticks(())
ix = list(range(0, 30, 10))
fi = f[im][::-1]
plt.yticks(ix, list(map(int, fi[ix])))
box_off(ax1)
plt.axis('tight')
plt.ylabel('Freq (Hz)')
# plot EMG amplitude
ax2 = plt.subplot(212)
im = np.where((f>=10) & (f<100))[0]
df = np.mean(np.diff(f))
# amplitude is the square root of the integral
ax2.plot(t, np.sqrt(SM[im,:].sum(axis=0)*df)/1000.0)
plt.xlim((0, t[-1]))
plt.ylabel('EMG Ampl (mV)')
plt.xlabel('Time (s)')
box_off(ax2)
plt.show(block=False)
return SE, SM, f
def recursive_sleepstate_rem(ppath, recordings, sf=0.3, alpha=0.3, past_mu=0.2, std_thdelta = 1.5, past_len=120, sdt=2.5, psave=False, xemg=False):
"""
predict a REM period only based on EEG/EMG history; the same algorithm is also used for
closed-loop REM sleep manipulation.
The algorithm uses for REM sleep detection a threshold on delta power, EMG power, and theta/delta power.
For theta/delta I use two thresholds: A hard (larger) threshold and a soft (lower) threshold. Initially,
theta/delta has to cross the hard threshold to initiate a REM period. Then, as long as,
theta/delta is above the soft threshold (and EMG power stays low) REM sleep continues.
@Parameters:
ppath base folder with recordings
recordings list of recordings
sf smoothing factor for each powerspectrum
alpha smoothing factor along time dimension
past_mu percentage (0 .. 1) of brain states that are allowed to have EMG power larger than threshold
during the last $past_len seconds
past_len window to calculate $past_mu
std_thdelta the hard theta/delta threshold is given by, mean(theta/delta) + $std_thdelta * std(theta/delta)
sdt time bin for brain sttate, typically 2.5s
psave if True, save threshold parameters to file.
"""
idf = re.split('_', recordings[0])[0]
# 02/05/2020 changed from int to float:
past_len = float(np.round(past_len/sdt))
# calculate spectrogram
(SE, SM) = ([],[])
for rec in recordings:
A,B, freq = recursive_spectrogram(ppath, rec, sf=sf, alpha=alpha)
SE.append(A)
SM.append(B)
# fuse lists SE and SM
SE = np.squeeze(reduce(lambda x,y: np.concatenate((x,y)), SE))
if not xemg:
SM = np.squeeze(reduce(lambda x,y: np.concatenate((x,y)), SM))
else:
SM = SE
# EEG, EMG bands
ntbins = SE.shape[1]
r_delta = [0.5, 4]
r_theta = [5,12]
# EMG band
r_mu = [300, 500]
i_delta = np.where((freq >= r_delta[0]) & (freq <= r_delta[1]))[0]
i_theta = np.where((freq >= r_theta[0]) & (freq <= r_theta[1]))[0]
i_mu = np.where((freq >= r_mu[0]) & (freq <= r_mu[1]))[0]
pow_delta = np.sum(SE[i_delta,:], axis=0)
pow_theta = np.sum(SE[i_theta,:], axis=0)
pow_mu = np.sum(SM[i_mu,:], axis=0)
# theta/delta
th_delta = np.divide(pow_theta, pow_delta)
thr_th_delta1 = np.nanmean(th_delta) + std_thdelta*np.nanstd(th_delta)
thr_th_delta2 = np.nanmean(th_delta) + 0.0*np.nanstd(th_delta)
thr_delta = pow_delta.mean()
thr_mu = pow_mu.mean() + 0.5*np.nanstd(pow_mu)
### The actual algorithm for REM detection
rem_idx = np.zeros((ntbins,))
prem = 0 # whether or not we are in REM
for i in range(ntbins):
if prem == 0 and pow_delta[i] < thr_delta and pow_mu[i] < thr_mu:
### could be REM
if th_delta[i] > thr_th_delta1:
### we are potentially entering REM
if (i - past_len) >= 0:
sstart = int(i-past_len)
else:
sstart = 0
# count the percentage of brainstate bins with elevated EMG power
c_mu = np.sum( np.where(pow_mu[sstart:i]>thr_mu)[0] ) / (past_len*1.0)
if c_mu < past_mu:
### we are in REM
prem = 1 # turn laser on
rem_idx[i] = 1
# We are currently in REM; do we stay there?
if prem == 1:
### REM continues, if theta/delta is larger than soft threshold and if there's
### no EMG activation
if (th_delta[i] > thr_th_delta2) and (pow_mu[i] < thr_mu):
rem_idx[i] = 1
else:
prem = 0 #turn laser off
# for loop ends
# Determine which channel is EEG, EMG
ch_alloc = get_infoparam(os.path.join(ppath, recordings[0], 'info.txt'), 'ch_alloc')[0]
# plot the whole stuff:
# (1) spectrogram
# (2) EMG Power
# (3) Delta
# (4) TH_Delta
plt.figure()
t = np.arange(0, sdt*(ntbins-1)+sdt/2.0, sdt)
ax1 = plt.subplot(411)
im = np.where((freq>=0) & (freq<=30))[0]
med = np.median(SE.max(axis=0))
ax1.imshow(np.flipud(SE[im,:]), vmin=0, vmax=med*2)
plt.yticks(list(range(0, 31, 10)), list(range(30, -1, -10)))
plt.ylabel('Freq. (Hz)')
plt.axis('tight')
ax2 = plt.subplot(412)
ax2.plot(t, pow_mu, color='black')
ax2.plot(t, np.ones((len(t),))*thr_mu, color='red')
plt.ylabel('EMG Pow.')
plt.xlim((t[0], t[-1]))
ax3 = plt.subplot(413, sharex=ax2)
ax3.plot(t, pow_delta, color='black')
ax3.plot(t, np.ones((len(t),))*thr_delta, color='red')
plt.ylabel('Delta Pow.')
plt.xlim((t[0], t[-1]))
ax4 = plt.subplot(414, sharex=ax3)
ax4.plot(t, th_delta, color='black')
ax4.plot(t, np.ones((len(t),))*thr_th_delta1, color='red')
ax4.plot(t, np.ones((len(t),))*thr_th_delta2, color='pink')
ax4.plot(t, rem_idx*thr_th_delta1, color='blue')
plt.ylabel('Theta/Delta')
plt.xlabel('Time (s)')
plt.xlim((t[0], t[-1]))
plt.show(block=False)
# write config file
if psave:
cfile = os.path.join(ppath, idf + '_rem.txt')
fid = open(cfile, 'w')
fid.write(('IDF: %s'+os.linesep) % idf)
fid.write(('ch_alloc: %s'+os.linesep) % ch_alloc)
fid.write(('THR_DELTA: %.2f'+os.linesep) % thr_delta)
fid.write(('THR_MU: %.2f'+os.linesep) % thr_mu)
fid.write(('THR_TH_DELTA: %.2f %.2f'+os.linesep) % (thr_th_delta1, thr_th_delta2))
fid.write(('STD_THDELTA: %.2f'+os.linesep) % std_thdelta)
fid.write(('PAST_MU: %.2f'+os.linesep) % past_mu)
fid.write(('SF: %.2f'+os.linesep) % sf)
fid.write(('ALPHA: %.2f'+os.linesep) % alpha)
fid.write(('Bern: %.2f' + os.linesep) % 0.5)
if xemg:
fid.write(('XEMG: %d'+os.linesep) % 1)
else:
fid.write(('XEMG: %d' + os.linesep) % 0)
fid.close()
print('wrote file %s' % cfile)
def recursive_sleepstate_rem_control(ppath, recordings, past_len=120, sdt=2.5, delay=120):
"""
algorithm running laser control for REM sleep dependent activation/inhibtion.
$delay s after a detected REM sleep period, the laser is turned on for the same duration. If a new REM period starts,
the laser stops, but we keep track of the missing time. The next time is laser turns on again,
it stays on for the duration of the most recent REM period + the remaining time.
The algorithm for REM detection is the same as used forclosed-loop REM sleep manipulation.
The function reads in the required parameters from the configuration file (MOUSEID_rem.txt)
The algorithm uses for REM sleep detection a threshold on delta power, EMG power, and theta/delta power.
For theta/delta I use two thresholds: A hard (larger) threshold and a soft (lower) threshold. Initially,
theta/delta has to cross the hard threshold to initiate a REM period. Then, as long as,
theta/delta is above the soft threshold (and EMG power stays low) REM sleep continues.
@Parameters:
ppath base folder with recordings
recordings list of recordings
past_len window to calculate $past_mu
sdt time bin for brain sttate, typically 2.5s
delay delay to wait after a REM sleep periods ends, till the laser is turned on.
"""
idf = re.split('_', recordings[0])[0]
past_len = int(np.round(past_len/sdt))
# load parameters
cfile = os.path.join(ppath, idf + '_rem.txt')
params = load_sleep_params(ppath, cfile)
thr_th_delta1 = params['THR_TH_DELTA'][0]
thr_th_delta2 = params['THR_TH_DELTA'][1]
thr_delta = params['THR_DELTA'][0]
thr_mu = params['THR_MU'][0]
alpha = params['ALPHA'][0]
sf = params['SF'][0]
past_mu = params['PAST_MU'][0]
xemg = params['XEMG'][0]
# calculate spectrogram
(SE, SM) = ([], [])
for rec in recordings:
A, B, freq = recursive_spectrogram(ppath, rec, sf=sf, alpha=alpha)
SE.append(A)
SM.append(B)
# fuse lists SE and SM
SE = np.squeeze(reduce(lambda x, y: np.concatenate((x, y)), SE))
if not xemg:
SM = np.squeeze(reduce(lambda x, y: np.concatenate((x, y)), SM))
else:
SM = SE
# EEG, EMG bands
ntbins = SE.shape[1]
r_delta = [0.5, 4]
r_theta = [5, 12]
# EMG band
r_mu = [300, 500]
i_delta = np.where((freq >= r_delta[0]) & (freq <= r_delta[1]))[0]
i_theta = np.where((freq >= r_theta[0]) & (freq <= r_theta[1]))[0]
i_mu = np.where((freq >= r_mu[0]) & (freq <= r_mu[1]))[0]
pow_delta = np.sum(SE[i_delta, :], axis=0)
pow_theta = np.sum(SE[i_theta, :], axis=0)
pow_mu = np.sum(SM[i_mu, :], axis=0)
th_delta = np.divide(pow_theta, pow_delta)
### The actual algorithm for REM detection
rem_idx = np.zeros((ntbins,))
prem = 0 # whether or not we are in REM
# NEW variables:
laser_idx = np.zeros((ntbins,))
delay = int(np.round(delay/sdt))
delay_count = 0
curr_rem_dur = 0
dur_count = 0
on_delay = False
laser_on = False
for i in range(ntbins):
if prem == 0 and pow_delta[i] < thr_delta and pow_mu[i] < thr_mu:
### could be REM
if th_delta[i] > thr_th_delta1:
### we are potentially entering REM
if (i - past_len) >= 0:
sstart = i - past_len
else:
sstart = 0
# count the percentage of brainstate bins with elevated EMG power
c_mu = np.sum(np.where(pow_mu[sstart:i] > thr_mu)[0]) / past_len
if c_mu < past_mu:
### we are in REM
prem = 1 # turn laser on
rem_idx[i] = 1
curr_rem_dur += 1 #NEW
# We are currently in REM; do we stay there?
if prem == 1:
### REM continues, if theta/delta is larger than soft threshold and if there's
### no EMG activation
if (th_delta[i] > thr_th_delta2) and (pow_mu[i] < thr_mu):
rem_idx[i] = 1
curr_rem_dur += 1
else:
prem = 0 # turn laser off
dur_count += curr_rem_dur #NEW
delay_count = delay #NEW
curr_rem_dur = 0 #NEW
on_delay = True #NEW
# NEW:
if on_delay:
if prem == 0:
delay_count -=1
if delay_count == 0:
laser_on = True
on_delay = False
if laser_on:
if prem == 0:
if dur_count >= 0:
dur_count -= 1
laser_idx[i] = 1
else:
laser_on = False
else:
laser_on = False
# plot the whole stuff:
# (1) spectrogram
# (2) EMG Power
# (3) Delta
# (4) TH_Delta
plt.figure()
t = np.arange(0, sdt*(ntbins-1)+sdt/2.0, sdt)
ax1 = plt.subplot(411)
im = np.where((freq>=0) & (freq<=30))[0]
med = np.median(SE.max(axis=0))
ax1.imshow(np.flipud(SE[im,:]), vmin=0, vmax=med*2)
plt.yticks(list(range(0, 31, 10)), list(range(30, -1, -10)))
plt.ylabel('Freq. (Hz)')
plt.axis('tight')
ax2 = plt.subplot(412)
ax2.plot(t, pow_mu, color='black')
ax2.plot(t, np.ones((len(t),))*thr_mu, color='red')
plt.ylabel('EMG Pow.')
plt.xlim((t[0], t[-1]))
ax3 = plt.subplot(413, sharex=ax2)
ax3.plot(t, pow_delta, color='black')
ax3.plot(t, np.ones((len(t),))*thr_delta, color='red')
plt.ylabel('Delta Pow.')
plt.xlim((t[0], t[-1]))
ax4 = plt.subplot(414, sharex=ax3)
ax4.plot(t, th_delta, color='black')
ax4.plot(t, np.ones((len(t),))*thr_th_delta1, color='red')
ax4.plot(t, np.ones((len(t),))*thr_th_delta2, color='pink')
ax4.plot(t, rem_idx*thr_th_delta1, color='green', label='REM')
ax4.plot(t, laser_idx * thr_th_delta1, color='blue', label='Laser')
plt.ylabel('Theta/Delta')
plt.xlabel('Time (s)')
plt.xlim((t[0], t[-1]))
plt.legend()
plt.show(block=False)
def load_sleep_params(path, param_file):
"""
load parameter file generated by &recursive_sleepstate_rem || &recursive_sleepstate_nrem
@Return:
Dictionary: Parameter --> Value
"""
fid = open(os.path.join(path, param_file), 'r')
lines = fid.readlines()
params = {}
for line in lines:
if re.match('^[\S_]+:', line):
a = re.split('\s+', line)
key = a[0][:-1]
params[key] = a[1:-1]
# transform number strings to floats
for k in params:
vals = params[k]
new_vals = []
for v in vals:
if re.match('^[\d\.]+$', v):
new_vals.append(float(v))
else:
new_vals.append(v)
params[k] = new_vals
return params
def recursive_sleepstate_nrem(ppath, recordings, sf=0.3, alpha=0.3, std_thdelta = 1.5, sdt=2.5, psave=False, xemg=False):
"""
predict NREMs period only based on EEG/EMG history; the same algorithm is also used for
closed-loop NREM sleep manipulation.
The algorithm uses for NREM sleep detection thresholds for delta power, EMG power, and theta/delta power.
For delta I use two thresholds: A hard (larger) threshold and a soft (lower) threshold. Initially,
theta/delta has to cross the hard threshold to initiate a NREM period. Then, as long as,
theta/delta is above the soft threshold (and EMG power stays low) REM sleep continues.
The values for hard and soft threshold are fitted using a Gaussian mixture model
:param ppath: base folder
:param recordings: list of recordings
:param sf: smoothing factor for each powerspectrum
:param alpha: spatial smoothing factor
:param std_thdelta: factor to set threshold for theta/delta
:param sdt: time step of brain state classification, typically 2.5 s
:param psave: save parameters to text file?
:param xemg: use EEG instead of EMG?
"""
# to fit Gaussian mixture model to delta power distributino
from sklearn import mixture
idf = re.split('_', recordings[0])[0]
# calculate spectrogram
(SE, SM) = ([],[])
for rec in recordings:
A,B, freq = recursive_spectrogram(ppath, rec, sf=sf, alpha=alpha)
SE.append(A)
SM.append(B)
# fuse lists SE and SM
SE = np.squeeze(reduce(lambda x,y: np.concatenate((x,y)), SE))
if not xemg:
SM = np.squeeze(reduce(lambda x,y: np.concatenate((x,y)), SM))
else:
SM = SE
# EEG, EMG bands
ntbins = SE.shape[1]
r_delta = [0.5, 4]
r_theta = [5,12]
# EMG band
r_mu = [300, 500]
i_delta = np.where((freq >= r_delta[0]) & (freq <= r_delta[1]))[0]
i_theta = np.where((freq >= r_theta[0]) & (freq <= r_theta[1]))[0]
i_mu = np.where((freq >= r_mu[0]) & (freq <= r_mu[1]))[0]
pow_delta = np.sum(SE[i_delta,:], axis=0)
pow_theta = np.sum(SE[i_theta,:], axis=0)
pow_mu = np.sum(SM[i_mu,:], axis=0)
# theta/delta
th_delta = np.divide(pow_theta, pow_delta)
thr_th_delta1 = np.nanmean(th_delta) + std_thdelta*np.nanstd(th_delta)
thr_th_delta2 = np.nanmean(th_delta) + 0.0*np.nanstd(th_delta)
thr_mu = pow_mu.mean() + 0.5*np.nanstd(pow_mu)
med_delta = np.median(pow_delta)
pow_delta_fit = pow_delta[np.where(pow_delta<=3*med_delta)]
# fit Gaussian mixture model to delta power
# see http://www.astroml.org/book_figures/chapter4/fig_GMM_1D.html
gm = mixture.GaussianMixture(n_components=2)
fit = gm.fit(pow_delta_fit.reshape(-1, 1))
means = np.squeeze(fit.means_)
x = np.arange(0, med_delta*3, 100)
plt.figure()
plt.hist(pow_delta_fit, 100, normed=True, histtype='stepfilled', alpha=0.4)
logprob = fit.score_samples(x.reshape(-1,1))
responsibilities = fit.predict_proba(x.reshape((-1,1)))
pdf = np.exp(logprob)
pdf_individual = responsibilities * pdf[:, np.newaxis]
plt.plot(x, pdf, '-k')
plt.plot(x, pdf_individual, '--k')
plt.xlim((0, med_delta*3))
plt.ylabel('p(x)')
plt.xlabel('x = Delta power')
# get point where curves cut each other
if means[0] < means[1]:
idx = np.where((x>= means[0]) & (x<= means[1]))[0]
else:
idx = np.where((x >= means[1]) & (x <= means[0]))[0]
imin = np.argmin(pdf[idx])
xcut = x[idx[0]+imin]
plt.plot(xcut, pdf[idx[0]+imin], 'ro')
ilow = np.argmin(np.abs(x-means[0]))
plt.plot(x[ilow], pdf[ilow], 'bo')
ihigh = np.argmin(np.abs(x-means[1]))
plt.plot(x[ihigh], pdf[ihigh], 'go')
plt.show(block=False)
# set parameters for hard and soft delta thresholds
tmp = np.array([x[ihigh], xcut, x[ilow]])
tmp.sort()
thr_delta1 = tmp[-1] # x[ihigh]; right peak of distribution
thr_delta2 = tmp[1] # trough of distribution
# NREM yes or no according to thresholds
# However, this variable does not directly control whether laser should
# be on or off; whether NREM sleep is really on or off is determined
# by nrem_idx; if pnrem_hidden == 1, then all threshold critera, but not
# sleep history criteria are fulfilled
pnrem_hidden = 0
# if nrem_idx[i] == 1, time point i is NREM
nrem_idx = np.zeros((ntbins,), dtype='int8')
# NREM stays on after thresholds are NOT fulfilled to avoid interruptions by microarousals
grace_period = int(20 / sdt)
# nrem_delay: NREM only starts with some delay
nrem_delay = int(10 / sdt)
grace_count = grace_period
delay_count = nrem_delay
for i in range(ntbins):
if pnrem_hidden == 0:
### Entering NREM:
# Delta power laser than high threshold
if pow_delta[i] > thr_delta1 and pow_mu[i] < thr_mu and th_delta[i] < thr_th_delta1:
### NOT-NREM -> NREM
pnrem_hidden = 1
nrem_idx[i] = 0
delay_count -= 1
# we are fully in NREM, that's why grace_count is reset:
grace_count = grace_period
else:
### NOT-NREM -> NOT-NREM
if grace_count > 0:
grace_count -= 1
nrem_idx[i] = 1
else:
nrem_idx[i] = 0
else:
### pnrem_hidden == 1
if pow_delta[i] > thr_delta2 and pow_mu[i] < thr_mu and th_delta[i] < thr_th_delta1:
if delay_count > 0:
delay_count -= 1
nrem_idx[i] = 0
else :
nrem_idx[i] = 1
else:
### Exit NREM -> NOT-NREM
# were are fully out of NREM, so delay_count can be reset:
delay_count = nrem_delay
pnrem_hidden = 0
if grace_count > 0:
grace_count -= 1
nrem_idx[i] = 1
#### figure ##############################################
plt.figure()
t = np.arange(0, sdt * (ntbins - 1) + sdt / 2.0, sdt)
ax1 = plt.subplot(411)
im = np.where((freq >= 0) & (freq <= 30))[0]
med = np.median(SE.max(axis=0))
ax1.imshow(np.flipud(SE[im, :]), vmin=0, vmax=med * 2, cmap='jet')
ax1.pcolorfast(t, freq[im], np.flipud(SE[im, :]), vmin=0, vmax=med * 2, cmap='jet')
plt.yticks(list(range(0, 31, 10)), list(range(30, -1, -10)))
plt.ylabel('Freq. (Hz)')
plt.axis('tight')
ax2 = plt.subplot(412, sharex=ax1)
ax2.plot(t, pow_mu, color='black')
ax2.plot(t, np.ones((len(t),)) * thr_mu, color='red')
plt.ylabel('EMG Pow.')
plt.xlim((t[0], t[-1]))
ax3 = plt.subplot(413, sharex=ax2)
ax3.plot(t, pow_delta, color='black')
ax3.plot(t, np.ones((len(t),)) * thr_delta1, color='red')
ax3.plot(t, np.ones((len(t),)) * thr_delta2, color=[1, 0.6, 0.6])
ax3.plot(t, nrem_idx * thr_delta1, color=[0.6, 0.6, 0.6])
plt.ylabel('Delta Pow.')
plt.xlim((t[0], t[-1]))
ax4 = plt.subplot(414, sharex=ax3)
ax4.plot(t, th_delta, color='black')
ax4.plot(t, np.ones((len(t),)) * thr_th_delta1, color='red')
plt.ylabel('Theta/Delta')
plt.xlabel('Time (s)')
plt.xlim((t[0], t[-1]))
plt.show(block=False)
# Determine which channel is EEG, EMG
ch_alloc = get_infoparam(os.path.join(ppath, recordings[0], 'info.txt'), 'ch_alloc')[0]
# write config file
if psave:
cfile = os.path.join(ppath, idf + '_nrem.txt')
fid = open(cfile, 'w')
fid.write(('IDF: %s' + os.linesep) % idf)
fid.write(('ch_alloc: %s' + os.linesep) % ch_alloc)
fid.write(('THR_DELTA: %.2f %.2f' + os.linesep) % (thr_delta1, thr_delta2))
fid.write(('THR_MU: %.2f' + os.linesep) % thr_mu)
fid.write(('THR_TH_DELTA: %.2f %.2f' + os.linesep) % (thr_th_delta1, thr_th_delta2))
fid.write(('STD_THDELTA: %.2f' + os.linesep) % std_thdelta)
fid.write(('SF: %.2f' + os.linesep) % sf)
fid.write(('ALPHA: %.2f' + os.linesep) % alpha)
if xemg:
fid.write(('XEMG: %d' + os.linesep) % 1)
else:
fid.write(('XEMG: %d' + os.linesep) % 0)
fid.close()
print('wrote file %s' % cfile)
def rem_online_analysis(ppath, recordings, backup='', single_mode=False, fig_file='', overlap=0):
"""
analyze results from closed-loop experiments
:param ppath: base folder
:param recordings: list of strings, recordinds
:param backup: string, potential second backup folder with recordings
:param single_mode: boolean, if True, average across all REM periods (irrespective of mouse)
and plot each single REM period as dot
:param overlap: float between 0 and 100; specifices percentage by which the online detected REM period has to
overlap with real (annotated) REM period to be further consided for analysis;
if overlap == 0, then any overlap counts, i.e. this parameter has no influence
:return: df, pd.DataFrame, with control and experimental REM durations as data columns
"""
if type(recordings) != list:
recordings = [recordings]
overlap = overlap / 100.0
paths = dict()
for rec in recordings:
if os.path.isdir(os.path.join(ppath, rec)):
paths[rec] = ppath
else:
paths[rec] = backup
mice = dict()
for rec in recordings:
idf = re.split('_', rec)[0]
if not idf in mice:
mice[idf] = 1
mice = list(mice.keys())
if len(mice) == 1:
single_mode=True
dur_exp = {m:[] for m in mice}
dur_ctr = {m:[] for m in mice}
for rec in recordings:
idf = re.split('_', rec)[0]
M,S = load_stateidx(paths[rec], rec)
sr = get_snr(paths[rec], rec)
nbin = int(np.round(sr)*2.5)
dt = (1.0/sr)*nbin
laser = load_laser(paths[rec], rec)
rem_trig = so.loadmat(os.path.join(paths[rec], rec, 'rem_trig_%s.mat'%rec), squeeze_me=True)['rem_trig']
laser = downsample_vec(laser, nbin)
laser[np.where(laser>0)] = 1
rem_trig = downsample_vec(rem_trig, nbin)
rem_trig[np.where(rem_trig>0)] = 1
laser_idx = np.where(laser==1)[0]
rem_idx = np.where(rem_trig==1)[0]
# REM sequences from offline analysis (assumed to be the
# "ground truth"
seq = get_sequences(np.where(M==1)[0])
for s in seq:
# check true REM sequences overlapping with online detected sequences
isect = np.intersect1d(s, rem_idx)
#print(len(isect)/ len(s))
# test if real REM period s overlaps with online detected REM periods and,
# if yes, make sure that the overlap is at least overlap *100 percent
if len(np.intersect1d(s, rem_idx)) > 0 and float(len(isect)) / len(s) >= overlap:
drn = (s[-1]-s[0]+1)*dt
# does the sequence overlap with laser?
if len(np.intersect1d(isect, laser_idx))>0:
dur_exp[idf].append(drn)
else:
dur_ctr[idf].append(drn)
data = {'exp':[], 'ctr':[]}
# if single_mode put all REM periods together,
# otherwise average across REM periods for each mouse
if len(mice) == 1 or single_mode==True:
for m in mice:
data['exp'] += dur_exp[m]
data['ctr'] += dur_ctr[m]
else:
for idf in dur_ctr:
dur_ctr[idf] = np.array(dur_ctr[idf]).mean()
dur_exp[idf] = np.array(dur_exp[idf]).mean()
data['exp'] = np.array(list(dur_exp.values()))
data['ctr'] = np.array(list(dur_ctr.values()))
df = pd.DataFrame({'ctr':pd.Series(data['ctr']), 'exp' : pd.Series(data['exp'])})
# plot everything
if not single_mode:
plt.ion()
plt.figure()
ax = plt.axes([0.2, 0.15, 0.3, 0.7])
df_mean = df.mean()
plt.bar([1], [df_mean['ctr']], color='grey', label='W/o Laser')
plt.bar([2], [df_mean['exp']], color='blue', label='With laser')
plt.xticks([1,2])
box_off(ax)
#ax.set_xticklabels(['ctr', 'exp'], rotation=30)
plt.ylabel('REM duration (s)')
for (a,b) in zip(df['ctr'], df['exp']):
plt.plot([1,2], [a,b], color='black')
plt.legend(bbox_to_anchor=(0., 1.0, 1., .102), loc=3, mode='expand', ncol=1, frameon=False)
else:
plt.figure()
ax = plt.axes([0.2, 0.15, 0.3, 0.7])
df_mean = df.mean()
plt.bar([1], [df_mean['ctr']], color='grey')
plt.bar([2], [df_mean['exp']], color='blue')
plt.xticks([1,2])
box_off(ax)
#ax.set_xticklabels(['ctr', 'exp'], rotation=30)
plt.ylabel('REM duration (s)')
a = df['ctr']
b = df['exp']
plt.plot(np.ones((len(a),)), a, '.', color='black', label='W/o Laser')
plt.plot(2*np.ones((len(b),)), b, '.', color='black', label='With laser')
plt.legend(bbox_to_anchor=(0., 1.0, 1., .102), loc=3, mode='expand', ncol=1, frameon=False)
plt.show()
if len(fig_file) > 0:
save_figure(fig_file)
return df
def online_homeostasis(ppath, recordings, backup='', mode=0, single_mode=False, pplot=True, overlap=0, ma_thr=0):
"""
Further analysis of data obtained from closed loop stimulation
Assume the sleep structure looks like this
R R R R W W N N N N N W W N N N N R R R R R
REM_pre -- inter REM ---- REM_post
REM_pre is the duration of the first REM period, inter-REM is everything between REM_pre and the
next REM period REM_post.
The function calculates the inter REM duration after REM periods with laser and after REM periods w/o laser
:param ppath: base folder
:param recordings: list of recording, or file listing
:param backup: backup folder for $ppath
:param mode: mode == 0, calculate complete inter REM duration
mode == 2, only calculate duration of wake in inter REM periods
mode == 3, only calculate duration of NREM in inter REM periods
:param single_mode: consider each single recording, instead of mice
:param overlap: percentage (number between 0 and 100). Defines the percentage
how much a true (offline annotated) REM period should overlap with laser
to be considered as REM sleep with laser.
Of note, REM periods w/o laser have to have 0 overlap with laser.
All remaining REM periods are discarded.
:param pplot: if True, plot figure; errorbars show 95% confidence intervals,
calculated using bootstrapping
:param ma:
:return: df, if single_mode == True $df is a pandas DataFrame:
REM iREM laser
mouse - mouse ID
REM - REM duration
iREM - inter REM duration after REM periods with laser
laser - 'y' or 'n'; depending on whether laser was on during REM sleep period (for "REM") or during the
preceding REM sleep period (for "iREM")
if single_mode == False, mouse is the data frame index
"""
if type(recordings) != list:
recordings = [recordings]
if overlap > 0:
overlap = overlap / 100
paths = dict()
for rec in recordings:
if os.path.isdir(os.path.join(ppath, rec)):
paths[rec] = ppath
else:
paths[rec] = backup
mice = dict()
for rec in recordings:
idf = re.split('_', rec)[0]
if not idf in mice:
mice[idf] = 1
mice = list(mice.keys())
if len(mice) == 1:
single_mode=True
remdur_exp = {m:[] for m in mice}
remdur_ctr = {m:[] for m in mice}
itdur_exp = {m:[] for m in mice}
itdur_ctr = {m:[] for m in mice}
for rec in recordings:
idf = re.split('_', rec)[0]
M = load_stateidx(paths[rec], rec)[0]
sr = get_snr(paths[rec], rec)
nbin = int(np.round(sr)*2.5)
dt = (1.0/sr)*nbin
if ma_thr>0:
seq = get_sequences(np.where(M==2)[0])
for s in seq:
if len(s)*dt <= ma_thr:
M[s] = 3
laser = load_laser(paths[rec], rec)
rem_trig = so.loadmat(os.path.join(paths[rec], rec, 'rem_trig_%s.mat' % rec), squeeze_me=True)['rem_trig']
laser = downsample_vec(laser, nbin)
laser[np.where(laser>0)] = 1
rem_trig = downsample_vec(rem_trig, nbin)
rem_trig[np.where(rem_trig>0)] = 1
laser_idx = np.where(laser==1)[0]
rem_idx = np.where(rem_trig==1)[0]
# REM sequences from offline analysis (assumed to be the
# "ground truth"
seq = get_sequences(np.where(M==1)[0])
for (p,q) in zip(seq[0:-1], seq[1:]):
# check if true REM sequences do overlap with online detected sequences
# and only continue working with those:
if len(np.intersect1d(p, rem_idx)) > 0:
drn = (p[-1]-p[0]+1)*dt
it_M = M[p[-1]+1:q[0]]
if mode == 0:
it_drn = len(it_M)*dt
elif mode == 2:
it_drn = len(np.where(it_M==2)[0]) * dt
else:
it_drn = len(np.where(it_M == 3)[0]) * dt
# does the true REM sequence overlap with laser?
# by setting overlap to a value > 0, you can
# set a percentage how much the REM period should overlap with laser
# NEW 08/26/21
if len(np.intersect1d(p, laser_idx)) / len(p) > overlap:
remdur_exp[idf].append(drn)
itdur_exp[idf].append(it_drn)
elif len(np.intersect1d(p, laser_idx)) == 0:
remdur_ctr[idf].append(drn)
itdur_ctr[idf].append(it_drn)
else:
pass
# if single_mode put all REM periods together,
# otherwise average across REM periods for each mouse
if len(mice) == 1 or single_mode==True:
data = {'itexp':[], 'itctr':[], 'remexp':[], 'remctr':[]}
for m in mice:
data['itexp'] += itdur_exp[m]
data['itctr'] += itdur_ctr[m]
data['remexp'] += remdur_exp[m]
data['remctr'] += remdur_ctr[m]
df = pd.DataFrame({'REM': data['remexp']+data['remctr'], 'iREM':data['itexp']+data['itctr'], 'laser': ['y']*len(data['remexp']) + ['n']*len(data['remctr'])})
else:
for idf in mice:
itdur_ctr[idf] = np.array(itdur_ctr[idf]).mean()
itdur_exp[idf] = np.array(itdur_exp[idf]).mean()
remdur_ctr[idf] = np.array(remdur_ctr[idf]).mean()
remdur_exp[idf] = np.array(remdur_exp[idf]).mean()
data = {}
for s in ['itexp', 'itctr', 'remexp', 'remctr']:
data[s] = np.zeros((len(mice),))
i = 0
for m in mice:
data['itexp'][i] = itdur_exp[m]
data['itctr'][i] = itdur_ctr[m]
data['remexp'][i] = remdur_exp[m]
data['remctr'][i] = remdur_ctr[m]
i += 1
df = pd.DataFrame({'REM': np.concatenate((data['remexp'], data['remctr'])),
'iREM': np.concatenate((data['itexp'], data['itctr'])),
'laser': ['y']*len(mice) + ['n']*len(mice),
'mouse': mice+mice})
if pplot and not single_mode:
dfm = pd.melt(df, id_vars=['laser', 'mouse'], var_name='state')
sns.set_style('whitegrid')
plt.ion()
plt.figure()
sns.barplot(data=dfm, hue='laser', x='state', y='value', palette=['blue', 'gray'])
sns.swarmplot(data=dfm, hue='laser', x='state', y='value', dodge=True, color='black')
sns.despine()
plt.ylabel('Duration (s)')
if pplot and single_mode:
dfm = pd.melt(df, id_vars=['laser'], var_name='state')
plt.ion()
plt.figure()
sns.set(style="whitegrid")
#sns.swarmplot(data=df[['itctr', 'itexp']], color='black')
#sns.barplot(data=df[['itctr', 'itexp']], palette=['gray', 'blue'], errcolor='black')
sns.barplot(data=dfm, hue='laser', x='state', y='value', palette=['blue', 'gray'])
sns.swarmplot(data=dfm, hue='laser', x='state', y='value', dodge=True, color='black')
sns.despine()
plt.ylabel('Duration (s)')
return df
### FUNCTIONS USED BY SLEEP_STATE #####################################################
def get_sequences(idx, ibreak=1) :
"""
get_sequences(idx, ibreak=1)
idx - np.vector of indices
@RETURN:
seq - list of np.vectors
"""
diff = idx[1:] - idx[0:-1]
breaks = np.nonzero(diff>ibreak)[0]
breaks = np.append(breaks, len(idx)-1)
seq = []
iold = 0
for i in breaks:
r = list(range(iold, i+1))
seq.append(idx[r])
iold = i+1
return seq
def threshold_crossing(data, th, ilen, ibreak, m):
"""
seq = threshold_crossing(data, th, ilen, ibreak, m)
"""
if m>=0:
idx = np.where(data>=th)[0]
else:
idx = np.where(data<=th)[0]
# gather sequences
j = 0
seq = []
while (j <= len(idx)-1):
s = [idx[j]]
for k in range(j+1,len(idx)):
if (idx[k] - idx[k-1]-1) <= ibreak:
# add j to sequence
s.append(idx[k])
else:
break
if (s[-1] - s[0]+1) >= ilen and not(s[0] in [i[1] for i in seq]):
seq.append((s[0], s[-1]))
if j == len(idx)-1:
break
j=k
return seq
def closest_precessor(seq, i):
"""
find the preceding element in seq which is closest to i
helper function for sleep_state
"""
tmp = seq-i;
d = np.where(tmp<0)[0]
if len(d)>0:
id = seq[d[-1]];
else:
id = 0;
return id
def write_remidx(M, K, ppath, name, mode=1) :
"""
rewrite_remidx(idx, states, ppath, name)
replace the indices idx in the remidx file of recording name
with the assignment given in states
"""
if mode == 0 :
outfile = os.path.join(ppath, name, 'remidx_' + name + '.txt')
else :
outfile = os.path.join(ppath, name, 'remidx_' + name + '_corr.txt')
f = open(outfile, 'w')
s = ["%d\t%d\n" % (i,j) for (i,j) in zip(M[0,:],K)]
f.writelines(s)
f.close()
#######################################################################################
### MANIPULATING FIGURES ##############################################################
def set_fontsize(fs):
import matplotlib
matplotlib.rcParams.update({'font.size': fs})
def set_fontarial():
"""
set Arial as default font
"""
import matplotlib
matplotlib.rcParams['font.sans-serif'] = "Arial"
def save_figure(fig_file):
# alternative way of setting nice fonts:
#matplotlib.rcParams['pdf.fonttype'] = 42
#matplotlib.rcParams['ps.fonttype'] = 42
#matplotlib.pylab.savefig(fig_file, dpi=300)
#matplotlib.rcParams['text.usetex'] = False
#matplotlib.rcParams['text.usetex'] = True
plt.savefig(fig_file, bbox_inches="tight", dpi=200)
#matplotlib.rcParams['text.usetex'] = False
def box_off(ax):
"""
similar to Matlab's box off
"""
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
#######################################################################################
def sleep_state(ppath, name, th_delta_std=1, mu_std=0, sf=1, sf_delta=3, pwrite=0,
pplot=True, pemg=True, vmax=2.5, pspec_norm=False, use_idx=[]):
"""
automatic sleep state detection based on
delta, theta, sigma, gamma and EMG power.
New: use also sigma band: that's very helpful to classify pre-REM periods
as NREM; otherwise they tend to be classified as wake.
Gamma peaks nicely pick up during microarousals.
My strategy is the following:
I smooth delta band a lot to avoid strong fragmentation of sleep; but to
still pick up microarousals I use the gamma power.
spectrogram data has to be calculated before using calculate_spectrum
Each bin in the spectrogram gets assigned one of four states:
1-REM
2-Wake
3-NREM
0-undef
:param ppath: base folder
:param name: recording name
:param th_delta_std: threshold for theta/delta band is calculated as mean(theta/delta) + th_delta_std*std(theta/delta)
:param mu_std: threshold for EMG power is calculate as "mean(EMG) + mu_std * mean(EMG)
:param sf: smoothing factor for gamma and sigma power
:param sf_delta: smoothing factor for delta power
:param pwrite: if True, save sleep classification to file remidx_$name.txt
:param pplot: if True, plot figures
:param pemg: if True, use EMG as EMG, otherwise use EEG gamma power instead
:param vmax: float, set maximum of color range of EEG heatmap.
:param pspec_norm: boolean, if True, normalized EEG spectrogram by deviding each frequency band by its mean; only affects
plotting, no effect on sleep state calculation
:param use_idx: list, if not empty, use only given indices to calculate sleep state
:return:
"""
PRE_WAKE_REM = 30.0
# Minimum Duration and Break in
# high theta/delta, high emg, high delta, high sigma and gamma sequences
#
# duration[i,0] is the minimum duration of sequence of state i
# duration[i,1] is maximal break duration allowed in a sequence of state i
duration = np.zeros((5,2))
# high theta/delta
duration[0,:] = [5,15]
# high emg
duration[1,:] = [0, 5]
# high delta
duration[2,:] = [10, 10]
# high sigma
duration[3,:] = [10, 10]
# gamma
duration[4,:] = [0, 5]
# Frequency Bands/Ranges for delta, theta, and, gamma
r_delta = [0.5, 4]
r_sigma = [12, 20]
r_theta = [5,12]
# EMG band
r_mu = [50, 500]
if not pemg:
r_mu = [250, 500]
# high gamma power
r_gamma = [100, 150]
#load EEG and EMG spectrum, calculated by calculate_spectrum
P = so.loadmat(os.path.join(ppath, name, 'sp_' + name + '.mat'))
if pemg:
Q = so.loadmat(os.path.join(ppath, name, 'msp_' + name + '.mat'))
else:
Q = so.loadmat(os.path.join(ppath, name, 'sp_' + name + '.mat'))
SPEEG = np.squeeze(P['SP'])
if pemg == 1:
SPEMG = np.squeeze(Q['mSP'])
else:
SPEMG = np.squeeze(P['SP'])
if use_idx == []:
use_idx = range(0, SPEEG.shape[1])
freq = np.squeeze(P['freq'])
t = np.squeeze(P['t'])
dt = float(np.squeeze(P['dt']))
N = len(t)
duration = np.divide(duration,dt)
# get indices for frequency bands
i_delta = np.where((freq >= r_delta[0]) & (freq <= r_delta[1]))[0]
i_theta = np.where((freq >= r_theta[0]) & (freq <= r_theta[1]))[0]
i_mu = np.where((freq >= r_mu[0]) & (freq <= r_mu[1]))[0]
i_sigma = np.where((freq >= r_sigma[0]) & (freq <= r_sigma[1]))[0]
i_gamma = np.where((freq >= r_gamma[0]) & (freq <= r_gamma[1]))[0]
p_delta = smooth_data( SPEEG[i_delta,:].mean(axis=0), sf_delta )
p_theta = smooth_data( SPEEG[i_theta,:].mean(axis=0), 0 )
# now filtering for EMG to pick up microarousals
p_mu = smooth_data( SPEMG[i_mu,:].mean(axis=0), sf )
p_sigma = smooth_data( SPEEG[i_sigma,:].mean(axis=0), sf )
p_gamma = smooth_data( SPEEG[i_gamma,:].mean(axis=0), 0 )
th_delta = np.divide(p_theta, p_delta)
#th_delta = smooth_data(th_delta, 2);
seq = {}
seq['high_theta'] = threshold_crossing(th_delta, np.nanmean(th_delta[use_idx])+th_delta_std*np.nanstd(th_delta[use_idx]),
duration[0,1], duration[0,1], 1)
seq['high_emg'] = threshold_crossing(p_mu, np.nanmean(p_mu[use_idx])+mu_std*np.nanstd(p_mu[use_idx]),
duration[1,0], duration[1,1], 1)
seq['high_delta'] = threshold_crossing(p_delta, np.nanmean(p_delta[use_idx]), duration[2,0], duration[2,1], 1)
seq['high_sigma'] = threshold_crossing(p_sigma, np.nanmean(p_sigma[use_idx]), duration[3,0], duration[3,1], 1)
seq['high_gamma'] = threshold_crossing(p_gamma, np.nanmean(p_gamma[use_idx]), duration[4,0], duration[4,1], 1)
# Sleep-State Rules
idx = {}
for k in seq:
tmp = [list(range(i,j+1)) for (i,j) in seq[k]]
# now idea why this works to flatten a list
# idx[k] = sum(tmp, [])
# alternative that I understand:
if len(tmp) == 0:
idx[k] = np.array([])
else:
idx[k] = np.array(reduce(lambda x,y: x+y, tmp))
idx['low_emg'] = np.setdiff1d(np.arange(0,N), np.array(idx['high_emg']))
idx['low_delta'] = np.setdiff1d(np.arange(0,N), np.array(idx['high_delta']))
idx['low_theta'] = np.setdiff1d(np.arange(0,N), np.array(idx['high_theta']))
#REM Sleep: thdel up, emg down, delta down
a = np.intersect1d(idx['high_theta'], idx['low_delta'])
# non high_emg phases
b = np.setdiff1d(a, idx['high_emg'])
rem = get_sequences(b, duration[0,1])
rem_idx = reduce(lambda x,y: np.concatenate((x,y)), rem)
# SWS Sleep
# delta high, no theta, no emg
a = np.setdiff1d(idx['high_delta'], idx['high_emg']) # no emg activation
b = np.setdiff1d(a, idx['high_theta']) # no theta;
sws = get_sequences(b)
sws_idx = reduce(lambda x,y: np.concatenate((x,y)), sws)
#print a
# Wake
# low delta + high emg and not rem
a = np.unique(np.union1d(idx['low_delta'], idx['high_emg']))
b = np.setdiff1d(a, rem_idx)
wake = get_sequences(b)
wake_idx = reduce(lambda x,y: np.concatenate((x,y)), wake)
# sequences with low delta, high sigma and low emg are NREM
a = np.intersect1d(np.intersect1d(idx['high_sigma'], idx['low_delta']), idx['low_emg'])
a = np.setdiff1d(a, rem_idx)
sws_idx = np.unique(np.union1d(a, sws_idx))
wake_idx = np.setdiff1d(wake_idx, a)
#NREM sequences with high gamma are wake
a = np.intersect1d(sws_idx, idx['high_gamma'])
sws_idx = np.setdiff1d(sws_idx, a)
wake_idx = np.unique(np.union1d(wake_idx,a))
# Wake and Theta
wake_motion_idx = np.intersect1d(wake_idx, idx['high_theta'])
# Wake w/o Theta
wake_nomotion_idx = np.setdiff1d(wake_idx, idx['low_theta'])
# Are there overlapping sequences?
a = np.intersect1d(np.intersect1d(rem_idx, wake_idx), sws_idx)
# Are there undefined sequences?
undef_idx = np.setdiff1d(np.setdiff1d(np.setdiff1d(np.arange(0,N), rem_idx), wake_idx), sws_idx)
# Wake wins over SWS
sws_idx = np.setdiff1d(sws_idx, wake_idx)
# Special rules
# if there's a REM sequence directly following a short wake sequence (PRE_WAKE_REM),
# this wake sequence goes to SWS
# NREM to REM transitions are sometimes mistaken as quite wake periods
for rem_seq in rem:
if len(rem_seq) > 0:
irem_start = rem_seq[0]
# is there wake in the preceding bin?
if irem_start-1 in wake_idx:
# get the closest sws bin in the preceding history
isws_end = closest_precessor(sws_idx, irem_start)
if (irem_start - isws_end)*dt < PRE_WAKE_REM:
new_rem = np.arange(isws_end+1,irem_start)
rem_idx = np.union1d(rem_idx, new_rem)
wake_idx = np.setdiff1d(wake_idx, new_rem)
else:
new_wake = rem_seq
wake_idx = np.union1d(wake_idx, new_wake)
rem_idx = np.setdiff1d(rem_idx, new_wake)
# two different representations for the results:
S = {}
S['rem'] = rem_idx
S['nrem'] = sws_idx
S['wake'] = wake_idx
S['awake'] = wake_motion_idx
S['qwake'] = wake_nomotion_idx
M = np.zeros((N,))
if len(rem_idx) > 0:
M[rem_idx] = 1
if len(wake_idx) > 0:
M[wake_idx] = 2
if len(sws_idx) > 0:
M[sws_idx] = 3
if len(undef_idx) > 0:
M[undef_idx] = 0
# write sleep annotation to file
if pwrite:
outfile = os.path.join(ppath, name, 'remidx_' + name + '.txt')
print("writing annotation to %s" % outfile)
f = open(outfile, 'w')
s = ["%d\t%d\n" % (i,j) for (i,j) in zip(M,np.zeros((N,)))]
f.writelines(s)
f.close()
# nice plotting
plt.ion()
if pplot:
plt.figure(figsize=(18,9))
axes1=plt.axes([0.1, 0.9, 0.8, 0.05])
A = np.zeros((1,len(M)))
A[0,:] = M
cmap = plt.cm.jet
my_map = cmap.from_list('ha', [[0,0,0], [0,1,1],[0.5,0,1], [0.8, 0.8, 0.8]], 4)
#tmp = axes1.imshow(A, vmin=0, vmax=3)
tmp = axes1.pcolorfast(t, [0,1], A, vmin=0, vmax=3)
tmp.set_cmap(my_map)
axes1.axis('tight')
tmp.axes.get_xaxis().set_visible(False)
tmp.axes.get_yaxis().set_visible(False)
box_off(axes1)
# show spectrogram
axes2=plt.axes([0.1, 0.75, 0.8, 0.1], sharex=axes1)
ifreq = np.where(freq <= 30)[0]
med = np.median(SPEEG.max(axis=0))
if pspec_norm:
ifreq = np.where(freq <= 80)[0]
filt = np.ones((6, 1))
filt = filt / np.sum(filt)
SPEEG = scipy.signal.convolve2d(SPEEG, filt, mode='same')
spec_mean = SPEEG.mean(axis=1)
SPEEG = np.divide(SPEEG, np.repeat([spec_mean], SPEEG.shape[1], axis=0).T)
med = np.median(SPEEG.max(axis=0))
axes2.pcolorfast(t, freq[ifreq], SPEEG[ifreq, :], vmax = med*vmax, cmap='jet')
else:
axes2.pcolorfast(t, freq[ifreq], SPEEG[ifreq, :], vmax=med * vmax, cmap='jet')
axes2.axis('tight')
plt.ylabel('Freq (Hz)')
box_off(axes2)
# show delta power
axes3=plt.axes([0.1, 0.6, 0.8, 0.1], sharex=axes2)
axes3.plot(t,p_delta, color='gray')
plt.ylabel('Delta (a.u.)')
plt.xlim((t[0], t[-1]))
seq = get_sequences(S['nrem'])
#for s in seq:
# plt.plot(t[s],p_delta[s], color='red')
s = idx['high_delta']
seq = get_sequences(s)
for s in seq:
plt.plot(t[s],p_delta[s], color='red')
box_off(axes3)
axes4=plt.axes([0.1, 0.45, 0.8, 0.1], sharex=axes3)
axes4.plot(t,p_sigma, color='gray')
plt.ylabel('Sigma (a.u.)')
plt.xlim((t[0], t[-1]))
s = idx['high_sigma']
seq = get_sequences(s)
for s in seq:
plt.plot(t[s],p_sigma[s], color='red')
box_off(axes4)
axes5=plt.axes([0.1, 0.31, 0.8, 0.1], sharex=axes4)
axes5.plot(t,th_delta, color='gray')
plt.ylabel('Th/Delta (a.u.)')
plt.xlim((t[0], t[-1]))
s = idx['high_theta']
seq = get_sequences(s)
for s in seq:
plt.plot(t[s],th_delta[s], color='red')
box_off(axes5)
axes6=plt.axes([0.1, 0.17, 0.8, 0.1], sharex=axes5)
axes6.plot(t,p_gamma, color='gray')
plt.ylabel('Gamma (a.u.)')
plt.xlim((t[0], t[-1]))
s = idx['high_gamma']
seq = get_sequences(s)
for s in seq:
plt.plot(t[s],p_gamma[s], color='red')
box_off(axes6)
axes7=plt.axes([0.1, 0.03, 0.8, 0.1], sharex=axes6)
axes7.plot(t,p_mu, color='gray')
plt.xlabel('Time (s)')
plt.ylabel('EMG (a.u.)')
plt.xlim((t[0], t[-1]))
s = idx['high_emg']
seq = get_sequences(s)
for s in seq:
plt.plot(t[s],p_mu[s], color='red')
box_off(axes7)
plt.show()
# 2nd figure showing distribution of different bands
plt.figure(figsize=(20,3))
axes1 = plt.axes([0.05, 0.1, 0.13, 0.8])
plt.hist(p_delta, bins=100)
plt.plot(np.nanmean(p_delta), 10, 'ro')
plt.title('delta')
plt.ylabel('# Occurances')
box_off(axes1)
axes1 = plt.axes([0.25, 0.1, 0.13, 0.8])
plt.hist(th_delta, bins=100)
plt.plot(np.nanmean(th_delta)+th_delta_std*np.nanstd(th_delta), 10, 'ro')
plt.title('theta/delta')
box_off(axes1)
axes1 = plt.axes([0.45, 0.1, 0.13, 0.8])
plt.hist(p_sigma, bins=100)
plt.plot(np.nanmean(p_sigma), 10, 'ro')
plt.title('sigma')
box_off(axes1)
axes1 = plt.axes([0.65, 0.1, 0.13, 0.8])
plt.hist(p_gamma, bins=100)
plt.plot(np.nanmean(p_gamma), 10, 'ro')
plt.title('gamma')
box_off(axes1)
axes1 = plt.axes([0.85, 0.1, 0.13, 0.8])
plt.hist(p_mu, bins=100)
plt.plot(np.nanmean(p_mu)+np.nanstd(p_mu), 10, 'ro')
plt.title('EMG')
plt.show(block=False)
box_off(axes1)
plt.show()
return M,S
def plot_hypnograms(ppath, recordings, tbin=0, unit='h', ma_thr=20, title='', tstart=0, tend=-1):
"""
plot all hypnograms specified in @recordings
:param ppath: base folder
:param recordings: list of recordings
:param tbin: tbin for xticks
:param unit: time unit; h - hour, min - minute, s - second
:param ma_thr: float, wake periods shorter than $ma_thr are considered as microarousals and further converted to NREM
:param tstart: float, start time point (in seconds!) of hypnograms
:param tend: float, last shown time point (in seconds!)
:param title: optional title for figure
"""
recordings = recordings[::-1]
sr = get_snr(ppath, recordings[0])
nbin = int(np.round(sr) * 2.5)
dt_sec = (1.0 / sr) * nbin
istart = int(np.round(tstart/dt_sec))
dt = dt_sec
if unit == 'h':
dt /= 3600
elif unit == 'min':
dt /= 60
rec_len = dict()
irec = 0
ny = (1.0-0.2) / len(recordings)
dy = ny * 0.75
cmap = plt.cm.jet
my_map = cmap.from_list('brs', [[0, 0, 0], [0, 1, 1], [0.5, 0, 1], [0.8, 0.8, 0.8]], 4)
plt.ion()
plt.figure(figsize=(9,4))
axes = []
for rec in recordings:
M,K = load_stateidx(ppath, rec)
#kcut = np.where(K<0)[0]
#M = M[kcut]
#M[kcut] = 0
if tend == -1:
iend = len(M)
else:
iend = int(tend/dt_sec)
M = M[istart:iend]
if ma_thr>0:
seq = get_sequences(np.where(M==2)[0])
for s in seq:
if len(s)*dt_sec <= ma_thr:
M[s] = 3
rec_len[rec] = len(M)*dt
t = np.arange(0, len(M))*dt
ax = plt.axes([0.05, ny*irec+0.15, 0.75, dy])
tmp = ax.pcolorfast(t, [0, 1], np.array([M]), vmin=0, vmax=3, cmap=my_map)
box_off(ax)
ax.axis('tight')
tmp.axes.get_yaxis().set_visible(False)
if irec > 0:
tmp.axes.get_xaxis().set_visible(False)
if irec == 0:
plt.xlabel('Time (%s)' % unit)
irec += 1
axes.append(ax)
if len(title) > 0:
plt.title(title)
max_dur = max(rec_len.values())
if tbin > 0:
xtick = np.arange(0, max_dur, tbin)
for (ax, rec) in zip(axes, recordings):
ax.set_xlim([0, max_dur])
if tbin > 0:
ax.set_xticks(xtick)
ax.text(max_dur+max_dur*0.01, 0.5, rec)
plt.show()
def plot_swa(ppath, name, delta_win, alpha, band=[0.5, 4.5], swa_yrange=[]):
"""
plot slow wave (delta) activity during NREM
The top plot shows the hynogram.
The middle plot shows the delta power (irrespective of brain state) as line plot
The bottom plot shows for consecutive $delta_win seconds long bins, the
median delta power (SWA) during NREM, if the ration of NREM during the
corresponding bin >= $alpha
Example call:
dm=plot_swa(ppath, name, 30, 0.5, swa_yrange=[0, 0.012])
:param ppath, name: basefolder, recording name
:param delta_win: plot median swa value for each consecutive $delta_win seconds long window, if
:param alpha: the ratio of NREM in this window is larger than alpha (value between 0 and 1)
:param swa_yrange: tuple, minimun and maximum value of yrange for SWA
:return df: pd.DataFrame with SWA time points and corresponding median SWA values
"""
r_delta = band
sr = get_snr(ppath, name)
nbin = int(np.round(2.5*sr))
dt = nbin*(1.0/sr)
M,_ = load_stateidx(ppath, name)
t = np.arange(0, len(M))*dt
P = so.loadmat(os.path.join(ppath, name, 'sp_%s.mat' % name), squeeze_me=True)
SP = P['SP']
freq = P['freq']
df = freq[1]-freq[0]
idelta = np.where((freq>=r_delta[0]) & (freq<=r_delta[1]))[0]
pow_delta = SP[idelta,:].sum(axis=0)*df
# get NREM sequences contributing points for fitting
iwin = int(delta_win/dt)
#seq = get_sequences(nrem_idx, ibreak=int((delta_win/dt)*0.1))
delta_med = []
for j in range(0, len(M)-iwin, iwin):
s = range(j, j+iwin)
sc = j+int(iwin/2)
Mcut = M[s]
if (1.0*len(np.where(Mcut==3)[0])) / len(s) >= alpha:
i = np.where(Mcut==3)[0]
i = i+s[0]
a = np.median(pow_delta[i])
delta_med.append((t[sc],a))
df = pd.DataFrame(columns=['time', 'pow'], data=delta_med)
# generate figure
# show brainstate
plt.ion()
plt.figure(figsize=(10, 4))
axes_brs = plt.axes([0.1, 0.85, 0.8, 0.1])
cmap = plt.cm.jet
my_map = cmap.from_list('brs', [[0, 0, 0], [0, 1, 1], [0.6, 0, 1], [0.8, 0.8, 0.8]], 4)
tmp = axes_brs.pcolorfast(t, [0, 1], np.array([M]), vmin=0, vmax=3)
tmp.set_cmap(my_map)
axes_brs.axis('tight')
axes_brs.axes.get_xaxis().set_visible(False)
axes_brs.axes.get_yaxis().set_visible(False)
axes_brs.spines["top"].set_visible(False)
axes_brs.spines["right"].set_visible(False)
axes_brs.spines["bottom"].set_visible(False)
axes_brs.spines["left"].set_visible(False)
# plot delta power as function of time
c = 1000**2
axes_tdelta = plt.axes([0.1, 0.55, 0.8, 0.2], sharex=axes_brs)
plt.plot(t, pow_delta/c, 'k')
box_off(axes_tdelta)
axes_tdelta.axes.get_xaxis().set_visible(False)
axes_tdelta.spines["bottom"].set_visible(False)
plt.ylabel('SWA (mV$\mathrm{^2}$)')
# plot delta power medians
axes_delta = plt.axes([0.1, 0.12, 0.8, 0.35], sharex=axes_brs)
for (s,delta) in delta_med:
plt.plot(s, delta/c, 'ko')
print(t)
plt.xlim((t[0], t[-1]))
box_off(axes_delta)
plt.xlabel('Time (s)')
plt.ylabel('NREM SWA (mV$\mathrm{^2}$)')
if swa_yrange == []:
ymax = df['pow'].max()/c
plt.ylim([0, ymax+0.1*ymax])
else:
plt.ylim(swa_yrange)
plt.show()
return df
def laser_triggered_eeg(ppath, name, pre, post, f_max, pnorm=2, pplot=False, psave=False, tstart=0, tend=-1,
peeg2=False, vm=2.5, prune_trials=True, mu=[10, 200], trig_state=0, harmcs=0, iplt_level=1):
"""
calculate laser triggered, averaged EEG and EMG spectrum
:param ppath: base folder containing mouse recordings
:param name: recording
:param pre: time before laser
:param post: time after laser
:param f_max: calculate/plot frequencies up to frequency f_max
:param pnorm: normalization,
pnorm = 0, no normalization
pnorm = 1, normalize each frequency band by its average power
pnorm = 2, normalize each frequency band by the average power
during the preceding baseline period
:param vm: float to set saturation level of colormap
:param pplot: plot figure yes=True, no=False
:param psave: save the figure, yes=True, no = False
:param tstart: float, starting time point. Only lasers trials after tstart will be considered
:param tend: float, only laser trials up to tend will be considered; if tend==-1, use whole recording
:param peeg2: if True, use EEG channel 2
:param prune_trials: if True, throw out trials with EEG or EMG artifacts
:param mu: tuple; range used for EMG amplitude calculation
:param trig_state: int; if > 0, only use trials where brain is at laser onset in brainstate trig_state
1=REM, 2=Wake, 3=NREM
:param harmcs: if >0, interpolate all frequencies corresponding to multiples of harmcs by the average power
of the two neighboring frequencies.
:param iplt_level: options - 1 or 2. If 1 only take one neighboring frequency above and below the harmonic;
if 2, take 2 neighbors above and below, respectively
"""
def _interpolate_harmonics(SP, freq, f_max, harmcs, iplt_level):
df = freq[2]-freq[1]
for h in np.arange(harmcs, f_max, harmcs):
i = np.argmin(np.abs(freq - h))
if np.abs(freq[i] - h) < df and h != 60:
if iplt_level == 2:
SP[i,:] = (SP[i-2:i,:] + SP[i+1:i+3,:]).mean(axis=0) * 0.5
else:
SP[i,:] = (SP[i-1,:] + SP[i+1,:]) * 0.5
return SP
SR = get_snr(ppath, name)
NBIN = np.round(2.5*SR)
lsr = load_laser(ppath, name)
idxs, idxe = laser_start_end(lsr)
laser_dur = np.mean((idxe-idxs)/SR)
print('%s: Average laser duration: %f; Number of trials %d' % (name, laser_dur, len(idxs)))
# downsample EEG time to spectrogram time
idxs = [int(i/NBIN) for i in idxs]
idxe = [int(i/NBIN) for i in idxe]
#load EEG and EMG
P = so.loadmat(os.path.join(ppath, name, 'sp_' + name + '.mat'))
Q = so.loadmat(os.path.join(ppath, name, 'msp_' + name + '.mat'))
if not peeg2:
SPEEG = np.squeeze(P['SP'])
else:
SPEEG = np.squeeze(P['SP2'])
SPEMG = np.squeeze(Q['mSP'])
freq = np.squeeze(P['freq'])
t = np.squeeze(P['t'])
dt = float(np.squeeze(P['dt']))
ifreq = np.where(freq<=f_max)[0]
ipre = int(np.round(pre/dt))
ipost = int(np.round(post/dt))
speeg_mean = SPEEG.mean(axis=1)
spemg_mean = SPEMG.mean(axis=1)
# interpolate frequencies corresponding to harmonics of $harmcs
if harmcs > 0:
SPEEG = _interpolate_harmonics(SPEEG, freq, f_max, harmcs)
SPEMG = _interpolate_harmonics(SPEMG, freq, f_max, harmcs)
if tend > -1:
i = np.where((np.array(idxs)*dt >= tstart) & (np.array(idxs)*dt <= tend))[0]
else:
i = np.where(np.array(idxs)*dt >= tstart)[0]
idxs = [idxs[j] for j in i]
idxe = [idxe[j] for j in i]
skips = []
skipe = []
if prune_trials:
for (i,j) in zip(idxs, idxe):
A = SPEEG[0,i-ipre:i+ipost+1] / speeg_mean[0]
B = SPEMG[0,i-ipre:i+ipost+1] / spemg_mean[0]
k = np.where(A >= np.median(A)*50)[0]
l = np.where(B >= np.median(B)*500)[0]
if len(k) > 0 or len(l) > 0:
skips.append(i)
skipe.append(j)
print("%s: kicking out %d trials" % (name, len(skips)))
idxs_new = []
idxe_new = []
for (i,j) in zip(idxs, idxe):
if not i in skips:
idxs_new.append(i)
idxe_new.append(j)
idxs = idxs_new
idxe = idxe_new
# select trials where brain state is right before laser in trig_state
if trig_state > 0:
idxs_new = []
idxe_new = []
M = load_stateidx(ppath, name)[0]
for (i,j) in zip(idxs, idxe):
if i < len(M) and M[i] == trig_state:
idxs_new.append(i)
idxe_new.append(j)
idxs = idxs_new
idxe = idxe_new
# Spectrogram for EEG and EMG normalized by average power in each frequency band
if pnorm == 1:
SPEEG = np.divide(SPEEG, np.repeat(speeg_mean, len(t)).reshape(len(speeg_mean), len(t)))
SPEMG = np.divide(SPEMG, np.repeat(spemg_mean, len(t)).reshape(len(spemg_mean), len(t)))
speeg_parts = []
spemg_parts = []
for (i,j) in zip(idxs, idxe):
if i>=ipre and j+ipost < len(t):
eeg_part = SPEEG[ifreq,i-ipre:i+ipost+1]
speeg_parts.append(eeg_part)
spemg_parts.append(SPEMG[ifreq,i-ipre:i+ipost+1])
EEGLsr = np.array(speeg_parts).mean(axis=0)
EMGLsr = np.array(spemg_parts).mean(axis=0)
# smooth spectrogram
nfilt = 3
filt = np.ones((nfilt,nfilt))
filt = np.divide(filt, filt.sum())
EEGLsr = scipy.signal.convolve2d(EEGLsr, filt, boundary='symm', mode='same')
if pnorm == 2:
for i in range(EEGLsr.shape[0]):
EEGLsr[i,:] = np.divide(EEGLsr[i,:], np.sum(np.abs(EEGLsr[i,0:ipre]))/(1.0*ipre))
EMGLsr[i,:] = np.divide(EMGLsr[i,:], np.sum(np.abs(EMGLsr[i,0:ipre]))/(1.0*ipre))
# get time axis
dt = (1.0/SR)*NBIN
t = np.linspace(-ipre*dt, ipost*dt, ipre+ipost+1)
f = freq[ifreq]
if pplot:
# get rid of boxes around matplotlib plots
def box_off(ax):
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
plt.ion()
plt.figure(figsize=(10,8))
ax = plt.axes([0.1, 0.55, 0.4, 0.35])
plt.pcolormesh(t,f,EEGLsr, vmin=0, vmax=np.median(EEGLsr)*vm, cmap='jet')
plt.plot([0,0], [0,f[-1]], color=(1,1,1))
plt.plot([laser_dur,laser_dur], [0,f[-1]], color=(1,1,1))
plt.axis('tight')
plt.xlabel('Time (s)')
plt.ylabel('Freq (Hz)')
box_off(ax)
plt.title('EEG', fontsize=12)
cbar = plt.colorbar()
if pnorm >0:
cbar.set_label('Rel. Power')
else:
cbar.set_label('Power uV^2s')
ax = plt.axes([0.62, 0.55, 0.35, 0.35])
ilsr = np.where((t>=0) & (t<=120))[0]
plt.plot(f,EEGLsr[:,0:ipre].mean(axis=1), color='gray', label='baseline', lw=2)
plt.plot(f,EEGLsr[:,ilsr].mean(axis=1), color='blue', label='laser', lw=2)
box_off(ax)
plt.xlabel('Freq. (Hz)')
plt.ylabel('Power (uV^2)')
#plt.legend(loc=0)
#plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3, ncol=2, borderaxespad=0.)
ax = plt.axes([0.1, 0.1, 0.4, 0.35])
plt.pcolormesh(t,f,EMGLsr, cmap='jet')
plt.plot([0,0], [0,f[-1]], color=(1,1,1))
plt.plot([laser_dur,laser_dur], [0,f[-1]], color=(1,1,1))
plt.axis('tight')
plt.xlabel('Time (s)')
plt.ylabel('Freq (Hz)')
box_off(ax)
plt.title('EMG', fontsize=12)
cbar = plt.colorbar()
if pnorm >0:
cbar.set_label('Rel. Power')
else:
cbar.set_label('Power (uV^2s)')
ax = plt.axes([0.62, 0.1, 0.35, 0.35])
mf = np.where((f>=mu[0]) & (f <= mu[1]))[0]
df = f[1]-f[0]
# amplitude is square root of (integral over each frequency)
avg_emg = np.sqrt(EMGLsr[mf,:].sum(axis=0)*df)
m = np.max(avg_emg)*1.5
plt.plot([0,0], [0,np.max(avg_emg)*1.5], color=(0,0,0))
plt.plot([laser_dur,laser_dur], [0,np.max(avg_emg)*1.5], color=(0,0,0))
plt.xlim((t[0], t[-1]))
plt.ylim((0,m))
plt.plot(t,avg_emg, color='black', lw=2)
box_off(ax)
plt.xlabel('Time (s)')
plt.ylabel('EMG ampl. (uV)')
plt.show()
if psave:
img_file = os.path.join(ppath, name, 'fig_'+name+'_spec.png')
save_figure(img_file)
return EEGLsr, EMGLsr, freq[ifreq], t
def laser_triggered_eeg_avg(ppath, recordings, pre, post, f_max, laser_dur, pnorm=1, pplot=1, tstart=0, tend=-1,
vm=[], cb_ticks=[], mu=[10, 100], trig_state=0, harmcs=0, iplt_level=1, peeg2=False, fig_file=''):
"""
calculate average spectrogram for all recordings listed in @recordings; for averaging take
mouse identity into account
:param ppath: base folder
:param recordings: list of recordings
:param pre: time before laser onset
:param post: time after laser onset
:param f_max: maximum frequency shown for EEG spectrogram
:param laser_dur: duration of laser stimulation
:param pnorm: normalization,
pnorm = 0, no normalization
pnorm = 1, normalize each frequency band by its average power
pnorm = 2, normalize each frequency band by the average power
during the preceding baseline period
:param pplot: pplot==0 - no figure;
pplot==1 - conventional figure;
pplot==2 - pretty figure showing EEG spectrogram
along with EMG amplitude
note: the errorbar for the EMG amplitude is the S.E.M.
:param tstart: only consider laser trials with laser onset after tstart seconds
:param tend: only consider laser trials with laser onset before tend seconds
:param vm: saturation of heatmap for EEG spectrogram
:param cb_ticks: ticks for colorbar (only applies for pplot==2)
:param mu: frequencies for EMG amplitude calculation
:param trig_state: if > 0, only use trials where brain is at laser onset in brainstate trig_state
1=REM, 2=Wake, 3=NREM
:param peeg2: if True, use EEG2 instead of EEG
:param harmcs: if >0, interpolate all frequencies corresponding to multiples of harmcs by the average power
of the two neighboring frequencies.
:param iplt_level: options - 1 or 2. If 1 only take one neighboring frequency above and below the harmonic;
if 2, take 2 neighbors above and below, respectively
:param fig_file: if specified, save figure to given file
:return:
t, f, EEGSpec, EMGSpec, EEGLsr
t - time axis
f - frequency axis
EEGSpec - dict with mouse id -> 2D np.array(frequency x time)
EMGSpec - dict with mouse id -> 2D np.array(frequency x time)
EEGLsr - 2D np.array(frequency x time)
"""
EEGSpec = {}
EMGSpec = {}
mice = []
for rec in recordings:
idf = re.split('_', rec)[0]
if not(idf in mice):
mice.append(idf)
EEGSpec[idf] = []
EMGSpec[idf] = []
for rec in recordings:
idf = re.split('_', rec)[0]
EEG, EMG, f, t = laser_triggered_eeg(ppath, rec, pre, post, f_max, mu=mu, pnorm=pnorm, pplot=False,
psave=False, tstart=tstart, tend=tend, trig_state=trig_state,
peeg2=peeg2, harmcs=harmcs, iplt_level=iplt_level)
EEGSpec[idf].append(EEG)
EMGSpec[idf].append(EMG)
for idf in mice:
EEGSpec[idf] = np.array(EEGSpec[idf]).mean(axis=0)
EMGSpec[idf] = np.array(EMGSpec[idf]).mean(axis=0)
EEGLsr = np.array([EEGSpec[k] for k in mice]).mean(axis=0)
EMGLsr = np.array([EMGSpec[k] for k in mice]).mean(axis=0)
mf = np.where((f >= mu[0]) & (f <= mu[1]))[0]
if harmcs > 0:
harm_freq = np.arange(0, f.max(), harmcs)
for h in harm_freq:
mf = np.setdiff1d(mf, mf[np.where(f[mf]==h)[0]])
df = f[1] - f[0]
EMGAmpl = np.zeros((len(mice), EEGLsr.shape[1]))
i=0
for idf in mice:
# amplitude is square root of (integral over each frequency)
if harmcs == 0:
EMGAmpl[i,:] = np.sqrt(EMGSpec[idf][mf,:].sum(axis=0)*df)
else:
tmp = 0
for qf in mf:
tmp += EMGSpec[idf][qf,:] * (f[qf] - f[qf-1])
EMGAmpl[i,:] = np.sqrt(tmp)
i += 1
avg_emg = EMGAmpl.mean(axis=0)
sem_emg = EMGAmpl.std(axis=0) / np.sqrt(len(mice))
if pplot==1:
plt.ion()
plt.figure(figsize=(12,10))
ax = plt.axes([0.1, 0.55, 0.4, 0.4])
if len(vm) == 2:
plt.pcolormesh(t,f,EEGLsr, cmap='jet', vmin=vm[0], vmax=vm[1])
else:
plt.pcolormesh(t, f, EEGLsr, cmap='jet')
plt.plot([0,0], [0,f[-1]], color=(1,1,1))
plt.plot([laser_dur,laser_dur], [0,f[-1]], color=(1,1,1))
plt.axis('tight')
plt.xlabel('Time (s)')
plt.ylabel('Freq (Hz)')
box_off(ax)
plt.title('EEG')
cbar = plt.colorbar()
if pnorm >0:
cbar.set_label('Rel. Power')
else:
cbar.set_label('Power uV^2s')
ax = plt.axes([0.6, 0.55, 0.3, 0.4])
ipre = np.where(t<0)[0]
ilsr = np.where((t>=0) & (t<=120))[0]
plt.plot(f,EEGLsr[:,ipre].mean(axis=1), color='gray', label='baseline', lw=2)
plt.plot(f,EEGLsr[:,ilsr].mean(axis=1), color='blue', label='laser', lw=2)
box_off(ax)
plt.xlabel('Freq. (Hz)')
plt.ylabel('Power (uV^2)')
#plt.legend(loc=0)
#plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3, ncol=2, borderaxespad=0.)
ax = plt.axes([0.1, 0.05, 0.4, 0.4])
plt.pcolormesh(t,f,EMGLsr, cmap='jet')
plt.plot([0,0], [0,f[-1]], color=(1,1,1))
plt.plot([laser_dur,laser_dur], [0,f[-1]], color=(1,1,1))
plt.axis('tight')
plt.xlabel('Time (s)')
plt.ylabel('Freq (Hz)')
box_off(ax)
plt.title('EMG')
cbar = plt.colorbar()
if pnorm >0:
cbar.set_label('Rel. Power')
else:
cbar.set_label('Power uV^2s')
ax = plt.axes([0.6, 0.05, 0.3, 0.4])
m = np.max(avg_emg)*1.5
plt.plot([0,0], [0,np.max(avg_emg)*1.5], color=(0,0,0))
plt.plot([laser_dur,laser_dur], [0,np.max(avg_emg)*1.5], color=(0,0,0))
plt.xlim((t[0], t[-1]))
plt.ylim((0,m))
plt.plot(t,avg_emg, color='black', lw=2)
plt.fill_between(t, avg_emg-sem_emg, avg_emg+sem_emg)
box_off(ax)
plt.xlabel('Time (s)')
plt.ylabel('EMG ampl. (uV)')
plt.show()
elif pplot==2:
# pretty figure
plt.figure()
if len(vm) > 0:
cb_ticks = vm
# plot EEG spectrogram
axes_cbar = plt.axes([0.8, 0.75, 0.1, 0.2])
ax = plt.axes([0.1, 0.55, 0.75, 0.4])
if len(vm) == 2:
im=ax.pcolorfast(t, f, EEGLsr, cmap='jet', vmin=vm[0], vmax=vm[1])
else:
im = ax.pcolorfast(t, f, EEGLsr, cmap='jet')
plt.plot([0,0], [0,f[-1]], color=(1,1,1))
plt.plot([laser_dur,laser_dur], [0,f[-1]], color=(1,1,1))
plt.axis('tight')
plt.xlabel('Time (s)')
plt.ylabel('Freq (Hz)')
box_off(ax)
# colorbar for EEG spectrogram
cb = plt.colorbar(im, ax=axes_cbar, pad=0.0, aspect=10.0, orientation='vertical')
if pnorm > 0:
cb.set_label('Rel. Power')
else:
cb.set_label('Power (uV^2s)')
cb.ax.xaxis.set_ticks_position("bottom")
cb.ax.xaxis.set_label_position('top')
if len(cb_ticks) > 0:
cb.set_ticks(cb_ticks)
axes_cbar.set_alpha(0.0)
axes_cbar.spines["top"].set_visible(False)
axes_cbar.spines["right"].set_visible(False)
axes_cbar.spines["bottom"].set_visible(False)
axes_cbar.spines["left"].set_visible(False)
axes_cbar.axes.get_xaxis().set_visible(False)
axes_cbar.axes.get_yaxis().set_visible(False)
# EMG amplitude
ax = plt.axes([0.1, 0.1, 0.75, 0.3])
m = np.max(avg_emg) * 1.5
ax.add_patch(patches.Rectangle((0, 0), laser_dur, np.max(avg_emg)*1.5, facecolor=[0.6, 0.6, 1], edgecolor=[0.6, 0.6, 1]))
plt.xlim((t[0], t[-1]))
plt.ylim((0, m))
plt.fill_between(t, avg_emg-sem_emg, avg_emg+sem_emg, color='gray', zorder=2)
plt.plot(t, avg_emg, color='black', lw=2)
box_off(ax)
plt.xlabel('Time (s)')
plt.ylabel('EMG ampl. ($\mathrm{\mu V}$)')
plt.show()
if len(fig_file) > 0:
save_figure(fig_file)
return t, f, EEGSpec, EMGSpec, EEGLsr
def laser_brainstate(ppath, recordings, pre, post, pplot=True, fig_file='', start_time=0, end_time=-1,
ma_thr=0, edge=0, sf=0, cond=0, single_mode=False, ci=95, backup='', csv_file=''):
"""
calculate laser triggered probability of REM, Wake, NREM
ppath - base folder holding all recording
recordings - list of recording
pre - time before laser onset
post - time after laser onset
@Optional:
pplot - pplot==True: plot figure
fig_file - specify filename including ending, if you wish to save figure
start_time - in [s], only consider laser onsets starting after $start_time
end_time - in [s], only consider laset onsets starting before $end_time
sf - smoothing factor for Gaussian kernel; if sf=0, no filtering
edge - only use if $sf > 0: to avoid smoothing artifacts, set edge to a value > 0, e.g. 20
ma_thr - if > 0, smooth out microarousals with duration < $ma_thr
cond - cond==0: consider all trials; cond==[1,2,3] only plot trials,
where mouse was in REM, Wake, or NREM as laser turned on
single_mode - if True, plot every single mouse
backup - optional backup folder; if specified each single recording folder can be either on $ppath or $backup;
if it's on both folders, the version in ppath is used
ci - string; possible values: 'sem', 'sd', or value betwen 0 and 100, corresponding
to the bootstrapped confidence interval. The default is ci=95
csv_file - if filename (without or including full file path) is provided,
save pd.DataFrame df (see @Return) to csv file
@Return:
df_timecourse: pd.DataFrame with columns: mouse, time, perc, state.
df: pd.DataFrame with columns mouse_id, REM, NREM, Wake, Lsr
Lsr has three values: 0 - before laser, 1 - during laser, 2 - after laser
if laser was on for laser_dur s, then
df[df['Lsr'] == 0]['REM'] is the average % of REM sleep during laser stimulation for each mouse
df[df['Lsr'] == 0]['REM'] is the average % of REM sleep
during the laser_dur s long time interval preceding laser onset.
df[df['Lsr'] == 2]['REM'] is the average during the time inverval of duration laser_dur that
directly follows laser stimulation
"""
if type(recordings) != list:
recordings = [recordings]
rec_paths = dict()
for rec in recordings:
if os.path.isdir(os.path.join(ppath, rec)):
rec_paths[rec] = ppath
else:
rec_paths[rec] = backup
pre += edge
post += edge
BrainstateDict = {}
mouse_order = []
for rec in recordings:
idf = re.split('_', rec)[0]
BrainstateDict[idf] = []
if not idf in mouse_order:
mouse_order.append(idf)
nmice = len(BrainstateDict)
for rec in recordings:
ppath = rec_paths[rec]
SR = get_snr(ppath, rec)
NBIN = np.round(2.5*SR)
dt = NBIN * 1.0/SR
istart_time = int(np.round(start_time / dt))
M = load_stateidx(ppath, rec)[0]
if end_time == -1:
iend_time = len(M)
else:
iend_time = int(np.round(end_time / dt))
seq = get_sequences(np.where(M==2)[0])
for s in seq:
if len(s)*dt <= ma_thr:
M[s] = 3
(idxs, idxe) = laser_start_end(load_laser(ppath, rec))
idf = re.split('_', rec)[0]
ipre = int(np.round(pre/dt))
ipost = int(np.round(post/dt))
idxs = [int(i/NBIN) for i in idxs]
idxe = [int(i/NBIN) for i in idxe]
laser_dur = np.mean((np.array(idxe) - np.array(idxs))) * dt
for (i,j) in zip(idxs, idxe):
if i>=ipre and i+ipost<=len(M)-1 and i>istart_time and i < iend_time:
bs = M[i-ipre:i+ipost+1]
BrainstateDict[idf].append(bs)
# I assume here that every recording has same dt
t = np.linspace(-ipre*dt, ipost*dt, ipre+ipost+1)
# first time point where the laser was fully on (during the complete bin).
izero = np.where(t>0)[0][0]
# the first time bin overlapping with laser is then
izero -= 1
# @BS: mouse x time x state
BS = np.zeros((nmice, len(t), 3))
Trials = []
imouse = 0
for mouse in mouse_order:
if cond==0:
M = np.array(BrainstateDict[mouse])
Trials.append(M)
for state in range(1,4):
C = np.zeros(M.shape)
C[np.where(M==state)] = 1
BS[imouse,:,state-1] = C.mean(axis=0)
if cond>0:
M = BrainstateDict[mouse]
Msel = []
for trial in M:
if trial[izero] == cond:
Msel.append(trial)
M = np.array(Msel)
Trials.append(M)
for state in range(1,4):
C = np.zeros(M.shape)
C[np.where(M==state)] = 1
BS[imouse,:,state-1] = C.mean(axis=0)
imouse += 1
# flatten Trials
Trials = reduce(lambda x,y: np.concatenate((x,y), axis=0), Trials)
BS = BS*100
if sf > 0:
for state in [2, 1, 0]:
for i in range(nmice):
BS[i, :, state] = smooth_data(BS[i, :, state], sf)
df_timecourse = pd.DataFrame()
state_map = {1: 'REM', 2: 'Wake', 3: 'NREM'}
for s in state_map:
df = nparray2df(BS[:, :, s - 1], mouse_order, t, 'perc', 'mouse', 'time')
df['state'] = state_map[s]
df_timecourse = df_timecourse.append(df)
nmice = imouse
if pplot:
state_label = {0:'REM', 1:'Wake', 2:'NREM'}
it = np.where((t >= -pre + edge) & (t <= post - edge))[0]
plt.ion()
if not single_mode:
plt.figure()
ax = plt.axes([0.15, 0.15, 0.6, 0.7])
colors = [[0, 1, 1 ],[0.5, 0, 1],[0.6, 0.6, 0.6]]
if ci == 'sem':
for state in [2,1,0]:
tmp = BS[:, :, state].mean(axis=0)
plt.plot(t[it], tmp[it], color=colors[state], lw=3, label=state_label[state])
if nmice > 1:
smp = BS[:,:,state].std(axis=0) / np.sqrt(nmice)
plt.fill_between(t[it], tmp[it]-smp[it], tmp[it]+smp[it], color=colors[state], alpha=0.4, zorder=3)
plt.xlim([-pre+edge, post-edge])
plt.ylim([0,100])
ax.add_patch(patches.Rectangle((0,0), laser_dur, 100, facecolor=[0.6, 0.6, 1], edgecolor=[0.6, 0.6, 1]))
box_off(ax)
plt.xlabel('Time (s)')
plt.ylabel('Probability')
#plt.legend(bbox_to_anchor=(0., 1.02, 0.5, .102), loc=3, ncol=3, borderaxespad=0.)
plt.draw()
else:
bs_colors = {'REM': [0, 1, 1], 'Wake': [0.5, 0, 1], 'NREM': [0.6, 0.6, 0.6]}
dfm = df_timecourse.groupby(['mouse', 'state', 'time']).mean().reset_index()
for s in [3, 2, 1]:
sns.lineplot(data=dfm[dfm.state == state_map[s]], ci=ci, x='time', y='perc',
color=bs_colors[state_map[s]], err_kws={'alpha': 0.8, 'zorder': 3})
plt.xlim([-pre+edge, post-edge])
plt.ylim([0,100])
ax.add_patch(patches.Rectangle((0,0), laser_dur, 100, facecolor=[0.6, 0.6, 1], edgecolor=[0.6, 0.6, 1]))
box_off(ax)
plt.xlabel('Time (s)')
plt.ylabel('Probability')
else:
plt.figure(figsize=(7,7))
clrs = sns.color_palette("husl", nmice)
for state in [2,1,0]:
ax = plt.subplot('31' + str(3-state))
for i in range(nmice):
plt.plot(t[it], BS[i,it,state], color=clrs[i], label=mouse_order[i])
ax.add_patch(patches.Rectangle((0, 0), laser_dur, 100, facecolor=[0.6, 0.6, 1], edgecolor=[0.6, 0.6, 1], alpha=0.8))
plt.xlim((t[it][0], t[it][-1]))
plt.ylim((0,100))
plt.ylabel('% ' + state_label[state])
if state==0:
plt.xlabel('Time (s)')
else:
ax.set_xticklabels([])
if state==2:
ax.legend(mouse_order, bbox_to_anchor=(0., 1.0, 1., .102), loc=3, mode='expand', ncol=len(mouse_order),
frameon=False)
box_off(ax)
# figure showing all trials
plt.figure(figsize=(4,6))
set_fontarial()
plt.ion()
ax = plt.axes([0.15, 0.1, 0.8, 0.8])
cmap = plt.cm.jet
my_map = cmap.from_list('ha', [[0,1,1],[0.5,0,1], [0.6, 0.6, 0.6]], 3)
x = list(range(Trials.shape[0]))
plt.pcolormesh(t,np.array(x), np.flipud(Trials), cmap=my_map, vmin=1, vmax=3)
plt.plot([0,0], [0, len(x)-1], color='white')
plt.plot([laser_dur,laser_dur], [0, len(x)-1], color='white')
ax.axis('tight')
plt.draw()
plt.xlabel('Time (s)')
plt.ylabel('Trial No.')
box_off(ax)
plt.show()
if len(fig_file)>0:
plt.savefig(fig_file)
# compile dataframe with all baseline and laser values
ilsr = np.where((t>=0) & (t<=laser_dur))[0]
ibase = np.where((t>=-laser_dur) & (t<0))[0]
iafter = np.where((t>=laser_dur) & (t<laser_dur*2))[0]
df = pd.DataFrame(columns = ['Mouse', 'REM', 'NREM', 'Wake', 'Lsr'])
mice = mouse_order + mouse_order + mouse_order
lsr = np.concatenate((np.ones((nmice,), dtype='int'), np.zeros((nmice,), dtype='int'), np.ones((nmice,), dtype='int')*2))
df['Mouse'] = mice
df['Lsr'] = lsr
df['REM'] = np.concatenate((BS[:,ilsr,0].mean(axis=1), BS[:,ibase,0].mean(axis=1), BS[:,iafter,0].mean(axis=1)))
df['NREM'] = np.concatenate((BS[:,ilsr,2].mean(axis=1), BS[:,ibase,2].mean(axis=1), BS[:,iafter,2].mean(axis=1)))
df['Wake'] = np.concatenate((BS[:,ilsr,1].mean(axis=1), BS[:,ibase,1].mean(axis=1), BS[:,iafter,1].mean(axis=1)))
if len(csv_file) > 0:
df.to_csv(csv_file, index=False)
return df_timecourse, df, Trials
def laser_brainstate_bootstrap(ppath, recordings, pre, post, edge=0, sf=0, nboots=1000, alpha=0.05, backup='',
start_time=0, ma_thr=20, bootstrap_mode=0, fig_file=''):
"""
Align brain state with laser stimulation and calculate two-sided 1-$alpha confidence intervals using
bootstrapping.
:param ppath: base folder
:param recordings: list of recordings
:param pre: time before laser
:param post: time after laser onset
:param edge: add $edge seconds add beginning and end (that are not shown in the plot) to avoid filtering artifacts
:param sf: smoothing factor for Gaussian filter; better do not use
:param nboots: int, how many times the whole data set is resampled for boot-strapping
:param alpha: plot shows 1-$alpha confidence interval
:param backup: optional backup folder where recordings are stored
:param start_time: start time of recordding used for analysis
:param ma_thr: sleep periods < ma_thr are thrown away
:param bootstrap_mode: default=0
bootstrap_mode == 0: Take inter-mouse variance and inter-trial variance (of each mouse) into account.
That is, bootstrapping re-models the variance expected when re-doing the same
experimental design (same mouse number and total trial number).
To account for potentially different number of trials per mouse, resample the data
during each iteration the following way: Assume that there are n laser trials from m mice;
randomly select (with replacment) ntrial mice; then select from each mouse randomly one trial.
bootstrap_mode == 1: Only take inter-trial variance (of each mouse) into account. That is,
bootstrapping models the variance expected when redoing the experiment with exactly the same mice.
:param fig_file, if file name is specified, the figure will be saved
:return: P - p-values for NREM, REM, Wake
Mod - by how much the percentage of NREM, REM, Wake is increased compared to baseline
"""
pre += edge
post += edge
rec_paths = dict()
for rec in recordings:
if os.path.isdir(os.path.join(ppath, rec)):
rec_paths[rec] = ppath
else:
rec_paths[rec] = backup
# dict: mouse_id --> laser trials, R W N sequence
BrainstateDict = {}
for rec in recordings:
idf = re.split('_', rec)[0]
BrainstateDict[idf] = []
mice = list(BrainstateDict.keys())
nmice = len(BrainstateDict)
for rec in recordings:
ppath = rec_paths[rec]
SR = get_snr(ppath, rec)
NBIN = np.round(2.5 * SR)
dt = NBIN * 1 / SR
istart_time = int(np.round(start_time / dt))
M = load_stateidx(ppath, rec)[0]
seq = get_sequences(np.where(M == 2)[0])
for s in seq:
if len(s) * dt <= ma_thr:
M[s] = 3
(idxs, idxe) = laser_start_end(load_laser(ppath, rec))
idf = re.split('_', rec)[0]
#SR = get_snr(ppath, rec)
#NBIN = np.round(2.5 * SR)
ipre = int(np.round(pre / dt))
ipost = int(np.round(post / dt))
idxs = [int(i / NBIN) for i in idxs]
idxe = [int(i / NBIN) for i in idxe]
laser_dur = np.mean((np.array(idxe) - np.array(idxs))) * dt
for (i, j) in zip(idxs, idxe):
if i >= ipre and j + ipost <= len(M) - 1 and i > istart_time:
bs = M[i - ipre:i + ipost + 1]
BrainstateDict[idf].append(bs)
for mouse in mice:
BrainstateDict[mouse] = np.array(BrainstateDict[mouse])
# I assume here that every recording has same dt
t = np.linspace(-ipre*dt, ipost*dt, ipre+ipost+1)
Trials = dict()
for mouse in BrainstateDict:
Trials[mouse] = np.zeros((BrainstateDict[mouse].shape[0], len(t), 3))
# total number of trials:
ntrials = 0
for mouse in BrainstateDict:
M = np.array(BrainstateDict[mouse])
for state in range(1, 4):
C = np.zeros(M.shape)
C[np.where(M == state)] = 100.
Trials[mouse][:,:,state-1] = C
ntrials += Trials[mouse].shape[0]
Prob = np.zeros((nboots, len(t), 3))
if bootstrap_mode == 1:
for b in range(nboots):
# average brain state percentage for each mouse during iteration b
mouse_mean_state = np.zeros((nmice, len(t), 3))
i = 0
for mouse in mice:
mmouse = Trials[mouse].shape[0]
iselect = rand.randint(0, mmouse, (mmouse,))
for s in [1,2,3]:
#bBS[s][offset:offset+mmouse,:] = Trials[mouse][iselect,:,s-1]
mouse_mean_state[i,:,s-1] = Trials[mouse][iselect,:,s-1].mean(axis=0)
i += 1
for s in [1,2,3]:
Prob[b,:,s-1] = mouse_mean_state[:,:,s-1].mean(axis=0)
else:
mx_iter = np.zeros((ntrials, len(t), 3))
for b in range(nboots):
# for each iteration select randomly select ntrials mice
irand_mice = rand.randint(0, nmice, ntrials)
# average brain state percentage for each mouse during iteration b
# mouse_mean_state = np.zeros((nmice, len(t), 3))
i = 0
# there are ntrials mice
for j in irand_mice:
mouse = mice[irand_mice[j]]
# we have nmouse trials per mouse
mmouse = Trials[mouse].shape[0]
# select one random trial from the current mouse
iselect = rand.randint(0, mmouse)
for s in [1, 2, 3]:
mx_iter[i,:,s-1] = Trials[mouse][iselect,:,s-1]
i += 1
# mx_iter is the resampled data set for bootstrap iteration b
# now we calculate the statistics we're interesting in, which is the mean
for s in [1, 2, 3]:
Prob[b,:,s-1] = mx_iter[:,:,s-1].mean(axis=0)
# simple average for each brainstate across mice (w/o) bootstrapping
Prob_mean = np.zeros((nmice, len(t), 3))
for s in [1,2,3]:
i = 0
for mouse in mice:
Prob_mean[i,:,s-1] = Trials[mouse][:,:,s-1].mean(axis=0)
i += 1
usProb = Prob.copy()
Prob = np.sort(Prob, axis=0)
Bounds = np.zeros((2, len(t), 3))
a = int((nboots * alpha) / 2.0)
for s in [1,2,3]:
Bounds[0,:,s-1] = Prob[a,:,s-1]
Bounds[1,:,s-1] = Prob[-a,:, s-1]
# smooth_data
if sf > 0:
for s in range(3):
Bounds[0, :, s] = smooth_data(Bounds[0, :, s], sf)
Bounds[1, :, s] = smooth_data(Bounds[1, :, s], sf)
for i in range(nmice):
for s in range(3):
Prob_mean[i, :, s] = smooth_data(Prob_mean[i,:,s], sf)
# plot figure
colors = np.array([[0, 1, 1], [0.5, 0, 1], [0.6, 0.6, 0.6]])
br_states = {1:'REM', 2:'Wake', 3:'NREM'}
#colors = np.array([[55,255,255], [153,255,153],[153,153,153]])/255.
it = np.where((t>=-pre+edge) & (t<=post-edge))[0]
plt.ion()
plt.figure()
ax = plt.axes([0.15, 0.15, 0.6, 0.7])
for s in [3,2,1]:
ax.fill_between(t[it], Bounds[0,it,s-1], Bounds[1,it,s-1], color=colors[s-1,:], alpha=0.8, zorder=3, edgecolor=None)
ax.plot(t[it], Prob_mean[:, it, s-1].mean(axis=0), color=colors[s-1,:], label=br_states[s])
ax.add_patch(patches.Rectangle((0, 0), laser_dur, 100, facecolor=[0.6, 0.6, 1], edgecolor=[0.6, 0.6, 1]))
plt.xlim([-pre+edge, post-edge])
plt.ylim([0,100])
plt.xlabel('Time (s)')
plt.ylabel('Brain state (%)')
plt.legend(bbox_to_anchor = (1.0, 0.7, 1., .102), loc = 3, mode = 'expand', ncol = 1, frameon = False)
box_off(ax)
plt.draw()
# statistics
# OLD VERSION
# ibase = np.where((t>=-laser_dur) & (t<0))[0]
# ilsr = np.where((t>=0) & (t<laser_dur))[0]
# P = np.zeros((3,))
# Mod = np.zeros((3,))
# for istate in [1,2,3]:
# basel = usProb[:,ibase,istate-1].mean(axis=1)
# laser = usProb[:,ilsr, istate-1].mean(axis=1)
# d = laser - basel
# if np.mean(d) >= 0:
# # now we want all values be larger than 0
# p = len(np.where(d>0)[0]) / (1.0*nboots)
# sig = 1 - p
# if sig == 0:
# sig = 1.0/nboots
# Mod[istate-1] = (np.mean(laser) / np.mean(basel) - 1) * 100
# else:
# p = len(np.where(d<0)[0]) / (1.0*nboots)
# sig = 1 - p
# if sig == 0:
# sig = 1.0/nboots
# Mod[istate-1] = -(1 - np.mean(laser) / np.mean(basel)) * 100
# P[istate-1] = sig
# NEW VERSION
ibase = np.where((t>=-laser_dur) & (t<0))[0]
ilsr = np.where((t>=0) & (t<laser_dur))[0]
P = np.zeros((3,))
Mod = np.zeros((3,))
for istate in [1,2,3]:
basel = usProb[:,ibase,istate-1].mean(axis=1)
laser = usProb[:,ilsr, istate-1].mean(axis=1)
d = laser - basel
p = 2 * np.min([len(np.where(d > 0)[0]) / nboots, len(np.where(d <= 0)[0]) / nboots])
if np.mean(d) >= 0:
# now we want all values be larger than 0
#p = len(np.where(d>0)[0]) / (1.0*nboots)
sig = p
if sig == 0:
sig = 1.0/nboots
Mod[istate-1] = (np.mean(laser) / np.mean(basel) - 1) * 100
else:
# p = len(np.where(d<0)[0]) / (1.0*nboots)
sig = p
if sig == 0:
sig = 1.0/nboots
Mod[istate-1] = -(1 - np.mean(laser) / np.mean(basel)) * 100
P[istate-1] = sig
labels = {1:'REM', 2:'Wake', 3:'NREM'}
for s in [1,2,3]:
print('%s is changed by %f perc.; P = %f, bootstrap' % (labels[s], Mod[s-1], P[s-1]))
print("n = %d mice" % len(mice))
if len(fig_file) > 0:
plt.savefig(fig_file, bbox_inches="tight")
return P, Mod
def _despine_axes(ax):
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
ax.spines["bottom"].set_visible(False)
ax.spines["left"].set_visible(False)
ax.axes.get_xaxis().set_visible(False)
ax.axes.get_yaxis().set_visible(False)
def sleep_example(ppath, name, tlegend, tstart, tend, fmax=30, fig_file='', vm=[], ma_thr=10,
fontsize=12, cb_ticks=[], emg_ticks=[], r_mu = [10, 100],
fw_color=True, pemg_ampl=False, raw_ex = [], eegemg_legend=[], eegemg_max=[]):
"""
plot sleep example
:param ppath: base folder
:param name: recording name
:param tstart: start (in seconds) of shown example interval
:param tend: end of example interval
:param tlegend: length of time legend
:param fmax: maximum frequency shown for EEG spectrogram
:param fig_file: file name where figure will be saved
:param vm: saturation of EEG spectrogram
:param fontsize: fontsize
:param cb_ticks: ticks for colorbar
:param emg_ticks: ticks for EMG amplitude axis (uV)
:param r_mu: range of frequencies for EMG amplitude
:param fw_color: if True, use standard color scheme for brainstate (gray - NREM, violet - Wake, cyan - REM);
otherwise use Shinjae's color scheme
:param pemg_ampl: if True, plot EMG amplitude, other EMG raw traces
:param raw_ex: list of tuples; e.g. if you wish to show 2 raw examples of length t s at time point i and j s,
set raw_ex = [(i,t), (j,t)].
If raw_ex == [], no raw traces are plotted
The raw examples are labeled by gray rectangles
:param eegemg_legend: list with 2 floats: scale bar (in micro Volts) for EEG and EMG raw example
:param eegemg_max: list of 2 floats, the y range (ylim) for EEG and EMG raw examples (in micro Volts)
goes from -eegemg_max[0] to eegemg_max[0] (for EEG) and
from -eegemg_max[1] to eegemg_max[1] (for EMG)
Example call including EEG/EMG raw traces:
sleepy.sleep_example(ppath, name2, 300, 1000, 4000, raw_ex=[(2140, 5), (3000, 5)],
eegemg_legend=[200, 200], eegemg_max=[200, 200],
fig_file='/Users/tortugar/Desktop/example.png')
"""
set_fontarial()
set_fontsize(fontsize)
# True, if laser exists, otherwise set to False
plaser = True
sr = get_snr(ppath, name)
nbin = np.round(2.5 * sr)
dt = nbin * 1 / sr
ddt = 1.0/sr
istart = int(np.round(tstart/dt))
iend = int(np.round(tend/dt))
dur = (iend-istart+1)*dt
istart_emg = int(istart*nbin)
iend_emg = int((iend+1)*nbin)
M,K = load_stateidx(ppath, name)
#kcut = np.where(K>=0)[0]
#M = M[kcut]
if tend==-1:
iend = len(M)
M = M[istart:iend]
seq = get_sequences(np.where(M==2)[0])
for s in seq:
if len(s)*dt <= ma_thr:
M[s] = 3
t = np.arange(0, len(M))*dt
t_emg = np.arange(0, iend_emg-istart_emg)*ddt
P = so.loadmat(os.path.join(ppath, name, 'sp_%s.mat' % name), squeeze_me=True)
SPEEG = P['SP']
# calculate median for choosing right saturation for heatmap
med = np.median(SPEEG.max(axis=0))
if len(vm) == 0:
vm = [0, med*2.5]
#t = np.squeeze(P['t'])
freq = P['freq']
if pemg_ampl:
P = so.loadmat(os.path.join(ppath, name, 'msp_%s.mat' % name), squeeze_me=True)
SPEMG = P['mSP']#/1000000.0
else:
emg = so.loadmat(os.path.join(ppath, name, 'EMG.mat'), squeeze_me=True)['EMG']
# load laser
if not os.path.isfile(os.path.join(ppath, name, 'laser_%s.mat' % name)):
plaser = False
if plaser:
laser = load_laser(ppath, name)
idxs, idxe = laser_start_end(laser, SR=sr)
idxs = [int(i / nbin) for i in idxs]
idxe = [int(i / nbin) for i in idxe]
# laser
if plaser:
laser_start = []
laser_end = []
for (i,j) in zip(idxs, idxe):
if i>=istart and j <= iend:
laser_start.append(i-istart)
laser_end.append(j-istart)
# create figure
plt.ion()
plt.figure(figsize=(8,4))
# axis in the background to draw laser patches
axes_back = plt.axes([0.1, .4, 0.8, 0.52])
_despine_axes(axes_back)
if plaser:
for (i,j) in zip(laser_start, laser_end):
axes_back.add_patch(patches.Rectangle((i*dt, 0), (j-i+1)*dt, 1, facecolor=[0.6, 0.6, 1], edgecolor=[0.6, 0.6, 1]))
axes_back.text(laser_end[0] * dt + dur * 0.01, 0.94, 'Laser', color=[0.6, 0.6, 1])
plt.ylim((0,1))
plt.xlim([t[0], t[-1]])
# show brainstate
axes_brs = plt.axes([0.1, 0.4, 0.8, 0.05])
cmap = plt.cm.jet
if fw_color:
my_map = cmap.from_list('brs', [[0, 0, 0], [0, 1, 1], [0.6, 0, 1], [0.8, 0.8, 0.8]], 4)
else:
my_map = cmap.from_list('brs', [[0, 0, 0], [153 / 255.0, 76 / 255.0, 9 / 255.0],
[120 / 255.0, 120 / 255.0, 120 / 255.0], [1, 0.75, 0]], 4)
tmp = axes_brs.pcolorfast(t, [0, 1], np.array([M]), vmin=0, vmax=3)
tmp.set_cmap(my_map)
axes_brs.axis('tight')
_despine_axes(axes_brs)
axes_legend = plt.axes([0.1, 0.33, 0.8, 0.05])
plt.ylim((0,1.1))
plt.xlim([t[0], t[-1]])
plt.plot([0, tlegend], [1, 1], color='black', lw=1)
plt.text(tlegend/4.0, 0.1, str(tlegend) + ' s')
_despine_axes(axes_legend)
# show spectrogram
ifreq = np.where(freq <= fmax)[0]
# axes for colorbar
axes_cbar = plt.axes([0.82, 0.68, 0.1, 0.2])
# axes for EEG spectrogram
axes_spec = plt.axes([0.1, 0.68, 0.8, 0.2], sharex=axes_brs)
im = axes_spec.pcolorfast(t, freq[ifreq], SPEEG[ifreq, istart:iend], cmap='jet', vmin=vm[0], vmax=vm[1])
axes_spec.axis('tight')
axes_spec.set_xticklabels([])
axes_spec.set_xticks([])
axes_spec.spines["bottom"].set_visible(False)
plt.ylabel('Freq (Hz)')
box_off(axes_spec)
plt.xlim([t[0], t[-1]])
# colorbar for EEG spectrogram
cb = plt.colorbar(im, ax=axes_cbar, pad=0.0, aspect=10.0)
cb.set_label('Power ($\mathrm{\mu}$V$^2$s)')
if len(cb_ticks) > 0:
cb.set_ticks(cb_ticks)
axes_cbar.set_alpha(0.0)
_despine_axes(axes_cbar)
# show EMG
axes_emg = plt.axes([0.1, 0.5, 0.8, 0.1], sharex=axes_spec)
if pemg_ampl:
i_mu = np.where((freq >= r_mu[0]) & (freq <= r_mu[1]))[0]
p_mu = np.sqrt(SPEMG[i_mu, :].sum(axis=0) * (freq[1] - freq[0])) #* 1000.0 # back to muV
axes_emg.plot(t, p_mu[istart:iend], color='black')
# * 1000: to go from mV to uV
if len(emg_ticks) > 0:
axes_emg.set_yticks(emg_ticks)
plt.ylabel('Ampl. ' + '$\mathrm{(\mu V)}$')
plt.xlim((t[0], t[-1] + 1))
else:
axes_emg.plot(t_emg, emg[istart_emg:iend_emg], color='black', lw=0.2)
plt.xlim((t_emg[0], t_emg[-1] + 1))
box_off(axes_emg)
axes_emg.patch.set_alpha(0.0)
axes_emg.spines["bottom"].set_visible(False)
# axis for raw data example
if len(raw_ex) > 0:
axes_raw_ex = plt.axes([0.1, .39, 0.8, 0.51])
axes_raw_ex.patch.set_alpha(0)
_despine_axes(axes_raw_ex)
for (ta, tlen) in raw_ex:
ta = ta-tstart
axes_raw_ex.add_patch(patches.Rectangle((ta, 0), tlen, 1, fill=False, edgecolor=[0.4, 0.4, 0.4], lw=0.3))
plt.ylim((0,1))
plt.xlim([t[0], t[-1]])
eeg = so.loadmat(os.path.join(ppath, name, 'EEG.mat'), squeeze_me=True)['EEG']
emg = so.loadmat(os.path.join(ppath, name, 'EMG.mat'), squeeze_me=True)['EMG']
# axes to label EEG EMG
ax_eeg_label = plt.axes([0.04, 0.18, 0.05, 0.1])
ax_eeg_label.set_xlim([0, 1])
ax_eeg_label.set_ylim([0, 1])
ax_eeg_label.text(0, 0.5, 'EEG', verticalalignment='center')
_despine_axes(ax_eeg_label)
ax_emg_label = plt.axes([0.04, 0.05, 0.05, 0.1])
ax_emg_label.set_xlim([0, 1])
ax_emg_label.set_ylim([0, 1])
ax_emg_label.text(0, 0.5, 'EMG', verticalalignment='center')
_despine_axes(ax_emg_label)
# axes for legend
ax_eeg_legend = plt.axes([0.92, 0.05, 0.05, 0.1])
ax_emg_legend = plt.axes([0.92, 0.18, 0.05, 0.1])
ax_eeg_legend.set_xlim([0, 1])
ax_emg_legend.set_xlim([0, 1])
ax_eeg_legend.set_ylim([-eegemg_max[0], eegemg_max[0]])
ax_emg_legend.set_ylim([-eegemg_max[1], eegemg_max[1]])
ax_eeg_legend.plot([0., 0.], [-eegemg_legend[0]/2, eegemg_legend[0]/2], color='black')
ax_emg_legend.plot([0., 0.], [-eegemg_legend[1]/2, eegemg_legend[1]/2], color='black')
ax_eeg_legend.text(0.1, -eegemg_legend[0]/2, str(eegemg_legend[0]/1000) + 'mV', rotation=90, fontsize=8)
ax_emg_legend.text(0.1, -eegemg_legend[1]/2, str(eegemg_legend[1]/1000) + 'mV', rotation=90, fontsize=8)
_despine_axes(ax_eeg_legend)
_despine_axes(ax_emg_legend)
nraw_ex = len(raw_ex)
raw_axes_eeg = []
raw_axes_emg = []
len_x = 0.8/nraw_ex-0.02
start_x = np.linspace(0.1+len_x, 0.9, nraw_ex) - len_x
for i in range(nraw_ex):
a = plt.axes([start_x[i], 0.05, (0.8/nraw_ex)-0.02, .1])
raw_axes_emg.append(a)
a = plt.axes([start_x[i], 0.18, (0.8/nraw_ex)-0.02, .1])
raw_axes_eeg.append(a)
for (ax, i) in zip(raw_axes_eeg, range(len(raw_ex))):
ta, tlen = raw_ex[i]
idx = range(int(ta*sr), int(ta*sr+tlen*sr))
t_eeg = np.arange(0, len(idx))*ddt
ax.plot(t_eeg, eeg[idx], color='k', lw=0.5)
ax.set_xlim([t_eeg[0], t_eeg[-1]])
_despine_axes(ax)
ax.set_ylim([-eegemg_max[0], eegemg_max[0]])
for (ax, i) in zip(raw_axes_emg, range(len(raw_ex))):
ta, tlen = raw_ex[i]
idx = range(int(ta*sr), int(ta*sr+tlen*sr))
t_eeg = np.arange(0, len(idx))*ddt
ax.plot(t_eeg, emg[idx], color='k', lw=0.5)
ax.set_xlim([t_eeg[0], t_eeg[-1]])
_despine_axes(ax)
ax.set_ylim([-eegemg_max[1], eegemg_max[1]])
axes_raw_time = plt.axes([0.1, 0.03, len_x, 0.02])
plt.plot([0, tlen/10], [0,0], color='black', lw=0.8)
plt.ylim([-1,1])
plt.xlim([t_eeg[0], t_eeg[-1]])
_despine_axes(axes_raw_time)
if len(fig_file) > 0:
save_figure(fig_file)
plt.show()
def sleep_stats(ppath, recordings, ma_thr=10.0, tstart=0, tend=-1, pplot=True, csv_file=''):
"""
Calculate average percentage of each brain state,
average duration and average frequency
plot histograms for REM, NREM, and Wake durations
@PARAMETERS:
ppath - base folder
recordings - single string specifying recording or list of recordings
@OPTIONAL:
ma_thr - threshold for wake periods to be considered as microarousals
tstart - only consider recorded data starting from time tstart, default 0s
tend - only consider data recorded up to tend s, default -1, i.e. everything till the end
pplot - generate plot in the end; True or False
csv_file - file where data should be saved as csv file (e.g. csv_file = '/home/Users/Franz/Documents/my_data.csv')
@RETURN:
ndarray of percentages (# mice x [REM,Wake,NREM])
ndarray of state durations
ndarray of transition frequency / hour
"""
if type(recordings) != list:
recordings = [recordings]
Percentage = {}
Duration = {}
Frequency = {}
mice = []
for rec in recordings:
idf = re.split('_', os.path.split(rec)[-1])[0]
if not idf in mice:
mice.append(idf)
Percentage[idf] = {1:[], 2:[], 3:[]}
Duration[idf] = {1:[], 2:[], 3:[]}
Frequency[idf] = {1:[], 2:[], 3:[]}
nmice = len(Frequency)
for rec in recordings:
idf = re.split('_', os.path.split(rec)[-1])[0]
SR = get_snr(ppath, rec)
NBIN = np.round(2.5*SR)
dt = NBIN * 1/SR
# load brain state
M, K = load_stateidx(ppath, rec)
kcut = np.where(K >= 0)[0]
M = M[kcut]
istart = int(np.round((1.0 * tstart) / dt))
if tend==-1:
iend = len(M)-1
else:
iend = int(np.round((1.0*tend) / dt))
M[np.where(M==5)] = 2
# polish out microarousals
seq = get_sequences(np.where(M==2)[0])
for s in seq:
if np.round(len(s)*dt) <= ma_thr:
M[s] = 3
midx = np.arange(istart,iend+1)
Mcut = M[midx]
nm = len(Mcut)*1.0
# get percentage of each state
for s in [1,2,3]:
Percentage[idf][s].append(len(np.where(Mcut==s)[0]) / nm)
# get frequency of each state
for s in [1,2,3]:
Frequency[idf][s].append( len(get_sequences(np.where(Mcut==s)[0])) * (3600. / (nm*dt)) )
# get average duration for each state
for s in [1,2,3]:
seq = get_sequences(np.where(Mcut==s)[0])
Duration[idf][s] += [len(i)*dt for i in seq]
PercMx = np.zeros((nmice,3))
i=0
for k in mice:
for s in [1,2,3]:
PercMx[i,s-1] = np.array(Percentage[k][s]).mean()
i += 1
PercMx *= 100
FreqMx = np.zeros((nmice,3))
i = 0
for k in mice:
for s in [1,2,3]:
FreqMx[i,s-1] = np.array(Frequency[k][s]).mean()
i += 1
DurMx = np.zeros((nmice,3))
i = 0
for k in mice:
for s in [1,2,3]:
DurMx[i,s-1] = np.array(Duration[k][s]).mean()
i += 1
DurHist = {1:[], 2:[], 3:[]}
for s in [1,2,3]:
DurHist[s] = np.squeeze(np.array(reduce(lambda x,y: x+y, [Duration[k][s] for k in Duration])))
if pplot:
clrs = sns.color_palette("husl", nmice)
plt.ion()
# plot bars summarizing results - Figure 1
plt.figure(figsize=(10, 5))
ax = plt.axes([0.1, 0.15, 0.2, 0.8])
plt.bar([1,2,3], PercMx.mean(axis=0), align='center', color='gray', fill=False)
plt.xticks([1,2,3], ['REM', 'Wake', 'NREM'], rotation=60)
for i in range(nmice):
plt.plot([1,2,3], PercMx[i,:], 'o', label=mice[i], color=clrs[i])
plt.ylabel('Percentage (%)')
plt.legend(fontsize=9)
plt.xlim([0.2, 3.8])
box_off(ax)
ax = plt.axes([0.4, 0.15, 0.2, 0.8])
plt.bar([1,2,3], DurMx.mean(axis=0), align='center', color='gray', fill=False)
plt.xticks([1,2,3], ['REM', 'Wake', 'NREM'], rotation=60)
for i in range(nmice):
plt.plot([1, 2, 3], DurMx[i, :], 'o', label=mice[i], color=clrs[i])
plt.ylabel('Duration (s)')
plt.xlim([0.2, 3.8])
box_off(ax)
ax = plt.axes([0.7, 0.15, 0.2, 0.8])
plt.bar([1,2,3], FreqMx.mean(axis=0), align='center', color='gray', fill=False)
plt.xticks([1,2,3], ['REM', 'Wake', 'NREM'], rotation=60)
for i in range(nmice):
plt.plot([1, 2, 3], FreqMx[i, :], 'o', label=mice[i], color=clrs[i])
plt.ylabel('Frequency (1/h)')
plt.xlim([0.2, 3.8])
box_off(ax)
plt.show(block=False)
# plot histograms - Figure 2
plt.figure(figsize=(5, 10))
ax = plt.axes([0.2,0.1, 0.7, 0.2])
h, edges = np.histogram(DurHist[1], bins=40, range=(0, 300), density=True)
binWidth = edges[1] - edges[0]
plt.bar(edges[0:-1], h*binWidth, width=5)
plt.xlim((edges[0], edges[-1]))
plt.xlabel('Duration (s)')
plt.ylabel('Freq. REM')
box_off(ax)
ax = plt.axes([0.2,0.4, 0.7, 0.2])
h, edges = np.histogram(DurHist[2], bins=40, range=(0, 1200), density=True)
binWidth = edges[1] - edges[0]
plt.bar(edges[0:-1], h*binWidth, width=20)
plt.xlim((edges[0], edges[-1]))
plt.xlabel('Duration (s)')
plt.ylabel('Freq. Wake')
box_off(ax)
ax = plt.axes([0.2,0.7, 0.7, 0.2])
h, edges = np.histogram(DurHist[3], bins=40, range=(0, 1200), density=True)
binWidth = edges[1] - edges[0]
plt.bar(edges[0:-1], h*binWidth, width=20)
plt.xlim((edges[0], edges[-1]))
plt.xlabel('Duration (s)')
plt.ylabel('Freq. NREM')
box_off(ax)
plt.show()
mouse_list = [[m]*3 for m in mice]
mouse_list = sum(mouse_list, [])
state_list = ['REM', 'Wake', 'NREM']*nmice
df = pd.DataFrame({'mouse':mouse_list, 'state':state_list, 'Perc':PercMx.flatten(), 'Dur':DurMx.flatten(), 'Freq':FreqMx.flatten()})
if len(csv_file) > 0:
df.to_csv(csv_file, index=False)
return PercMx, DurMx, FreqMx, df
def sleep_timecourse_list(ppath, recordings, tbin, n, tstart=0, tend=-1, ma_thr=-1, pplot=True, single_mode=False, csv_file=''):
"""
simplified version of sleep_timecourse
plot sleep timecourse for a list of recordings
The function does not distinguish between control and experimental mice.
It computes/plots the how the percentage, frequency (1/h) of brain states and duration
of brain state episodes evolves over time.
See also sleep_timecourse
@Parameters:
ppath Base folder with recordings
recordings list of recordings as e.g. generated by &load_recordings
tbin duration of single time bin in seconds
n number of time bins
@Optional:
tstart start time of first bin in seconds
tend end time of last bin; end of recording if tend==-1
ma_thr set microarousals (wake periods <= ma_thr seconds) to NREM
if ma_thr==-1, don't do anything
pplot plot figures summarizing results
single_mode if True, plot each single mouse
csv_file string, if non-empty, write data into file $ppath/$csv_file .csv
to load csv file: data = pd.read_csv($csv_file.csv, header=[0,1,2])
@Return:
TimeMx, DurMx, FreqMx, df Dict[state][time_bin x mouse_id]
df is a pandas DataFrame of the format
Perc DUR
REM Wake NREM REM Wake etc.
bin1 ... binn bin1 ... binn bin1 ... bin2 bin1 ... bin2 etc.
mouse1
.
.
.
mousen
"""
if type(recordings) != list:
recordings = [recordings]
Mice = {}
mouse_order = []
for rec in recordings:
idf = re.split('_', os.path.split(rec)[-1])[0]
if not idf in mouse_order:
mouse_order.append(idf)
Mice[idf] = 1
Mice = list(Mice.keys())
TimeCourse = {}
FreqCourse = {}
DurCourse = {}
for rec in recordings:
idf = re.split('_', rec)[0]
SR = get_snr(ppath, rec)
NBIN = np.round(2.5*SR)
# time bin in Fourier time
dt = NBIN * 1/SR
M,K = load_stateidx(ppath, rec)
kcut = np.where(K>=0)[0]
#kidx = np.setdiff1d(np.arange(0, M.shape[0]), kcut)
M = M[kcut]
M[np.where(M)==5] = 2
# polish out microarousals
if ma_thr>0:
seq = get_sequences(np.where(M==2)[0])
for s in seq:
if len(s)*dt <= ma_thr:
M[s] = 3
if tend==-1:
iend = len(M)-1
else:
iend = int(np.round((1.0*tend) / dt))
M = M[0:iend+1]
istart = int(np.round((1.0*tstart) / dt))
ibin = int(np.round(tbin / dt))
# how brain state percentage changes over time
perc_time = []
for i in range(n):
#midx = np.arange(istart+i*ibin, istart+(i+1)*ibin)
#midx = np.setdiff1d(midx, kcut)
#M_cut = M[np.arange(istart+i*ibin, istart+(i+1)*ibin)]
M_cut = M[(istart+i*ibin):(istart+(i+1)*ibin)]
perc = []
for s in [1,2,3]:
perc.append( len(np.where(M_cut==s)[0]) / (1.0*len(M_cut)) )
perc_time.append(perc)
perc_vec = np.zeros((n,3))
for i in range(3):
perc_vec[:,i] = np.array([v[i] for v in perc_time])
TimeCourse[rec] = perc_vec
# how frequency of sleep stage changes over time
freq_time = []
for i in range(n):
#midx = np.arange(istart+i*ibin, istart+(i+1)*ibin)
#midx = np.setdiff1d(midx, kcut)
#M_cut = M[np.arange(istart+i*ibin, istart+(i+1)*ibin)]
M_cut = M[(istart+i*ibin):(istart+(i+1)*ibin)]
freq = []
for s in [1,2,3]:
tmp = len(get_sequences(np.where(M_cut==s)[0])) * (3600. / (len(M_cut)*dt))
freq.append(tmp)
freq_time.append(freq)
freq_vec = np.zeros((n,3))
for i in range(3):
freq_vec[:,i] = np.array([v[i] for v in freq_time])
FreqCourse[rec] = freq_vec
# how duration of sleep stage changes over time
dur_time = []
for i in range(n):
#midx = np.arange(istart+i*ibin, istart+(i+1)*ibin)
#midx = np.setdiff1d(midx, kcut)
M_cut = M[(istart+i*ibin):(istart+(i+1)*ibin)]
dur = []
for s in [1,2,3]:
tmp = get_sequences(np.where(M_cut==s)[0])
tmp = np.array([len(j)*dt for j in tmp]).mean()
dur.append(tmp)
dur_time.append(dur)
dur_vec = np.zeros((n,3))
for i in range(3):
dur_vec[:,i] = np.array([v[i] for v in dur_time])
DurCourse[rec] = dur_vec
# collect all recordings belonging to a Control mouse
TimeCourseMouse = {}
DurCourseMouse = {}
FreqCourseMouse = {}
# Dict[mouse_id][time_bin x br_state]
for mouse in Mice:
TimeCourseMouse[mouse] = []
DurCourseMouse[mouse] = []
FreqCourseMouse[mouse] = []
for rec in recordings:
idf = re.split('_', rec)[0]
TimeCourseMouse[idf].append(TimeCourse[rec])
DurCourseMouse[idf].append(DurCourse[rec])
FreqCourseMouse[idf].append(FreqCourse[rec])
mx = np.zeros((n, len(Mice)))
TimeMx = {1:mx, 2:mx.copy(), 3:mx.copy()}
mx = np.zeros((n, len(Mice)))
DurMx = {1:mx, 2:mx.copy(), 3:mx.copy()}
mx = np.zeros((n, len(Mice)))
FreqMx = {1:mx, 2:mx.copy(), 3:mx.copy()}
# Dict[R|W|N][time_bin x mouse_id]
i = 0
for k in mouse_order:
for s in range(1,4):
tmp = np.array(TimeCourseMouse[k]).mean(axis=0)
TimeMx[s][:,i] = tmp[:,s-1]
tmp = np.array(DurCourseMouse[k]).mean(axis=0)
DurMx[s][:,i] = tmp[:,s-1]
tmp = np.array(FreqCourseMouse[k]).mean(axis=0)
FreqMx[s][:,i] = tmp[:,s-1]
i += 1
if pplot:
clrs = sns.color_palette("husl", len(mouse_order))
label = {1:'REM', 2:'Wake', 3:'NREM'}
tlabel = np.linspace(istart*dt, istart*dt+n*ibin*dt, n+1)
t = np.linspace(istart*dt, istart*dt+n*ibin*dt, n+1)[0:-1] + (ibin*dt/2.0)
t /= 3600.0
tlabel /= 3600.0
# plot percentage of brain state as function of time
plt.ion()
plt.figure()
for s in range(1,4):
ax = plt.axes([0.1, (s-1)*0.3+0.1, 0.8, 0.2])
if not single_mode:
plt.errorbar(t, np.nanmean(TimeMx[s],axis=1), yerr = np.nanstd(TimeMx[s],axis=1), color='gray', fmt = 'o', linestyle='-', linewidth=2, elinewidth=2)
else:
for i in range(len(mouse_order)):
plt.plot(t, TimeMx[s][:,i], 'o-', linewidth=1.5, color=clrs[i])
if s==3:
ax.legend(mouse_order, bbox_to_anchor = (0., 1.0, 1., .102), loc=3, mode='expand', ncol=len(mouse_order), frameon=False)
box_off(ax)
plt.xlim((-0.5, n-0.5))
if s==1:
#plt.ylim([0, 0.2])
pass
else:
plt.ylim([0, 1.0])
plt.ylabel('Perc ' + label[s] + '(%)')
plt.xticks(tlabel)
plt.xlim([tlabel[0], tlabel[-1]])
if s == 1:
plt.xlabel('Time (h)')
plt.draw()
# plot duration as function of time
plt.figure()
for s in range(1,4):
ax = plt.axes([0.1, (s-1)*0.3+0.1, 0.8, 0.2])
if not single_mode:
plt.errorbar(t, np.nanmean(DurMx[s],axis=1), yerr = np.nanstd(DurMx[s],axis=1), color='gray', fmt = 'o', linestyle='-', linewidth=2, elinewidth=2)
else:
for i in range(len(mouse_order)):
plt.plot(t, DurMx[s][:,i], 'o-', linewidth=1.5, color=clrs[i])
if s==3:
ax.legend(mouse_order, bbox_to_anchor = (0., 1.0, 1., .102), loc=3, mode='expand', ncol=len(mouse_order), frameon=False)
box_off(ax)
plt.xlim((-0.5, n-0.5))
plt.ylabel('Dur ' + label[s] + '(s)')
plt.xticks(tlabel)
plt.xlim([tlabel[0], tlabel[-1]])
if s==1:
plt.xlabel('Time (h)')
plt.draw()
# plot frequency as function of time
plt.figure()
for s in range(1,4):
ax = plt.axes([0.1, (s-1)*0.3+0.1, 0.8, 0.2])
if not single_mode:
plt.errorbar(t, np.nanmean(FreqMx[s],axis=1), yerr = np.nanstd(FreqMx[s],axis=1), color='gray', fmt = 'o', linestyle='-', linewidth=2, elinewidth=2)
else:
for i in range(len(mouse_order)):
plt.plot(t, FreqMx[s][:,i], 'o-', linewidth=1.5, color=clrs[i])
if s==3:
ax.legend(mouse_order, bbox_to_anchor = (0., 1.0, 1., .102), loc=3, mode='expand', ncol=len(mouse_order), frameon=False)
box_off(ax)
plt.xlim((-0.5, n-0.5))
plt.ylabel('Freq ' + label[s] + '(1/h)')
plt.xticks(tlabel)
plt.xlim([tlabel[0], tlabel[-1]])
if s==1:
plt.xlabel('Time (h)')
plt.draw()
# write data into dataframe and csv file
bins = ['bin' + str(i+1) for i in range(n)]
columns = pd.MultiIndex.from_product([['Perc', 'Dur', 'Freq'], ['REM', 'Wake', 'NREM'], bins],
names=['stats', 'state', 'bin'])
D = np.concatenate((TimeMx[1].T, TimeMx[2].T, TimeMx[3].T, DurMx[1].T, DurMx[2].T, DurMx[3].T, FreqMx[1].T, FreqMx[2].T, FreqMx[3].T), axis=1)
df = pd.DataFrame(D, index=mouse_order, columns=columns)
if len(csv_file) > 0:
df.to_csv(csv_file, index=False)
return TimeMx, DurMx, FreqMx, df
def ma_timecourse_list(ppath, recordings, tbin, n, tstart=0, tend=-1, ma_thr=20, pplot=True, single_mode=False, csv_file=''):
"""
Calculate percentage, duration, and frequency of microarousals
:param ppath: base folder
:param recordings: single recording or list of recordings
:param tbin: time bin in seconds
:param n: number of time bins
:param tstart: start time in recording(s) for analysi
:param tend: end time for analysis
:param ma_thr: microarousal threshold; any wake period shorter than $ma_thr will be considered as microarousal
:param pplot: if True, plot figure
:param single_mode: if True, plot each single mouse with different color
:param csv_file: string, if non-empty, write data into file "csv_file";
file name should end with ".csv"
:return: TimeMX, DurMX, FreqMx, df - np.array(# time bins x mice)
TimeMX, DurMX, FreqMx: arrays with shape "time bins x mice"
df: DataFrame with columns: mouse, perc, dur, freq, bin
For example, to get the first time bins of perc, dur, freq of mouse M1 type
df[(df.mouse == 'M1') & (df.bin == 't0')]
"""
if type(recordings) != list:
recordings = [recordings]
mouse_order = []
for rec in recordings:
idf = re.split('_', rec)[0]
if not idf in mouse_order:
mouse_order.append(idf)
TimeCourse = {}
FreqCourse = {}
DurCourse = {}
for rec in recordings:
SR = get_snr(ppath, rec)
NBIN = np.round(2.5 * SR)
# time bin in Fourier time
dt = NBIN * 1 / SR
M, K = load_stateidx(ppath, rec)
kcut = np.where(K >= 0)[0]
# kidx = np.setdiff1d(np.arange(0, M.shape[0]), kcut)
M = M[kcut]
Mnew = np.zeros(M.shape)
Mnew[np.where(M) == 5] = 1
# polish out microarousals
if ma_thr > 0:
seq = get_sequences(np.where(M == 2)[0])
for s in seq:
if len(s) * dt <= ma_thr:
Mnew[s] = 1
M = Mnew
if tend == -1:
iend = len(M) - 1
else:
iend = int(np.round((1.0 * tend) / dt))
M = M[0:iend + 1]
istart = int(np.round((1.0 * tstart) / dt))
ibin = int(np.round(tbin / dt))
# how brain state percentage changes over time
perc_time = []
for i in range(n):
midx = np.arange(istart + i * ibin, istart + (i + 1) * ibin)
# midx = np.setdiff1d(midx, kcut)
M_cut = M[midx]
perc = len(np.where(M_cut == 1)[0]) / (1.0 * len(M_cut))
perc_time.append(perc)
TimeCourse[rec] = np.array(perc_time)
# how frequency of sleep stage changes over time
freq_time = []
for i in range(n):
midx = np.arange(istart + i * ibin, istart + (i + 1) * ibin)
# midx = np.setdiff1d(midx, kcut)
M_cut = M[midx]
s = 1
freq = len(get_sequences(np.where(M_cut == s)[0])) * (3600. / (len(M_cut) * dt))
freq_time.append(freq)
FreqCourse[rec] = np.array(freq_time)
# how duration of microarousals changes over time
dur_time = []
for i in range(n):
midx = np.arange(istart + i * ibin, istart + (i + 1) * ibin)
# midx = np.setdiff1d(midx, kcut)
M_cut = M[midx]
s = 1
tmp = get_sequences(np.where(M_cut == s)[0])
dur = np.array([len(j) * dt for j in tmp]).mean()
dur_time.append(dur)
DurCourse[rec] = np.array(dur_time)
# collect all recordings belonging to a Control mouse
TimeCourseMouse = {}
DurCourseMouse = {}
FreqCourseMouse = {}
# Dict[mouse_id][time_bin x br_state]
for mouse in mouse_order:
TimeCourseMouse[mouse] = []
DurCourseMouse[mouse] = []
FreqCourseMouse[mouse] = []
for rec in recordings:
idf = re.split('_', rec)[0]
TimeCourseMouse[idf].append(TimeCourse[rec])
DurCourseMouse[idf].append(DurCourse[rec])
FreqCourseMouse[idf].append(FreqCourse[rec])
# np.array(time x mouse_id)
TimeMx = np.zeros((n, len(mouse_order)))
DurMx = np.zeros((n, len(mouse_order)))
FreqMx = np.zeros((n, len(mouse_order)))
i = 0
for k in mouse_order:
tmp = np.array(TimeCourseMouse[k]).mean(axis=0)
TimeMx[:,i] = tmp
tmp = np.array(DurCourseMouse[k]).mean(axis=0)
DurMx[:,i] = tmp
tmp = np.array(FreqCourseMouse[k]).mean(axis=0)
FreqMx[:,i] = tmp
i += 1
# plotting
if pplot:
plot_dict = {0:TimeMx, 1:DurMx, 2:FreqMx}
clrs = sns.color_palette("husl", len(mouse_order))
ylabel = {0:'Perc (%)', 1:'Dur (s)', 2:'Freq ($h^{-1}$)'}
tlabel = np.linspace(istart*dt, istart*dt+n*ibin*dt, n+1)
t = np.linspace(istart*dt, istart*dt+n*ibin*dt, n+1)[0:-1] + (ibin*dt/2.0)
t /= 3600.0
tlabel /= 3600.0
# plot percentage of brain state as function of time
plt.ion()
plt.figure()
for s in range(0, 3):
ax = plt.axes([0.15, s*0.3+0.1, 0.8, 0.2])
if not single_mode:
plt.errorbar(t, np.nanmean(plot_dict[s],axis=1), yerr = np.nanstd(plot_dict[s],axis=1), color='gray', fmt = 'o', linestyle='-', linewidth=2, elinewidth=2)
else:
for i in range(len(mouse_order)):
plt.plot(t, plot_dict[s][:,i], 'o-', linewidth=1.5, color=clrs[i])
if s==2:
ax.legend(mouse_order, bbox_to_anchor = (0., 1.0, 1., .102), loc=3, mode='expand', ncol=len(mouse_order), frameon=False)
box_off(ax)
plt.xlim((-0.5, n-0.5))
plt.ylabel(ylabel[s])
plt.xticks(tlabel)
plt.xlim([tlabel[0], tlabel[-1]])
if s == 0:
plt.xlabel('Time (h)')
plt.draw()
bins = [['t' + str(i)]*len(mouse_order) for i in range(n)]
bins = sum(bins, [])
cols = ['mouse', 'perc', 'dur', 'freq', 'bin']
mice = mouse_order*n
df = pd.DataFrame(columns=cols)
df['mouse'] = mice
df['bin'] = bins
df['perc'] = TimeMx.flatten()
df['dur'] = DurMx.flatten()
df['freq'] = FreqMx.flatten()
if len(csv_file) > 0:
df.to_csv(csv_file, index=False)
return TimeMx, DurMx, FreqMx, df
def transition_timecourse_list(ppath, recordings, tbin, n, tdown=10, tstart=0, tend=-1, ma_thr=-1, pplot=True, single_mode=False, csv_file=''):
if type(recordings) != list:
recordings = [recordings]
mouse_order = []
for rec in recordings:
idf = re.split('_', rec)[0]
if not idf in mouse_order:
mouse_order.append(idf)
Recordings = {idf:[] for idf in mouse_order}
SR = get_snr(ppath, recordings[0])
NBIN = np.round(2.5 * SR)
# time bin in Fourier time
dt = NBIN * 1 / SR
istart = int(np.round((1.0 * tstart) / dt))
ibin = int(np.round(tbin / dt))
idown = int(tdown/dt)
for rec in recordings:
idf = re.split('_', rec)[0]
M = load_stateidx(ppath, rec)[0]
# polish out microarousals
if ma_thr > 0:
seq = get_sequences(np.where(M == 2)[0])
for s in seq:
if len(s) * dt <= ma_thr:
M[s] = 1
if tend == -1:
iend = len(M) - 1
else:
iend = int(np.round((1.0 * tend) / dt))
M = M[0:iend + 1]
# how brain state percentage changes over time
Recordings[idf].append(M)
MX = {idf:[] for idf in mouse_order}
for i in range(n):
for idf in mouse_order:
recs = Recordings[idf]
midx = np.arange(istart + i * ibin, istart + (i + 1) * ibin)
recs = [downsample_states(rec[midx], idown) for rec in recs]
recs = np.array(recs, dtype='int')
#recs = downsample_states(recs, idown)
pmx = complete_transition_matrix(recs, np.array(range(recs.shape[1])))
MX[idf].append(pmx)
#transform MX to a DataFrame
trans_map = {'11':'RR', '12':'RW', '13':'RN',
'21':'WR', '22':'WW', '23':'WN',
'31':'NR', '32':'NW', '33':'NN'}
data = []
for i in range(n):
for si in [1,2,3]:
for sj in [1,2,3]:
for idf in mouse_order:
trans = trans_map[str(si)+str(sj)]
data += [[idf, 't'+str(i), MX[idf][i][si-1, sj-1], trans]]
df = pd.DataFrame(data=data, columns=['mouse', 'time', 'prob', 'trans'])
return df
def sleep_through_days(ppath, recordings, tstart=0, tend=-1, stats=0, xticks=[], ma_thr=20, min_dur=[0,0,0], single_mode=True, csv_file = ''):
"""
Follow sleep quantity (percentage, bout duration, or frequency / hour) over multiple days
:param ppath: base folder
:param recordings: list of lists of recordings, for example [[F1_010118n1, F2_010118n1], [F1_010218n1, F1_010218n1]]
specifies the recordings of F1 and F2 for two days
:param tstart: float, quantificiation of sleep starts at $start s
:param tend: float, quantification of sleep ends at $tend s
:param stats: Measured sleep variable (statistics):
0 - percentage, 1 - episode duration, 2 - episode frequency, 3 - latency to first state occurance REM, Wake, and NREM
:param xticks: list of string, specifying the xticks
:param ma_thr: float, wake periods shorter than $ma_thr are considered as microarousals and further converted to NREM
:param min_dur: list with 3 floats, specifying the minimum duration of the first REM, Wake, and NREM period,
only relevant if $stats == 3
:param single_mode: if True, plot each single mouse in different color
:param csv_file: string, save pd.DataFrame to file; the actual file name will be "$csv_file + stats + $stats .csv" and
will be save in the folder $ppath
:return: np.array, mice x [REM,Wake,NREM] x days AND pd.DataFrame
the pd.DataFrame has the following format:
state REM Wake NREM
day Day1 ... Dayn Day1 ... Dayn Day1 ... Dayn
mouse1
.
.
.
mousen
"""
states = {1:'REM', 2:'Wake', 3:'NREM'}
stats_label = {0:'(%)', 1:'Dur (s)', 2: 'Freq. (1/h)', 3: 'Lat. (min)'}
mice_per_day = {}
iday = 0
for day in recordings:
mice = []
for rec in day:
idf = re.split('_', os.path.split(rec)[-1])[0]
if not idf in mice:
mice.append(idf)
mice_per_day[iday] = mice
iday += 1
ndays = len(mice_per_day)
nmice = len(mice_per_day[0])
for i in range(ndays):
for j in range(i+1, ndays):
if mice_per_day[i] != mice_per_day[j]:
print("ERROR: mice on day %d and %d not consistent" % (i+1, j+1))
return
#DayResults: mice x [R|W|N] x days
DayResults = np.zeros((nmice, 3, ndays))
for day in range(ndays):
if stats<=2:
res = sleep_stats(ppath, recordings[day], tstart=tstart, tend=tend, pplot=False, ma_thr=ma_thr)[stats]
else:
res = np.zeros((nmice, 3))
for s in range(1,4):
res[:,s-1] = state_onset(ppath, recordings[day], s, min_dur=min_dur[s-1], tstart=tstart, tend=tend, pplot=False)
DayResults[:,:,day] = res
plt.ion()
clrs = sns.color_palette("husl", nmice)
plt.figure(figsize=(10,6))
for s in range(1, 4):
ax = plt.axes([0.1, (s - 1) * 0.3 + 0.1, 0.8, 0.2])
if single_mode:
for i in range(nmice):
plt.plot(list(range(1,ndays+1)), DayResults[i,s-1,:], 'o-', color=clrs[i], label=mice[i])
else:
plt.errorbar(list(range(1, ndays+1)), DayResults[:, s-1, :].mean(axis=0), yerr=DayResults[:, s-1, :].std(axis=0),
color='gray', label='avg', linewidth=2)
if s == 1:
if len(xticks) == 0:
plt.xticks(list(range(1,ndays+1)))
else:
plt.xticks(list(range(1, ndays + 1), xticks))
else:
plt.xticks(list(range(1, ndays + 1)))
ax.set_xticklabels([])
if s == 3:
ax.legend(bbox_to_anchor=(0., 1.0, 1., .102), loc=3, mode='expand', ncol=nmice,
frameon=False)
box_off(ax)
if s == 1:
plt.xlabel('Day')
plt.ylabel(states[s] + ' ' + stats_label[stats])
if len(xticks) > 0:
col = xticks
else:
col = ['Day' + str(i+1) for i in range(ndays)]
# put data into pandas dataframe
columns = pd.MultiIndex.from_product([['REM', 'Wake', 'NREM'], col], names=['state', 'day'])
D = np.concatenate((DayResults[:,0,:], DayResults[:,1,:], DayResults[:,2,:]), axis=1)
df = | pd.DataFrame(D, index=mice, columns=columns) | pandas.DataFrame |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
READ IN:
1) <NAME> Data "../../../AKJ_Replication/Replication/data/data_replication.csv"
2) Alternative data "../output/alternativedata.csv"
EXPORT:
"../output/alternativedata.csv"
@author: olivergiesecke
"""
import pandas as pd
import numpy as np
import os
import re
ref_df = pd.read_csv("../output/alternativedata.csv")
ref_df["start_date"] = pd.to_datetime(ref_df["start_date"])
ref_df["end_date"] = pd.to_datetime(ref_df["end_date"])
dates = ref_df.drop_duplicates("start_date", "first")["start_date"].reset_index()
dates["year"] = dates.start_date.apply(lambda x:x.year)
dates["month"] =dates.start_date.apply(lambda x:x.month)
dates["dup"] = dates.duplicated(subset=["year","month"])
print(f"Number of duplicates in therms of year and month: {dates['dup'].sum()}")
dates.drop(columns="dup",inplace=True)
econ_df = | pd.read_csv("../../../AKJ_Replication/Replication/data/data_replication.csv") | pandas.read_csv |
# -*- coding: utf-8 -*-
from itertools import product
import numpy as np
import pytest
import pandas.util.testing as tm
from pandas import DatetimeIndex, MultiIndex
from pandas._libs import hashtable
from pandas.compat import range, u
@pytest.mark.parametrize('names', [None, ['first', 'second']])
def test_unique(names):
mi = MultiIndex.from_arrays([[1, 2, 1, 2], [1, 1, 1, 2]], names=names)
res = mi.unique()
exp = MultiIndex.from_arrays([[1, 2, 2], [1, 1, 2]], names=mi.names)
tm.assert_index_equal(res, exp)
mi = MultiIndex.from_arrays([list('aaaa'), list('abab')],
names=names)
res = mi.unique()
exp = MultiIndex.from_arrays([list('aa'), list('ab')], names=mi.names)
tm.assert_index_equal(res, exp)
mi = MultiIndex.from_arrays([list('aaaa'), list('aaaa')], names=names)
res = mi.unique()
exp = MultiIndex.from_arrays([['a'], ['a']], names=mi.names)
tm.assert_index_equal(res, exp)
# GH #20568 - empty MI
mi = MultiIndex.from_arrays([[], []], names=names)
res = mi.unique()
tm.assert_index_equal(mi, res)
def test_unique_datetimelike():
idx1 = DatetimeIndex(['2015-01-01', '2015-01-01', '2015-01-01',
'2015-01-01', 'NaT', 'NaT'])
idx2 = DatetimeIndex(['2015-01-01', '2015-01-01', '2015-01-02',
'2015-01-02', 'NaT', '2015-01-01'],
tz='Asia/Tokyo')
result = MultiIndex.from_arrays([idx1, idx2]).unique()
eidx1 = DatetimeIndex(['2015-01-01', '2015-01-01', 'NaT', 'NaT'])
eidx2 = DatetimeIndex(['2015-01-01', '2015-01-02',
'NaT', '2015-01-01'],
tz='Asia/Tokyo')
exp = MultiIndex.from_arrays([eidx1, eidx2])
tm.assert_index_equal(result, exp)
@pytest.mark.parametrize('level', [0, 'first', 1, 'second'])
def test_unique_level(idx, level):
# GH #17896 - with level= argument
result = idx.unique(level=level)
expected = idx.get_level_values(level).unique()
tm.assert_index_equal(result, expected)
# With already unique level
mi = MultiIndex.from_arrays([[1, 3, 2, 4], [1, 3, 2, 5]],
names=['first', 'second'])
result = mi.unique(level=level)
expected = mi.get_level_values(level)
tm.assert_index_equal(result, expected)
# With empty MI
mi = MultiIndex.from_arrays([[], []], names=['first', 'second'])
result = mi.unique(level=level)
expected = mi.get_level_values(level)
@pytest.mark.parametrize('dropna', [True, False])
def test_get_unique_index(idx, dropna):
mi = idx[[0, 1, 0, 1, 1, 0, 0]]
expected = mi._shallow_copy(mi[[0, 1]])
result = mi._get_unique_index(dropna=dropna)
assert result.unique
tm.assert_index_equal(result, expected)
def test_duplicate_multiindex_labels():
# GH 17464
# Make sure that a MultiIndex with duplicate levels throws a ValueError
with pytest.raises(ValueError):
mi = MultiIndex([['A'] * 10, range(10)], [[0] * 10, range(10)])
# And that using set_levels with duplicate levels fails
mi = MultiIndex.from_arrays([['A', 'A', 'B', 'B', 'B'],
[1, 2, 1, 2, 3]])
with pytest.raises(ValueError):
mi.set_levels([['A', 'B', 'A', 'A', 'B'], [2, 1, 3, -2, 5]],
inplace=True)
@pytest.mark.parametrize('names', [['a', 'b', 'a'], [1, 1, 2],
[1, 'a', 1]])
def test_duplicate_level_names(names):
# GH18872, GH19029
mi = MultiIndex.from_product([[0, 1]] * 3, names=names)
assert mi.names == names
# With .rename()
mi = MultiIndex.from_product([[0, 1]] * 3)
mi = mi.rename(names)
assert mi.names == names
# With .rename(., level=)
mi.rename(names[1], level=1, inplace=True)
mi = mi.rename([names[0], names[2]], level=[0, 2])
assert mi.names == names
def test_duplicate_meta_data():
# GH 10115
mi = MultiIndex(
levels=[[0, 1], [0, 1, 2]],
labels=[[0, 0, 0, 0, 1, 1, 1],
[0, 1, 2, 0, 0, 1, 2]])
for idx in [mi,
mi.set_names([None, None]),
mi.set_names([None, 'Num']),
mi.set_names(['Upper', 'Num']), ]:
assert idx.has_duplicates
assert idx.drop_duplicates().names == idx.names
def test_has_duplicates(idx, idx_dup):
# see fixtures
assert idx.is_unique is True
assert idx.has_duplicates is False
assert idx_dup.is_unique is False
assert idx_dup.has_duplicates is True
mi = MultiIndex(levels=[[0, 1], [0, 1, 2]],
labels=[[0, 0, 0, 0, 1, 1, 1],
[0, 1, 2, 0, 0, 1, 2]])
assert mi.is_unique is False
assert mi.has_duplicates is True
def test_has_duplicates_from_tuples():
# GH 9075
t = [(u('x'), u('out'), u('z'), 5, u('y'), u('in'), u('z'), 169),
(u('x'), u('out'), u('z'), 7, u('y'), u('in'), u('z'), 119),
(u('x'), u('out'), u('z'), 9, u('y'), u('in'), u('z'), 135),
(u('x'), u('out'), u('z'), 13, u('y'), u('in'), u('z'), 145),
(u('x'), u('out'), u('z'), 14, u('y'), u('in'), u('z'), 158),
(u('x'), u('out'), u('z'), 16, u('y'), u('in'), u('z'), 122),
(u('x'), u('out'), u('z'), 17, u('y'), u('in'), u('z'), 160),
(u('x'), u('out'), u('z'), 18, u('y'), u('in'), u('z'), 180),
(u('x'), u('out'), u('z'), 20, u('y'), u('in'), u('z'), 143),
(u('x'), u('out'), u('z'), 21, u('y'), u('in'), u('z'), 128),
(u('x'), u('out'), u('z'), 22, u('y'), u('in'), u('z'), 129),
(u('x'), u('out'), u('z'), 25, u('y'), u('in'), u('z'), 111),
(u('x'), u('out'), u('z'), 28, u('y'), u('in'), u('z'), 114),
(u('x'), u('out'), u('z'), 29, u('y'), u('in'), u('z'), 121),
(u('x'), u('out'), u('z'), 31, u('y'), u('in'), u('z'), 126),
(u('x'), u('out'), u('z'), 32, u('y'), u('in'), u('z'), 155),
(u('x'), u('out'), u('z'), 33, u('y'), u('in'), u('z'), 123),
(u('x'), u('out'), u('z'), 12, u('y'), u('in'), u('z'), 144)]
mi = MultiIndex.from_tuples(t)
assert not mi.has_duplicates
def test_has_duplicates_overflow():
# handle int64 overflow if possible
def check(nlevels, with_nulls):
labels = np.tile(np.arange(500), 2)
level = np.arange(500)
if with_nulls: # inject some null values
labels[500] = -1 # common nan value
labels = [labels.copy() for i in range(nlevels)]
for i in range(nlevels):
labels[i][500 + i - nlevels // 2] = -1
labels += [np.array([-1, 1]).repeat(500)]
else:
labels = [labels] * nlevels + [np.arange(2).repeat(500)]
levels = [level] * nlevels + [[0, 1]]
# no dups
mi = MultiIndex(levels=levels, labels=labels)
assert not mi.has_duplicates
# with a dup
if with_nulls:
def f(a):
return np.insert(a, 1000, a[0])
labels = list(map(f, labels))
mi = MultiIndex(levels=levels, labels=labels)
else:
values = mi.values.tolist()
mi = MultiIndex.from_tuples(values + [values[0]])
assert mi.has_duplicates
# no overflow
check(4, False)
check(4, True)
# overflow possible
check(8, False)
check(8, True)
@pytest.mark.parametrize('keep, expected', [
('first', np.array([False, False, False, True, True, False])),
('last', np.array([False, True, True, False, False, False])),
(False, np.array([False, True, True, True, True, False]))
])
def test_duplicated(idx_dup, keep, expected):
result = idx_dup.duplicated(keep=keep)
tm.assert_numpy_array_equal(result, expected)
@pytest.mark.parametrize('keep', ['first', 'last', False])
def test_duplicated_large(keep):
# GH 9125
n, k = 200, 5000
levels = [np.arange(n), | tm.makeStringIndex(n) | pandas.util.testing.makeStringIndex |
def lstm_prediction(se, stock_symbol):
import pandas as pd
import numpy as np
def fetch_stock_data(se, stock_symbol):
from pandas_datareader import data as pdr
import yfinance as yf
yf.pdr_override()
if se == 'NSE': stock_symbol += ".NS"
return pdr.get_data_yahoo(stock_symbol, period="5y")
from sklearn.preprocessing import MinMaxScaler
from keras.models import Sequential
from keras.layers import Dense, Dropout, LSTM
og_df = fetch_stock_data(se, stock_symbol)
todataframe = og_df.reset_index(inplace=False)
print("\n<----------------------Info of the OG dataset---------------------->")
print(todataframe.info())
print("<-------------------------------------------------------------------->\n")
seriesdata = todataframe.sort_index(ascending=True, axis=0)
new_seriesdata = pd.DataFrame(index=range(0,len(todataframe)),columns=['Date','Close'])
for i in range(0,len(seriesdata)):
new_seriesdata['Date'][i] = seriesdata['Date'][i]
new_seriesdata['Close'][i] = seriesdata['Close'][i]
new_seriesdata.index = new_seriesdata.Date
new_seriesdata.drop('Date', axis=1, inplace=True)
myseriesdataset = new_seriesdata.values
totrain = myseriesdataset
scalerdata = MinMaxScaler(feature_range=(0, 1))
scale_data = scalerdata.fit_transform(myseriesdataset)
x_totrain, y_totrain = [], []
length_of_totrain=len(totrain)
for i in range(60,length_of_totrain):
x_totrain.append(scale_data[i-60:i,0])
y_totrain.append(scale_data[i,0])
x_totrain, y_totrain = np.array(x_totrain), np.array(y_totrain)
x_totrain = np.reshape(x_totrain, (x_totrain.shape[0],x_totrain.shape[1],1))
lstm_model = Sequential()
lstm_model.add(LSTM(units=50, return_sequences=True, input_shape=(x_totrain.shape[1],1)))
lstm_model.add(LSTM(units=50))
lstm_model.add(Dense(1))
lstm_model.compile(loss='mean_squared_error', optimizer='adam')
lstm_model.fit(x_totrain, y_totrain, epochs=1, batch_size=1, verbose=2)
myinputs = new_seriesdata[len(new_seriesdata) - (100) - 60:].values
myinputs = myinputs.reshape(-1,1)
myinputs = scalerdata.transform(myinputs)
tostore_test_result = []
for i in range(60,myinputs.shape[0]):
tostore_test_result.append(myinputs[i-60:i,0])
tostore_test_result = np.array(tostore_test_result)
tostore_test_result = np.reshape(tostore_test_result,(tostore_test_result.shape[0],tostore_test_result.shape[1],1))
myclosing_priceresult = lstm_model.predict(tostore_test_result)
myclosing_priceresult = scalerdata.inverse_transform(myclosing_priceresult)
datelist = pd.date_range(pd.datetime.now().date(), periods=101)[1:]
predicted_df = | pd.DataFrame(myclosing_priceresult, columns=['Close'], index=datelist) | pandas.DataFrame |
"""
Calculate Transporation Statistics
Copyright (c) 2022 Cannlytics
Authors: <NAME> <<EMAIL>>
Created: 1/29/2022
Updated: 2/9/2022
License: MIT License <https://opensource.org/licenses/MIT>
Description: This script calculates various transportation statistics from the
Washington State traceability data (2018-01-31 to 11-10-2021).
Data sources:
- WA State Traceability Data January 2018 - November 2021
https://lcb.app.box.com/s/e89t59s0yb558tjoncjsid710oirqbgd?page=1
https://lcb.app.box.com/s/e89t59s0yb558tjoncjsid710oirqbgd?page=2
Data Guide:
- Washington State Leaf Data Systems Guide
https://lcb.wa.gov/sites/default/files/publications/Marijuana/traceability/WALeafDataSystems_UserManual_v1.37.5_AddendumC_LicenseeUser.pdf
"""
# Standard imports.
from datetime import datetime
from typing import Any, Optional, Tuple
# External imports.
from dotenv import dotenv_values
import googlemaps
import matplotlib.pyplot as plt
from matplotlib.ticker import FuncFormatter
from mpl_toolkits.basemap import Basemap # pip install basemap
import pandas as pd
import polyline # pip install polyline
import seaborn as sns
# Internal imports
from utils import format_thousands
# Specify where your data lives.
DATA_DIR = 'D:\\leaf-data'
# Define the plot style.
palette = sns.color_palette('Set2', n_colors=10)
plt.style.use('fivethirtyeight')
plt.rcParams.update({
'font.family': 'Times New Roman',
'font.size': 20,
})
#------------------------------------------------------------------------------
# Read transfer data.
#------------------------------------------------------------------------------
# Define useful metadata.
transfer_datatypes = {
# 'global_id': 'string',
# 'user_id': 'string',
# 'external_id': 'string',
# 'number_of_edits': 'float',
'void': 'bool',
'from_mme_id': 'string',
'to_mme_id': 'string',
# 'transporting_mme_id': 'string',
# 'from_user_id': 'string',
# 'to_user_id': 'string',
# 'status': 'string',
# 'transfer_type': 'string',
# 'sale_id': 'string',
}
transfer_date_fields = [
'created_at',
# 'updated_at',
# 'hold_starts_at',
# 'hold_ends_at',
# 'deleted_at',
# 'transferred_at',
]
transfer_columns = list(transfer_datatypes.keys()) + transfer_date_fields
# Read in the data.
transfers = pd.read_csv(
f'{DATA_DIR}/InventoryTransfers_0.csv',
sep='\t',
encoding='utf-16',
usecols=transfer_columns,
dtype=transfer_datatypes,
parse_dates=transfer_date_fields,
)
#------------------------------------------------------------------------------
# Augment the data.
#------------------------------------------------------------------------------
# Specify stats to collect.
daily_transfers = {}
daily_transfers_by_license = []
# Specify the time range to calculate statistics.
time_range = pd.date_range(start='2021-10-02', end='2021-10-31')
transfers['created_at_day'] = transfers['created_at'].dt.date
for date in time_range:
# Get the day's data.
day = date.date()
day_data = transfers.loc[
(transfers['created_at_day'] == date) &
(~transfers['void'])
]
total_transfers = len(day_data)
daily_transfers[day] = total_transfers
# Count the number of transfers for each licensee
transfers_by_license = []
senders = list(day_data['from_mme_id'].unique())
for sender in senders:
# license_transfers = {}
sender_data = day_data.loc[day_data['from_mme_id'] == sender]
recipient_count = sender_data['to_mme_id'].value_counts()
try:
try:
for index, value in recipient_count.iterrows():
daily_transfers_by_license.append({
'day': day,
'sender': sender,
'recipient': index,
'count': value,
})
except AttributeError:
index = recipient_count.index[0]
value = recipient_count.values[0]
daily_transfers_by_license.append({
'day': day,
'sender': sender,
'recipient': index,
'count': value,
})
except IndexError:
pass
print('Counted %i transfers for %s' % (total_transfers, day))
#------------------------------------------------------------------------------
# Get sender and recipient licensee details (name, type, latitude, and longitude).
# Licensees data: https://cannlytics.com/data/market/augmented-washington-state-licensees
#------------------------------------------------------------------------------
# Create panel data.
panel = | pd.DataFrame(daily_transfers_by_license) | pandas.DataFrame |
import pandas as pd
import datetime
import numpy as np
import os
import re
import matplotlib.pyplot as plot
import pytz
# @timeit (repeat=3,number=10)
def EclatedSubPlot(SerieAfterGrpBy,ActivatePlotting,ListOfDateAndTime,Abbreviation):
DicoDayOfWeek={
"00":('Mon','Monday'), "01":('Tue','Tuesday'), "02":('Wed','Wednesday'), "03":('Thu','Thursday'),
"04":('Fri','Friday'), "05":('Sat','Saturday'), "06":('Sun','Sunday')
}
DicoMonthOfTheYear = {
"01":("Jan", "January"),"02":("Feb","February"),"03":("Mar","March"),"04":("Apr","April"),"05":("May","May"),
"06":("Jun","June"),"07":("Jul","July"),"08":("Aug","August"),"09":("Sep","September"),"10":("Oct","October"),
"11":("Nov","November"),"12":("Dec","December")
}
df_unstack=SerieAfterGrpBy.unstack(level=0)
nblevels = df_unstack.index.nlevels
if nblevels!=1:
for ColumnsName in ListOfDateAndTime:
ListMultiIndexName=df_unstack.index.names
if ColumnsName in ListMultiIndexName:
level_index=ListMultiIndexName.index(ColumnsName)
if Abbreviation==True:
if ColumnsName=="WeekDay":
df_unstack.index = df_unstack.index.set_levels(df_unstack.index.levels[level_index].map(lambda x : DicoDayOfWeek[x][0],DicoDayOfWeek), level=level_index)
elif ColumnsName=="M":
df_unstack.index = df_unstack.index.set_levels(df_unstack.index.levels[level_index].map(lambda x : DicoMonthOfTheYear[x][0],DicoDayOfWeek), level=level_index)
elif Abbreviation==False:
if ColumnsName=="WeekDay":
df_unstack.index = df_unstack.index.set_levels(df_unstack.index.levels[level_index].map(lambda x : DicoDayOfWeek[x][1],DicoDayOfWeek), level=level_index)
elif ColumnsName=="M":
df_unstack.index = df_unstack.index.set_levels(df_unstack.index.levels[level_index].map(lambda x : DicoMonthOfTheYear[x][1],DicoDayOfWeek), level=level_index)
else:
if Abbreviation==True:
if ColumnsName=="WeekDay":
df_unstack.columns = df_unstack.columns.map(lambda x : DicoDayOfWeek[x][0],DicoDayOfWeek)
elif ColumnsName=="M":
df_unstack.columns = df_unstack.columns.map(lambda x : DicoMonthOfTheYear[x][0],DicoMonthOfTheYear)
elif Abbreviation==False:
if ColumnsName=="WeekDay":
df_unstack.columns = df_unstack.columns.map(lambda x : DicoDayOfWeek[x][1],DicoDayOfWeek)
elif ColumnsName=="M":
df_unstack.columns = df_unstack.columns.map(lambda x : DicoMonthOfTheYear[x][1],DicoMonthOfTheYear)
else:
if "WeekDay" in ListOfDateAndTime and "WeekDay"==ListOfDateAndTime[0]:
if Abbreviation==True:
df_unstack.columns = df_unstack.columns.map(lambda x : DicoDayOfWeek[x][0],DicoDayOfWeek)
else:
df_unstack.columns = df_unstack.columns.map(lambda x : DicoDayOfWeek[x][1],DicoDayOfWeek)
if "M" in ListOfDateAndTime and "M"==ListOfDateAndTime[0]:
if Abbreviation==True:
df_unstack.columns = df_unstack.columns.map(lambda x : DicoMonthOfTheYear[x][0],DicoMonthOfTheYear)
elif Abbreviation==False:
df_unstack.columns = df_unstack.columns.map(lambda x : DicoMonthOfTheYear[x][1],DicoMonthOfTheYear)
DicoConfigRowColumsSubPlot={"Y":(4,3),"M":(4,3),"W":(13,4),"D":(8,4),"WeekDay":(4,2),"h":(6,4),"m":(10,6),"s":(10,6)}
fig=df_unstack.plot(subplots=True,figsize=(70, 60), layout=DicoConfigRowColumsSubPlot[ListOfDateAndTime[0]],kind="bar",sharex=True,sharey=True,legend=False,)#.flatten()#.map(set_xlabel=("toto"))#**kwargs)
# Add Legend for axis in function of the dimention of the subplot
for Row in range(DicoConfigRowColumsSubPlot[ListOfDateAndTime[0]][0]):
FigRow=fig[Row].flatten()
if DicoConfigRowColumsSubPlot[ListOfDateAndTime[0]][0]%2!=0 and Row%3==1 and Row!=DicoConfigRowColumsSubPlot[ListOfDateAndTime[0]][0]:
FigRow[0].set_ylabel("Nb. Video Trending")
elif DicoConfigRowColumsSubPlot[ListOfDateAndTime[0]][0]%2==0 and Row%2==1 and Row!=DicoConfigRowColumsSubPlot[ListOfDateAndTime[0]][0]:
FigRow[0].set_ylabel("Nb. Video Trending")
elif DicoConfigRowColumsSubPlot[ListOfDateAndTime[0]][0]==4:
FigRow[0].set_ylabel("Nb. Video Trending")
for Column in range(len(FigRow)):
FigRow[Column].set_xlabel("Time")
plot.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0.2, hspace=0.5)
plot.show()
return df_unstack
def testtemps():
print(pytz.country_timezones('JP'))
# Hours=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23]
# Hours=pd.date_range('17:30:00', '21:00:00',freq='15T').strftime('%H:%M').tolist()
# pd.to_datetime(Hours,format='%H:%M')
# print(Hours)
Hours=pd.date_range('00:00:00', '23:59:00',freq=str(30)+'T').time
df_NumberHours=pd.DataFrame(0,index=Hours,columns=["Number","Label"])
# df_NumberHours["Label"]=HoursForLabels
# print(df_NumberHours["Label"].head(3))
Country="FRA"
PathToInputData=os.path.join("Script","Data","Data_IN","Youtube_CSV__And_JSON",Country+"videos.csv")
df=pd.read_csv(PathToInputData)#,engine="python")
#'video_id','title',
df=df.drop(columns=['channel_title','category_id','tags','thumbnail_link','comments_disabled','ratings_disabled','video_error_or_removed','description'])
#get the plublish time and put in the column publish time
df['publish_time'] = | pd.to_datetime(df['publish_time'], format='%Y-%m-%dT%H:%M:%S.%fZ') | pandas.to_datetime |
from __future__ import unicode_literals, division, print_function
import json
import os
import pandas as pd
import unittest
from matminer.featurizers.dos import DOSFeaturizer, DopingFermi, \
Hybridization, SiteDOS, DosAsymmetry
from pymatgen.electronic_structure.dos import CompleteDos
from pymatgen.util.testing import PymatgenTest
test_dir = os.path.join(os.path.dirname(__file__))
class DOSFeaturesTest(PymatgenTest):
def setUp(self):
with open(os.path.join(test_dir, 'si_dos.json'), 'r') as sDOS:
si_dos = CompleteDos.from_dict(json.load(sDOS))
self.df = | pd.DataFrame({'dos': [si_dos], 'site': [0]}) | pandas.DataFrame |
from bokeh.models import HoverTool
from bokeh.io import curdoc
from bokeh.layouts import column,row
import pandas as pd
from statement_parser import parse_ofx_statements
import holoviews as hv
from bokeh.models.formatters import DatetimeTickFormatter
pd.options.plotting.backend = 'holoviews'
merged_df = parse_ofx_statements()
def extract_month_year(date):
return f"{date.month_name()}, {date.year}"
def render_basic_graphs(df, transaction_type):
render_list = []
df['amount'] = abs(df['amount']).astype(float)
time_hover = HoverTool(tooltips=[("amount", "$@amount{0,0.00}"), ("date", '@date_formatted')])
time_line = df.plot.line(x='date', y='amount', logy=True, yformatter='$%.00f', title=f"{transaction_type} over time (Log scale)").opts(tools=[time_hover])
render_list.append(hv.render(time_line, backend='bokeh'))
cat_hover = HoverTool(tooltips=[("amount", "$@amount{0,0.00}"), ("category", "@category")])
categories_bar = df.groupby(['category'])['amount'].sum().plot.bar(x='category', y='amount',
yformatter='$%.00f', rot=90, title=f"{transaction_type} by Category").opts(tools=[cat_hover],
color='category', cmap='Category10')
render_list.append(hv.render(categories_bar, backend="bokeh"))
return render_list
def render_advanced_graphs(df, transaction_type):
render_list = []
df['amount'] = abs(df['amount']).astype(float)
cat_hover = HoverTool(tooltips=[("amount", "$@amount{0,0.00}"), ("category", "@category")])
df.set_index(pd.DatetimeIndex(df['date']), inplace=True)
df = df.groupby([pd.Grouper(freq='M'), 'category'])['amount'].sum()
formatter = DatetimeTickFormatter(days="%d-%b-%Y", months='%m/%Y', years='%m/%Y')
stacked_bar = df.plot.bar(stacked=True, xformatter=formatter, yformatter='$%.00f',
title=f"{transaction_type} per Category by Month").opts(tools=[cat_hover])
render_list.append(hv.render(stacked_bar, backend='bokeh'))
return render_list
def render_income_vs_expense_graphs(df):
render_list = []
df['amount'] = abs(df['amount']).astype(float)
time_hover = HoverTool(tooltips=[("amount", "$@amount{0,0.00}"), ("date", '@date_formatted')])
time_line = df.plot.line(x='date', y='amount', by='type', yformatter='$%.00f',
title="Income vs Expenses over time").opts(tools=[time_hover])
render_list.append(hv.render(time_line, backend='bokeh'))
cat_hover = HoverTool(tooltips=[("amount", "$@amount{0,0.00}"), ("type", "@type")])
df.set_index(pd.DatetimeIndex(df['date']), inplace=True)
df = df.groupby([pd.Grouper(freq='M'), 'type'])['amount'].sum()
df.to_csv("temp.csv")
df3 = pd.read_csv("temp.csv")
diff_series = df3.groupby(['date'])['amount'].diff().dropna().reset_index(drop=True)
date_series = df3['date'].drop_duplicates().reset_index(drop=True)
diff_series = pd.DataFrame(diff_series)
df4 = diff_series.join(date_series)
df4['type'] = 'Surplus'
dtformat = '%Y-%m-%d'
df4['date'] = pd.to_datetime(df4['date'], format=dtformat)
df4.set_index([pd.DatetimeIndex(df4['date']), 'type'], inplace=True)
df4 = df4.drop(['date'], axis=1)
df = | pd.DataFrame(df) | pandas.DataFrame |
# -*- coding: utf-8 -*-
"""
Gaussian Process Regression with Automatic Relevance Determination (ARD)
========================================================================
Hello world
"""
# sphinx_gallery_thumbnail_number = 4
import numpy as np
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
import tensorflow_probability as tfp
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
from sklearn.datasets import load_boston
from sklearn.preprocessing import normalize
from sklearn.utils import shuffle
from collections import defaultdict
# %%
# shortcuts
tfd = tfp.distributions
kernels = tfp.math.psd_kernels
# %%
# environment
golden_ratio = 0.5 * (1 + np.sqrt(5))
def golden_size(width):
return (width, width / golden_ratio)
width = 10.0
rc = {
"figure.figsize": golden_size(width),
"font.serif": ['Times New Roman'],
"text.usetex": False,
}
sns.set(context="notebook",
style="ticks",
palette="colorblind",
font="serif",
rc=rc)
# %%
# constants
boston = load_boston()
num_train, num_features = boston.data.shape
num_epochs = 500
kernel_cls = kernels.MaternFiveHalves
jitter = 1e-6
seed = 42 # set random seed for reproducibility
random_state = np.random.RandomState(seed)
# %%
# The dataset has 506 datapoints, with 13 continuous/categorical features and a
# single target, the median property value.
X, Y = shuffle(normalize(boston.data),
boston.target,
random_state=random_state)
print(X.shape, Y.shape)
# %%
# We can load this dataset into a Pandas DataFrame for ease of visualization.
boston_df = pd.DataFrame(boston.data, columns=boston.feature_names) \
.assign(MEDV=boston.target)
# %%
# For example, we can see how the median property value (MEDV) varies with the
# average number of rooms per dwelling (RM).
fig, ax = plt.subplots()
sns.scatterplot(x="RM", y="MEDV", data=boston_df, alpha=.8, ax=ax)
plt.show()
# %%
# Empirical Bayes (maximizing the log marginal likelihood)
# --------------------------------------------------------
#
# Now let us fit a GP regression model to this dataset. We consider the
# Matern5/2 covariance function as before, except now, we use the anisotropic
# variant of the kernel. That is, we incorporate a lengthscale vector of 13
# positive scalar values.
#
# These hyperparameter values determine how far you need to move along a
# particular axis in the input space for the function values to become
# uncorrelated. By estimating these values we effectively implement automatic
# relevance determination, as the inverse of the lengthscale determines the
# relevance of the dimension. If the lengthscale is very large, the covariance
# will practically become independence of that input, and effectively remove it
# from the inference (GPML Section 5.1 Rasmussen & Williams, 2006).
# Base (isotropic) kernel with some scalar base lengthscale
amplitude = tf.exp(tf.Variable(np.float64(0), name='amplitude'))
length_scale = tf.exp(tf.Variable(np.float64(-1), name='length_scale'))
base_kernel = kernel_cls(amplitude=amplitude, length_scale=length_scale)
# ARD (anisotropic) kernel with a vector of varying _effective_ lengthscales
scale_diag = tf.exp(tf.Variable(np.zeros(num_features), name='scale_diag'))
kernel = kernels.FeatureScaled(base_kernel, scale_diag=scale_diag)
# Finalize the model
observation_noise_variance = tf.exp(
tf.Variable(np.float64(-5)),
name='observation_noise_variance')
gp = tfd.GaussianProcess(
kernel=kernel,
index_points=X,
observation_noise_variance=observation_noise_variance
)
# log marginal likelihood
nll = - gp.log_prob(Y)
nll
optimizer = tf.train.AdamOptimizer(learning_rate=0.05, beta1=0.5, beta2=.99)
optimize = optimizer.minimize(nll)
# %%
# Training loop
# -------------
history = defaultdict(list)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for i in range(num_epochs):
(_, nll_value, amplitude_value, length_scale_value,
observation_noise_variance_value, scale_diag_value) = sess.run([optimize, nll, amplitude, length_scale, observation_noise_variance, scale_diag])
history["nll"].append(nll_value)
history["amplitude"].append(amplitude_value)
history["length_scale"].append(length_scale_value)
history["observation_noise_variance"].append(observation_noise_variance_value)
history["scale_diag"].append(scale_diag_value)
history_df = pd.DataFrame(history)
# %%
# Learning curve
# ^^^^^^^^^^^^^^
fig, ax = plt.subplots()
sns.lineplot(x='index', y='nll', data=history_df.reset_index(),
alpha=0.8, ax=ax)
ax.set_xlabel("epoch")
ax.set_yscale("log")
plt.show()
# %%
# Visualize scalar hyperparameters over epochs
# --------------------------------------------
scalars = ["nll", "amplitude", "length_scale", "observation_noise_variance"]
scalars_history_df = history_df[scalars]
g = sns.PairGrid(history_df[scalars], hue="nll", palette="viridis")
g = g.map_lower(plt.scatter)
# %%
# Visualize input feature scales over epochs
# ------------------------------------------
d = | pd.DataFrame(history["scale_diag"], columns=boston.feature_names) | pandas.DataFrame |
#! /usr/bin/env python
# coding: utf-8
"""
Used to convert IMDb metadata in .mat format to .pickle format
Modified from https://gist.github.com/messefor/e2ee5fe1c18a040c90bbf91f2ee279e3
Data source: IMDB-WIKI – 500k+ face images with age and gender labels
- https://data.vision.ee.ethz.ch/cvl/rrothe/imdb-wiki/
"""
from datetime import datetime, timedelta
import numpy as np
import scipy
from scipy.io import loadmat
import pandas as pd
def matlab_datenum2dt(matlab_datenum):
matlab_datenum = matlab_datenum if matlab_datenum > 700000 else 700000
return datetime.fromordinal(int(matlab_datenum) - 366) + timedelta(days=int(matlab_datenum % 1))
def main():
path_save = '/Users/yu/Dropbox/CS230_Project/Data_Processing/imdb.pkl'
path_mat = '/Users/yu/Dropbox/CS230_Project/Data_Processing/imdb.mat'
mat = loadmat(path_mat)
print(mat['__header__'])
print(mat['__version__'])
# Extract values
dt = mat['imdb'][0, 0]
# Check for columns
print('columns:\n', dt.dtype.names)
# Extract values with simple format
keys_s = ('gender', 'dob', 'photo_taken',
'face_score', 'second_face_score')
values = {k: dt[k].squeeze() for k in keys_s}
# Extract values with nested format
keys_n = ('full_path', 'name')
for k in keys_n:
values[k] = np.array(['' if not x else x[0] for x in dt[k][0]])
# Convert face location to DataFrame
# img(face_location(2):face_location(4),face_location(1):face_location(3),:))
values['face_location'] = [tuple(x[0].tolist()) for x in dt['face_location'].squeeze()]
# Check all values extracted have same length
set_nrows = {len(v) for _, v in values.items()}
assert len(set_nrows) == 1
df_values = | pd.DataFrame(values) | pandas.DataFrame |
# Copyright (c) 2018-2021, NVIDIA CORPORATION.
import operator
import string
import numpy as np
import pandas as pd
import pytest
import cudf
from cudf.core._compat import PANDAS_GE_110
from cudf.testing._utils import (
NUMERIC_TYPES,
assert_eq,
assert_exceptions_equal,
)
@pytest.fixture
def pd_str_cat():
categories = list("abc")
codes = [0, 0, 1, 0, 1, 2, 0, 1, 1, 2]
return pd.Categorical.from_codes(codes, categories=categories)
def test_categorical_basic():
cat = pd.Categorical(["a", "a", "b", "c", "a"], categories=["a", "b", "c"])
cudf_cat = cudf.Index(cat)
pdsr = pd.Series(cat, index=["p", "q", "r", "s", "t"])
sr = cudf.Series(cat, index=["p", "q", "r", "s", "t"])
assert_eq(pdsr.cat.codes, sr.cat.codes, check_dtype=False)
# Test attributes
assert_eq(pdsr.cat.categories, sr.cat.categories)
assert pdsr.cat.ordered == sr.cat.ordered
np.testing.assert_array_equal(
pdsr.cat.codes.values, sr.cat.codes.to_array()
)
string = str(sr)
expect_str = """
p a
q a
r b
s c
t a
"""
assert all(x == y for x, y in zip(string.split(), expect_str.split()))
assert_eq(cat.codes, cudf_cat.codes.to_array())
def test_categorical_integer():
if not PANDAS_GE_110:
pytest.xfail(reason="pandas >=1.1 required")
cat = pd.Categorical(["a", "_", "_", "c", "a"], categories=["a", "b", "c"])
pdsr = pd.Series(cat)
sr = cudf.Series(cat)
np.testing.assert_array_equal(
cat.codes, sr.cat.codes.astype(cat.codes.dtype).fillna(-1).to_array()
)
assert sr.null_count == 2
np.testing.assert_array_equal(
pdsr.cat.codes.values,
sr.cat.codes.astype(pdsr.cat.codes.dtype).fillna(-1).to_array(),
)
string = str(sr)
expect_str = """
0 a
1 <NA>
2 <NA>
3 c
4 a
dtype: category
Categories (3, object): ['a', 'b', 'c']
"""
assert string.split() == expect_str.split()
def test_categorical_compare_unordered():
cat = pd.Categorical(["a", "a", "b", "c", "a"], categories=["a", "b", "c"])
pdsr = pd.Series(cat)
sr = cudf.Series(cat)
# test equal
out = sr == sr
assert out.dtype == np.bool_
assert type(out[0]) == np.bool_
assert np.all(out.to_array())
assert np.all(pdsr == pdsr)
# test inequality
out = sr != sr
assert not np.any(out.to_array())
assert not np.any(pdsr != pdsr)
assert not pdsr.cat.ordered
assert not sr.cat.ordered
# test using ordered operators
assert_exceptions_equal(
lfunc=operator.lt,
rfunc=operator.lt,
lfunc_args_and_kwargs=([pdsr, pdsr],),
rfunc_args_and_kwargs=([sr, sr],),
)
def test_categorical_compare_ordered():
cat1 = pd.Categorical(
["a", "a", "b", "c", "a"], categories=["a", "b", "c"], ordered=True
)
pdsr1 = pd.Series(cat1)
sr1 = cudf.Series(cat1)
cat2 = pd.Categorical(
["a", "b", "a", "c", "b"], categories=["a", "b", "c"], ordered=True
)
pdsr2 = pd.Series(cat2)
sr2 = cudf.Series(cat2)
# test equal
out = sr1 == sr1
assert out.dtype == np.bool_
assert type(out[0]) == np.bool_
assert np.all(out.to_array())
assert np.all(pdsr1 == pdsr1)
# test inequality
out = sr1 != sr1
assert not np.any(out.to_array())
assert not np.any(pdsr1 != pdsr1)
assert pdsr1.cat.ordered
assert sr1.cat.ordered
# test using ordered operators
np.testing.assert_array_equal(pdsr1 < pdsr2, (sr1 < sr2).to_array())
np.testing.assert_array_equal(pdsr1 > pdsr2, (sr1 > sr2).to_array())
def test_categorical_binary_add():
cat = pd.Categorical(["a", "a", "b", "c", "a"], categories=["a", "b", "c"])
pdsr = pd.Series(cat)
sr = cudf.Series(cat)
assert_exceptions_equal(
lfunc=operator.add,
rfunc=operator.add,
lfunc_args_and_kwargs=([pdsr, pdsr],),
rfunc_args_and_kwargs=([sr, sr],),
expected_error_message="Series of dtype `category` cannot perform "
"the operation: add",
)
def test_categorical_unary_ceil():
cat = pd.Categorical(["a", "a", "b", "c", "a"], categories=["a", "b", "c"])
pdsr = pd.Series(cat)
sr = cudf.Series(cat)
assert_exceptions_equal(
lfunc=getattr,
rfunc=sr.ceil,
lfunc_args_and_kwargs=([pdsr, "ceil"],),
check_exception_type=False,
expected_error_message="Series of dtype `category` cannot "
"perform the operation: ceil",
)
def test_categorical_element_indexing():
"""
Element indexing to a cat column must give the underlying object
not the numerical index.
"""
cat = pd.Categorical(["a", "a", "b", "c", "a"], categories=["a", "b", "c"])
pdsr = pd.Series(cat)
sr = cudf.Series(cat)
assert_eq(pdsr, sr)
assert_eq(pdsr.cat.codes, sr.cat.codes, check_dtype=False)
def test_categorical_masking():
"""
Test common operation for getting a all rows that matches a certain
category.
"""
cat = pd.Categorical(["a", "a", "b", "c", "a"], categories=["a", "b", "c"])
pdsr = pd.Series(cat)
sr = cudf.Series(cat)
# check scalar comparison
expect_matches = pdsr == "a"
got_matches = sr == "a"
np.testing.assert_array_equal(
expect_matches.values, got_matches.to_array()
)
# mask series
expect_masked = pdsr[expect_matches]
got_masked = sr[got_matches]
assert len(expect_masked) == len(got_masked)
assert len(expect_masked) == got_masked.valid_count
assert_eq(got_masked, expect_masked)
def test_df_cat_set_index():
df = cudf.DataFrame()
df["a"] = pd.Categorical(list("aababcabbc"), categories=list("abc"))
df["b"] = np.arange(len(df))
got = df.set_index("a")
pddf = df.to_pandas(nullable_pd_dtype=False)
expect = pddf.set_index("a")
assert_eq(got, expect)
def test_df_cat_sort_index():
df = cudf.DataFrame()
df["a"] = pd.Categorical(list("aababcabbc"), categories=list("abc"))
df["b"] = np.arange(len(df))
got = df.set_index("a").sort_index()
expect = df.to_pandas(nullable_pd_dtype=False).set_index("a").sort_index()
assert_eq(got, expect)
def test_cat_series_binop_error():
df = cudf.DataFrame()
df["a"] = pd.Categorical(list("aababcabbc"), categories=list("abc"))
df["b"] = np.arange(len(df))
dfa = df["a"]
dfb = df["b"]
# lhs is a categorical
assert_exceptions_equal(
lfunc=operator.add,
rfunc=operator.add,
lfunc_args_and_kwargs=([dfa, dfb],),
rfunc_args_and_kwargs=([dfa, dfb],),
check_exception_type=False,
expected_error_message="Series of dtype `category` cannot "
"perform the operation: add",
)
# if lhs is a numerical
assert_exceptions_equal(
lfunc=operator.add,
rfunc=operator.add,
lfunc_args_and_kwargs=([dfb, dfa],),
rfunc_args_and_kwargs=([dfb, dfa],),
check_exception_type=False,
expected_error_message="'add' operator not supported",
)
@pytest.mark.parametrize("num_elements", [10, 100, 1000])
def test_categorical_unique(num_elements):
# create categorical series
np.random.seed(12)
pd_cat = pd.Categorical(
pd.Series(
np.random.choice(
list(string.ascii_letters + string.digits), num_elements
),
dtype="category",
)
)
# gdf
gdf = cudf.DataFrame()
gdf["a"] = cudf.Series.from_categorical(pd_cat)
gdf_unique_sorted = np.sort(gdf["a"].unique().to_pandas())
# pandas
pdf = pd.DataFrame()
pdf["a"] = pd_cat
pdf_unique_sorted = np.sort(pdf["a"].unique())
# verify
np.testing.assert_array_equal(pdf_unique_sorted, gdf_unique_sorted)
@pytest.mark.parametrize("nelem", [20, 50, 100])
def test_categorical_unique_count(nelem):
# create categorical series
np.random.seed(12)
pd_cat = pd.Categorical(
pd.Series(
np.random.choice(
list(string.ascii_letters + string.digits), nelem
),
dtype="category",
)
)
# gdf
gdf = cudf.DataFrame()
gdf["a"] = cudf.Series.from_categorical(pd_cat)
gdf_unique_count = gdf["a"].nunique()
# pandas
pdf = pd.DataFrame()
pdf["a"] = pd_cat
pdf_unique = pdf["a"].unique()
# verify
assert gdf_unique_count == len(pdf_unique)
def test_categorical_empty():
cat = pd.Categorical([])
pdsr = pd.Series(cat)
sr = cudf.Series(cat)
np.testing.assert_array_equal(cat.codes, sr.cat.codes.to_array())
# Test attributes
assert_eq(pdsr.cat.categories, sr.cat.categories)
assert pdsr.cat.ordered == sr.cat.ordered
np.testing.assert_array_equal(
pdsr.cat.codes.values, sr.cat.codes.to_array()
)
def test_categorical_set_categories():
cat = pd.Categorical(["a", "a", "b", "c", "a"], categories=["a", "b", "c"])
psr = pd.Series(cat)
sr = cudf.Series.from_categorical(cat)
# adding category
expect = psr.cat.set_categories(["a", "b", "c", "d"])
got = sr.cat.set_categories(["a", "b", "c", "d"])
assert_eq(expect, got)
# removing category
expect = psr.cat.set_categories(["a", "b"])
got = sr.cat.set_categories(["a", "b"])
assert_eq(expect, got)
def test_categorical_set_categories_preserves_order():
series = pd.Series([1, 0, 0, 0, 2]).astype("category")
# reassigning categories should preserve element ordering
assert_eq(
series.cat.set_categories([1, 2]),
cudf.Series(series).cat.set_categories([1, 2]),
)
@pytest.mark.parametrize("inplace", [True, False])
def test_categorical_as_ordered(pd_str_cat, inplace):
pd_sr = pd.Series(pd_str_cat.copy().set_ordered(False))
cd_sr = cudf.Series(pd_str_cat.copy().set_ordered(False))
assert cd_sr.cat.ordered is False
assert cd_sr.cat.ordered == pd_sr.cat.ordered
pd_sr_1 = pd_sr.cat.as_ordered(inplace=inplace)
cd_sr_1 = cd_sr.cat.as_ordered(inplace=inplace)
pd_sr_1 = pd_sr if pd_sr_1 is None else pd_sr_1
cd_sr_1 = cd_sr if cd_sr_1 is None else cd_sr_1
assert cd_sr_1.cat.ordered is True
assert cd_sr_1.cat.ordered == pd_sr_1.cat.ordered
assert str(cd_sr_1) == str(pd_sr_1)
@pytest.mark.parametrize("inplace", [True, False])
def test_categorical_as_unordered(pd_str_cat, inplace):
pd_sr = pd.Series(pd_str_cat.copy().set_ordered(True))
cd_sr = cudf.Series(pd_str_cat.copy().set_ordered(True))
assert cd_sr.cat.ordered is True
assert cd_sr.cat.ordered == pd_sr.cat.ordered
pd_sr_1 = pd_sr.cat.as_unordered(inplace=inplace)
cd_sr_1 = cd_sr.cat.as_unordered(inplace=inplace)
pd_sr_1 = pd_sr if pd_sr_1 is None else pd_sr_1
cd_sr_1 = cd_sr if cd_sr_1 is None else cd_sr_1
assert cd_sr_1.cat.ordered is False
assert cd_sr_1.cat.ordered == pd_sr_1.cat.ordered
assert str(cd_sr_1) == str(pd_sr_1)
@pytest.mark.parametrize("from_ordered", [True, False])
@pytest.mark.parametrize("to_ordered", [True, False])
@pytest.mark.parametrize("inplace", [True, False])
def test_categorical_reorder_categories(
pd_str_cat, from_ordered, to_ordered, inplace
):
pd_sr = pd.Series(pd_str_cat.copy().set_ordered(from_ordered))
cd_sr = cudf.Series(pd_str_cat.copy().set_ordered(from_ordered))
assert_eq(pd_sr, cd_sr)
assert str(pd_sr) == str(cd_sr)
kwargs = dict(ordered=to_ordered, inplace=inplace)
pd_sr_1 = pd_sr.cat.reorder_categories(list("cba"), **kwargs)
cd_sr_1 = cd_sr.cat.reorder_categories(list("cba"), **kwargs)
pd_sr_1 = pd_sr if pd_sr_1 is None else pd_sr_1
cd_sr_1 = cd_sr if cd_sr_1 is None else cd_sr_1
assert_eq(pd_sr_1, cd_sr_1)
assert str(cd_sr_1) == str(pd_sr_1)
@pytest.mark.parametrize("inplace", [True, False])
def test_categorical_add_categories(pd_str_cat, inplace):
pd_sr = pd.Series(pd_str_cat.copy())
cd_sr = cudf.Series(pd_str_cat.copy())
assert_eq(pd_sr, cd_sr)
assert str(pd_sr) == str(cd_sr)
pd_sr_1 = pd_sr.cat.add_categories(["d"], inplace=inplace)
cd_sr_1 = cd_sr.cat.add_categories(["d"], inplace=inplace)
pd_sr_1 = pd_sr if pd_sr_1 is None else pd_sr_1
cd_sr_1 = cd_sr if cd_sr_1 is None else cd_sr_1
assert "d" in pd_sr_1.cat.categories.to_list()
assert "d" in cd_sr_1.cat.categories.to_pandas().to_list()
assert_eq(pd_sr_1, cd_sr_1)
@pytest.mark.parametrize("inplace", [True, False])
def test_categorical_remove_categories(pd_str_cat, inplace):
pd_sr = pd.Series(pd_str_cat.copy())
cd_sr = cudf.Series(pd_str_cat.copy())
assert_eq(pd_sr, cd_sr)
assert str(pd_sr) == str(cd_sr)
pd_sr_1 = pd_sr.cat.remove_categories(["a"], inplace=inplace)
cd_sr_1 = cd_sr.cat.remove_categories(["a"], inplace=inplace)
pd_sr_1 = pd_sr if pd_sr_1 is None else pd_sr_1
cd_sr_1 = cd_sr if cd_sr_1 is None else cd_sr_1
assert "a" not in pd_sr_1.cat.categories.to_list()
assert "a" not in cd_sr_1.cat.categories.to_pandas().to_list()
assert_eq(pd_sr_1, cd_sr_1)
# test using ordered operators
assert_exceptions_equal(
lfunc=cd_sr.to_pandas().cat.remove_categories,
rfunc=cd_sr.cat.remove_categories,
lfunc_args_and_kwargs=([["a", "d"]], {"inplace": inplace}),
rfunc_args_and_kwargs=([["a", "d"]], {"inplace": inplace}),
expected_error_message="removals must all be in old categories",
)
def test_categorical_dataframe_slice_copy():
pdf = pd.DataFrame({"g": pd.Series(["a", "b", "z"], dtype="category")})
gdf = cudf.from_pandas(pdf)
exp = pdf[1:].copy()
gdf = gdf[1:].copy()
assert_eq(exp, gdf)
@pytest.mark.parametrize(
"data",
[
pd.Series([1, 2, 3, 89]),
pd.Series([1, 2, 3, 89, 3, 1, 89], dtype="category"),
pd.Series(["1", "2", "3", "4", "5"], dtype="category"),
pd.Series(["1.0", "2.5", "3.001", "9"], dtype="category"),
pd.Series(["1", "2", "3", None, "4", "5"], dtype="category"),
pd.Series(["1.0", "2.5", "3.001", None, "9"], dtype="category"),
pd.Series(["a", "b", "c", "c", "b", "a", "b", "b"]),
pd.Series(["aa", "b", "c", "c", "bb", "bb", "a", "b", "b"]),
pd.Series([1, 2, 3, 89, None, np.nan, np.NaN], dtype="float64"),
pd.Series([1, 2, 3, 89], dtype="float64"),
pd.Series([1, 2.5, 3.001, 89], dtype="float64"),
pd.Series([None, None, None]),
pd.Series([], dtype="float64"),
],
)
@pytest.mark.parametrize(
"cat_type",
[
pd.CategoricalDtype(categories=["aa", "bb", "cc"]),
pd.CategoricalDtype(categories=[2, 4, 10, 100]),
pd.CategoricalDtype(categories=["aa", "bb", "c"]),
pd.CategoricalDtype(categories=["a", "bb", "c"]),
pd.CategoricalDtype(categories=["a", "b", "c"]),
pd.CategoricalDtype(categories=["1", "2", "3", "4"]),
pd.CategoricalDtype(categories=["1.0", "2.5", "3.001", "9"]),
pd.CategoricalDtype(categories=[]),
],
)
def test_categorical_typecast(data, cat_type):
pd_data = data.copy()
gd_data = cudf.from_pandas(data)
assert_eq(pd_data.astype(cat_type), gd_data.astype(cat_type))
@pytest.mark.parametrize(
"data",
[
pd.Series([1, 2, 3, 89]),
pd.Series(["a", "b", "c", "c", "b", "a", "b", "b"]),
pd.Series(["aa", "b", "c", "c", "bb", "bb", "a", "b", "b"]),
pd.Series([1, 2, 3, 89, None, np.nan, np.NaN], dtype="float64"),
pd.Series([1, 2, 3, 89], dtype="float64"),
pd.Series([1, 2.5, 3.001, 89], dtype="float64"),
pd.Series([None, None, None]),
pd.Series([], dtype="float64"),
],
)
@pytest.mark.parametrize(
"new_categories",
[
["aa", "bb", "cc"],
[2, 4, 10, 100],
["aa", "bb", "c"],
["a", "bb", "c"],
["a", "b", "c"],
[],
pd.Series(["a", "b", "c"]),
pd.Series(["a", "b", "c"], dtype="category"),
pd.Series([-100, 10, 11, 0, 1, 2], dtype="category"),
],
)
def test_categorical_set_categories_categoricals(data, new_categories):
pd_data = data.copy().astype("category")
gd_data = cudf.from_pandas(pd_data)
assert_eq(
pd_data.cat.set_categories(new_categories=new_categories),
gd_data.cat.set_categories(new_categories=new_categories),
)
assert_eq(
pd_data.cat.set_categories(
new_categories=pd.Series(new_categories, dtype="category")
),
gd_data.cat.set_categories(
new_categories=cudf.Series(new_categories, dtype="category")
),
)
@pytest.mark.parametrize(
"data",
[
[1, 2, 3, 4],
["a", "1", "2", "1", "a"],
pd.Series(["a", "1", "22", "1", "aa"]),
pd.Series(["a", "1", "22", "1", "aa"], dtype="category"),
pd.Series([1, 2, 3, -4], dtype="int64"),
pd.Series([1, 2, 3, 4], dtype="uint64"),
pd.Series([1, 2.3, 3, 4], dtype="float"),
[None, 1, None, 2, None],
[],
],
)
@pytest.mark.parametrize(
"dtype",
[
pd.CategoricalDtype(categories=["aa", "bb", "cc"]),
pd.CategoricalDtype(categories=[2, 4, 10, 100]),
pd.CategoricalDtype(categories=["aa", "bb", "c"]),
pd.CategoricalDtype(categories=["a", "bb", "c"]),
pd.CategoricalDtype(categories=["a", "b", "c"]),
pd.CategoricalDtype(categories=["22", "b", "c"]),
pd.CategoricalDtype(categories=[]),
],
)
def test_categorical_creation(data, dtype):
expected = pd.Series(data, dtype=dtype)
got = cudf.Series(data, dtype=dtype)
assert_eq(expected, got)
got = cudf.Series(data, dtype=cudf.from_pandas(dtype))
assert_eq(expected, got)
expected = pd.Series(data, dtype="category")
got = cudf.Series(data, dtype="category")
assert_eq(expected, got)
@pytest.mark.parametrize(
"categories",
[
[],
[1, 2, 3],
pd.Series(["a", "c", "b"], dtype="category"),
pd.Series([1, 2, 3, 4, -100], dtype="category"),
],
)
@pytest.mark.parametrize("ordered", [True, False])
def test_categorical_dtype(categories, ordered):
expected = pd.CategoricalDtype(categories=categories, ordered=ordered)
got = cudf.CategoricalDtype(categories=categories, ordered=ordered)
assert_eq(expected, got)
@pytest.mark.parametrize(
("data", "expected"),
[
(cudf.Series([1]), np.uint8),
(cudf.Series([1, None]), np.uint8),
(cudf.Series(np.arange(np.iinfo(np.int8).max)), np.uint8),
(
cudf.Series(np.append(np.arange(np.iinfo(np.int8).max), [None])),
np.uint8,
),
(cudf.Series(np.arange(np.iinfo(np.int16).max)), np.uint16),
(
cudf.Series(np.append(np.arange(np.iinfo(np.int16).max), [None])),
np.uint16,
),
(cudf.Series(np.arange(np.iinfo(np.uint8).max)), np.uint8),
(
cudf.Series(np.append(np.arange(np.iinfo(np.uint8).max), [None])),
np.uint8,
),
(cudf.Series(np.arange(np.iinfo(np.uint16).max)), np.uint16),
(
cudf.Series(np.append(np.arange(np.iinfo(np.uint16).max), [None])),
np.uint16,
),
],
)
def test_astype_dtype(data, expected):
got = data.astype("category").cat.codes.dtype
np.testing.assert_equal(got, expected)
@pytest.mark.parametrize(
"data,add",
[
([1, 2, 3], [100, 11, 12]),
([1, 2, 3], [0.01, 9.7, 15.0]),
([0.0, 6.7, 10.0], [100, 11, 12]),
([0.0, 6.7, 10.0], [0.01, 9.7, 15.0]),
(["a", "bd", "ef"], ["asdfsdf", "bddf", "eff"]),
([1, 2, 3], []),
([0.0, 6.7, 10.0], []),
(["a", "bd", "ef"], []),
],
)
def test_add_categories(data, add):
pds = pd.Series(data, dtype="category")
gds = cudf.Series(data, dtype="category")
expected = pds.cat.add_categories(add)
actual = gds.cat.add_categories(add)
assert_eq(
expected.cat.codes, actual.cat.codes.astype(expected.cat.codes.dtype)
)
# Need to type-cast pandas object to str due to mixed-type
# support in "object"
assert_eq(
expected.cat.categories.astype("str")
if (expected.cat.categories.dtype == "object")
else expected.cat.categories,
actual.cat.categories,
)
@pytest.mark.parametrize(
"data,add",
[
([1, 2, 3], [1, 3, 11]),
([0.0, 6.7, 10.0], [1, 2, 0.0]),
(["a", "bd", "ef"], ["a", "bd", "a"]),
],
)
def test_add_categories_error(data, add):
pds = | pd.Series(data, dtype="category") | pandas.Series |
from datetime import date, timedelta, datetime
import numpy as np
import pandas as pd
from dateutil.relativedelta import relativedelta
from sqlalchemy import func, or_, and_, text, column
from app import db
from app.context import get_import_date, get_import_id
from app.models import OckovaciMisto, Okres, Kraj, OckovaciMistoMetriky, CrMetriky, OckovaniRegistrace, Populace, \
PrakticiKapacity, OckovaniRezervace, OckovaniLide, Vakcina, ZdravotnickeStredisko, OckovaciZarizeni
def unique_nrpzs_subquery():
"""Returns unique NRPZS within all centers."""
return db.session.query(OckovaciMisto.nrpzs_kod) \
.group_by(OckovaciMisto.nrpzs_kod) \
.having(func.count(OckovaciMisto.nrpzs_kod) == 1)
def unique_nrpzs_active_subquery():
"""Returns unique NRPZS within active centers."""
return db.session.query(OckovaciMisto.nrpzs_kod) \
.filter(OckovaciMisto.status == True) \
.group_by(OckovaciMisto.nrpzs_kod) \
.having(func.count(OckovaciMisto.nrpzs_kod) == 1)
def has_unique_nrpzs(center_id):
res = db.session.query(func.count(OckovaciMisto.id)) \
.filter(OckovaciMisto.id == center_id) \
.filter(or_(and_(OckovaciMisto.status == True, OckovaciMisto.nrpzs_kod.in_(unique_nrpzs_active_subquery())),
and_(OckovaciMisto.status == False, OckovaciMisto.nrpzs_kod.in_(unique_nrpzs_subquery())))) \
.one()
return res[0] == 1
def find_kraj_options():
return db.session.query(Kraj.nazev, Kraj.id).order_by(Kraj.nazev).all()
def find_centers(filter_column, filter_value):
centers = db.session.query(OckovaciMisto.id, OckovaciMisto.nazev, Okres.nazev.label("okres"),
Kraj.nazev_kratky.label("kraj"), Kraj.id.label("kraj_id"), OckovaciMisto.longitude,
OckovaciMisto.latitude, OckovaciMisto.adresa, OckovaciMisto.status,
OckovaciMisto.bezbarierovy_pristup, OckovaciMisto.vekove_skupiny, OckovaciMisto.typ,
OckovaciMisto.davky, OckovaciMisto.vakciny,
OckovaciMistoMetriky.registrace_fronta, OckovaciMistoMetriky.registrace_prumer_cekani,
OckovaciMistoMetriky.ockovani_odhad_cekani,
OckovaciMistoMetriky.registrace_fronta_prumer_cekani,
OckovaciMistoMetriky.registrace_pred_zavorou) \
.join(OckovaciMistoMetriky) \
.outerjoin(Okres, OckovaciMisto.okres_id == Okres.id) \
.outerjoin(Kraj, Okres.kraj_id == Kraj.id) \
.filter(filter_column == filter_value) \
.filter(OckovaciMistoMetriky.datum == get_import_date()) \
.filter(or_(OckovaciMisto.status == True, OckovaciMistoMetriky.registrace_fronta > 0,
OckovaciMistoMetriky.rezervace_cekajici > 0, OckovaciMisto.typ == 'WALKIN')) \
.filter(OckovaciMisto.typ != 'AČR') \
.group_by(OckovaciMisto.id, OckovaciMisto.nazev, Okres.id, Kraj.id, OckovaciMisto.longitude,
OckovaciMisto.latitude, OckovaciMisto.adresa, OckovaciMisto.status,
OckovaciMisto.bezbarierovy_pristup, OckovaciMisto.vekove_skupiny, OckovaciMisto.typ,
OckovaciMisto.davky, OckovaciMisto.vakciny, OckovaciMistoMetriky.registrace_fronta,
OckovaciMistoMetriky.registrace_prumer_cekani, OckovaciMistoMetriky.ockovani_odhad_cekani,
OckovaciMistoMetriky.registrace_fronta_prumer_cekani, OckovaciMistoMetriky.registrace_pred_zavorou) \
.order_by(Kraj.nazev_kratky, Okres.nazev, OckovaciMisto.nazev) \
.all()
return centers
def find_third_doses_centers():
center_ids = db.session.query(OckovaniRezervace.ockovaci_misto_id) \
.distinct() \
.filter(OckovaniRezervace.kalendar_ockovani == 'V3') \
.all()
return [center[0] for center in center_ids]
def find_centers_vaccine_options():
return db.session.query(func.unnest(OckovaciMisto.vakciny).label('vyrobce')).order_by('vyrobce').distinct().all()
def find_doctor_offices(nrpzs_kod):
df = pd.read_sql_query(
f"""
select coalesce(z.zarizeni_nazev, min(s.nazev_cely)) zarizeni_nazev, o.nazev okres, k.nazev kraj,
k.nazev_kratky kraj_kratky, s.druh_zarizeni, s.obec, s.psc, s.ulice, s.cislo_domu, s.telefon, s.email,
s.web, s.latitude, s.longitude
from ockovaci_zarizeni z
full join zdravotnicke_stredisko s on s.nrpzs_kod = z.id
left join okresy o on o.id = coalesce(z.okres_id, s.okres_kod)
join kraje k on k.id = o.kraj_id
where z.id = '{nrpzs_kod}' or s.nrpzs_kod = '{nrpzs_kod}'
group by z.zarizeni_nazev, o.nazev, k.nazev, k.nazev_kratky, s.druh_zarizeni, s.obec, s.psc, s.ulice,
s.cislo_domu, s.telefon, s.email, s.web, s.latitude, s.longitude
""",
db.engine)
return df
NRPZS_PEDIATRICIAN_CODE = 321
def find_doctors(okres_id=None, kraj_id=None):
okres_id_sql = 'null' if okres_id is None else f"'{okres_id}'"
kraj_id_sql = 'null' if kraj_id is None else f"'{kraj_id}'"
df = pd.read_sql_query(
f"""
select z.id, z.zarizeni_nazev, o.nazev okres, o.kraj_id, k.nazev kraj, k.nazev_kratky kraj_kratky,
z.provoz_ukoncen, m.ockovani_pocet_davek, m.ockovani_pocet_davek_zmena_tyden, m.ockovani_vakciny_7,
count(n.nrpzs_kod) nabidky,
case when s.druh_zarizeni_kod = {NRPZS_PEDIATRICIAN_CODE} then true else false end pediatr
from ockovaci_zarizeni z
left join zdravotnicke_stredisko s on s.nrpzs_kod = z.id
left join okresy o on o.id = z.okres_id
join kraje k on k.id = o.kraj_id
left join zarizeni_metriky m on m.zarizeni_id = z.id and m.datum = '{get_import_date()}'
left join (
select left(zdravotnicke_zarizeni_kod, 11) nrpzs_kod
from praktici_kapacity n
where n.pocet_davek > 0 and (n.expirace is null or n.expirace >= '{get_import_date()}')
) n on n.nrpzs_kod = z.id
where prakticky_lekar = True
and (z.okres_id = {okres_id_sql} or {okres_id_sql} is null)
and (o.kraj_id = {kraj_id_sql} or {kraj_id_sql} is null)
group by z.id, z.zarizeni_nazev, o.nazev, o.kraj_id, k.nazev, k.nazev_kratky, z.provoz_ukoncen,
m.ockovani_pocet_davek, m.ockovani_pocet_davek_zmena_tyden, m.ockovani_vakciny_7, pediatr
order by k.nazev_kratky, o.nazev, z.zarizeni_nazev
""",
db.engine
)
df['ockovani_vakciny_7'] = df['ockovani_vakciny_7'].replace({None: ''})
df['provoz_ukoncen'] = df['provoz_ukoncen'].astype('bool')
df['ockovani_pocet_davek'] = df['ockovani_pocet_davek'].replace({np.nan: 0})
df['ockovani_pocet_davek_zmena_tyden'] = df['ockovani_pocet_davek_zmena_tyden'].replace({np.nan: 0})
return df
def find_doctors_map():
df = pd.read_sql_query(
f"""
select z.id, z.zarizeni_nazev, z.provoz_ukoncen, s.latitude, s.longitude, m.ockovani_pocet_davek,
m.ockovani_pocet_davek_zmena_tyden, m.ockovani_vakciny_7, count(n.nrpzs_kod) nabidky,
case when s.druh_zarizeni_kod = {NRPZS_PEDIATRICIAN_CODE} then true else false end pediatr
from ockovaci_zarizeni z
left join zdravotnicke_stredisko s on s.nrpzs_kod = z.id
left join zarizeni_metriky m on m.zarizeni_id = z.id and m.datum = '{get_import_date()}'
left join (
select left(zdravotnicke_zarizeni_kod, 11) nrpzs_kod
from praktici_kapacity n
where n.pocet_davek > 0 and (n.expirace is null or n.expirace >= '{get_import_date()}')
) n on n.nrpzs_kod = z.id
where prakticky_lekar = True
group by z.id, z.zarizeni_nazev, z.provoz_ukoncen, s.latitude, s.longitude, m.ockovani_pocet_davek,
m.ockovani_pocet_davek_zmena_tyden, m.ockovani_vakciny_7, pediatr
""",
db.engine
)
df['ockovani_vakciny_7'] = df['ockovani_vakciny_7'].replace({None: ''})
df['provoz_ukoncen'] = df['provoz_ukoncen'].astype('bool')
df['latitude'] = df['latitude'].replace({np.nan: None})
df['longitude'] = df['longitude'].replace({np.nan: None})
df['ockovani_pocet_davek'] = df['ockovani_pocet_davek'].replace({np.nan: 0})
df['ockovani_pocet_davek_zmena_tyden'] = df['ockovani_pocet_davek_zmena_tyden'].replace({np.nan: 0})
return df
def find_doctors_vaccine_options():
return db.session.query(Vakcina.vyrobce) \
.join(OckovaniLide, Vakcina.vakcina == OckovaniLide.vakcina) \
.distinct(Vakcina.vyrobce) \
.order_by(Vakcina.vyrobce) \
.all()
def find_free_vaccines_available(nrpzs_kod=None, okres_id=None, kraj_id=None):
return db.session.query(PrakticiKapacity.datum_aktualizace, PrakticiKapacity.pocet_davek,
PrakticiKapacity.typ_vakciny, PrakticiKapacity.mesto, PrakticiKapacity.nazev_ordinace,
PrakticiKapacity.deti, PrakticiKapacity.dospeli, PrakticiKapacity.kontakt_tel,
PrakticiKapacity.kontakt_email, PrakticiKapacity.expirace, PrakticiKapacity.poznamka,
PrakticiKapacity.kraj, ZdravotnickeStredisko.nrpzs_kod, ZdravotnickeStredisko.latitude,
ZdravotnickeStredisko.longitude) \
.outerjoin(ZdravotnickeStredisko, ZdravotnickeStredisko.zdravotnicke_zarizeni_kod == PrakticiKapacity.zdravotnicke_zarizeni_kod) \
.filter(or_(func.left(PrakticiKapacity.zdravotnicke_zarizeni_kod, 11) == nrpzs_kod, nrpzs_kod is None)) \
.filter(or_(ZdravotnickeStredisko.okres_kod == okres_id, okres_id is None)) \
.filter(or_(ZdravotnickeStredisko.kraj_kod == kraj_id, kraj_id is None)) \
.filter(PrakticiKapacity.pocet_davek > 0) \
.filter(or_(PrakticiKapacity.expirace == None, PrakticiKapacity.expirace >= get_import_date())) \
.order_by(PrakticiKapacity.kraj, PrakticiKapacity.mesto, PrakticiKapacity.nazev_ordinace,
PrakticiKapacity.typ_vakciny) \
.all()
def find_free_vaccines_vaccine_options():
return db.session.query(PrakticiKapacity.typ_vakciny) \
.filter(PrakticiKapacity.pocet_davek > 0) \
.filter(or_(PrakticiKapacity.expirace == None, PrakticiKapacity.expirace >= get_import_date())) \
.distinct(PrakticiKapacity.typ_vakciny) \
.order_by(PrakticiKapacity.typ_vakciny) \
.all()
def count_vaccines_center(center_id):
mista = pd.read_sql_query(
"""
select ockovaci_mista.id ockovaci_misto_id, ockovaci_mista.nazev, okres_id, kraj_id
from ockovaci_mista join okresy on ockovaci_mista.okres_id=okresy.id
where ockovaci_mista.id='{}';
""".format(center_id),
db.engine
)
prijato = pd.read_sql_query(
"""
select ockovaci_misto_id, vyrobce, sum(pocet_davek) prijato
from ockovani_distribuce
where akce = 'Příjem' and ockovaci_misto_id = '{}' and datum < '{}'
group by (ockovaci_misto_id, vyrobce);
""".format(center_id, get_import_date()),
db.engine
)
prijato_odjinud = pd.read_sql_query(
"""
select cilove_ockovaci_misto_id ockovaci_misto_id, vyrobce, sum(pocet_davek) prijato_odjinud
from ockovani_distribuce
where akce = 'Výdej' and cilove_ockovaci_misto_id = '{}' and datum < '{}'
group by (cilove_ockovaci_misto_id, vyrobce);
""".format(center_id, get_import_date()),
db.engine
)
vydano = pd.read_sql_query(
"""
select ockovaci_misto_id, vyrobce, sum(pocet_davek) vydano
from ockovani_distribuce
where akce = 'Výdej' and ockovaci_misto_id = '{}' and datum < '{}'
group by (ockovaci_misto_id, vyrobce);
""".format(center_id, get_import_date()),
db.engine
)
spotreba = pd.read_sql_query(
"""
select ockovaci_misto_id, vyrobce, sum(pouzite_davky) pouzito, sum(znehodnocene_davky) znehodnoceno
from ockovani_spotreba
where ockovaci_misto_id = '{}' and datum < '{}'
group by (ockovaci_misto_id, vyrobce);
""".format(center_id, get_import_date()),
db.engine
)
vyrobci = pd.read_sql_query("select vyrobce from vakciny;", db.engine)
mista_key = mista
mista_key['join'] = 0
vyrobci_key = vyrobci
vyrobci_key['join'] = 0
df = mista_key.merge(vyrobci_key).drop('join', axis=1)
df = pd.merge(df, prijato, how="left")
df = pd.merge(df, prijato_odjinud, how="left")
df = pd.merge(df, vydano, how="left")
df = pd.merge(df, spotreba, how="left")
df['prijato'] = df['prijato'].fillna(0).astype('int')
df['prijato_odjinud'] = df['prijato_odjinud'].fillna(0).astype('int')
df['vydano'] = df['vydano'].fillna(0).astype('int')
df['pouzito'] = df['pouzito'].fillna(0).astype('int')
df['znehodnoceno'] = df['znehodnoceno'].fillna(0).astype('int')
df['prijato_celkem'] = df['prijato'] + df['prijato_odjinud'] - df['vydano']
df['skladem'] = df['prijato_celkem'] - df['pouzito'] - df['znehodnoceno']
df = df.groupby(by=['vyrobce'], as_index=False).sum().sort_values(by=['vyrobce'])
df = df[(df['prijato_celkem'] > 0) | (df['pouzito'] > 0) | (df['znehodnoceno'] > 0)]
return df
def count_vaccines_kraj(kraj_id):
mista = pd.read_sql_query(
"""
select ockovaci_mista.id ockovaci_misto_id, ockovaci_mista.nazev, kraj_id
from ockovaci_mista join okresy on ockovaci_mista.okres_id=okresy.id
where kraj_id='{}';
""".format(kraj_id),
db.engine
)
mista_ids = ','.join("'" + misto + "'" for misto in mista['ockovaci_misto_id'].tolist())
prijato = pd.read_sql_query(
"""
select ockovaci_misto_id, vyrobce, sum(pocet_davek) prijato
from ockovani_distribuce
where akce = 'Příjem' and ockovaci_misto_id in ({}) and datum < '{}'
group by (ockovaci_misto_id, vyrobce);
""".format(mista_ids, get_import_date()),
db.engine
)
prijato_odjinud = pd.read_sql_query(
"""
select cilove_ockovaci_misto_id ockovaci_misto_id, vyrobce, sum(pocet_davek) prijato_odjinud
from ockovani_distribuce
where akce = 'Výdej' and cilove_ockovaci_misto_id in ({}) and ockovaci_misto_id not in({}) and datum < '{}'
group by (cilove_ockovaci_misto_id, vyrobce);
""".format(mista_ids, mista_ids, get_import_date()),
db.engine
)
vydano = pd.read_sql_query(
"""
select ockovaci_misto_id, vyrobce, sum(pocet_davek) vydano
from ockovani_distribuce
where akce = 'Výdej' and ockovaci_misto_id in ({}) and cilove_ockovaci_misto_id not in({}) and cilove_ockovaci_misto_id != '-' and datum < '{}'
group by (ockovaci_misto_id, vyrobce);
""".format(mista_ids, mista_ids, get_import_date()),
db.engine
)
spotreba = pd.read_sql_query(
"""
select ockovaci_misto_id, vyrobce, sum(znehodnocene_davky) znehodnoceno
from ockovani_spotreba
where ockovaci_misto_id in ({}) and datum < '{}'
group by (ockovaci_misto_id, vyrobce);
""".format(mista_ids, get_import_date()),
db.engine
)
ockovano = pd.read_sql_query(
"""
select kraj_nuts_kod kraj_id, sum(pocet) ockovano, vyrobce
from ockovani_lide
join vakciny on vakciny.vakcina = ockovani_lide.vakcina
where kraj_nuts_kod = '{}' and datum < '{}'
group by kraj_nuts_kod, vyrobce
""".format(kraj_id, get_import_date()),
db.engine
)
vyrobci = pd.read_sql_query("select vyrobce from vakciny;", db.engine)
mista_key = mista
mista_key['join'] = 0
vyrobci_key = vyrobci
vyrobci_key['join'] = 0
df = mista_key.merge(vyrobci_key).drop('join', axis=1)
df = pd.merge(df, prijato, how="left")
df = pd.merge(df, prijato_odjinud, how="left")
df = pd.merge(df, vydano, how="left")
df = pd.merge(df, spotreba, how="left")
df['prijato'] = df['prijato'].fillna(0).astype('int')
df['prijato_odjinud'] = df['prijato_odjinud'].fillna(0).astype('int')
df['vydano'] = df['vydano'].fillna(0).astype('int')
df['znehodnoceno'] = df['znehodnoceno'].fillna(0).astype('int')
df = df.groupby(by=['kraj_id', 'vyrobce'], as_index=False).sum()
df = pd.merge(df, ockovano, how="left")
df['ockovano'] = df['ockovano'].fillna(0).astype('int')
df['prijato_celkem'] = df['prijato'] + df['prijato_odjinud'] - df['vydano']
df['skladem'] = df['prijato_celkem'] - df['ockovano'] - df['znehodnoceno']
df = df.groupby(by=['vyrobce'], as_index=False).sum().sort_values(by=['vyrobce'])
df = df[(df['prijato_celkem'] > 0) | (df['ockovano'] > 0) | (df['znehodnoceno'] > 0)]
return df
def count_vaccines_cr():
prijato = pd.read_sql_query(
"""
select vyrobce, sum(pocet_davek) prijato
from ockovani_distribuce
where akce = 'Příjem' and datum < '{}'
group by (vyrobce);
""".format(get_import_date()),
db.engine
)
spotreba = pd.read_sql_query(
"""
select vyrobce, sum(znehodnocene_davky) znehodnoceno
from ockovani_spotreba
where datum < '{}'
group by (vyrobce);
""".format(get_import_date()),
db.engine
)
ockovano = pd.read_sql_query(
"""
select sum(pocet) ockovano, vyrobce
from ockovani_lide
join vakciny on vakciny.vakcina = ockovani_lide.vakcina
where datum < '{}'
group by vyrobce
""".format(get_import_date()),
db.engine
)
vyrobci = pd.read_sql_query("select vyrobce from vakciny;", db.engine)
df = pd.merge(vyrobci, prijato, how="left")
df = | pd.merge(df, spotreba, how="left") | pandas.merge |
from pathlib import Path
import copy
import pickle as pkl
from mmap import mmap
from scipy import stats as st
from scipy.stats._continuous_distns import FitDataError
import torch
from sklearn import svm
from sklearn import linear_model
import pandas as pd
import seaborn as sns
import warnings
import numpy as np
import os
import matplotlib.colors as mcolors
from matplotlib import pyplot as plt
from mpl_toolkits.mplot3d import axes3d, Axes3D
from mpl_toolkits.mplot3d.art3d import juggle_axes
from matplotlib.ticker import MaxNLocator
from joblib import Memory
import math
import lyap
import model_loader_utils as loader
import initialize_and_train as train
import utils
memory = Memory(location='./memoization_cache', verbose=2)
# memory.clear()
## Functions for computing means and error bars for the plots. 68% confidence
# intervals and means are currently
# implemented in this code. The commented out code is for using a gamma
# distribution to compute these, but uses a
# custom version of seaborn plotting library to plot.
def orth_proj(v):
n = len(v)
vv = v.reshape(-1, 1)
return torch.eye(n) - ([email protected])/(v@v)
USE_ERRORBARS = True
# USE_ERRORBARS = False
LEGEND = False
# LEGEND = True
folder_root = '../results/figs/'
def ci_acc(vals):
median, bounds = median_and_bound(vals, perc_bound=0.75, loc=1.,
shift=-.0001, reflect=True)
return bounds[1], bounds[0]
# ci_acc = 68
# ci_acc = 95
def est_acc(vals):
median, bounds = median_and_bound(vals, perc_bound=0.75, loc=1.,
shift=-.0001, reflect=True)
return median
# est_acc = "mean"
def ci_dim(vals):
median, bounds = median_and_bound(vals, perc_bound=0.75, loc=.9999)
return bounds[1], bounds[0]
# ci_dim = 68
# ci_dim = 95
def est_dim(vals):
median, bounds = median_and_bound(vals, perc_bound=0.75, loc=.9999)
return median
# est_dim = "mean"
def point_replace(a_string):
a_string = str(a_string)
return a_string.replace(".", "p")
def get_color(x, cmap=plt.cm.plasma):
"""Get normalized color assignments based on input data x and colormap
cmap."""
mag = torch.max(x) - torch.min(x)
x_norm = (x.float() - torch.min(x))/mag
return cmap(x_norm)
def median_and_bound(samples, perc_bound, dist_type='gamma', loc=0., shift=0,
reflect=False):
"""Get median and probability mass intervals for a gamma distribution fit
of samples."""
samples = np.array(samples)
def do_reflect(x, center):
return -1*(x - center) + center
if dist_type == 'gamma':
if np.sum(samples[0] == samples) == len(samples):
median = samples[0]
interval = [samples[0], samples[0]]
return median, interval
if reflect:
samples_reflected = do_reflect(samples, loc)
shape_ps, loc_fit, scale = st.gamma.fit(samples_reflected,
floc=loc + shift)
median_reflected = st.gamma.median(shape_ps, loc=loc, scale=scale)
interval_reflected = np.array(
st.gamma.interval(perc_bound, shape_ps, loc=loc, scale=scale))
median = do_reflect(median_reflected, loc)
interval = do_reflect(interval_reflected, loc)
else:
shape_ps, loc, scale = st.gamma.fit(samples, floc=loc + shift)
median = st.gamma.median(shape_ps, loc=loc, scale=scale)
interval = np.array(
st.gamma.interval(perc_bound, shape_ps, loc=loc, scale=scale))
else:
raise ValueError("Distribution option (dist_type) not recognized.")
return median, interval
## Set parameters for figure aesthetics
plt.rcParams['font.size'] = 6
plt.rcParams['font.size'] = 6
plt.rcParams['lines.markersize'] = 1
plt.rcParams['lines.linewidth'] = 1
plt.rcParams['axes.labelsize'] = 7
plt.rcParams['axes.spines.right'] = False
plt.rcParams['axes.spines.top'] = False
plt.rcParams['axes.titlesize'] = 8
# Colormaps
class_style = 'color'
cols11 = np.array([90, 100, 170])/255
cols12 = np.array([37, 50, 120])/255
cols21 = np.array([250, 171, 62])/255
cols22 = np.array([156, 110, 35])/255
cmap_activation_pnts = mcolors.ListedColormap([cols11, cols21])
cmap_activation_pnts_edge = mcolors.ListedColormap([cols12, cols22])
rasterized = False
dpi = 800
ext = 'pdf'
# Default figure size
figsize = (1.5, 1.2)
ax_pos = (0, 0, 1, 1)
def make_fig(figsize=figsize, ax_pos=ax_pos):
"""Create figure."""
fig = plt.figure(figsize=figsize)
ax = fig.add_axes(ax_pos)
return fig, ax
def out_fig(fig, figname, subfolder='', show=False, save=True, axis_type=0,
name_order=0, data=None):
""" Save figure."""
folder = Path(folder_root)
figname = point_replace(figname)
# os.makedirs('../results/figs/', exist_ok=True)
os.makedirs(folder, exist_ok=True)
ax = fig.axes[0]
ax.set_xlabel('')
ax.set_ylabel('')
ax.set_rasterized(rasterized)
if axis_type == 1:
ax.tick_params(axis='both', which='both',
# both major and minor ticks are affected
bottom=False, # ticks along the bottom edge are off
left=False, top=False,
# ticks along the top edge are off
labelbottom=False,
labelleft=False) # labels along the bottom edge are off
elif axis_type == 2:
ax.axis('off')
if name_order == 0:
fig_path = folder/subfolder/figname
else:
fig_path = folder/subfolder/figname
if save:
os.makedirs(folder/subfolder, exist_ok=True)
fig_file = fig_path.with_suffix('.' + ext)
print(f"Saving figure to {fig_file}")
fig.savefig(fig_file, dpi=dpi, transparent=True, bbox_inches='tight')
if show:
fig.tight_layout()
fig.show()
if data is not None:
os.makedirs(folder/subfolder/'data/', exist_ok=True)
with open(folder/subfolder/'data/{}_data'.format(figname),
'wb') as fid:
pkl.dump(data, fid, protocol=4)
plt.close('all')
def autocorrelation(train_params, figname='autocorrelation'):
train_params_loc = train_params.copy()
model, params, run_dir = train.initialize_and_train(**train_params_loc)
class_datasets = params['datasets']
# val_loss = params['history']['losses']['val']
# val_losses[i0, i1] = val_loss
# val_acc = params['history']['accuracies']['val']
# val_accs[i0, i1] = val_acc
train_samples_per_epoch = len(class_datasets['train'])
class_datasets['train'].max_samples = 10
torch.manual_seed(params['model_seed'])
X = class_datasets['train'][:][0]
T = 0
if T > 0:
X = utils.extend_input(X, T)
X0 = X[:, 0]
elif train_params_loc['network'] != 'feedforward':
X0 = X[:, 0]
else:
X0 = X
# X = utils.extend_input(X, 10)
loader.load_model_from_epoch_and_dir(model, run_dir, -1)
hid = []
hid += model.get_post_activations(X)[:-1]
# auto_corr_mean = []
# auto_corr_var = []
auto_corr_table = pd.DataFrame(columns=['t_next', 'autocorr'])
h = hid[0]
for i0 in range(len(hid)):
h_next = hid[i0]
overlap = torch.sum(h*h_next, dim=1)
norms_h = torch.sqrt(torch.sum(h**2, dim=1))
norms_h_next = torch.sqrt(torch.sum(h_next**2, dim=1))
corrs = overlap/(norms_h*norms_h_next)
avg_corr = torch.mean(corrs)
d = {'t_next': i0, 'autocorr': corrs}
auto_corr_table = auto_corr_table.append(pd.DataFrame(d),
ignore_index=True)
fig, ax = make_fig(figsize)
sns.lineplot(ax=ax, x='t_next', y='autocorr', data=auto_corr_table)
out_fig(fig, figname)
def snapshots_through_time(train_params, figname="snap", subdir="snaps"):
"""
Plot PCA snapshots of the representation through time.
Parameters
----------
train_params : dict
Dictionary of training parameters that specify the model and dataset
to use for training.
"""
subdir = Path(subdir)
X_dim = train_params['X_dim']
FEEDFORWARD = train_params['network'] == 'feedforward'
num_pnts_dim_red = 800
num_plot = 600
train_params_loc = copy.deepcopy(train_params)
model, params, run_dir = train.initialize_and_train(**train_params_loc)
class_datasets = params['datasets']
class_datasets['train'].max_samples = num_pnts_dim_red
torch.manual_seed(train_params_loc['model_seed'])
X, Y = class_datasets['train'][:]
if FEEDFORWARD:
T = 10
y = Y
X0 = X
else:
T = 30
# T = 100
X = utils.extend_input(X, T + 2)
X0 = X[:, 0]
y = Y[:, -1]
loader.load_model_from_epoch_and_dir(model, run_dir, 0, 0)
hid_0 = [X0]
hid_0 += model.get_post_activations(X)[:-1]
loader.load_model_from_epoch_and_dir(model, run_dir,
train_params_loc['num_epochs'], 0)
hid = [X0]
hid += model.get_post_activations(X)[:-1]
if FEEDFORWARD:
r = model.layer_weights[-1].detach().clone().T
else:
r = model.Wout.detach().clone()
# r0_n = r[0] / torch.norm(r[0])
# r1_n = r[1] / torch.norm(r[1])
#
# r0_n_v = r0_n.reshape(r0_n.shape[0], 1)
# r1_n_v = r1_n.reshape(r1_n.shape[0], 1)
# r0_orth = torch.eye(len(r0_n)) - r0_n_v @ r0_n_v.T
# r1_orth = torch.eye(len(r1_n)) - r1_n_v @ r1_n_v.T
# h = hid[10]
# # h_proj = h @ r_orth
# u, s, v = torch.svd(h)
# v0 = v[:, 0]
# def orth_projector(v):
# n = len(v)
# return (torch.eye(n) - v.reshape(n, 1)@v.reshape(1, n))/(v@v)
# v0_orth = (torch.eye(n) - v0.reshape(n,1)@v0.reshape(1,n))/(v0@v0)
# h_v0_orth = h @ v0_orth
# r0_e_p = orth_projector(r0_e)
# r1_e_p = orth_projector(r1_e)
# h_r0_e_p0 = h[y] @ r0_e_p
# h_r0_e_p1 = h[y] @ r1_e_p
coloring = get_color(y, cmap_activation_pnts)[:num_plot]
edge_coloring = get_color(y, cmap_activation_pnts_edge)[:num_plot]
## Now get principal components (pcs) and align them from time point to
# time point
pcs = []
p_track = 0
norm = np.linalg.norm
projs = []
for i1 in range(1, len(hid)):
# pc = utils.get_pcs_covariance(hid[i1], [0, 1])
out = utils.get_pcs_covariance(hid[i1], [0, 1], return_extra=True)
pc = out['pca_projection']
mu = out['mean']
proj = out['pca_projectors']
mu_proj = mu@proj[:, :2]
if i1 > 0:
# Check for the best alignment
pc_flip_x = pc.clone()
pc_flip_x[:, 0] = -pc_flip_x[:, 0]
pc_flip_y = pc.clone()
pc_flip_y[:, 1] = -pc_flip_y[:, 1]
pc_flip_both = pc.clone()
pc_flip_both[:, 0] = -pc_flip_both[:, 0]
pc_flip_both[:, 1] = -pc_flip_both[:, 1]
difference0 = norm(p_track - pc)
difference1 = norm(p_track - pc_flip_x)
difference2 = norm(p_track - pc_flip_y)
difference3 = norm(p_track - pc_flip_both)
amin = np.argmin(
[difference0, difference1, difference2, difference3])
if amin == 1:
pc[:, 0] = -pc[:, 0]
proj[:, 0] = -proj[:, 0]
elif amin == 2:
pc[:, 1] = -pc[:, 1]
proj[:, 1] = -proj[:, 1]
elif amin == 3:
pc[:, 0] = -pc[:, 0]
pc[:, 1] = -pc[:, 1]
proj[:, 0] = -proj[:, 0]
proj[:, 1] = -proj[:, 1]
pc = pc + mu_proj
p_track = pc.clone()
pcs.append(pc[:num_plot])
projs.append(proj)
def take_snap(i0, scats, fig, dim=2, border=False):
# ax = fig.axes[0]
hid_pcs_plot = pcs[i0][:, :dim].numpy()
xm = np.min(hid_pcs_plot[:, 0])
xM = np.max(hid_pcs_plot[:, 0])
ym = np.min(hid_pcs_plot[:, 1])
yM = np.max(hid_pcs_plot[:, 1])
xc = (xm + xM)/2
yc = (ym + yM)/2
hid_pcs_plot[:, 0] = hid_pcs_plot[:, 0] - xc
hid_pcs_plot[:, 1] = hid_pcs_plot[:, 1] - yc
v = projs[i0]
# u, s, v = torch.svd(h)
if r.shape[0] == 2:
r0_p = r[0]@v
r1_p = r[1]@v
else:
r0_p = r.flatten()@v
r1_p = -r.flatten()@v
if class_style == 'shape':
scats[0][0].set_offsets(hid_pcs_plot)
else:
if dim == 3:
scat._offsets3d = juggle_axes(*hid_pcs_plot[:, :dim].T, 'z')
scat._offsets3d = juggle_axes(*hid_pcs_plot[:, :dim].T, 'z')
else:
scats[0].set_offsets(hid_pcs_plot)
scats[1].set_offsets(r0_p[:2].reshape(1, 2))
scats[2].set_offsets(r1_p[:2].reshape(1, 2))
xm = np.min(hid_pcs_plot[:, 0])
xM = np.max(hid_pcs_plot[:, 0])
ym = np.min(hid_pcs_plot[:, 1])
yM = np.max(hid_pcs_plot[:, 1])
max_extent = max(xM - xm, yM - ym)
max_extent_arg = xM - xm > yM - ym
if dim == 2:
x_factor = .4
if max_extent_arg:
ax.set_xlim(
[xm - x_factor*max_extent, xM + x_factor*max_extent])
ax.set_ylim([xm - .1*max_extent, xM + .1*max_extent])
else:
ax.set_xlim(
[ym - x_factor*max_extent, yM + x_factor*max_extent])
ax.set_ylim([ym - .1*max_extent, yM + .1*max_extent])
else:
if max_extent_arg:
ax.set_xlim([xm - .1*max_extent, xM + .1*max_extent])
ax.set_ylim([xm - .1*max_extent, xM + .1*max_extent])
ax.set_zlim([xm - .1*max_extent, xM + .1*max_extent])
else:
ax.set_xlim([ym - .1*max_extent, yM + .1*max_extent])
ax.set_ylim([ym - .1*max_extent, yM + .1*max_extent])
ax.set_zlim([ym - .1*max_extent, yM + .1*max_extent])
# ax.plot([r0_p[0]], [r0_p[1]], 'x', markersize=3, color='black')
# ax.plot([r1_p[0]], [r1_p[1]], 'x', markersize=3, color='black')
ax.set_ylim([-4, 4])
if dim == 3:
out_fig(fig, f"{figname}_{i0}",
subfolder=subdir, axis_type=0,
name_order=1)
else:
out_fig(fig, f"{figname}_{i0}",
subfolder=subdir, axis_type=0,
name_order=1)
return scats,
dim = 2
hid_pcs_plot = pcs[0]
if dim == 3:
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.set_xlim([-10, 10])
ax.set_ylim([-10, 10])
ax.set_zlim([-10, 10])
else:
fig, ax = make_fig()
ax.grid(False)
scat1 = ax.scatter(*hid_pcs_plot[:num_plot, :dim].T, c=coloring,
edgecolors=edge_coloring, s=10, linewidths=.65)
ax.plot([0], [0], 'x', markersize=7)
scat2 = ax.scatter([0], [0], marker='x', s=3, c='black')
scat3 = ax.scatter([0], [0], marker='x', s=3, color='black')
scats = [scat1, scat2, scat3]
# ax.plot([0], [0], 'o', markersize=10)
if FEEDFORWARD:
snap_idx = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
else:
snap_idx = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 16, 21, 26,
31]) # snap_idx = list(range(T + 1))
for i0 in snap_idx:
take_snap(i0, scats, fig, dim=dim, border=False)
print
def _cluster_holdout_test_acc_stat_fun(h, y, clust_identity,
classifier_type='logistic_regression',
num_repeats=5, train_ratio=0.8, seed=11):
np.random.seed(seed)
num_clusts = np.max(clust_identity) + 1
num_clusts_train = int(round(num_clusts*train_ratio))
num_samples = h.shape[0]
test_accs = np.zeros(num_repeats)
train_accs = np.zeros(num_repeats)
for i0 in range(num_repeats):
permutation = np.random.permutation(np.arange(len(clust_identity)))
perm_inv = np.argsort(permutation)
clust_identity_shuffled = clust_identity[permutation]
train_idx = clust_identity_shuffled <= num_clusts_train
test_idx = clust_identity_shuffled > num_clusts_train
hid_train = h[train_idx[perm_inv]]
y_train = y[train_idx[perm_inv]]
y_test = y[test_idx[perm_inv]]
hid_test = h[test_idx[perm_inv]]
if classifier_type == 'svm':
classifier = svm.LinearSVC(random_state=3*i0 + 1)
else:
classifier = linear_model.LogisticRegression(random_state=3*i0 + 1,
solver='lbfgs')
with warnings.catch_warnings():
warnings.simplefilter("ignore")
classifier.fit(hid_train, y_train)
train_accs[i0] = classifier.score(hid_train, y_train)
test_accs[i0] = classifier.score(hid_test, y_test)
return train_accs, test_accs
def clust_holdout_over_layers(seeds, gs, train_params,
figname="clust_holdout_over_layers"):
"""
Logistic regression training and testing error on the representation
through the layers. Compares networks trained
with different choices of g_radius (specified by input parameter gs).
Parameters
----------
seeds : List[int]
List of random number seeds to use for generating instantiations of
the model and dataset. Variation over
these seeds is used to plot error bars.
gs : List[float]
Values of g_radius to iterate over.
train_params : dict
Dictionary of training parameters that specify the model and dataset
to use for training. Value of g_radius
is overwritten by values in gs.
figname : str
Name of the figure to save.
"""
if not hasattr(gs, '__len__'):
gs = [gs]
layer_label = 'layer'
@memory.cache
def generate_data_table_clust(seeds, gs, train_params):
layer_label = 'layer'
clust_acc_table = pd.DataFrame(
columns=['seed', 'g_radius', 'training', layer_label, 'LR training',
'LR testing'])
train_params_loc = copy.deepcopy(train_params)
for i0, seed in enumerate(seeds):
for i1, g in enumerate(gs):
train_params_loc['g_radius'] = g
train_params_loc['model_seed'] = seed
num_pnts_dim_red = 500
model, params, run_dir = train.initialize_and_train(
**train_params_loc)
class_datasets = params['datasets']
num_train_samples = len(class_datasets['train'])
class_datasets['train'].max_samples = num_pnts_dim_red
torch.manual_seed(params['model_seed'])
X, Y = class_datasets['train'][:]
if train_params_loc['network'] == 'feedforward':
X0 = X
else:
X0 = X[:, 0]
for epoch, epoch_label in zip([0, -1], ['before', 'after']):
loader.load_model_from_epoch_and_dir(model, run_dir, epoch)
hid = [X0]
hid += model.get_post_activations(X)[:-1]
if len(Y.shape) > 1:
Y = Y[:, -1]
cluster_identity = class_datasets['train'].cluster_identity
ds = []
for lay, h in enumerate(hid):
stat = _cluster_holdout_test_acc_stat_fun(h.numpy(),
Y.numpy(),
cluster_identity)
ds.extend([{
'seed': seed, 'g_radius': g,
'training': epoch_label, layer_label: lay,
'LR training': stat[0][k], 'LR testing': stat[1][k]
} for k in range(len(stat[0]))])
clust_acc_table = clust_acc_table.append(pd.DataFrame(ds),
ignore_index=True)
clust_acc_table['seed'] = clust_acc_table['seed'].astype('category')
clust_acc_table['g_radius'] = clust_acc_table['g_radius'].astype(
'category')
clust_acc_table['training'] = clust_acc_table['training'].astype(
'category')
return clust_acc_table
clust_acc_table = generate_data_table_clust(seeds, gs, train_params)
layers = set(clust_acc_table[layer_label])
for stage in ['LR training', 'LR testing']:
if stage == 'LR training':
clust_acc_table_stage = clust_acc_table.drop(columns=['LR testing'])
else:
clust_acc_table_stage = clust_acc_table.drop(
columns=['LR training'])
fig, ax = make_fig((1.5, 1.2))
if USE_ERRORBARS:
g = sns.lineplot(ax=ax, x=layer_label, y=stage,
data=clust_acc_table_stage, estimator=est_acc,
ci=ci_acc, style='training',
style_order=['after', 'before'], hue='g_radius')
else:
g1 = sns.lineplot(ax=ax, x=layer_label, y=stage,
data=clust_acc_table_stage, estimator=None,
units='seed', style='training',
style_order=['after', 'before'], hue='g_radius',
alpha=0.6)
g2 = sns.lineplot(ax=ax, x=layer_label, y=stage,
data=clust_acc_table_stage, estimator='mean',
ci=None, style='training',
style_order=['after', 'before'], hue='g_radius')
if g1.legend_ is not None:
g1.legend_.remove()
if not LEGEND and g2.legend_ is not None:
g2.legend_.remove()
if not LEGEND and g.legend_ is not None:
g.legend_.remove()
ax.set_ylim([-.01, 1.01])
ax.set_xticks(range(len(layers)))
out_fig(fig, figname + '_' + stage, subfolder=train_params[
'network'] +
'/clust_holdout_over_layers/',
show=False, save=True, axis_type=0, name_order=0,
data=clust_acc_table)
plt.close('all')
def get_stats(stat_fun, train_params_list_hue, train_params_list_style=None,
seeds=None, hue_key=None, style_key=None, *args, **kwargs):
train_params_list_hue = [copy.deepcopy(t) for t in train_params_list_hue]
style_bool = train_params_list_style is not None
if style_bool:
train_params_list_style = [copy.deepcopy(t) for t in
train_params_list_style]
style_bool = train_params_list_style is not None
if style_bool and style_key is None:
raise ValueError("Please specify a style_key.")
hue_bool = len(train_params_list_hue) > 1
if hue_bool and hue_key is None:
raise ValueError("Please specify a hue_key.")
if seeds is None:
seeds = [train_params_list_hue[0]['model_seed']]
params_cat = [[], []]
params_cat[0] = train_params_list_hue
if style_bool:
params_cat[1] = train_params_list_style
else:
params_cat[1] = [None]
table = pd.DataFrame()
if hue_bool:
table.reindex(columns=table.columns.tolist() + [hue_key])
if style_bool:
table.reindex(columns=table.columns.tolist() + [style_key])
for i0 in range(len(params_cat)): # hue params
for i1 in range(len(params_cat[i0])):
params = params_cat[i0][i1]
table_piece = stat_fun(params, hue_key, style_key, seeds,
*args, **kwargs)
table = table.append(table_piece, ignore_index=True)
if hue_key is not None:
table[hue_key] = table[hue_key].astype('category')
if style_key is not None:
table[style_key] = table[style_key].astype('category')
return table
def dim_through_training(train_params_list_hue, train_params_list_style=None,
seeds=None, hue_key=None, style_key=None, figname='',
subdir=None, multiprocess_lock=None):
if subdir is None:
subdir = train_params_list_hue[0][
'network'] + '/' + 'dim_over_training' + '/'
@memory.cache
def compute_dim_through_training(params, hue_key, style_key, seeds):
num_pnts_dim_red = 500
table_piece = pd.DataFrame()
if params is not None:
if hue_key is not None:
hue_value = params[hue_key]
if style_key is not None:
style_value = params[style_key]
for seed in seeds:
params['model_seed'] = seed
model, returned_params, run_dir = train.initialize_and_train(
**params, multiprocess_lock=multiprocess_lock)
class_datasets = returned_params['datasets']
class_datasets['train'].max_samples = num_pnts_dim_red
torch.manual_seed(int(params['model_seed']))
np.random.seed(int(params['model_seed']))
X, Y = class_datasets['train'][:]
T = 0
if T > 0:
X = utils.extend_input(X, T)
X0 = X[:, 0]
elif params['network'] != 'feedforward':
X0 = X[:, 0]
else:
X0 = X
epochs, saves = loader.get_epochs_and_saves(run_dir)
epochs = [epoch for epoch in epochs if
epoch <= params['num_epochs']]
for i_epoch, epoch in enumerate(epochs):
loader.load_model_from_epoch_and_dir(model, run_dir, epoch)
hid = [X0]
hid += model.get_post_activations(X)[:-1]
try:
dim = utils.get_effdim(hid[-1],
preserve_gradients=False).item()
except RuntimeError:
print("Dim computation didn't converge.")
dim = np.nan
num_updates = int(
params['num_train_samples_per_epoch']/params[
'batch_size'])*epoch
d = {
'effective_dimension': dim, 'seed': seed,
'epoch_index': i_epoch, 'epoch': epoch,
'num_updates': num_updates
}
if hue_key is not None:
d.update({hue_key: hue_value})
if style_key is not None:
d.update({style_key: style_value})
# casting d to DataFrame necessary to preserve type
table_piece = table_piece.append(pd.DataFrame(d, index=[0]),
ignore_index=True)
return table_piece
table = get_stats(compute_dim_through_training, train_params_list_hue,
train_params_list_style, seeds, hue_key, style_key)
table = table.replace([np.inf, -np.inf], np.nan)
table = table.dropna()
fig, ax = make_fig((1.5, 1.2))
if USE_ERRORBARS:
g = sns.lineplot(ax=ax, x='epoch_index', y='effective_dimension',
data=table, estimator=est_dim, ci=ci_dim, hue=hue_key,
style=style_key)
if not LEGEND and g.legend_ is not None:
g.legend_.remove()
else:
g1 = sns.lineplot(ax=ax, x='epoch_index', y='effective_dimension',
data=table, estimator=None, units='seed', hue=hue_key,
style=style_key, alpha=.6)
g2 = sns.lineplot(ax=ax, x='epoch_index', y='effective_dimension',
data=table, estimator='mean', ci=None, hue=hue_key,
style=style_key)
if g1.legend_ is not None:
g1.legend_.remove()
if not LEGEND and g2.legend_ is not None:
g2.legend_.remove()
ax.xaxis.set_major_locator(plt.MaxNLocator(integer=True))
ax.set_ylim([0, None])
out_fig(fig, figname, subfolder=subdir, show=False, save=True, axis_type=0,
data=table)
plt.close('all')
def dim_over_layers(train_params_list_hue, train_params_list_style=None,
seeds=None, hue_key=None, style_key=None,
figname="dim_over_layers", subdir=None, T=0,
multiprocess_lock=None, use_error_bars=None, **plot_kwargs):
"""
Effective dimension measured over layers (or timepoints if looking at an
RNN) of the network, before and after
training.
Parameters
----------
seeds : List[int]
List of random number seeds to use for generating instantiations of
the model and dataset. Variation over
these seeds is used to plot error bars.
gs : List[float]
Values of g_radius to iterate over.
train_params : dict
Dictionary of training parameters that specify the model and dataset
to use for training. Value of g_radius
is overwritten by values in gs.
figname : str
Name of the figure to save.
T : int
Final timepoint to plot (if looking at an RNN). If 0, disregard this
parameter.
"""
if subdir is None:
subdir = train_params_list_hue[0]['network'] + '/dim_over_layers/'
if use_error_bars is None:
use_error_bars = USE_ERRORBARS
train_params_list_hue = [copy.deepcopy(t) for t in train_params_list_hue]
style_bool = train_params_list_style is not None
if style_bool:
train_params_list_style = [copy.deepcopy(t) for t in
train_params_list_style]
@memory.cache
def compute_dim_over_layers(params, hue_key, style_key, seeds):
num_pnts_dim_red = 500
table_piece = pd.DataFrame()
if params is not None:
if hue_key is not None:
hue_value = params[hue_key]
if style_key is not None:
style_value = params[style_key]
for seed in seeds:
params['model_seed'] = seed
model, returned_params, run_dir = train.initialize_and_train(
**params, multiprocess_lock=multiprocess_lock)
class_datasets = returned_params['datasets']
class_datasets['train'].max_samples = num_pnts_dim_red
torch.manual_seed(int(params['model_seed']))
np.random.seed(int(params['model_seed']))
X, Y = class_datasets['train'][:]
T = 15
if T > 0:
X = utils.extend_input(X, T)
X0 = X[:, 0]
elif params['network'] != 'feedforward':
X0 = X[:, 0]
else:
X0 = X
# epochs, saves = loader.get_epochs_and_saves(run_dir)
# for i_epoch, epoch in enumerate([0, -1]):
loader.load_model_from_epoch_and_dir(model, run_dir,
params['num_epochs'])
hid = [X0]
hid += model.get_post_activations(X)[:-1]
dims = []
for h in hid:
try:
dims.append(utils.get_effdim(h,
preserve_gradients=False).item())
except RuntimeError:
dims.append(np.nan)
d = {
'effective_dimension': dims,
'layer': list(range(len(dims))), 'seed': seed
}
if hue_key is not None:
d.update({hue_key: hue_value})
if style_key is not None:
d.update({style_key: style_value})
# casting d to DataFrame necessary to preserve type
table_piece = table_piece.append(pd.DataFrame(d),
ignore_index=True)
return table_piece
table = get_stats(compute_dim_over_layers, train_params_list_hue,
train_params_list_style, seeds, hue_key, style_key)
table = table.replace([np.inf, -np.inf], np.nan)
table = table.dropna()
# breakpoint()
# print(table)
fig, ax = make_fig((1.5, 1.2))
# table['g_radius'] = table['g_radius'].astype('float64')
# norm = plt.Normalize(table['g_radius'].min(), table['g_radius'].max())
# sm = plt.cm.ScalarMappable(cmap="viridis", norm=norm)
# sm.set_array([])
# try:
if use_error_bars:
g = sns.lineplot(ax=ax, x='layer', y='effective_dimension',
data=table, estimator=est_dim, ci=ci_dim,
style=style_key, hue=hue_key, **plot_kwargs)
# g.figure.colorbar(sm)
if not LEGEND and g.legend_ is not None:
g.legend_.remove()
else:
g1 = sns.lineplot(ax=ax, x='layer', y='effective_dimension',
data=table, estimator=None, units='seed',
style=style_key, hue=hue_key, alpha=0.6,
**plot_kwargs)
g2 = sns.lineplot(ax=ax, x='layer', y='effective_dimension',
data=table, estimator='mean', ci=None,
style=style_key, hue=hue_key, **plot_kwargs)
if g1.legend_ is not None:
g1.legend_.remove()
if not LEGEND and g2.legend_ is not None:
g2.legend_.remove()
# except FitDataError:
# print("Plotting data invalid.")
layers = set(table['layer'])
if len(layers) < 12:
ax.set_xticks(range(len(layers)))
else:
ax.xaxis.set_major_locator(plt.MaxNLocator(
integer=True)) # ax.xaxis.set_major_locator(plt.MaxNLocator(10))
# ax.set_ylim([0, None])
# ax.set_ylim([0, 15])
out_fig(fig, figname, subfolder=subdir, show=False, save=True, axis_type=0,
data=table)
plt.close('all')
def orth_compression_through_layers(train_params_list_hue,
train_params_list_style=None, seeds=None,
hue_key=None, style_key=None,
figname="orth_compression_through_layers",
subdir=None, multiprocess_lock=None,
**plot_kwargs):
"""
"""
# if train_params_list_hue[0]['loss'] != 'mse_scalar':
# raise ValueError("Expected scalar mse loss.")
if subdir is None:
subdir = train_params_list_hue[0][
'network'] + '/orth_compression_through_layers/'
train_params_list_hue = [copy.deepcopy(t) for t in train_params_list_hue]
style_bool = train_params_list_style is not None
if style_bool:
train_params_list_style = [copy.deepcopy(t) for t in
train_params_list_style]
@memory.cache
def compute_orth_compression_through_layers(params, hue_key, style_key,
seeds):
num_pnts = 500
# num_dims = 2
table_piece = pd.DataFrame()
if params is not None:
if hue_key is not None:
hue_value = params[hue_key]
if style_key is not None:
style_value = params[style_key]
for seed in seeds:
params['model_seed'] = seed
model, returned_params, run_dir = train.initialize_and_train(
**params, multiprocess_lock=multiprocess_lock)
num_dims = int(returned_params['X_dim'])
class_datasets = returned_params['datasets']
def pca(v):
out = utils.get_pcs(v, list(range(num_dims)),
return_extra=True)
h_pcs = out['pca_projection']
v = out['pca_projectors'][:, :num_dims]
return h_pcs, v
class_datasets['train'].max_samples = num_pnts
torch.manual_seed(int(params['model_seed']))
np.random.seed(int(params['model_seed']))
X, Y = class_datasets['train'][:]
T = 0
# T = 20
if T > 0:
X = utils.extend_input(X, T)
X0 = X[:, 0]
elif params['network'] != 'feedforward':
X0 = X[:, 0]
else:
X0 = X
epochs, saves = loader.get_epochs_and_saves(run_dir)
epochs = [epoch for epoch in epochs if
epoch <= params['num_epochs']]
r0s = []
r1s = []
for save in saves[-2][:]:
loader.load_model_from_epoch_and_dir(model, run_dir,
epochs[-1], save)
if params['network'] == 'feedforward':
r = model.layer_weights[-1].detach().clone().T
else:
r = model.Wout.detach().clone()
r0s.append(r[0].double())
if params['loss'] != 'mse_scalar':
r1s.append(r[1].double())
r0 = torch.mean(torch.stack(r0s), dim=0)
if params['loss'] != 'mse_scalar':
r1 = torch.mean(torch.stack(r1s), dim=0)
if params['network'] == 'feedforward':
y = Y.flatten()
else:
y = Y[:, -1]
# for i_epoch, epoch in enumerate([0, -1]):
loader.load_model_from_epoch_and_dir(model, run_dir, 0)
hid0 = [X0]
hid0 += model.get_post_activations(X)[:-1]
loader.load_model_from_epoch_and_dir(model, run_dir,
params['num_epochs'])
hid = [X0]
hid += model.get_post_activations(X)[:-1]
rs = []
avg_ratios = []
for i0, (h, h0) in enumerate(zip(hid, hid0)):
h = h.double()
h_pcs, v = pca(h)
h0 = h0.double()
h0_pcs, v0 = pca(h0)
if params['loss'] == 'mse_scalar':
h_proj = h_pcs@orth_proj(r0@v).T
h0_proj = h0_pcs@orth_proj(r0@v0).T
h_norms = torch.norm(h_proj, dim=1)
h0_norms = torch.norm(h0_proj, dim=1)
ratios = h_norms/h0_norms
avg_ratio = torch.mean(ratios).item()
else:
h_proj = h_pcs[y == 0]@orth_proj(
r0@v).T # todo: maybe need to use yh (net
# prediction)
h0_proj = h0_pcs[y == 0]@orth_proj(r0@v0).T
h_norms = torch.norm(h_proj, dim=1)
h0_norms = torch.norm(h0_proj, dim=1)
ratios = h_norms/h0_norms
avg_ratio1 = torch.mean(ratios).item()
h_proj = h_pcs[y == 1]@orth_proj(r1@v).T
h0_proj = h0_pcs[y == 1]@orth_proj(r1@v).T
h_norms = torch.norm(h_proj, dim=1)
h0_norms = torch.norm(h0_proj, dim=1)
ratios = h_norms/h0_norms
avg_ratio2 = torch.mean(ratios).item()
avg_ratio = (avg_ratio1 + avg_ratio2)/2
avg_ratios.append(avg_ratio)
# u, s, v = torch.svd(h)
# proj_mags = [(h @ r_orth.T)]
# def get_shrink(r, h, h0):
d = {
'projections_magnitude': avg_ratios,
'layer': list(range(len(avg_ratios))), 'seed': seed
}
if hue_key is not None:
d.update({hue_key: hue_value})
if style_key is not None:
d.update({style_key: style_value})
# casting d to DataFrame necessary to preserve type
table_piece = table_piece.append(pd.DataFrame(d),
ignore_index=True)
return table_piece
table = get_stats(compute_orth_compression_through_layers,
train_params_list_hue, train_params_list_style, seeds,
hue_key, style_key)
print(table)
table = table.replace([np.inf, -np.inf], np.nan)
table = table.dropna()
fig, ax = make_fig((1.5, 1.2))
try:
if USE_ERRORBARS:
g = sns.lineplot(ax=ax, x='layer', y='projections_magnitude',
data=table, estimator='mean', ci=68,
style=style_key, hue=hue_key)
else:
g = sns.lineplot(ax=ax, x='layer', y='projections_magnitude',
data=table, estimator=None, units='seed',
style=style_key, hue=hue_key)
if not LEGEND and g.legend_ is not None:
g.legend_.remove()
except FitDataError:
print("Invalid data.")
layers = set(table['layer'])
if len(layers) < 12:
ax.set_xticks(range(len(layers)))
else:
ax.xaxis.set_major_locator(plt.MaxNLocator(10))
ax.set_ylim([-.05, None])
out_fig(fig, figname, subfolder=subdir, show=False, save=True, axis_type=0,
data=table)
plt.close('all')
def orth_compression_through_training(train_params_list_hue,
train_params_list_style=None, seeds=None,
hue_key=None, style_key=None,
figname="orth_compression_through_training",
subdir=None, multiprocess_lock=None,
**plot_kwargs):
"""
"""
# if train_params_list_hue[0]['loss'] != 'mse_scalar':
# raise ValueError("Expected scalar mse loss.")
if subdir is None:
subdir = train_params_list_hue[0][
'network'] + '/orth_compression_through_training/'
train_params_list_hue = [copy.deepcopy(t) for t in train_params_list_hue]
style_bool = train_params_list_style is not None
if style_bool:
train_params_list_style = [copy.deepcopy(t) for t in
train_params_list_style]
@memory.cache
def compute_orth_compression_through_training(params, hue_key, style_key,
seeds):
num_pnts = 500
table_piece = | pd.DataFrame() | pandas.DataFrame |
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import StandardScaler
from scipy.stats import norm
from scipy import stats
df_test = | pd.read_csv("../../test.csv") | pandas.read_csv |
import lightgbm as lgb
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from lightgbm import LGBMRegressor
from sklearn.feature_selection import SelectFromModel, SelectKBest, f_regression
from sklearn.model_selection import KFold
from src import data_frame
params = {'num_leaves': 86,
'objective': 'regression',
'max_depth': 7,
'learning_rate': 0.2,
"boosting_type": "gbdt",
"subsample_freq": 1,
"subsample": 0.9,
"feature_fraction": 0.2,
"bagging_seed": 11,
"metrics": 'rmse',
"verbosity": -1,
'reg_alpha': 0.1,
'reg_lambda': 0.1,
# 'early_stopping_rounds': 200,
# 'n_estimators': 50000,
'random_state': 0,
}
def main(train_x=None, train_y=None, test_x=None, ids=None, seed=22):
if train_x is None:
train_x, train_y, test_x, ids = data_frame.main()
lgbr = LGBMRegressor(n_estimators=500, learning_rate=0.1, num_leaves=86, subsample_freq=1,
subsample=0.9, feature_fraction=0.2, bagging_seed=11, metrics="rmse",
reg_alpha=0.1, reg_lambda=0.1, random_state=0)
embeded_lgb_selector = SelectFromModel(lgbr, threshold='1.25*median')
embeded_lgb_selector.fit(train_x, train_y)
embeded_lgb_support = embeded_lgb_selector.get_support()
embeded_lgb_feature = train_x.loc[:, embeded_lgb_support].columns.tolist()
print(str(len(embeded_lgb_feature)), 'selected features')
return embeded_lgb_feature
def select_k_best(train_x=None, train_y=None, test_x=None, ids=None, seed=22, k=300):
if train_x is None:
train_x, train_y, test_x, ids = data_frame.main()
selector = SelectKBest(score_func=f_regression, k=5)
selector.fit(train_x, train_y)
mask = selector.get_support()
return selector.transform(train_x), selector.transform(test_x)
def get_feature_importances(train_x, train_y, shuffle=False, seed=22):
# 必要ならば目的変数をシャッフル
if shuffle:
train_y = pd.Series(np.random.permutation(train_y))
importance = pd.DataFrame()
importance["feature"] = train_x.keys()
importance["importance"] = 0
sss = KFold(n_splits=3, shuffle=True, random_state=seed)
# クロスバリデーションで学習・予測を行い、予測値とインデックスを保存する
dtrain = lgb.Dataset(train_x, train_y)
# dtest = lgb.Dataset(va_x, va_y, reference=dtrain)
model = lgb.train(params, dtrain, 400, verbose_eval=100)
importance["importance"] += model.feature_importance()
# 特徴量の重要度を含むデータフレームを作成
return importance.sort_values("importance", ascending=False)
def display_distributions(actual_imp_df, null_imp_df, feature):
# ある特徴量に対する重要度を取得
actual_imp = actual_imp_df.query(f"feature == '{feature}'")["importance"].mean()
null_imp = null_imp_df.query(f"feature == '{feature}'")["importance"]
# 可視化
fig, ax = plt.subplots(1, 1, figsize=(6, 4))
a = ax.hist(null_imp, label="Null importances")
ax.vlines(x=actual_imp, ymin=0, ymax=np.max(a[0]), color='r', linewidth=10, label='Real Target')
ax.legend(loc="upper right")
ax.set_title(f"Importance of {feature.upper()}", fontweight='bold')
plt.xlabel(f"Null Importance Distribution for {feature.upper()}")
plt.ylabel("Importance")
plt.show()
def null_importance(train_x=None, train_y=None, test_x=None, ids=None, seed=22, create=False):
# 閾値を設定
THRESHOLD = 40
if not create:
print(f"Create {create}")
actual_importance = | pd.read_csv("./data/null_importance.csv") | pandas.read_csv |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
test_hydrofunctions
----------------------------------
Tests for `hydrofunctions` module.
"""
from __future__ import (
absolute_import,
print_function,
division,
unicode_literals,
)
from unittest import mock
import unittest
import warnings
from pandas.testing import assert_frame_equal
import pandas as pd
import numpy as np
import pyarrow as pa
import json
import hydrofunctions as hf
from .fixtures import (
fakeResponse,
daily_dupe,
daily_dupe_altered,
tzfail,
JSON15min2day,
two_sites_two_params_iv,
nothing_avail,
mult_flags,
diff_freq,
startDST,
endDST,
recent_only,
)
class TestHydrofunctionsParsing(unittest.TestCase):
"""Test the parsing of hf.extract_nwis_df()
test the following:
Can it handle multiple qualifier flags?
how does it encode mult params & mult sites?
Does it raise HydroNoDataError if nothing returned?
"""
def test_hf_extract_nwis_df_accepts_response_obj(self):
fake_response = fakeResponse()
actual_df, actual_dict = hf.extract_nwis_df(fake_response, interpolate=False)
self.assertIsInstance(
actual_df, pd.core.frame.DataFrame, msg="Did not return a df"
)
self.assertIsInstance(actual_dict, dict, msg="Did not return a dict.")
def test_hf_extract_nwis_df_parse_multiple_flags(self):
actual_df, actual_dict = hf.extract_nwis_df(mult_flags, interpolate=False)
self.assertIsInstance(
actual_df, pd.core.frame.DataFrame, msg="Did not return a df"
)
self.assertIsInstance(actual_dict, dict, msg="Did not return a dict.")
def test_hf_extract_nwis_df_parse_two_sites_two_params_iv_return_df(self):
actual_df, actual_dict = hf.extract_nwis_df(
two_sites_two_params_iv, interpolate=False
)
self.assertIs(
type(actual_df), pd.core.frame.DataFrame, msg="Did not return a df"
)
self.assertIs(type(actual_dict), dict, msg="Did not return a dict.")
# TODO: test that data is organized correctly
def test_hf_extract_nwis_df_parse_two_sites_two_params_iv_return_df(self):
actual_df, actual_dict = hf.extract_nwis_df(
two_sites_two_params_iv, interpolate=False
)
actual_len, actual_width = actual_df.shape
self.assertIs(
type(actual_df), pd.core.frame.DataFrame, msg="Did not return a df"
)
self.assertEqual(actual_len, 93, "Wrong length for dataframe")
self.assertEqual(actual_width, 8, "Wrong width for dataframe")
expected_columns = [
"USGS:01541000:00060:00000",
"USGS:01541000:00060:00000_qualifiers",
"USGS:01541000:00065:00000",
"USGS:01541000:00065:00000_qualifiers",
"USGS:01541200:00060:00000",
"USGS:01541200:00060:00000_qualifiers",
"USGS:01541200:00065:00000",
"USGS:01541200:00065:00000_qualifiers",
]
actual_columns = actual_df.columns.values
self.assertCountEqual(
actual_columns, expected_columns, "column names don't match expected"
)
self.assertTrue(actual_df.index.is_unique, "index has repeated values.")
self.assertTrue(actual_df.index.is_monotonic, "index is not monotonic.")
def test_hf_extract_nwis_df_parse_JSON15min2day_return_df(self):
actual_df, actual_dict = hf.extract_nwis_df(JSON15min2day, interpolate=False)
actual_len, actual_width = actual_df.shape
self.assertIs(
type(actual_df), pd.core.frame.DataFrame, msg="Did not return a df"
)
self.assertEqual(actual_len, 192, "Wrong length for dataframe")
self.assertEqual(actual_width, 2, "Wrong width for dataframe")
expected_columns = [
"USGS:03213700:00060:00000",
"USGS:03213700:00060:00000_qualifiers",
]
actual_columns = actual_df.columns.values
self.assertCountEqual(
actual_columns, expected_columns, "column names don't match expected"
)
self.assertTrue(actual_df.index.is_unique, "index has repeated values.")
self.assertTrue(actual_df.index.is_monotonic, "index is not monotonic.")
def test_hf_extract_nwis_df_parse_mult_flags_return_df(self):
actual_df, actual_dict = hf.extract_nwis_df(mult_flags, interpolate=False)
actual_len, actual_width = actual_df.shape
self.assertIs(
type(actual_df), pd.core.frame.DataFrame, msg="Did not return a df"
)
self.assertEqual(actual_len, 480, "Wrong length for dataframe")
self.assertEqual(actual_width, 2, "Wrong width for dataframe")
expected_columns = [
"USGS:01542500:00060:00000",
"USGS:01542500:00060:00000_qualifiers",
]
actual_columns = actual_df.columns.values
self.assertCountEqual(
actual_columns, expected_columns, "column names don't match expected"
)
self.assertTrue(actual_df.index.is_unique, "index has repeated values.")
self.assertTrue(actual_df.index.is_monotonic, "index is not monotonic.")
def test_hf_extract_nwis_raises_exception_when_df_is_empty(self):
empty_response = {"value": {"timeSeries": []}}
with self.assertRaises(hf.HydroNoDataError):
hf.extract_nwis_df(empty_response, interpolate=False)
def test_hf_extract_nwis_raises_exception_when_df_is_empty_nothing_avail(self):
with self.assertRaises(hf.HydroNoDataError):
hf.extract_nwis_df(nothing_avail, interpolate=False)
@unittest.skip(
"assertWarns errors on Linux. See https://bugs.python.org/issue29620"
)
def test_hf_extract_nwis_warns_when_diff_series_have_diff_freq(self):
with self.assertWarns(hf.HydroUserWarning):
hf.extract_nwis_df(diff_freq, interpolate=False)
def test_hf_extract_nwis_accepts_no_startdate_no_period_no_interpolate(self):
actual_df, actual_dict = hf.extract_nwis_df(recent_only, interpolate=False)
expected_shape = (
2,
4,
) # only the most recent data for two parameters, plus qualifiers = 4 columns; 2 rows: different dates.
self.assertEqual(
actual_df.shape,
expected_shape,
"The dataframe should have four columns and two rows.",
)
def test_hf_extract_nwis_accepts_no_startdate_no_period_interpolate(self):
actual_df, actual_dict = hf.extract_nwis_df(recent_only, interpolate=True)
expected_shape = (
2,
4,
) # only the most recent data for two parameters, plus qualifiers = 4 columns; 2 rows: different dates.
self.assertEqual(
actual_df.shape,
expected_shape,
"The dataframe should have four columns and two rows.",
)
def test_hf_extract_nwis_returns_comma_separated_qualifiers_1(self):
actual_df, actual_dict = hf.extract_nwis_df(mult_flags, interpolate=False)
actual_flags_1 = actual_df.loc[
"2019-01-24T10:30:00.000-05:00", "USGS:01542500:00060:00000_qualifiers"
]
expected_flags_1 = "P,e"
self.assertEqual(
actual_flags_1,
expected_flags_1,
"The data qualifier flags were not parsed correctly.",
)
def test_hf_extract_nwis_returns_comma_separated_qualifiers_2(self):
actual_df, actual_dict = hf.extract_nwis_df(mult_flags, interpolate=False)
actual_flags_2 = actual_df.loc[
"2019-01-28T16:00:00.000-05:00", "USGS:01542500:00060:00000_qualifiers"
]
expected_flags_2 = "P,Ice"
self.assertEqual(
actual_flags_2,
expected_flags_2,
"The data qualifier flags were not parsed correctly.",
)
def test_hf_extract_nwis_replaces_NWIS_noDataValue_with_npNan(self):
actual_df, actual_dict = hf.extract_nwis_df(mult_flags, interpolate=False)
actual_nodata = actual_df.loc[
"2019-01-28T16:00:00.000-05:00", "USGS:01542500:00060:00000"
]
self.assertTrue(
np.isnan(actual_nodata),
"The NWIS no data value was not replaced with np.nan. ",
)
def test_hf_extract_nwis_adds_missing_tags(self):
actual_df, actual_dict = hf.extract_nwis_df(mult_flags, interpolate=False)
actual_missing = actual_df.loc[
"2019-01-24 17:00:00-05:00", "USGS:01542500:00060:00000_qualifiers"
]
self.assertEqual(
actual_missing,
"hf.missing",
"Missing records should be given 'hf.missing' _qualifier tags.",
)
def test_hf_extract_nwis_adds_upsample_tags(self):
actual_df, actual_dict = hf.extract_nwis_df(diff_freq, interpolate=False)
actual_upsample = actual_df.loc[
"2018-06-01 00:15:00-04:00", "USGS:01570500:00060:00000_qualifiers"
]
self.assertEqual(
actual_upsample,
"hf.upsampled",
"New records created by upsampling should be given 'hf.upsample' _qualifier tags.",
)
def test_hf_extract_nwis_interpolates(self):
actual_df, actual_dict = hf.extract_nwis_df(diff_freq, interpolate=True)
actual_upsample_interpolate = actual_df.loc[
"2018-06-01 00:15:00-04:00", "USGS:01570500:00060:00000"
]
self.assertEqual(
actual_upsample_interpolate,
42200.0,
"New records created by upsampling should have NaNs replaced with interpolated values.",
)
@unittest.skip("This feature is not implemented yet.")
def test_hf_extract_nwis_interpolates_and_adds_tags(self):
# Ideally, every data value that was interpolated should have a tag
# added to the qualifiers that says it was interpolated.
actual_df, actual_dict = hf.extract_nwis_df(diff_freq, interpolate=True)
actual_upsample_interpolate_flag = actual_df.loc[
"2018-06-01 00:15:00-04:00", "USGS:01570500:00060:00000_qualifiers"
]
expected_flag = "hf.interpolated"
self.assertEqual(
actual_upsample_interpolate_flag,
expected_flag,
"Interpolated values should be marked with a flag.",
)
def test_hf_extract_nwis_corrects_for_start_of_DST(self):
actual_df, actual_dict = hf.extract_nwis_df(startDST, interpolate=False)
actual_len, width = actual_df.shape
expected = 284
self.assertEqual(
actual_len,
expected,
"Three days including the start of DST should have 3 * 24 * 4 = 288 observations, minus 4 = 284",
)
def test_hf_extract_nwis_corrects_for_end_of_DST(self):
actual_df, actual_dict = hf.extract_nwis_df(endDST, interpolate=False)
actual_len, width = actual_df.shape
expected = 292
self.assertEqual(
actual_len,
expected,
"Three days including the end of DST should have 3 * 24 * 4 = 288 observations, plus 4 = 292",
)
def test_hf_extract_nwis_can_find_tz_in_tzfail(self):
actualDF = hf.extract_nwis_df(tzfail, interpolate=False)
def test_hf_extract_nwis_can_deal_with_duplicated_records_as_input(self):
actualDF = hf.extract_nwis_df(daily_dupe, interpolate=False)
def test_hf_extract_nwis_can_deal_with_duplicated_records_that_have_been_altered_as_input(
self,
):
# What happens if a scientist replaces an empty record with new
# estimated data, and forgets to discard the old data?
actualDF = hf.extract_nwis_df(daily_dupe_altered, interpolate=False)
def test_hf_get_nwis_property(self):
sites = None
bBox = (-105.430, 39.655, -104, 39.863)
# TODO: test should be the json for a multiple site request.
names = hf.get_nwis_property(JSON15min2day, key="name")
self.assertIs(type(names), list, msg="Did not return a list")
class TestHydrofunctions(unittest.TestCase):
@mock.patch("requests.get")
def test_hf_get_nwis_calls_correct_url(self, mock_get):
"""
Thanks to
http://engineroom.trackmaven.com/blog/making-a-mockery-of-python/
"""
site = "A"
service = "iv"
start = "C"
end = "D"
expected_url = "https://waterservices.usgs.gov/nwis/" + service + "/?"
expected_headers = {"Accept-encoding": "gzip", "max-age": "120"}
expected_params = {
"format": "json,1.1",
"sites": "A",
"stateCd": None,
"countyCd": None,
"bBox": None,
"parameterCd": None,
"period": None,
"startDT": "C",
"endDT": "D",
}
expected = fakeResponse()
expected.status_code = 200
expected.reason = "any text"
mock_get.return_value = expected
actual = hf.get_nwis(site, service, start, end)
mock_get.assert_called_once_with(
expected_url, params=expected_params, headers=expected_headers
)
self.assertEqual(actual, expected)
@mock.patch("requests.get")
def test_hf_get_nwis_calls_correct_url_multiple_sites(self, mock_get):
site = ["site1", "site2"]
parsed_site = hf.check_parameter_string(site, "site")
service = "iv"
start = "C"
end = "D"
expected_url = "https://waterservices.usgs.gov/nwis/" + service + "/?"
expected_headers = {"max-age": "120", "Accept-encoding": "gzip"}
expected_params = {
"format": "json,1.1",
"sites": parsed_site,
"stateCd": None,
"countyCd": None,
"bBox": None,
"parameterCd": None,
"period": None,
"startDT": "C",
"endDT": "D",
}
expected = fakeResponse()
expected.status_code = 200
expected.reason = "any text"
mock_get.return_value = expected
actual = hf.get_nwis(site, service, start, end)
mock_get.assert_called_once_with(
expected_url, params=expected_params, headers=expected_headers
)
self.assertEqual(actual, expected)
@mock.patch("requests.get")
def test_hf_get_nwis_service_defaults_dv(self, mock_get):
site = "01541200"
expected_service = "dv"
expected_url = "https://waterservices.usgs.gov/nwis/" + expected_service + "/?"
expected_headers = {"max-age": "120", "Accept-encoding": "gzip"}
expected_params = {
"format": "json,1.1",
"sites": site,
"stateCd": None,
"countyCd": None,
"bBox": None,
"parameterCd": None,
"period": None,
"startDT": None,
"endDT": None,
}
expected = fakeResponse()
expected.status_code = 200
expected.reason = "any text"
mock_get.return_value = expected
actual = hf.get_nwis(site)
mock_get.assert_called_once_with(
expected_url, params=expected_params, headers=expected_headers
)
self.assertEqual(actual, expected)
@mock.patch("requests.get")
def test_hf_get_nwis_converts_parameterCd_all_to_None(self, mock_get):
site = "01541200"
service = "iv"
parameterCd = "all"
expected_parameterCd = None
expected_url = "https://waterservices.usgs.gov/nwis/" + service + "/?"
expected_headers = {"max-age": "120", "Accept-encoding": "gzip"}
expected_params = {
"format": "json,1.1",
"sites": site,
"stateCd": None,
"countyCd": None,
"bBox": None,
"parameterCd": None,
"period": None,
"startDT": None,
"endDT": None,
}
expected = fakeResponse()
expected.status_code = 200
expected.reason = "any text"
mock_get.return_value = expected
actual = hf.get_nwis(site, service, parameterCd=parameterCd)
mock_get.assert_called_once_with(
expected_url, params=expected_params, headers=expected_headers
)
self.assertEqual(actual, expected)
def test_hf_get_nwis_raises_ValueError_too_many_locations(self):
with self.assertRaises(ValueError):
hf.get_nwis("01541000", stateCd="MD")
def test_hf_get_nwis_raises_ValueError_start_and_period(self):
with self.assertRaises(ValueError):
hf.get_nwis("01541000", start_date="2014-01-01", period="P1D")
def test_hf_nwis_custom_status_codes_returns_None_for_200(self):
fake = fakeResponse()
fake.status_code = 200
fake.reason = "any text"
fake.url = "any text"
self.assertIsNone(hf.nwis_custom_status_codes(fake))
@unittest.skip(
"assertWarns errors on Linux. See https://bugs.python.org/issue29620"
)
def test_hf_nwis_custom_status_codes_raises_warning_for_non200(self):
expected_status_code = 400
bad_response = fakeResponse(code=expected_status_code)
with self.assertWarns(SyntaxWarning) as cm:
hf.nwis_custom_status_codes(bad_response)
def test_hf_nwis_custom_status_codes_returns_status_for_non200(self):
expected_status_code = 400
bad_response = fakeResponse(code=expected_status_code)
actual = hf.nwis_custom_status_codes(bad_response)
self.assertEqual(actual, expected_status_code)
def test_hf_calc_freq_returns_Timedelta_and_60min(self):
test_index = pd.date_range("2014-12-29", "2015-01-03", freq="60T")
actual = hf.calc_freq(test_index)
self.assertIsInstance(
actual, pd.Timedelta, "Calc_freq() should return pd.Timedelta."
)
expected = pd.Timedelta("60 minutes")
self.assertEqual(
actual, expected, "Calc_freq() should have converted 60T to 60 minutes."
)
def test_hf_calc_freq_accepts_Day(self):
test_index = pd.date_range("2014-12-29", periods=3)
actual = hf.calc_freq(test_index)
self.assertIsInstance(
actual, pd.Timedelta, "Calc_freq() should return pd.Timedelta."
)
expected = pd.Timedelta("1 day")
self.assertEqual(
actual, expected, "Calc_freq() should have found a 1 day frequency."
)
def test_hf_calc_freq_accepts_hour(self):
test_index = pd.date_range("2014-12-29", freq="1H", periods=30)
actual = hf.calc_freq(test_index)
self.assertIsInstance(
actual, pd.Timedelta, "Calc_freq() should return pd.Timedelta."
)
expected = pd.Timedelta("1 hour")
self.assertEqual(
actual, expected, "Calc_freq() should have found a 1 hour frequency."
)
def test_hf_calc_freq_accepts_1Day_1hour(self):
test_index = pd.date_range("2014-12-29", freq="1D1H2T", periods=30)
actual = hf.calc_freq(test_index)
self.assertIsInstance(
actual, pd.Timedelta, "Calc_freq() should return pd.Timedelta."
)
expected = pd.Timedelta("1 day 1 hour 2 minutes")
self.assertEqual(
actual,
expected,
"Calc_freq() should have found a 1 day, 1 hour, 2 minutes frequency.",
)
def test_hf_calc_freq_accepts_freq_None(self):
dates = ["2014-12-20", "2014-12-22", "2014-12-24", "2014-12-26"]
test_index = pd.DatetimeIndex(dates)
self.assertIsNone(
test_index.freq,
msg="The test_index was not properly set up so that test_index.freq is None.",
)
actual = hf.calc_freq(test_index)
self.assertIsInstance(
actual, pd.Timedelta, "Calc_freq() should return pd.Timedelta."
)
expected = pd.Timedelta("48 hours")
self.assertEqual(
actual, expected, "Calc_freq() should have returned a 48 hour period."
)
def test_hf_calc_freq_accepts_df(self):
test_index = pd.date_range("2014-12-29", "2014-12-30", freq="1T")
test_df = pd.DataFrame(index=test_index)
actual = hf.calc_freq(test_df)
self.assertIsInstance(
actual, pd.Timedelta, "Calc_freq() should return pd.Timedelta."
)
expected = pd.Timedelta("1 minute")
self.assertEqual(
actual, expected, "Calc_freq() should have returned a 1 minute period."
)
def test_hf_calc_freq_accepts_difficult_ts_freq_deleted(self):
test_index = pd.date_range("2014-12-29", "2014-12-30", freq="1H")
actual = hf.calc_freq(test_index)
self.assertIsInstance(
actual, pd.Timedelta, "Calc_freq() should return pd.Timedelta."
)
expected = pd.Timedelta("1 hour")
self.assertEqual(
actual, expected, "Calc_freq() should have returned a 1 hour frequency."
)
@unittest.skip("Difficulty dropping rows.")
def test_hf_calc_freq_accepts_difficult_ts_freq_deleted_row_dropped(self):
test_index = pd.date_range("2014-12-29", "2014-12-30", freq="1H")
test_df = pd.DataFrame(index=test_index)
# Can't get this to work.
test_df.drop("2014-12-30", axis=0)
actual = hf.calc_freq(test_df)
self.assertIsInstance(
actual, pd.Timedelta, "Calc_freq() should return pd.Timedelta."
)
expected = pd.Timedelta("1 hour")
self.assertEqual(
actual, expected, "Calc_freq() should have returned a 1 hour frequency."
)
@unittest.skip("")
def test_hf_calc_freq_accepts_difficult_ts_freq_deleted_no_rows(self):
pass
@unittest.skip("")
def test_hf_calc_freq_accepts_difficult_ts_freq_deleted_no_time_index(self):
pass
@unittest.skip("Not sure how to trigger a warning.")
def test_hf_calc_freq_raises_warning(self):
test_df = pd.DataFrame(data={"A": [1, 2, 3], "B": [4, 5, 6]})
actual = hf.calc_freq(test_df)
self.assertIsInstance(
actual, pd.Timedelta, "Calc_freq() should return pd.Timedelta."
)
expected = | pd.Timedelta("15 minutes") | pandas.Timedelta |
from typing import Dict, Optional, Union
import numpy
import pandas
from hts._t import ArrayLike, MethodT, NAryTreeT, TransformT
from hts.functions import to_sum_mat
from hts.revision import RevisionMethod
def _to_numpy(v: ArrayLike, kind: str = "forecasts") -> numpy.ndarray:
if isinstance(v, numpy.ndarray):
if v.ndim > 1:
raise ValueError(f"`{kind}` values must be of a dimension 1")
return v
elif isinstance(v, pandas.DataFrame):
if len(v.columns) > 1:
raise ValueError(
f"If providing `{kind}` as a DataFrame, it must have one column only"
)
col_name = v.columns[0]
return v[col_name].values
elif isinstance(v, pandas.Series):
return v.values
else:
raise ValueError(
f"`{kind}` must be a dict mapping string to array, series or DataFrame"
)
def _sanitize_errors_dict(errors: Dict[str, float]) -> Dict[str, float]:
for k, v in errors.items():
if not isinstance(v, float):
raise ValueError("`errors` dict must be a mapping from string to float")
return errors
def _sanitize_residuals_dict(
residuals: Dict[str, ArrayLike]
) -> Dict[str, numpy.ndarray]:
for k, v in residuals.items():
residuals[k] = _to_numpy(v, kind="residuals")
return residuals
def _sanitize_forecasts_dict(
forecasts: Dict[str, ArrayLike]
) -> Dict[str, pandas.DataFrame]:
for k, v in forecasts.items():
as_array = _to_numpy(v, kind="forecasts")
forecasts[k] = | pandas.DataFrame({"yhat": as_array}) | pandas.DataFrame |
import pandas as pd
import streamlit as st
import analysis
import queries
import utils
import visualization
from constants import STATES
def eviction_UI():
st.write('### Eviction Data Analysis')
with st.expander("About"):
st.write(
"""
This is an analysis based on work we did with [New Story](https://newstorycharity.org/) to help them
make decisions about how to distribute direct aid to families to help keep people in their homes. The
end result of this analysis is something we call 'Relative Risk.' This value is a synthesis of the
sociodemographic characteristics of a county that can be used to compare counties against each other.
It is *not* a measure of objective risk.
This analysis uses *total population* in its current iteration, not percentage values. This is to
capture that counties with more people represent more potential risk than smaller counties. Values from
a variety of data sources are normalized and then combined to represent the Relative Risk Index.
In addition to the Relative Risk calculation, we've also built calculations to estimate the cost to
avoid evictions by providing direct aid for a subset of the community.
As with any analysis that relies on public data, we should acknowledge that the underlying data is not
perfect. Public data has the potential to continue and exacerbate the under-representation of
certain groups. This data should not be equated with the ground truth of the conditions in a community.
You can read more about how we think about public data [here](https://medium.com/swlh/digital-government-and-data-theater-a-very-real-cause-of-very-fake-news-fe23c0dfa0a2).
You can read more about the data and calculations happening here on our [GitHub](https://github.com/arup-group/social-data).
"""
)
task = st.selectbox('What type of analysis are you doing?',
['Single County', 'Multiple Counties', 'State', 'National'], 1)
metro_areas, locations = queries.load_distributions()
if task == 'Single County' or task == '':
res = st.text_input('Enter the county and state (ie: Jefferson County, Colorado):')
if res:
res = res.strip().split(',')
county = res[0].strip()
state = res[1].strip()
if county and state:
df = queries.get_county_data(state, [county])
if st.checkbox('Show raw data'):
st.subheader('Raw Data')
st.dataframe(df)
st.markdown(utils.get_table_download_link(df, county + '_data', 'Download raw data'),
unsafe_allow_html=True)
with st.expander('Cost to avoid evictions'):
st.write("""
The cost to avoid evictions is defined as the cost to a municipality or other entity if it was to pay
people's rent directly. In this calculation, we assume a distribution of housing stock (0 bedroom to 4+ bedroom)
based on Census data. You can select which distribution to use that is most similar to the community that you're analyzing.
We default to using Fair Market Rents for this calculation, but you can use the Median value as well.
We also assume that only the burdened population is being considered for support, but not every burdened
person will receive support. You can adjust the percentage of the burdened population to consider.
The reported value is the *monthly cost* to an entity to support the chosen housing distribution, rent type, and percent of the burdened population.
This is only an estimate, and should not be used for detailed planning or policy making.
""")
if st.checkbox('Do cost to avoid eviction analysis?'):
evictions_cost_df = cost_of_evictions(df, metro_areas, locations)
st.markdown(
utils.get_table_download_link(evictions_cost_df, county + '_cost_data',
'Download cost data'),
unsafe_allow_html=True)
else:
st.error('Enter a valid county and state, separated by a comma')
st.stop()
elif task == 'Multiple Counties':
state = st.selectbox("Select a state", STATES).strip()
county_list = queries.counties_query()
county_list = county_list[county_list['State'] == state]['County Name'].to_list()
counties = st.multiselect('Please specify one or more counties', county_list)
counties = [_.strip().lower() for _ in counties]
if len(counties) > 0:
df = queries.get_county_data(state, counties)
if st.checkbox('Show raw data'):
st.subheader('Raw Data')
st.dataframe(df)
st.markdown(utils.get_table_download_link(df, state + '_custom_data', 'Download raw data'),
unsafe_allow_html=True)
with st.expander('Cost to avoid evictions'):
st.write("""
The cost to avoid evictions is defined as the cost to a municipality or other entity if it was to pay
people's rent directly. In this calculation, we assume a distribution of housing stock (0 bedroom to 4+ bedroom)
based on Census data. You can select which distribution to use that is most similar to the community that you're analyzing.
We default to using Fair Market Rents for this calculation, but you can use the Median value as well.
We also assume that only the burdened population is being considered for support, but not every burdened
person will receive support. You can adjust the percentage of the burdened population to consider.
The reported value is the *monthly cost* to an entity to support the chosen housing distribution, rent type, and percent of the burdened population.
This is only an estimate, and should not be used for detailed planning or policy making.
""")
if st.checkbox('Do cost to avoid eviction analysis?'):
evictions_cost_df = cost_of_evictions(df, metro_areas, locations)
st.markdown(
utils.get_table_download_link(evictions_cost_df, state + '_custom_cost_data',
'Download cost data'),
unsafe_allow_html=True)
ranks = relative_risk_ranking(df, state)
eviction_visualizations(ranks, state)
else:
st.error('Select counties to analyze')
st.stop()
elif task == 'State':
state = st.selectbox("Select a state", STATES).strip()
df = queries.get_county_data(state)
if st.checkbox('Show raw data'):
st.subheader('Raw Data')
st.dataframe(df)
st.markdown(utils.get_table_download_link(df, state + '_data', 'Download raw data'),
unsafe_allow_html=True)
with st.expander('Cost to avoid evictions'):
st.write("""
The cost to avoid evictions is defined as the cost to a municipality or other entity if it was to pay
people's rent directly. In this calculation, we assume a distribution of housing stock (0 bedroom to 4+ bedroom)
based on Census data. You can select which distribution to use that is most similar to the community that you're analyzing.
We default to using Fair Market Rents for this calculation, but you can use the Median value as well.
We also assume that only the burdened population is being considered for support, but not every burdened
person will receive support. You can adjust the percentage of the burdened population to consider.
The reported value is the *monthly cost* to an entity to support the chosen housing distribution, rent type, and percent of the burdened population.
This is only an estimate, and should not be used for detailed planning or policy making.
""")
if st.checkbox('Do cost to avoid eviction analysis?'):
evictions_cost_df = cost_of_evictions(df, metro_areas, locations)
st.markdown(
utils.get_table_download_link(evictions_cost_df, state + '_cost_data', 'Download cost data'),
unsafe_allow_html=True)
ranks = relative_risk_ranking(df, state)
eviction_visualizations(ranks, state)
elif task == 'National':
st.info('Analysis for every county in the US can take a while! Please wait...')
with st.expander("Caveats"):
st.write(
"There are some counties that don't show up in this analysis because of how they are named or because data is missing. We are aware of this issue.")
frames = []
for state in STATES:
df = queries.get_county_data(state)
frames.append(df)
natl_df = pd.concat(frames)
if st.checkbox('Show raw data'):
st.subheader('Raw Data')
st.dataframe(natl_df)
st.markdown(utils.get_table_download_link(natl_df, 'national_data', 'Download raw data'),
unsafe_allow_html=True)
with st.expander('Cost to avoid evictions'):
st.write("""
The cost to avoid evictions is defined as the cost to a municipality or other entity if it was to pay
people's rent directly. In this calculation, we assume a distribution of housing stock (0 bedroom to 4+ bedroom)
based on Census data. You can select which distribution to use that is most similar to the community that you're analyzing.
We default to using Fair Market Rents for this calculation, but you can use the Median value as well.
We also assume that only the burdened population is being considered for support, but not every burdened
person will receive support. You can adjust the percentage of the burdened population to consider.
The reported value is the *monthly cost* to an entity to support the chosen housing distribution, rent type, and percent of the burdened population.
This is only an estimate, and should not be used for detailed planning or policy making.
""")
if st.checkbox('Do cost to avoid eviction analysis?'):
evictions_cost_df = cost_of_evictions(natl_df, metro_areas, locations)
st.markdown(utils.get_table_download_link(evictions_cost_df, 'national_cost', 'Download cost data'),
unsafe_allow_html=True)
ranks = relative_risk_ranking(natl_df, 'National')
eviction_visualizations(ranks, 'National')
def eviction_visualizations(df: pd.DataFrame, state: str = None):
if state:
temp = df.copy()
temp.reset_index(inplace=True)
counties = temp['County Name'].to_list()
if state.lower() != 'national':
geo_df = queries.get_county_geoms(counties, state.lower())
visualization.make_map(geo_df, temp, 'Relative Risk')
else:
frames = []
for s in STATES:
frames.append(queries.get_county_geoms(counties, s.lower()))
geo_df = | pd.concat(frames) | pandas.concat |
# -*- coding: utf-8 -*-
# pylint: disable=E1101
# flake8: noqa
from datetime import datetime
import csv
import os
import sys
import re
import nose
import platform
from multiprocessing.pool import ThreadPool
from numpy import nan
import numpy as np
from pandas.io.common import DtypeWarning
from pandas import DataFrame, Series, Index, MultiIndex, DatetimeIndex
from pandas.compat import(
StringIO, BytesIO, PY3, range, long, lrange, lmap, u
)
from pandas.io.common import URLError
import pandas.io.parsers as parsers
from pandas.io.parsers import (read_csv, read_table, read_fwf,
TextFileReader, TextParser)
import pandas.util.testing as tm
import pandas as pd
from pandas.compat import parse_date
import pandas.lib as lib
from pandas import compat
from pandas.lib import Timestamp
from pandas.tseries.index import date_range
import pandas.tseries.tools as tools
from numpy.testing.decorators import slow
import pandas.parser
class ParserTests(object):
"""
Want to be able to test either C+Cython or Python+Cython parsers
"""
data1 = """index,A,B,C,D
foo,2,3,4,5
bar,7,8,9,10
baz,12,13,14,15
qux,12,13,14,15
foo2,12,13,14,15
bar2,12,13,14,15
"""
def read_csv(self, *args, **kwargs):
raise NotImplementedError
def read_table(self, *args, **kwargs):
raise NotImplementedError
def setUp(self):
import warnings
warnings.filterwarnings(action='ignore', category=FutureWarning)
self.dirpath = tm.get_data_path()
self.csv1 = os.path.join(self.dirpath, 'test1.csv')
self.csv2 = os.path.join(self.dirpath, 'test2.csv')
self.xls1 = os.path.join(self.dirpath, 'test.xls')
def construct_dataframe(self, num_rows):
df = DataFrame(np.random.rand(num_rows, 5), columns=list('abcde'))
df['foo'] = 'foo'
df['bar'] = 'bar'
df['baz'] = 'baz'
df['date'] = pd.date_range('20000101 09:00:00',
periods=num_rows,
freq='s')
df['int'] = np.arange(num_rows, dtype='int64')
return df
def generate_multithread_dataframe(self, path, num_rows, num_tasks):
def reader(arg):
start, nrows = arg
if not start:
return pd.read_csv(path, index_col=0, header=0, nrows=nrows,
parse_dates=['date'])
return pd.read_csv(path,
index_col=0,
header=None,
skiprows=int(start) + 1,
nrows=nrows,
parse_dates=[9])
tasks = [
(num_rows * i / num_tasks,
num_rows / num_tasks) for i in range(num_tasks)
]
pool = ThreadPool(processes=num_tasks)
results = pool.map(reader, tasks)
header = results[0].columns
for r in results[1:]:
r.columns = header
final_dataframe = pd.concat(results)
return final_dataframe
def test_converters_type_must_be_dict(self):
with tm.assertRaisesRegexp(TypeError, 'Type converters.+'):
self.read_csv(StringIO(self.data1), converters=0)
def test_empty_decimal_marker(self):
data = """A|B|C
1|2,334|5
10|13|10.
"""
self.assertRaises(ValueError, read_csv, StringIO(data), decimal='')
def test_empty_thousands_marker(self):
data = """A|B|C
1|2,334|5
10|13|10.
"""
self.assertRaises(ValueError, read_csv, StringIO(data), thousands='')
def test_multi_character_decimal_marker(self):
data = """A|B|C
1|2,334|5
10|13|10.
"""
self.assertRaises(ValueError, read_csv, StringIO(data), thousands=',,')
def test_empty_string(self):
data = """\
One,Two,Three
a,1,one
b,2,two
,3,three
d,4,nan
e,5,five
nan,6,
g,7,seven
"""
df = self.read_csv(StringIO(data))
xp = DataFrame({'One': ['a', 'b', np.nan, 'd', 'e', np.nan, 'g'],
'Two': [1, 2, 3, 4, 5, 6, 7],
'Three': ['one', 'two', 'three', np.nan, 'five',
np.nan, 'seven']})
tm.assert_frame_equal(xp.reindex(columns=df.columns), df)
df = self.read_csv(StringIO(data), na_values={'One': [], 'Three': []},
keep_default_na=False)
xp = DataFrame({'One': ['a', 'b', '', 'd', 'e', 'nan', 'g'],
'Two': [1, 2, 3, 4, 5, 6, 7],
'Three': ['one', 'two', 'three', 'nan', 'five',
'', 'seven']})
tm.assert_frame_equal(xp.reindex(columns=df.columns), df)
df = self.read_csv(
StringIO(data), na_values=['a'], keep_default_na=False)
xp = DataFrame({'One': [np.nan, 'b', '', 'd', 'e', 'nan', 'g'],
'Two': [1, 2, 3, 4, 5, 6, 7],
'Three': ['one', 'two', 'three', 'nan', 'five', '',
'seven']})
tm.assert_frame_equal(xp.reindex(columns=df.columns), df)
df = self.read_csv(StringIO(data), na_values={'One': [], 'Three': []})
xp = DataFrame({'One': ['a', 'b', np.nan, 'd', 'e', np.nan, 'g'],
'Two': [1, 2, 3, 4, 5, 6, 7],
'Three': ['one', 'two', 'three', np.nan, 'five',
np.nan, 'seven']})
tm.assert_frame_equal(xp.reindex(columns=df.columns), df)
# GH4318, passing na_values=None and keep_default_na=False yields
# 'None' as a na_value
data = """\
One,Two,Three
a,1,None
b,2,two
,3,None
d,4,nan
e,5,five
nan,6,
g,7,seven
"""
df = self.read_csv(
StringIO(data), keep_default_na=False)
xp = DataFrame({'One': ['a', 'b', '', 'd', 'e', 'nan', 'g'],
'Two': [1, 2, 3, 4, 5, 6, 7],
'Three': ['None', 'two', 'None', 'nan', 'five', '',
'seven']})
tm.assert_frame_equal(xp.reindex(columns=df.columns), df)
def test_read_csv(self):
if not compat.PY3:
if compat.is_platform_windows():
prefix = u("file:///")
else:
prefix = u("file://")
fname = prefix + compat.text_type(self.csv1)
# it works!
read_csv(fname, index_col=0, parse_dates=True)
def test_dialect(self):
data = """\
label1,label2,label3
index1,"a,c,e
index2,b,d,f
"""
dia = csv.excel()
dia.quoting = csv.QUOTE_NONE
df = self.read_csv(StringIO(data), dialect=dia)
data = '''\
label1,label2,label3
index1,a,c,e
index2,b,d,f
'''
exp = self.read_csv(StringIO(data))
exp.replace('a', '"a', inplace=True)
tm.assert_frame_equal(df, exp)
def test_dialect_str(self):
data = """\
fruit:vegetable
apple:brocolli
pear:tomato
"""
exp = DataFrame({
'fruit': ['apple', 'pear'],
'vegetable': ['brocolli', 'tomato']
})
dia = csv.register_dialect('mydialect', delimiter=':') # noqa
df = self.read_csv(StringIO(data), dialect='mydialect')
tm.assert_frame_equal(df, exp)
csv.unregister_dialect('mydialect')
def test_1000_sep(self):
data = """A|B|C
1|2,334|5
10|13|10.
"""
expected = DataFrame({
'A': [1, 10],
'B': [2334, 13],
'C': [5, 10.]
})
df = self.read_csv(StringIO(data), sep='|', thousands=',')
tm.assert_frame_equal(df, expected)
df = self.read_table(StringIO(data), sep='|', thousands=',')
tm.assert_frame_equal(df, expected)
def test_1000_sep_with_decimal(self):
data = """A|B|C
1|2,334.01|5
10|13|10.
"""
expected = DataFrame({
'A': [1, 10],
'B': [2334.01, 13],
'C': [5, 10.]
})
tm.assert_equal(expected.A.dtype, 'int64')
tm.assert_equal(expected.B.dtype, 'float')
tm.assert_equal(expected.C.dtype, 'float')
df = self.read_csv(StringIO(data), sep='|', thousands=',', decimal='.')
tm.assert_frame_equal(df, expected)
df = self.read_table(StringIO(data), sep='|',
thousands=',', decimal='.')
tm.assert_frame_equal(df, expected)
data_with_odd_sep = """A|B|C
1|2.334,01|5
10|13|10,
"""
df = self.read_csv(StringIO(data_with_odd_sep),
sep='|', thousands='.', decimal=',')
tm.assert_frame_equal(df, expected)
df = self.read_table(StringIO(data_with_odd_sep),
sep='|', thousands='.', decimal=',')
tm.assert_frame_equal(df, expected)
def test_separator_date_conflict(self):
# Regression test for issue #4678: make sure thousands separator and
# date parsing do not conflict.
data = '06-02-2013;13:00;1-000.215'
expected = DataFrame(
[[datetime(2013, 6, 2, 13, 0, 0), 1000.215]],
columns=['Date', 2]
)
df = self.read_csv(StringIO(data), sep=';', thousands='-',
parse_dates={'Date': [0, 1]}, header=None)
tm.assert_frame_equal(df, expected)
def test_squeeze(self):
data = """\
a,1
b,2
c,3
"""
idx = Index(['a', 'b', 'c'], name=0)
expected = Series([1, 2, 3], name=1, index=idx)
result = self.read_table(StringIO(data), sep=',', index_col=0,
header=None, squeeze=True)
tm.assertIsInstance(result, Series)
tm.assert_series_equal(result, expected)
def test_squeeze_no_view(self):
# GH 8217
# series should not be a view
data = """time,data\n0,10\n1,11\n2,12\n4,14\n5,15\n3,13"""
result = self.read_csv(StringIO(data), index_col='time', squeeze=True)
self.assertFalse(result._is_view)
def test_inf_parsing(self):
data = """\
,A
a,inf
b,-inf
c,Inf
d,-Inf
e,INF
f,-INF
g,INf
h,-INf
i,inF
j,-inF"""
inf = float('inf')
expected = Series([inf, -inf] * 5)
df = read_csv(StringIO(data), index_col=0)
tm.assert_almost_equal(df['A'].values, expected.values)
df = read_csv(StringIO(data), index_col=0, na_filter=False)
tm.assert_almost_equal(df['A'].values, expected.values)
def test_multiple_date_col(self):
# Can use multiple date parsers
data = """\
KORD,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000
KORD,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000
KORD,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000
KORD,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000
KORD,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000
KORD,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000
"""
def func(*date_cols):
return lib.try_parse_dates(parsers._concat_date_cols(date_cols))
df = self.read_csv(StringIO(data), header=None,
date_parser=func,
prefix='X',
parse_dates={'nominal': [1, 2],
'actual': [1, 3]})
self.assertIn('nominal', df)
self.assertIn('actual', df)
self.assertNotIn('X1', df)
self.assertNotIn('X2', df)
self.assertNotIn('X3', df)
d = datetime(1999, 1, 27, 19, 0)
self.assertEqual(df.ix[0, 'nominal'], d)
df = self.read_csv(StringIO(data), header=None,
date_parser=func,
parse_dates={'nominal': [1, 2],
'actual': [1, 3]},
keep_date_col=True)
self.assertIn('nominal', df)
self.assertIn('actual', df)
self.assertIn(1, df)
self.assertIn(2, df)
self.assertIn(3, df)
data = """\
KORD,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000
KORD,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000
KORD,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000
KORD,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000
KORD,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000
KORD,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000
"""
df = read_csv(StringIO(data), header=None,
prefix='X',
parse_dates=[[1, 2], [1, 3]])
self.assertIn('X1_X2', df)
self.assertIn('X1_X3', df)
self.assertNotIn('X1', df)
self.assertNotIn('X2', df)
self.assertNotIn('X3', df)
d = datetime(1999, 1, 27, 19, 0)
self.assertEqual(df.ix[0, 'X1_X2'], d)
df = read_csv(StringIO(data), header=None,
parse_dates=[[1, 2], [1, 3]], keep_date_col=True)
self.assertIn('1_2', df)
self.assertIn('1_3', df)
self.assertIn(1, df)
self.assertIn(2, df)
self.assertIn(3, df)
data = '''\
KORD,19990127 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000
KORD,19990127 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000
KORD,19990127 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000
KORD,19990127 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000
KORD,19990127 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000
'''
df = self.read_csv(StringIO(data), sep=',', header=None,
parse_dates=[1], index_col=1)
d = datetime(1999, 1, 27, 19, 0)
self.assertEqual(df.index[0], d)
def test_multiple_date_cols_int_cast(self):
data = ("KORD,19990127, 19:00:00, 18:56:00, 0.8100\n"
"KORD,19990127, 20:00:00, 19:56:00, 0.0100\n"
"KORD,19990127, 21:00:00, 20:56:00, -0.5900\n"
"KORD,19990127, 21:00:00, 21:18:00, -0.9900\n"
"KORD,19990127, 22:00:00, 21:56:00, -0.5900\n"
"KORD,19990127, 23:00:00, 22:56:00, -0.5900")
date_spec = {'nominal': [1, 2], 'actual': [1, 3]}
import pandas.io.date_converters as conv
# it works!
df = self.read_csv(StringIO(data), header=None, parse_dates=date_spec,
date_parser=conv.parse_date_time)
self.assertIn('nominal', df)
def test_multiple_date_col_timestamp_parse(self):
data = """05/31/2012,15:30:00.029,1306.25,1,E,0,,1306.25
05/31/2012,15:30:00.029,1306.25,8,E,0,,1306.25"""
result = self.read_csv(StringIO(data), sep=',', header=None,
parse_dates=[[0, 1]], date_parser=Timestamp)
ex_val = Timestamp('05/31/2012 15:30:00.029')
self.assertEqual(result['0_1'][0], ex_val)
def test_single_line(self):
# GH 6607
# Test currently only valid with python engine because sep=None and
# delim_whitespace=False. Temporarily copied to TestPythonParser.
# Test for ValueError with other engines:
with tm.assertRaisesRegexp(ValueError,
'sep=None with delim_whitespace=False'):
# sniff separator
buf = StringIO()
sys.stdout = buf
# printing warning message when engine == 'c' for now
try:
# it works!
df = self.read_csv(StringIO('1,2'), names=['a', 'b'],
header=None, sep=None)
tm.assert_frame_equal(DataFrame({'a': [1], 'b': [2]}), df)
finally:
sys.stdout = sys.__stdout__
def test_multiple_date_cols_with_header(self):
data = """\
ID,date,NominalTime,ActualTime,TDew,TAir,Windspeed,Precip,WindDir
KORD,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000
KORD,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000
KORD,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000
KORD,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000
KORD,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000
KORD,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000"""
df = self.read_csv(StringIO(data), parse_dates={'nominal': [1, 2]})
self.assertNotIsInstance(df.nominal[0], compat.string_types)
ts_data = """\
ID,date,nominalTime,actualTime,A,B,C,D,E
KORD,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000
KORD,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000
KORD,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000
KORD,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000
KORD,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000
KORD,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000
"""
def test_multiple_date_col_name_collision(self):
self.assertRaises(ValueError, self.read_csv, StringIO(self.ts_data),
parse_dates={'ID': [1, 2]})
data = """\
date_NominalTime,date,NominalTime,ActualTime,TDew,TAir,Windspeed,Precip,WindDir
KORD1,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000
KORD2,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000
KORD3,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000
KORD4,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000
KORD5,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000
KORD6,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000""" # noqa
self.assertRaises(ValueError, self.read_csv, StringIO(data),
parse_dates=[[1, 2]])
def test_index_col_named(self):
no_header = """\
KORD1,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000
KORD2,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000
KORD3,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000
KORD4,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000
KORD5,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000
KORD6,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000"""
h = "ID,date,NominalTime,ActualTime,TDew,TAir,Windspeed,Precip,WindDir\n"
data = h + no_header
rs = self.read_csv(StringIO(data), index_col='ID')
xp = self.read_csv(StringIO(data), header=0).set_index('ID')
tm.assert_frame_equal(rs, xp)
self.assertRaises(ValueError, self.read_csv, StringIO(no_header),
index_col='ID')
data = """\
1,2,3,4,hello
5,6,7,8,world
9,10,11,12,foo
"""
names = ['a', 'b', 'c', 'd', 'message']
xp = DataFrame({'a': [1, 5, 9], 'b': [2, 6, 10], 'c': [3, 7, 11],
'd': [4, 8, 12]},
index=Index(['hello', 'world', 'foo'], name='message'))
rs = self.read_csv(StringIO(data), names=names, index_col=['message'])
tm.assert_frame_equal(xp, rs)
self.assertEqual(xp.index.name, rs.index.name)
rs = self.read_csv(StringIO(data), names=names, index_col='message')
tm.assert_frame_equal(xp, rs)
self.assertEqual(xp.index.name, rs.index.name)
def test_usecols_index_col_False(self):
# Issue 9082
s = "a,b,c,d\n1,2,3,4\n5,6,7,8"
s_malformed = "a,b,c,d\n1,2,3,4,\n5,6,7,8,"
cols = ['a', 'c', 'd']
expected = DataFrame({'a': [1, 5], 'c': [3, 7], 'd': [4, 8]})
df = self.read_csv(StringIO(s), usecols=cols, index_col=False)
tm.assert_frame_equal(expected, df)
df = self.read_csv(StringIO(s_malformed),
usecols=cols, index_col=False)
tm.assert_frame_equal(expected, df)
def test_index_col_is_True(self):
# Issue 9798
self.assertRaises(ValueError, self.read_csv, StringIO(self.ts_data),
index_col=True)
def test_converter_index_col_bug(self):
# 1835
data = "A;B\n1;2\n3;4"
rs = self.read_csv(StringIO(data), sep=';', index_col='A',
converters={'A': lambda x: x})
xp = DataFrame({'B': [2, 4]}, index=Index([1, 3], name='A'))
tm.assert_frame_equal(rs, xp)
self.assertEqual(rs.index.name, xp.index.name)
def test_date_parser_int_bug(self):
# #3071
log_file = StringIO(
'posix_timestamp,elapsed,sys,user,queries,query_time,rows,'
'accountid,userid,contactid,level,silo,method\n'
'1343103150,0.062353,0,4,6,0.01690,3,'
'12345,1,-1,3,invoice_InvoiceResource,search\n'
)
def f(posix_string):
return datetime.utcfromtimestamp(int(posix_string))
# it works!
read_csv(log_file, index_col=0, parse_dates=0, date_parser=f)
def test_multiple_skts_example(self):
data = "year, month, a, b\n 2001, 01, 0.0, 10.\n 2001, 02, 1.1, 11."
pass
def test_malformed(self):
# all
data = """ignore
A,B,C
1,2,3 # comment
1,2,3,4,5
2,3,4
"""
try:
df = self.read_table(
StringIO(data), sep=',', header=1, comment='#')
self.assertTrue(False)
except Exception as inst:
self.assertIn('Expected 3 fields in line 4, saw 5', str(inst))
# skip_footer
data = """ignore
A,B,C
1,2,3 # comment
1,2,3,4,5
2,3,4
footer
"""
# GH 6607
# Test currently only valid with python engine because
# skip_footer != 0. Temporarily copied to TestPythonParser.
# Test for ValueError with other engines:
try:
with tm.assertRaisesRegexp(ValueError, 'skip_footer'): # XXX
df = self.read_table(
StringIO(data), sep=',', header=1, comment='#',
skip_footer=1)
self.assertTrue(False)
except Exception as inst:
self.assertIn('Expected 3 fields in line 4, saw 5', str(inst))
# first chunk
data = """ignore
A,B,C
skip
1,2,3
3,5,10 # comment
1,2,3,4,5
2,3,4
"""
try:
it = self.read_table(StringIO(data), sep=',',
header=1, comment='#',
iterator=True, chunksize=1,
skiprows=[2])
df = it.read(5)
self.assertTrue(False)
except Exception as inst:
self.assertIn('Expected 3 fields in line 6, saw 5', str(inst))
# middle chunk
data = """ignore
A,B,C
skip
1,2,3
3,5,10 # comment
1,2,3,4,5
2,3,4
"""
try:
it = self.read_table(StringIO(data), sep=',', header=1,
comment='#', iterator=True, chunksize=1,
skiprows=[2])
df = it.read(1)
it.read(2)
self.assertTrue(False)
except Exception as inst:
self.assertIn('Expected 3 fields in line 6, saw 5', str(inst))
# last chunk
data = """ignore
A,B,C
skip
1,2,3
3,5,10 # comment
1,2,3,4,5
2,3,4
"""
try:
it = self.read_table(StringIO(data), sep=',',
header=1, comment='#',
iterator=True, chunksize=1, skiprows=[2])
df = it.read(1)
it.read()
self.assertTrue(False)
except Exception as inst:
self.assertIn('Expected 3 fields in line 6, saw 5', str(inst))
def test_passing_dtype(self):
# GH 6607
# Passing dtype is currently only supported by the C engine.
# Temporarily copied to TestCParser*.
# Test for ValueError with other engines:
with tm.assertRaisesRegexp(ValueError,
"The 'dtype' option is not supported"):
df = DataFrame(np.random.rand(5, 2), columns=list(
'AB'), index=['1A', '1B', '1C', '1D', '1E'])
with tm.ensure_clean('__passing_str_as_dtype__.csv') as path:
df.to_csv(path)
# GH 3795
# passing 'str' as the dtype
result = self.read_csv(path, dtype=str, index_col=0)
tm.assert_series_equal(result.dtypes, Series(
{'A': 'object', 'B': 'object'}))
# we expect all object columns, so need to convert to test for
# equivalence
result = result.astype(float)
tm.assert_frame_equal(result, df)
# invalid dtype
self.assertRaises(TypeError, self.read_csv, path,
dtype={'A': 'foo', 'B': 'float64'},
index_col=0)
# valid but we don't support it (date)
self.assertRaises(TypeError, self.read_csv, path,
dtype={'A': 'datetime64', 'B': 'float64'},
index_col=0)
self.assertRaises(TypeError, self.read_csv, path,
dtype={'A': 'datetime64', 'B': 'float64'},
index_col=0, parse_dates=['B'])
# valid but we don't support it
self.assertRaises(TypeError, self.read_csv, path,
dtype={'A': 'timedelta64', 'B': 'float64'},
index_col=0)
with tm.assertRaisesRegexp(ValueError,
"The 'dtype' option is not supported"):
# empty frame
# GH12048
self.read_csv(StringIO('A,B'), dtype=str)
def test_quoting(self):
bad_line_small = """printer\tresult\tvariant_name
Klosterdruckerei\tKlosterdruckerei <Salem> (1611-1804)\tMuller, Jacob
Klosterdruckerei\tKlosterdruckerei <Salem> (1611-1804)\tMuller, Jakob
Klosterdruckerei\tKlosterdruckerei <Kempten> (1609-1805)\t"Furststiftische Hofdruckerei, <Kempten""
Klosterdruckerei\tKlosterdruckerei <Kempten> (1609-1805)\tGaller, Alois
Klosterdruckerei\tKlosterdruckerei <Kempten> (1609-1805)\tHochfurstliche Buchhandlung <Kempten>"""
self.assertRaises(Exception, self.read_table, StringIO(bad_line_small),
sep='\t')
good_line_small = bad_line_small + '"'
df = self.read_table(StringIO(good_line_small), sep='\t')
self.assertEqual(len(df), 3)
def test_non_string_na_values(self):
# GH3611, na_values that are not a string are an issue
with tm.ensure_clean('__non_string_na_values__.csv') as path:
df = DataFrame({'A': [-999, 2, 3], 'B': [1.2, -999, 4.5]})
df.to_csv(path, sep=' ', index=False)
result1 = read_csv(path, sep=' ', header=0,
na_values=['-999.0', '-999'])
result2 = read_csv(path, sep=' ', header=0,
na_values=[-999, -999.0])
result3 = read_csv(path, sep=' ', header=0,
na_values=[-999.0, -999])
tm.assert_frame_equal(result1, result2)
tm.assert_frame_equal(result2, result3)
result4 = read_csv(path, sep=' ', header=0, na_values=['-999.0'])
result5 = read_csv(path, sep=' ', header=0, na_values=['-999'])
result6 = read_csv(path, sep=' ', header=0, na_values=[-999.0])
result7 = read_csv(path, sep=' ', header=0, na_values=[-999])
tm.assert_frame_equal(result4, result3)
tm.assert_frame_equal(result5, result3)
tm.assert_frame_equal(result6, result3)
tm.assert_frame_equal(result7, result3)
good_compare = result3
# with an odd float format, so we can't match the string 999.0
# exactly, but need float matching
df.to_csv(path, sep=' ', index=False, float_format='%.3f')
result1 = read_csv(path, sep=' ', header=0,
na_values=['-999.0', '-999'])
result2 = read_csv(path, sep=' ', header=0,
na_values=[-999, -999.0])
result3 = read_csv(path, sep=' ', header=0,
na_values=[-999.0, -999])
tm.assert_frame_equal(result1, good_compare)
tm.assert_frame_equal(result2, good_compare)
tm.assert_frame_equal(result3, good_compare)
result4 = read_csv(path, sep=' ', header=0, na_values=['-999.0'])
result5 = read_csv(path, sep=' ', header=0, na_values=['-999'])
result6 = read_csv(path, sep=' ', header=0, na_values=[-999.0])
result7 = read_csv(path, sep=' ', header=0, na_values=[-999])
tm.assert_frame_equal(result4, good_compare)
tm.assert_frame_equal(result5, good_compare)
tm.assert_frame_equal(result6, good_compare)
tm.assert_frame_equal(result7, good_compare)
def test_default_na_values(self):
_NA_VALUES = set(['-1.#IND', '1.#QNAN', '1.#IND', '-1.#QNAN',
'#N/A', 'N/A', 'NA', '#NA', 'NULL', 'NaN',
'nan', '-NaN', '-nan', '#N/A N/A', ''])
self.assertEqual(_NA_VALUES, parsers._NA_VALUES)
nv = len(_NA_VALUES)
def f(i, v):
if i == 0:
buf = ''
elif i > 0:
buf = ''.join([','] * i)
buf = "{0}{1}".format(buf, v)
if i < nv - 1:
buf = "{0}{1}".format(buf, ''.join([','] * (nv - i - 1)))
return buf
data = StringIO('\n'.join([f(i, v) for i, v in enumerate(_NA_VALUES)]))
expected = DataFrame(np.nan, columns=range(nv), index=range(nv))
df = self.read_csv(data, header=None)
tm.assert_frame_equal(df, expected)
def test_custom_na_values(self):
data = """A,B,C
ignore,this,row
1,NA,3
-1.#IND,5,baz
7,8,NaN
"""
expected = [[1., nan, 3],
[nan, 5, nan],
[7, 8, nan]]
df = self.read_csv(StringIO(data), na_values=['baz'], skiprows=[1])
tm.assert_almost_equal(df.values, expected)
df2 = self.read_table(StringIO(data), sep=',', na_values=['baz'],
skiprows=[1])
tm.assert_almost_equal(df2.values, expected)
df3 = self.read_table(StringIO(data), sep=',', na_values='baz',
skiprows=[1])
tm.assert_almost_equal(df3.values, expected)
def test_nat_parse(self):
# GH 3062
df = DataFrame(dict({
'A': np.asarray(lrange(10), dtype='float64'),
'B': pd.Timestamp('20010101')}))
df.iloc[3:6, :] = np.nan
with tm.ensure_clean('__nat_parse_.csv') as path:
df.to_csv(path)
result = read_csv(path, index_col=0, parse_dates=['B'])
tm.assert_frame_equal(result, df)
expected = Series(dict(A='float64', B='datetime64[ns]'))
tm.assert_series_equal(expected, result.dtypes)
# test with NaT for the nan_rep
# we don't have a method to specif the Datetime na_rep (it defaults
# to '')
df.to_csv(path)
result = read_csv(path, index_col=0, parse_dates=['B'])
tm.assert_frame_equal(result, df)
def test_skiprows_bug(self):
# GH #505
text = """#foo,a,b,c
#foo,a,b,c
#foo,a,b,c
#foo,a,b,c
#foo,a,b,c
#foo,a,b,c
1/1/2000,1.,2.,3.
1/2/2000,4,5,6
1/3/2000,7,8,9
"""
data = self.read_csv(StringIO(text), skiprows=lrange(6), header=None,
index_col=0, parse_dates=True)
data2 = self.read_csv(StringIO(text), skiprows=6, header=None,
index_col=0, parse_dates=True)
expected = DataFrame(np.arange(1., 10.).reshape((3, 3)),
columns=[1, 2, 3],
index=[datetime(2000, 1, 1), datetime(2000, 1, 2),
datetime(2000, 1, 3)])
expected.index.name = 0
tm.assert_frame_equal(data, expected)
tm.assert_frame_equal(data, data2)
def test_deep_skiprows(self):
# GH #4382
text = "a,b,c\n" + \
"\n".join([",".join([str(i), str(i + 1), str(i + 2)])
for i in range(10)])
condensed_text = "a,b,c\n" + \
"\n".join([",".join([str(i), str(i + 1), str(i + 2)])
for i in [0, 1, 2, 3, 4, 6, 8, 9]])
data = self.read_csv(StringIO(text), skiprows=[6, 8])
condensed_data = self.read_csv(StringIO(condensed_text))
tm.assert_frame_equal(data, condensed_data)
def test_skiprows_blank(self):
# GH 9832
text = """#foo,a,b,c
#foo,a,b,c
#foo,a,b,c
#foo,a,b,c
1/1/2000,1.,2.,3.
1/2/2000,4,5,6
1/3/2000,7,8,9
"""
data = self.read_csv(StringIO(text), skiprows=6, header=None,
index_col=0, parse_dates=True)
expected = DataFrame(np.arange(1., 10.).reshape((3, 3)),
columns=[1, 2, 3],
index=[datetime(2000, 1, 1), datetime(2000, 1, 2),
datetime(2000, 1, 3)])
expected.index.name = 0
tm.assert_frame_equal(data, expected)
def test_detect_string_na(self):
data = """A,B
foo,bar
NA,baz
NaN,nan
"""
expected = [['foo', 'bar'],
[nan, 'baz'],
[nan, nan]]
df = self.read_csv(StringIO(data))
tm.assert_almost_equal(df.values, expected)
def test_unnamed_columns(self):
data = """A,B,C,,
1,2,3,4,5
6,7,8,9,10
11,12,13,14,15
"""
expected = [[1, 2, 3, 4, 5.],
[6, 7, 8, 9, 10],
[11, 12, 13, 14, 15]]
df = self.read_table(StringIO(data), sep=',')
tm.assert_almost_equal(df.values, expected)
self.assert_numpy_array_equal(df.columns,
['A', 'B', 'C', 'Unnamed: 3',
'Unnamed: 4'])
def test_string_nas(self):
data = """A,B,C
a,b,c
d,,f
,g,h
"""
result = self.read_csv(StringIO(data))
expected = DataFrame([['a', 'b', 'c'],
['d', np.nan, 'f'],
[np.nan, 'g', 'h']],
columns=['A', 'B', 'C'])
tm.assert_frame_equal(result, expected)
def test_duplicate_columns(self):
for engine in ['python', 'c']:
data = """A,A,B,B,B
1,2,3,4,5
6,7,8,9,10
11,12,13,14,15
"""
# check default beahviour
df = self.read_table(StringIO(data), sep=',', engine=engine)
self.assertEqual(list(df.columns), ['A', 'A.1', 'B', 'B.1', 'B.2'])
df = self.read_table(StringIO(data), sep=',',
engine=engine, mangle_dupe_cols=False)
self.assertEqual(list(df.columns), ['A', 'A', 'B', 'B', 'B'])
df = self.read_table(StringIO(data), sep=',',
engine=engine, mangle_dupe_cols=True)
self.assertEqual(list(df.columns), ['A', 'A.1', 'B', 'B.1', 'B.2'])
def test_csv_mixed_type(self):
data = """A,B,C
a,1,2
b,3,4
c,4,5
"""
df = self.read_csv(StringIO(data))
# TODO
def test_csv_custom_parser(self):
data = """A,B,C
20090101,a,1,2
20090102,b,3,4
20090103,c,4,5
"""
f = lambda x: datetime.strptime(x, '%Y%m%d')
df = self.read_csv(StringIO(data), date_parser=f)
expected = self.read_csv(StringIO(data), parse_dates=True)
tm.assert_frame_equal(df, expected)
def test_parse_dates_implicit_first_col(self):
data = """A,B,C
20090101,a,1,2
20090102,b,3,4
20090103,c,4,5
"""
df = self.read_csv(StringIO(data), parse_dates=True)
expected = self.read_csv(StringIO(data), index_col=0, parse_dates=True)
self.assertIsInstance(
df.index[0], (datetime, np.datetime64, Timestamp))
tm.assert_frame_equal(df, expected)
def test_parse_dates_string(self):
data = """date,A,B,C
20090101,a,1,2
20090102,b,3,4
20090103,c,4,5
"""
rs = self.read_csv(
StringIO(data), index_col='date', parse_dates='date')
idx = date_range('1/1/2009', periods=3)
idx.name = 'date'
xp = DataFrame({'A': ['a', 'b', 'c'],
'B': [1, 3, 4],
'C': [2, 4, 5]}, idx)
tm.assert_frame_equal(rs, xp)
def test_yy_format(self):
data = """date,time,B,C
090131,0010,1,2
090228,1020,3,4
090331,0830,5,6
"""
rs = self.read_csv(StringIO(data), index_col=0,
parse_dates=[['date', 'time']])
idx = DatetimeIndex([datetime(2009, 1, 31, 0, 10, 0),
datetime(2009, 2, 28, 10, 20, 0),
datetime(2009, 3, 31, 8, 30, 0)],
dtype=object, name='date_time')
xp = DataFrame({'B': [1, 3, 5], 'C': [2, 4, 6]}, idx)
tm.assert_frame_equal(rs, xp)
rs = self.read_csv(StringIO(data), index_col=0,
parse_dates=[[0, 1]])
idx = DatetimeIndex([datetime(2009, 1, 31, 0, 10, 0),
datetime(2009, 2, 28, 10, 20, 0),
datetime(2009, 3, 31, 8, 30, 0)],
dtype=object, name='date_time')
xp = DataFrame({'B': [1, 3, 5], 'C': [2, 4, 6]}, idx)
tm.assert_frame_equal(rs, xp)
def test_parse_dates_column_list(self):
from pandas.core.datetools import to_datetime
data = '''date;destination;ventilationcode;unitcode;units;aux_date
01/01/2010;P;P;50;1;12/1/2011
01/01/2010;P;R;50;1;13/1/2011
15/01/2010;P;P;50;1;14/1/2011
01/05/2010;P;P;50;1;15/1/2011'''
expected = self.read_csv(StringIO(data), sep=";", index_col=lrange(4))
lev = expected.index.levels[0]
levels = list(expected.index.levels)
levels[0] = lev.to_datetime(dayfirst=True)
# hack to get this to work - remove for final test
levels[0].name = lev.name
expected.index.set_levels(levels, inplace=True)
expected['aux_date'] = to_datetime(expected['aux_date'],
dayfirst=True)
expected['aux_date'] = lmap(Timestamp, expected['aux_date'])
tm.assertIsInstance(expected['aux_date'][0], datetime)
df = self.read_csv(StringIO(data), sep=";", index_col=lrange(4),
parse_dates=[0, 5], dayfirst=True)
tm.assert_frame_equal(df, expected)
df = self.read_csv(StringIO(data), sep=";", index_col=lrange(4),
parse_dates=['date', 'aux_date'], dayfirst=True)
tm.assert_frame_equal(df, expected)
def test_no_header(self):
data = """1,2,3,4,5
6,7,8,9,10
11,12,13,14,15
"""
df = self.read_table(StringIO(data), sep=',', header=None)
df_pref = self.read_table(StringIO(data), sep=',', prefix='X',
header=None)
names = ['foo', 'bar', 'baz', 'quux', 'panda']
df2 = self.read_table(StringIO(data), sep=',', names=names)
expected = [[1, 2, 3, 4, 5.],
[6, 7, 8, 9, 10],
[11, 12, 13, 14, 15]]
tm.assert_almost_equal(df.values, expected)
tm.assert_almost_equal(df.values, df2.values)
self.assert_numpy_array_equal(df_pref.columns,
['X0', 'X1', 'X2', 'X3', 'X4'])
self.assert_numpy_array_equal(df.columns, lrange(5))
self.assert_numpy_array_equal(df2.columns, names)
def test_no_header_prefix(self):
data = """1,2,3,4,5
6,7,8,9,10
11,12,13,14,15
"""
df_pref = self.read_table(StringIO(data), sep=',', prefix='Field',
header=None)
expected = [[1, 2, 3, 4, 5.],
[6, 7, 8, 9, 10],
[11, 12, 13, 14, 15]]
tm.assert_almost_equal(df_pref.values, expected)
self.assert_numpy_array_equal(df_pref.columns,
['Field0', 'Field1', 'Field2', 'Field3', 'Field4'])
def test_header_with_index_col(self):
data = """foo,1,2,3
bar,4,5,6
baz,7,8,9
"""
names = ['A', 'B', 'C']
df = self.read_csv(StringIO(data), names=names)
self.assertEqual(names, ['A', 'B', 'C'])
values = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
expected = DataFrame(values, index=['foo', 'bar', 'baz'],
columns=['A', 'B', 'C'])
tm.assert_frame_equal(df, expected)
def test_read_csv_dataframe(self):
df = self.read_csv(self.csv1, index_col=0, parse_dates=True)
df2 = self.read_table(self.csv1, sep=',', index_col=0,
parse_dates=True)
self.assert_numpy_array_equal(df.columns, ['A', 'B', 'C', 'D'])
self.assertEqual(df.index.name, 'index')
self.assertIsInstance(
df.index[0], (datetime, np.datetime64, Timestamp))
self.assertEqual(df.values.dtype, np.float64)
tm.assert_frame_equal(df, df2)
def test_read_csv_no_index_name(self):
df = self.read_csv(self.csv2, index_col=0, parse_dates=True)
df2 = self.read_table(self.csv2, sep=',', index_col=0,
parse_dates=True)
self.assert_numpy_array_equal(df.columns, ['A', 'B', 'C', 'D', 'E'])
self.assertIsInstance(
df.index[0], (datetime, np.datetime64, Timestamp))
self.assertEqual(df.ix[:, ['A', 'B', 'C', 'D']
].values.dtype, np.float64)
tm.assert_frame_equal(df, df2)
def test_read_csv_infer_compression(self):
# GH 9770
expected = self.read_csv(self.csv1, index_col=0, parse_dates=True)
inputs = [self.csv1, self.csv1 + '.gz',
self.csv1 + '.bz2', open(self.csv1)]
for f in inputs:
df = self.read_csv(f, index_col=0, parse_dates=True,
compression='infer')
tm.assert_frame_equal(expected, df)
inputs[3].close()
def test_read_table_unicode(self):
fin = BytesIO(u('\u0141aski, Jan;1').encode('utf-8'))
df1 = read_table(fin, sep=";", encoding="utf-8", header=None)
tm.assertIsInstance(df1[0].values[0], compat.text_type)
def test_read_table_wrong_num_columns(self):
# too few!
data = """A,B,C,D,E,F
1,2,3,4,5,6
6,7,8,9,10,11,12
11,12,13,14,15,16
"""
self.assertRaises(Exception, self.read_csv, StringIO(data))
def test_read_table_duplicate_index(self):
data = """index,A,B,C,D
foo,2,3,4,5
bar,7,8,9,10
baz,12,13,14,15
qux,12,13,14,15
foo,12,13,14,15
bar,12,13,14,15
"""
result = self.read_csv(StringIO(data), index_col=0)
expected = self.read_csv(StringIO(data)).set_index('index',
verify_integrity=False)
tm.assert_frame_equal(result, expected)
def test_read_table_duplicate_index_implicit(self):
data = """A,B,C,D
foo,2,3,4,5
bar,7,8,9,10
baz,12,13,14,15
qux,12,13,14,15
foo,12,13,14,15
bar,12,13,14,15
"""
# it works!
result = self.read_csv(StringIO(data))
def test_parse_bools(self):
data = """A,B
True,1
False,2
True,3
"""
data = self.read_csv(StringIO(data))
self.assertEqual(data['A'].dtype, np.bool_)
data = """A,B
YES,1
no,2
yes,3
No,3
Yes,3
"""
data = self.read_csv(StringIO(data),
true_values=['yes', 'Yes', 'YES'],
false_values=['no', 'NO', 'No'])
self.assertEqual(data['A'].dtype, np.bool_)
data = """A,B
TRUE,1
FALSE,2
TRUE,3
"""
data = self.read_csv(StringIO(data))
self.assertEqual(data['A'].dtype, np.bool_)
data = """A,B
foo,bar
bar,foo"""
result = self.read_csv(StringIO(data), true_values=['foo'],
false_values=['bar'])
expected = DataFrame({'A': [True, False], 'B': [False, True]})
tm.assert_frame_equal(result, expected)
def test_int_conversion(self):
data = """A,B
1.0,1
2.0,2
3.0,3
"""
data = self.read_csv(StringIO(data))
self.assertEqual(data['A'].dtype, np.float64)
self.assertEqual(data['B'].dtype, np.int64)
def test_infer_index_col(self):
data = """A,B,C
foo,1,2,3
bar,4,5,6
baz,7,8,9
"""
data = self.read_csv(StringIO(data))
self.assertTrue(data.index.equals(Index(['foo', 'bar', 'baz'])))
def test_read_nrows(self):
df = self.read_csv(StringIO(self.data1), nrows=3)
expected = self.read_csv(StringIO(self.data1))[:3]
tm.assert_frame_equal(df, expected)
def test_read_chunksize(self):
reader = self.read_csv(StringIO(self.data1), index_col=0, chunksize=2)
df = self.read_csv(StringIO(self.data1), index_col=0)
chunks = list(reader)
tm.assert_frame_equal(chunks[0], df[:2])
tm.assert_frame_equal(chunks[1], df[2:4])
tm.assert_frame_equal(chunks[2], df[4:])
def test_read_chunksize_named(self):
reader = self.read_csv(
StringIO(self.data1), index_col='index', chunksize=2)
df = self.read_csv(StringIO(self.data1), index_col='index')
chunks = list(reader)
tm.assert_frame_equal(chunks[0], df[:2])
tm.assert_frame_equal(chunks[1], df[2:4])
tm.assert_frame_equal(chunks[2], df[4:])
def test_get_chunk_passed_chunksize(self):
data = """A,B,C
1,2,3
4,5,6
7,8,9
1,2,3"""
result = self.read_csv(StringIO(data), chunksize=2)
piece = result.get_chunk()
self.assertEqual(len(piece), 2)
def test_read_text_list(self):
data = """A,B,C\nfoo,1,2,3\nbar,4,5,6"""
as_list = [['A', 'B', 'C'], ['foo', '1', '2', '3'], ['bar',
'4', '5', '6']]
df = self.read_csv(StringIO(data), index_col=0)
parser = TextParser(as_list, index_col=0, chunksize=2)
chunk = parser.read(None)
tm.assert_frame_equal(chunk, df)
def test_iterator(self):
# GH 6607
# Test currently only valid with python engine because
# skip_footer != 0. Temporarily copied to TestPythonParser.
# Test for ValueError with other engines:
with tm.assertRaisesRegexp(ValueError, 'skip_footer'):
reader = self.read_csv(StringIO(self.data1), index_col=0,
iterator=True)
df = self.read_csv(StringIO(self.data1), index_col=0)
chunk = reader.read(3)
tm.assert_frame_equal(chunk, df[:3])
last_chunk = reader.read(5)
tm.assert_frame_equal(last_chunk, df[3:])
# pass list
lines = list(csv.reader(StringIO(self.data1)))
parser = TextParser(lines, index_col=0, chunksize=2)
df = self.read_csv(StringIO(self.data1), index_col=0)
chunks = list(parser)
tm.assert_frame_equal(chunks[0], df[:2])
tm.assert_frame_equal(chunks[1], df[2:4])
tm.assert_frame_equal(chunks[2], df[4:])
# pass skiprows
parser = TextParser(lines, index_col=0, chunksize=2, skiprows=[1])
chunks = list(parser)
tm.assert_frame_equal(chunks[0], df[1:3])
# test bad parameter (skip_footer)
reader = self.read_csv(StringIO(self.data1), index_col=0,
iterator=True, skip_footer=True)
self.assertRaises(ValueError, reader.read, 3)
treader = self.read_table(StringIO(self.data1), sep=',', index_col=0,
iterator=True)
tm.assertIsInstance(treader, TextFileReader)
# stopping iteration when on chunksize is specified, GH 3967
data = """A,B,C
foo,1,2,3
bar,4,5,6
baz,7,8,9
"""
reader = self.read_csv(StringIO(data), iterator=True)
result = list(reader)
expected = DataFrame(dict(A=[1, 4, 7], B=[2, 5, 8], C=[
3, 6, 9]), index=['foo', 'bar', 'baz'])
tm.assert_frame_equal(result[0], expected)
# chunksize = 1
reader = self.read_csv(StringIO(data), chunksize=1)
result = list(reader)
expected = DataFrame(dict(A=[1, 4, 7], B=[2, 5, 8], C=[
3, 6, 9]), index=['foo', 'bar', 'baz'])
self.assertEqual(len(result), 3)
tm.assert_frame_equal(pd.concat(result), expected)
def test_header_not_first_line(self):
data = """got,to,ignore,this,line
got,to,ignore,this,line
index,A,B,C,D
foo,2,3,4,5
bar,7,8,9,10
baz,12,13,14,15
"""
data2 = """index,A,B,C,D
foo,2,3,4,5
bar,7,8,9,10
baz,12,13,14,15
"""
df = self.read_csv(StringIO(data), header=2, index_col=0)
expected = self.read_csv(StringIO(data2), header=0, index_col=0)
tm.assert_frame_equal(df, expected)
def test_header_multi_index(self):
expected = tm.makeCustomDataframe(
5, 3, r_idx_nlevels=2, c_idx_nlevels=4)
data = """\
C0,,C_l0_g0,C_l0_g1,C_l0_g2
C1,,C_l1_g0,C_l1_g1,C_l1_g2
C2,,C_l2_g0,C_l2_g1,C_l2_g2
C3,,C_l3_g0,C_l3_g1,C_l3_g2
R0,R1,,,
R_l0_g0,R_l1_g0,R0C0,R0C1,R0C2
R_l0_g1,R_l1_g1,R1C0,R1C1,R1C2
R_l0_g2,R_l1_g2,R2C0,R2C1,R2C2
R_l0_g3,R_l1_g3,R3C0,R3C1,R3C2
R_l0_g4,R_l1_g4,R4C0,R4C1,R4C2
"""
df = self.read_csv(StringIO(data), header=[0, 1, 2, 3], index_col=[
0, 1], tupleize_cols=False)
tm.assert_frame_equal(df, expected)
# skipping lines in the header
df = self.read_csv(StringIO(data), header=[0, 1, 2, 3], index_col=[
0, 1], tupleize_cols=False)
tm.assert_frame_equal(df, expected)
#### invalid options ####
# no as_recarray
self.assertRaises(ValueError, self.read_csv, StringIO(data), header=[0, 1, 2, 3],
index_col=[0, 1], as_recarray=True, tupleize_cols=False)
# names
self.assertRaises(ValueError, self.read_csv, StringIO(data), header=[0, 1, 2, 3],
index_col=[0, 1], names=['foo', 'bar'], tupleize_cols=False)
# usecols
self.assertRaises(ValueError, self.read_csv, StringIO(data), header=[0, 1, 2, 3],
index_col=[0, 1], usecols=['foo', 'bar'], tupleize_cols=False)
# non-numeric index_col
self.assertRaises(ValueError, self.read_csv, StringIO(data), header=[0, 1, 2, 3],
index_col=['foo', 'bar'], tupleize_cols=False)
def test_header_multiindex_common_format(self):
df = DataFrame([[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]],
index=['one', 'two'],
columns=MultiIndex.from_tuples([('a', 'q'), ('a', 'r'), ('a', 's'),
('b', 't'), ('c', 'u'), ('c', 'v')]))
# to_csv
data = """,a,a,a,b,c,c
,q,r,s,t,u,v
,,,,,,
one,1,2,3,4,5,6
two,7,8,9,10,11,12"""
result = self.read_csv(StringIO(data), header=[0, 1], index_col=0)
tm.assert_frame_equal(df, result)
# common
data = """,a,a,a,b,c,c
,q,r,s,t,u,v
one,1,2,3,4,5,6
two,7,8,9,10,11,12"""
result = self.read_csv(StringIO(data), header=[0, 1], index_col=0)
tm.assert_frame_equal(df, result)
# common, no index_col
data = """a,a,a,b,c,c
q,r,s,t,u,v
1,2,3,4,5,6
7,8,9,10,11,12"""
result = self.read_csv(StringIO(data), header=[0, 1], index_col=None)
tm.assert_frame_equal(df.reset_index(drop=True), result)
# malformed case 1
expected = DataFrame(np.array([[2, 3, 4, 5, 6],
[8, 9, 10, 11, 12]], dtype='int64'),
index=Index([1, 7]),
columns=MultiIndex(levels=[[u('a'), u('b'), u('c')], [u('r'), u('s'), u('t'), u('u'), u('v')]],
labels=[[0, 0, 1, 2, 2], [
0, 1, 2, 3, 4]],
names=[u('a'), u('q')]))
data = """a,a,a,b,c,c
q,r,s,t,u,v
1,2,3,4,5,6
7,8,9,10,11,12"""
result = self.read_csv(StringIO(data), header=[0, 1], index_col=0)
tm.assert_frame_equal(expected, result)
# malformed case 2
expected = DataFrame(np.array([[2, 3, 4, 5, 6],
[8, 9, 10, 11, 12]], dtype='int64'),
index=Index([1, 7]),
columns=MultiIndex(levels=[[u('a'), u('b'), u('c')], [u('r'), u('s'), u('t'), u('u'), u('v')]],
labels=[[0, 0, 1, 2, 2], [
0, 1, 2, 3, 4]],
names=[None, u('q')]))
data = """,a,a,b,c,c
q,r,s,t,u,v
1,2,3,4,5,6
7,8,9,10,11,12"""
result = self.read_csv(StringIO(data), header=[0, 1], index_col=0)
tm.assert_frame_equal(expected, result)
# mi on columns and index (malformed)
expected = DataFrame(np.array([[3, 4, 5, 6],
[9, 10, 11, 12]], dtype='int64'),
index=MultiIndex(levels=[[1, 7], [2, 8]],
labels=[[0, 1], [0, 1]]),
columns=MultiIndex(levels=[[u('a'), u('b'), u('c')], [u('s'), u('t'), u('u'), u('v')]],
labels=[[0, 1, 2, 2],
[0, 1, 2, 3]],
names=[None, u('q')]))
data = """,a,a,b,c,c
q,r,s,t,u,v
1,2,3,4,5,6
7,8,9,10,11,12"""
result = self.read_csv(StringIO(data), header=[0, 1], index_col=[0, 1])
tm.assert_frame_equal(expected, result)
def test_pass_names_with_index(self):
lines = self.data1.split('\n')
no_header = '\n'.join(lines[1:])
# regular index
names = ['index', 'A', 'B', 'C', 'D']
df = self.read_csv(StringIO(no_header), index_col=0, names=names)
expected = self.read_csv(StringIO(self.data1), index_col=0)
tm.assert_frame_equal(df, expected)
# multi index
data = """index1,index2,A,B,C,D
foo,one,2,3,4,5
foo,two,7,8,9,10
foo,three,12,13,14,15
bar,one,12,13,14,15
bar,two,12,13,14,15
"""
lines = data.split('\n')
no_header = '\n'.join(lines[1:])
names = ['index1', 'index2', 'A', 'B', 'C', 'D']
df = self.read_csv(StringIO(no_header), index_col=[0, 1],
names=names)
expected = self.read_csv(StringIO(data), index_col=[0, 1])
tm.assert_frame_equal(df, expected)
df = self.read_csv(StringIO(data), index_col=['index1', 'index2'])
tm.assert_frame_equal(df, expected)
def test_multi_index_no_level_names(self):
data = """index1,index2,A,B,C,D
foo,one,2,3,4,5
foo,two,7,8,9,10
foo,three,12,13,14,15
bar,one,12,13,14,15
bar,two,12,13,14,15
"""
data2 = """A,B,C,D
foo,one,2,3,4,5
foo,two,7,8,9,10
foo,three,12,13,14,15
bar,one,12,13,14,15
bar,two,12,13,14,15
"""
lines = data.split('\n')
no_header = '\n'.join(lines[1:])
names = ['A', 'B', 'C', 'D']
df = self.read_csv(StringIO(no_header), index_col=[0, 1],
header=None, names=names)
expected = self.read_csv(StringIO(data), index_col=[0, 1])
tm.assert_frame_equal(df, expected, check_names=False)
# 2 implicit first cols
df2 = self.read_csv(StringIO(data2))
tm.assert_frame_equal(df2, df)
# reverse order of index
df = self.read_csv(StringIO(no_header), index_col=[1, 0], names=names,
header=None)
expected = self.read_csv(StringIO(data), index_col=[1, 0])
tm.assert_frame_equal(df, expected, check_names=False)
def test_multi_index_parse_dates(self):
data = """index1,index2,A,B,C
20090101,one,a,1,2
20090101,two,b,3,4
20090101,three,c,4,5
20090102,one,a,1,2
20090102,two,b,3,4
20090102,three,c,4,5
20090103,one,a,1,2
20090103,two,b,3,4
20090103,three,c,4,5
"""
df = self.read_csv(StringIO(data), index_col=[0, 1], parse_dates=True)
self.assertIsInstance(df.index.levels[0][0],
(datetime, np.datetime64, Timestamp))
# specify columns out of order!
df2 = self.read_csv(StringIO(data), index_col=[1, 0], parse_dates=True)
self.assertIsInstance(df2.index.levels[1][0],
(datetime, np.datetime64, Timestamp))
def test_skip_footer(self):
# GH 6607
# Test currently only valid with python engine because
# skip_footer != 0. Temporarily copied to TestPythonParser.
# Test for ValueError with other engines:
with tm.assertRaisesRegexp(ValueError, 'skip_footer'):
data = """A,B,C
1,2,3
4,5,6
7,8,9
want to skip this
also also skip this
"""
result = self.read_csv(StringIO(data), skip_footer=2)
no_footer = '\n'.join(data.split('\n')[:-3])
expected = self.read_csv(StringIO(no_footer))
tm.assert_frame_equal(result, expected)
result = self.read_csv(StringIO(data), nrows=3)
tm.assert_frame_equal(result, expected)
# skipfooter alias
result = read_csv(StringIO(data), skipfooter=2)
no_footer = '\n'.join(data.split('\n')[:-3])
expected = read_csv(StringIO(no_footer))
tm.assert_frame_equal(result, expected)
def test_no_unnamed_index(self):
data = """ id c0 c1 c2
0 1 0 a b
1 2 0 c d
2 2 2 e f
"""
df = self.read_table(StringIO(data), sep=' ')
self.assertIsNone(df.index.name)
def test_converters(self):
data = """A,B,C,D
a,1,2,01/01/2009
b,3,4,01/02/2009
c,4,5,01/03/2009
"""
from pandas.compat import parse_date
result = self.read_csv(StringIO(data), converters={'D': parse_date})
result2 = self.read_csv(StringIO(data), converters={3: parse_date})
expected = self.read_csv(StringIO(data))
expected['D'] = expected['D'].map(parse_date)
tm.assertIsInstance(result['D'][0], (datetime, Timestamp))
tm.assert_frame_equal(result, expected)
tm.assert_frame_equal(result2, expected)
# produce integer
converter = lambda x: int(x.split('/')[2])
result = self.read_csv(StringIO(data), converters={'D': converter})
expected = self.read_csv(StringIO(data))
expected['D'] = expected['D'].map(converter)
tm.assert_frame_equal(result, expected)
def test_converters_no_implicit_conv(self):
# GH2184
data = """000102,1.2,A\n001245,2,B"""
f = lambda x: x.strip()
converter = {0: f}
df = self.read_csv(StringIO(data), header=None, converters=converter)
self.assertEqual(df[0].dtype, object)
def test_converters_euro_decimal_format(self):
data = """Id;Number1;Number2;Text1;Text2;Number3
1;1521,1541;187101,9543;ABC;poi;4,738797819
2;121,12;14897,76;DEF;uyt;0,377320872
3;878,158;108013,434;GHI;rez;2,735694704"""
f = lambda x: float(x.replace(",", "."))
converter = {'Number1': f, 'Number2': f, 'Number3': f}
df2 = self.read_csv(StringIO(data), sep=';', converters=converter)
self.assertEqual(df2['Number1'].dtype, float)
self.assertEqual(df2['Number2'].dtype, float)
self.assertEqual(df2['Number3'].dtype, float)
def test_converter_return_string_bug(self):
# GH #583
data = """Id;Number1;Number2;Text1;Text2;Number3
1;1521,1541;187101,9543;ABC;poi;4,738797819
2;121,12;14897,76;DEF;uyt;0,377320872
3;878,158;108013,434;GHI;rez;2,735694704"""
f = lambda x: float(x.replace(",", "."))
converter = {'Number1': f, 'Number2': f, 'Number3': f}
df2 = self.read_csv(StringIO(data), sep=';', converters=converter)
self.assertEqual(df2['Number1'].dtype, float)
def test_read_table_buglet_4x_multiindex(self):
# GH 6607
# Parsing multi-level index currently causes an error in the C parser.
# Temporarily copied to TestPythonParser.
# Here test that CParserError is raised:
with tm.assertRaises(pandas.parser.CParserError):
text = """ A B C D E
one two three four
a b 10.0032 5 -0.5109 -2.3358 -0.4645 0.05076 0.3640
a q 20 4 0.4473 1.4152 0.2834 1.00661 0.1744
x q 30 3 -0.6662 -0.5243 -0.3580 0.89145 2.5838"""
# it works!
df = self.read_table(StringIO(text), sep='\s+')
self.assertEqual(df.index.names, ('one', 'two', 'three', 'four'))
def test_line_comment(self):
data = """# empty
A,B,C
1,2.,4.#hello world
#ignore this line
5.,NaN,10.0
"""
expected = [[1., 2., 4.],
[5., np.nan, 10.]]
df = self.read_csv(StringIO(data), comment='#')
tm.assert_almost_equal(df.values, expected)
def test_comment_skiprows(self):
data = """# empty
random line
# second empty line
1,2,3
A,B,C
1,2.,4.
5.,NaN,10.0
"""
expected = [[1., 2., 4.],
[5., np.nan, 10.]]
# this should ignore the first four lines (including comments)
df = self.read_csv(StringIO(data), comment='#', skiprows=4)
tm.assert_almost_equal(df.values, expected)
def test_comment_header(self):
data = """# empty
# second empty line
1,2,3
A,B,C
1,2.,4.
5.,NaN,10.0
"""
expected = [[1., 2., 4.],
[5., np.nan, 10.]]
# header should begin at the second non-comment line
df = self.read_csv(StringIO(data), comment='#', header=1)
tm.assert_almost_equal(df.values, expected)
def test_comment_skiprows_header(self):
data = """# empty
# second empty line
# third empty line
X,Y,Z
1,2,3
A,B,C
1,2.,4.
5.,NaN,10.0
"""
expected = [[1., 2., 4.],
[5., np.nan, 10.]]
# skiprows should skip the first 4 lines (including comments), while
# header should start from the second non-commented line starting
# with line 5
df = self.read_csv(StringIO(data), comment='#', skiprows=4, header=1)
tm.assert_almost_equal(df.values, expected)
def test_read_csv_parse_simple_list(self):
text = """foo
bar baz
qux foo
foo
bar"""
df = read_csv(StringIO(text), header=None)
expected = DataFrame({0: ['foo', 'bar baz', 'qux foo',
'foo', 'bar']})
tm.assert_frame_equal(df, expected)
def test_parse_dates_custom_euroformat(self):
text = """foo,bar,baz
31/01/2010,1,2
01/02/2010,1,NA
02/02/2010,1,2
"""
parser = lambda d: parse_date(d, dayfirst=True)
df = self.read_csv(StringIO(text),
names=['time', 'Q', 'NTU'], header=0,
index_col=0, parse_dates=True,
date_parser=parser, na_values=['NA'])
exp_index = Index([datetime(2010, 1, 31), datetime(2010, 2, 1),
datetime(2010, 2, 2)], name='time')
expected = DataFrame({'Q': [1, 1, 1], 'NTU': [2, np.nan, 2]},
index=exp_index, columns=['Q', 'NTU'])
tm.assert_frame_equal(df, expected)
parser = lambda d: parse_date(d, day_first=True)
self.assertRaises(Exception, self.read_csv,
StringIO(text), skiprows=[0],
names=['time', 'Q', 'NTU'], index_col=0,
parse_dates=True, date_parser=parser,
na_values=['NA'])
def test_na_value_dict(self):
data = """A,B,C
foo,bar,NA
bar,foo,foo
foo,bar,NA
bar,foo,foo"""
df = self.read_csv(StringIO(data),
na_values={'A': ['foo'], 'B': ['bar']})
expected = DataFrame({'A': [np.nan, 'bar', np.nan, 'bar'],
'B': [np.nan, 'foo', np.nan, 'foo'],
'C': [np.nan, 'foo', np.nan, 'foo']})
tm.assert_frame_equal(df, expected)
data = """\
a,b,c,d
0,NA,1,5
"""
xp = DataFrame({'b': [np.nan], 'c': [1], 'd': [5]}, index=[0])
xp.index.name = 'a'
df = self.read_csv(StringIO(data), na_values={}, index_col=0)
tm.assert_frame_equal(df, xp)
xp = DataFrame({'b': [np.nan], 'd': [5]},
MultiIndex.from_tuples([(0, 1)]))
xp.index.names = ['a', 'c']
df = self.read_csv(StringIO(data), na_values={}, index_col=[0, 2])
tm.assert_frame_equal(df, xp)
xp = DataFrame({'b': [np.nan], 'd': [5]},
MultiIndex.from_tuples([(0, 1)]))
xp.index.names = ['a', 'c']
df = self.read_csv(StringIO(data), na_values={}, index_col=['a', 'c'])
tm.assert_frame_equal(df, xp)
@tm.network
def test_url(self):
# HTTP(S)
url = ('https://raw.github.com/pydata/pandas/master/'
'pandas/io/tests/data/salary.table')
url_table = self.read_table(url)
dirpath = tm.get_data_path()
localtable = os.path.join(dirpath, 'salary.table')
local_table = self.read_table(localtable)
tm.assert_frame_equal(url_table, local_table)
# TODO: ftp testing
@slow
def test_file(self):
# FILE
if sys.version_info[:2] < (2, 6):
raise nose.SkipTest("file:// not supported with Python < 2.6")
dirpath = tm.get_data_path()
localtable = os.path.join(dirpath, 'salary.table')
local_table = self.read_table(localtable)
try:
url_table = self.read_table('file://localhost/' + localtable)
except URLError:
# fails on some systems
raise nose.SkipTest("failing on %s" %
' '.join(platform.uname()).strip())
tm.assert_frame_equal(url_table, local_table)
def test_parse_tz_aware(self):
import pytz
# #1693
data = StringIO("Date,x\n2012-06-13T01:39:00Z,0.5")
# it works
result = read_csv(data, index_col=0, parse_dates=True)
stamp = result.index[0]
self.assertEqual(stamp.minute, 39)
try:
self.assertIs(result.index.tz, pytz.utc)
except AssertionError: # hello Yaroslav
arr = result.index.to_pydatetime()
result = tools.to_datetime(arr, utc=True)[0]
self.assertEqual(stamp.minute, result.minute)
self.assertEqual(stamp.hour, result.hour)
self.assertEqual(stamp.day, result.day)
def test_multiple_date_cols_index(self):
data = """\
ID,date,NominalTime,ActualTime,TDew,TAir,Windspeed,Precip,WindDir
KORD1,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000
KORD2,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000
KORD3,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000
KORD4,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000
KORD5,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000
KORD6,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000"""
xp = self.read_csv(StringIO(data), parse_dates={'nominal': [1, 2]})
df = self.read_csv(StringIO(data), parse_dates={'nominal': [1, 2]},
index_col='nominal')
tm.assert_frame_equal(xp.set_index('nominal'), df)
df2 = self.read_csv(StringIO(data), parse_dates={'nominal': [1, 2]},
index_col=0)
tm.assert_frame_equal(df2, df)
df3 = self.read_csv(StringIO(data), parse_dates=[[1, 2]], index_col=0)
tm.assert_frame_equal(df3, df, check_names=False)
def test_multiple_date_cols_chunked(self):
df = self.read_csv(StringIO(self.ts_data), parse_dates={
'nominal': [1, 2]}, index_col='nominal')
reader = self.read_csv(StringIO(self.ts_data), parse_dates={'nominal':
[1, 2]}, index_col='nominal', chunksize=2)
chunks = list(reader)
self.assertNotIn('nominalTime', df)
tm.assert_frame_equal(chunks[0], df[:2])
tm.assert_frame_equal(chunks[1], df[2:4])
tm.assert_frame_equal(chunks[2], df[4:])
def test_multiple_date_col_named_components(self):
xp = self.read_csv(StringIO(self.ts_data),
parse_dates={'nominal': [1, 2]},
index_col='nominal')
colspec = {'nominal': ['date', 'nominalTime']}
df = self.read_csv(StringIO(self.ts_data), parse_dates=colspec,
index_col='nominal')
tm.assert_frame_equal(df, xp)
def test_multiple_date_col_multiple_index(self):
df = self.read_csv(StringIO(self.ts_data),
parse_dates={'nominal': [1, 2]},
index_col=['nominal', 'ID'])
xp = self.read_csv(StringIO(self.ts_data),
parse_dates={'nominal': [1, 2]})
tm.assert_frame_equal(xp.set_index(['nominal', 'ID']), df)
def test_comment(self):
data = """A,B,C
1,2.,4.#hello world
5.,NaN,10.0
"""
expected = [[1., 2., 4.],
[5., np.nan, 10.]]
df = self.read_csv(StringIO(data), comment='#')
tm.assert_almost_equal(df.values, expected)
df = self.read_table(StringIO(data), sep=',', comment='#',
na_values=['NaN'])
tm.assert_almost_equal(df.values, expected)
def test_bool_na_values(self):
data = """A,B,C
True,False,True
NA,True,False
False,NA,True"""
result = self.read_csv(StringIO(data))
expected = DataFrame({'A': np.array([True, nan, False], dtype=object),
'B': np.array([False, True, nan], dtype=object),
'C': [True, False, True]})
tm.assert_frame_equal(result, expected)
def test_nonexistent_path(self):
# don't segfault pls #2428
path = '%s.csv' % tm.rands(10)
self.assertRaises(Exception, self.read_csv, path)
def test_missing_trailing_delimiters(self):
data = """A,B,C,D
1,2,3,4
1,3,3,
1,4,5"""
result = self.read_csv(StringIO(data))
self.assertTrue(result['D'].isnull()[1:].all())
def test_skipinitialspace(self):
s = ('"09-Apr-2012", "01:10:18.300", 2456026.548822908, 12849, '
'1.00361, 1.12551, 330.65659, 0355626618.16711, 73.48821, '
'314.11625, 1917.09447, 179.71425, 80.000, 240.000, -350, '
'70.06056, 344.98370, 1, 1, -0.689265, -0.692787, '
'0.212036, 14.7674, 41.605, -9999.0, -9999.0, '
'-9999.0, -9999.0, -9999.0, -9999.0, 000, 012, 128')
sfile = StringIO(s)
# it's 33 columns
result = self.read_csv(sfile, names=lrange(33), na_values=['-9999.0'],
header=None, skipinitialspace=True)
self.assertTrue(pd.isnull(result.ix[0, 29]))
def test_utf16_bom_skiprows(self):
# #2298
data = u("""skip this
skip this too
A\tB\tC
1\t2\t3
4\t5\t6""")
data2 = u("""skip this
skip this too
A,B,C
1,2,3
4,5,6""")
path = '__%s__.csv' % tm.rands(10)
with tm.ensure_clean(path) as path:
for sep, dat in [('\t', data), (',', data2)]:
for enc in ['utf-16', 'utf-16le', 'utf-16be']:
bytes = dat.encode(enc)
with open(path, 'wb') as f:
f.write(bytes)
s = BytesIO(dat.encode('utf-8'))
if compat.PY3:
# somewhat False since the code never sees bytes
from io import TextIOWrapper
s = TextIOWrapper(s, encoding='utf-8')
result = self.read_csv(path, encoding=enc, skiprows=2,
sep=sep)
expected = self.read_csv(s, encoding='utf-8', skiprows=2,
sep=sep)
tm.assert_frame_equal(result, expected)
def test_utf16_example(self):
path = tm.get_data_path('utf16_ex.txt')
# it works! and is the right length
result = self.read_table(path, encoding='utf-16')
self.assertEqual(len(result), 50)
if not compat.PY3:
buf = BytesIO(open(path, 'rb').read())
result = self.read_table(buf, encoding='utf-16')
self.assertEqual(len(result), 50)
def test_converters_corner_with_nas(self):
# skip aberration observed on Win64 Python 3.2.2
if hash(np.int64(-1)) != -2:
raise nose.SkipTest("skipping because of windows hash on Python"
" 3.2.2")
csv = """id,score,days
1,2,12
2,2-5,
3,,14+
4,6-12,2"""
def convert_days(x):
x = x.strip()
if not x:
return np.nan
is_plus = x.endswith('+')
if is_plus:
x = int(x[:-1]) + 1
else:
x = int(x)
return x
def convert_days_sentinel(x):
x = x.strip()
if not x:
return np.nan
is_plus = x.endswith('+')
if is_plus:
x = int(x[:-1]) + 1
else:
x = int(x)
return x
def convert_score(x):
x = x.strip()
if not x:
return np.nan
if x.find('-') > 0:
valmin, valmax = lmap(int, x.split('-'))
val = 0.5 * (valmin + valmax)
else:
val = float(x)
return val
fh = StringIO(csv)
result = self.read_csv(fh, converters={'score': convert_score,
'days': convert_days},
na_values=['', None])
self.assertTrue(pd.isnull(result['days'][1]))
fh = StringIO(csv)
result2 = self.read_csv(fh, converters={'score': convert_score,
'days': convert_days_sentinel},
na_values=['', None])
tm.assert_frame_equal(result, result2)
def test_unicode_encoding(self):
pth = tm.get_data_path('unicode_series.csv')
result = self.read_csv(pth, header=None, encoding='latin-1')
result = result.set_index(0)
got = result[1][1632]
expected = u('\xc1 k\xf6ldum klaka (Cold Fever) (1994)')
self.assertEqual(got, expected)
def test_trailing_delimiters(self):
# #2442. grumble grumble
data = """A,B,C
1,2,3,
4,5,6,
7,8,9,"""
result = self.read_csv(StringIO(data), index_col=False)
expected = DataFrame({'A': [1, 4, 7], 'B': [2, 5, 8],
'C': [3, 6, 9]})
tm.assert_frame_equal(result, expected)
def test_escapechar(self):
# http://stackoverflow.com/questions/13824840/feature-request-for-
# pandas-read-csv
data = '''SEARCH_TERM,ACTUAL_URL
"bra tv bord","http://www.ikea.com/se/sv/catalog/categories/departments/living_room/10475/?se%7cps%7cnonbranded%7cvardagsrum%7cgoogle%7ctv_bord"
"tv p\xc3\xa5 hjul","http://www.ikea.com/se/sv/catalog/categories/departments/living_room/10475/?se%7cps%7cnonbranded%7cvardagsrum%7cgoogle%7ctv_bord"
"SLAGBORD, \\"Bergslagen\\", IKEA:s 1700-tals serie","http://www.ikea.com/se/sv/catalog/categories/departments/living_room/10475/?se%7cps%7cnonbranded%7cvardagsrum%7cgoogle%7ctv_bord"'''
result = self.read_csv(StringIO(data), escapechar='\\',
quotechar='"', encoding='utf-8')
self.assertEqual(result['SEARCH_TERM'][2],
'SLAGBORD, "Bergslagen", IKEA:s 1700-tals serie')
self.assertTrue(np.array_equal(result.columns,
['SEARCH_TERM', 'ACTUAL_URL']))
def test_header_names_backward_compat(self):
# #2539
data = '1,2,3\n4,5,6'
result = self.read_csv(StringIO(data), names=['a', 'b', 'c'])
expected = self.read_csv(StringIO(data), names=['a', 'b', 'c'],
header=None)
tm.assert_frame_equal(result, expected)
data2 = 'foo,bar,baz\n' + data
result = self.read_csv(StringIO(data2), names=['a', 'b', 'c'],
header=0)
tm.assert_frame_equal(result, expected)
def test_int64_min_issues(self):
# #2599
data = 'A,B\n0,0\n0,'
result = self.read_csv(StringIO(data))
expected = DataFrame({'A': [0, 0], 'B': [0, np.nan]})
tm.assert_frame_equal(result, expected)
def test_parse_integers_above_fp_precision(self):
data = """Numbers
17007000002000191
17007000002000191
17007000002000191
17007000002000191
17007000002000192
17007000002000192
17007000002000192
17007000002000192
17007000002000192
17007000002000194"""
result = self.read_csv(StringIO(data))
expected = DataFrame({'Numbers': [17007000002000191,
17007000002000191,
17007000002000191,
17007000002000191,
17007000002000192,
17007000002000192,
17007000002000192,
17007000002000192,
17007000002000192,
17007000002000194]})
self.assertTrue(np.array_equal(result['Numbers'], expected['Numbers']))
def test_usecols_index_col_conflict(self):
# Issue 4201 Test that index_col as integer reflects usecols
data = """SecId,Time,Price,P2,P3
10000,2013-5-11,100,10,1
500,2013-5-12,101,11,1
"""
expected = DataFrame({'Price': [100, 101]}, index=[
datetime(2013, 5, 11), datetime(2013, 5, 12)])
expected.index.name = 'Time'
df = self.read_csv(StringIO(data), usecols=[
'Time', 'Price'], parse_dates=True, index_col=0)
tm.assert_frame_equal(expected, df)
df = self.read_csv(StringIO(data), usecols=[
'Time', 'Price'], parse_dates=True, index_col='Time')
tm.assert_frame_equal(expected, df)
df = self.read_csv(StringIO(data), usecols=[
1, 2], parse_dates=True, index_col='Time')
tm.assert_frame_equal(expected, df)
df = self.read_csv(StringIO(data), usecols=[
1, 2], parse_dates=True, index_col=0)
tm.assert_frame_equal(expected, df)
expected = DataFrame(
{'P3': [1, 1], 'Price': (100, 101), 'P2': (10, 11)})
expected = expected.set_index(['Price', 'P2'])
df = self.read_csv(StringIO(data), usecols=[
'Price', 'P2', 'P3'], parse_dates=True, index_col=['Price', 'P2'])
tm.assert_frame_equal(expected, df)
def test_chunks_have_consistent_numerical_type(self):
integers = [str(i) for i in range(499999)]
data = "a\n" + "\n".join(integers + ["1.0", "2.0"] + integers)
with tm.assert_produces_warning(False):
df = self.read_csv(StringIO(data))
# Assert that types were coerced.
self.assertTrue(type(df.a[0]) is np.float64)
self.assertEqual(df.a.dtype, np.float)
def test_warn_if_chunks_have_mismatched_type(self):
# See test in TestCParserLowMemory.
integers = [str(i) for i in range(499999)]
data = "a\n" + "\n".join(integers + ['a', 'b'] + integers)
with tm.assert_produces_warning(False):
df = self.read_csv(StringIO(data))
self.assertEqual(df.a.dtype, np.object)
def test_usecols(self):
data = """\
a,b,c
1,2,3
4,5,6
7,8,9
10,11,12"""
result = self.read_csv(StringIO(data), usecols=(1, 2))
result2 = self.read_csv(StringIO(data), usecols=('b', 'c'))
exp = self.read_csv(StringIO(data))
self.assertEqual(len(result.columns), 2)
self.assertTrue((result['b'] == exp['b']).all())
self.assertTrue((result['c'] == exp['c']).all())
tm.assert_frame_equal(result, result2)
result = self.read_csv(StringIO(data), usecols=[1, 2], header=0,
names=['foo', 'bar'])
expected = self.read_csv(StringIO(data), usecols=[1, 2])
expected.columns = ['foo', 'bar']
tm.assert_frame_equal(result, expected)
data = """\
1,2,3
4,5,6
7,8,9
10,11,12"""
result = self.read_csv(StringIO(data), names=['b', 'c'],
header=None, usecols=[1, 2])
expected = self.read_csv(StringIO(data), names=['a', 'b', 'c'],
header=None)
expected = expected[['b', 'c']]
tm.assert_frame_equal(result, expected)
result2 = self.read_csv(StringIO(data), names=['a', 'b', 'c'],
header=None, usecols=['b', 'c'])
tm.assert_frame_equal(result2, result)
# 5766
result = self.read_csv(StringIO(data), names=['a', 'b'],
header=None, usecols=[0, 1])
expected = self.read_csv(StringIO(data), names=['a', 'b', 'c'],
header=None)
expected = expected[['a', 'b']]
tm.assert_frame_equal(result, expected)
# length conflict, passed names and usecols disagree
self.assertRaises(ValueError, self.read_csv, StringIO(data),
names=['a', 'b'], usecols=[1], header=None)
def test_integer_overflow_bug(self):
# #2601
data = "65248E10 11\n55555E55 22\n"
result = self.read_csv(StringIO(data), header=None, sep=' ')
self.assertTrue(result[0].dtype == np.float64)
result = self.read_csv(StringIO(data), header=None, sep='\s+')
self.assertTrue(result[0].dtype == np.float64)
def test_catch_too_many_names(self):
# Issue 5156
data = """\
1,2,3
4,,6
7,8,9
10,11,12\n"""
tm.assertRaises(Exception, read_csv, StringIO(data),
header=0, names=['a', 'b', 'c', 'd'])
def test_ignore_leading_whitespace(self):
# GH 6607, GH 3374
data = ' a b c\n 1 2 3\n 4 5 6\n 7 8 9'
result = self.read_table(StringIO(data), sep='\s+')
expected = DataFrame({'a': [1, 4, 7], 'b': [2, 5, 8], 'c': [3, 6, 9]})
tm.assert_frame_equal(result, expected)
def test_nrows_and_chunksize_raises_notimplemented(self):
data = 'a b c'
self.assertRaises(NotImplementedError, self.read_csv, StringIO(data),
nrows=10, chunksize=5)
def test_single_char_leading_whitespace(self):
# GH 9710
data = """\
MyColumn
a
b
a
b\n"""
expected = DataFrame({'MyColumn': list('abab')})
result = self.read_csv(StringIO(data), skipinitialspace=True)
tm.assert_frame_equal(result, expected)
def test_chunk_begins_with_newline_whitespace(self):
# GH 10022
data = '\n hello\nworld\n'
result = self.read_csv(StringIO(data), header=None)
self.assertEqual(len(result), 2)
# GH 9735
chunk1 = 'a' * (1024 * 256 - 2) + '\na'
chunk2 = '\n a'
result = pd.read_csv(StringIO(chunk1 + chunk2), header=None)
expected = pd.DataFrame(['a' * (1024 * 256 - 2), 'a', ' a'])
tm.assert_frame_equal(result, expected)
def test_empty_with_index(self):
# GH 10184
data = 'x,y'
result = self.read_csv(StringIO(data), index_col=0)
expected = DataFrame([], columns=['y'], index=Index([], name='x'))
tm.assert_frame_equal(result, expected)
def test_emtpy_with_multiindex(self):
# GH 10467
data = 'x,y,z'
result = self.read_csv(StringIO(data), index_col=['x', 'y'])
expected = DataFrame([], columns=['z'],
index=MultiIndex.from_arrays([[]] * 2, names=['x', 'y']))
tm.assert_frame_equal(result, expected, check_index_type=False)
def test_empty_with_reversed_multiindex(self):
data = 'x,y,z'
result = self.read_csv(StringIO(data), index_col=[1, 0])
expected = DataFrame([], columns=['z'],
index=MultiIndex.from_arrays([[]] * 2, names=['y', 'x']))
tm.assert_frame_equal(result, expected, check_index_type=False)
def test_empty_index_col_scenarios(self):
data = 'x,y,z'
# None, no index
index_col, expected = None, DataFrame([], columns=list('xyz')),
tm.assert_frame_equal(self.read_csv(
StringIO(data), index_col=index_col), expected)
# False, no index
index_col, expected = False, DataFrame([], columns=list('xyz')),
tm.assert_frame_equal(self.read_csv(
StringIO(data), index_col=index_col), expected)
# int, first column
index_col, expected = 0, DataFrame(
[], columns=['y', 'z'], index=Index([], name='x'))
tm.assert_frame_equal(self.read_csv(
StringIO(data), index_col=index_col), expected)
# int, not first column
index_col, expected = 1, DataFrame(
[], columns=['x', 'z'], index=Index([], name='y'))
tm.assert_frame_equal(self.read_csv(
StringIO(data), index_col=index_col), expected)
# str, first column
index_col, expected = 'x', DataFrame(
[], columns=['y', 'z'], index=Index([], name='x'))
tm.assert_frame_equal(self.read_csv(
StringIO(data), index_col=index_col), expected)
# str, not the first column
index_col, expected = 'y', DataFrame(
[], columns=['x', 'z'], index=Index([], name='y'))
tm.assert_frame_equal(self.read_csv(
StringIO(data), index_col=index_col), expected)
# list of int
index_col, expected = [0, 1], DataFrame([], columns=['z'],
index=MultiIndex.from_arrays([[]] * 2, names=['x', 'y']))
tm.assert_frame_equal(self.read_csv(StringIO(data), index_col=index_col), expected,
check_index_type=False)
# list of str
index_col = ['x', 'y']
expected = DataFrame([], columns=['z'], index=MultiIndex.from_arrays(
[[]] * 2, names=['x', 'y']))
tm.assert_frame_equal(self.read_csv(StringIO(data), index_col=index_col), expected,
check_index_type=False)
# list of int, reversed sequence
index_col = [1, 0]
expected = DataFrame([], columns=['z'], index=MultiIndex.from_arrays(
[[]] * 2, names=['y', 'x']))
tm.assert_frame_equal(self.read_csv(StringIO(data), index_col=index_col), expected,
check_index_type=False)
# list of str, reversed sequence
index_col = ['y', 'x']
expected = DataFrame([], columns=['z'], index=MultiIndex.from_arrays(
[[]] * 2, names=['y', 'x']))
tm.assert_frame_equal(self.read_csv(StringIO(data), index_col=index_col), expected,
check_index_type=False)
def test_empty_with_index_col_false(self):
# GH 10413
data = 'x,y'
result = self.read_csv(StringIO(data), index_col=False)
expected = DataFrame([], columns=['x', 'y'])
tm.assert_frame_equal(result, expected)
def test_float_parser(self):
# GH 9565
data = '45e-1,4.5,45.,inf,-inf'
result = self.read_csv(StringIO(data), header=None)
expected = pd.DataFrame([[float(s) for s in data.split(',')]])
tm.assert_frame_equal(result, expected)
def test_int64_overflow(self):
data = """ID
00013007854817840016671868
00013007854817840016749251
00013007854817840016754630
00013007854817840016781876
00013007854817840017028824
00013007854817840017963235
00013007854817840018860166"""
result = self.read_csv(StringIO(data))
self.assertTrue(result['ID'].dtype == object)
self.assertRaises((OverflowError, pandas.parser.OverflowError),
self.read_csv, StringIO(data),
converters={'ID': np.int64})
# Just inside int64 range: parse as integer
i_max = np.iinfo(np.int64).max
i_min = np.iinfo(np.int64).min
for x in [i_max, i_min]:
result = pd.read_csv(StringIO(str(x)), header=None)
expected = pd.DataFrame([x])
tm.assert_frame_equal(result, expected)
# Just outside int64 range: parse as string
too_big = i_max + 1
too_small = i_min - 1
for x in [too_big, too_small]:
result = pd.read_csv(StringIO(str(x)), header=None)
expected = pd.DataFrame([str(x)])
tm.assert_frame_equal(result, expected)
def test_empty_with_nrows_chunksize(self):
# GH 9535
expected = pd.DataFrame([], columns=['foo', 'bar'])
result = self.read_csv(StringIO('foo,bar\n'), nrows=10)
tm.assert_frame_equal(result, expected)
result = next(iter(pd.read_csv(StringIO('foo,bar\n'), chunksize=10)))
tm.assert_frame_equal(result, expected)
result = pd.read_csv(StringIO('foo,bar\n'), nrows=10, as_recarray=True)
result = pd.DataFrame(result[2], columns=result[1], index=result[0])
tm.assert_frame_equal(pd.DataFrame.from_records(
result), expected, check_index_type=False)
result = next(
iter(pd.read_csv(StringIO('foo,bar\n'), chunksize=10, as_recarray=True)))
result = pd.DataFrame(result[2], columns=result[1], index=result[0])
tm.assert_frame_equal(pd.DataFrame.from_records(
result), expected, check_index_type=False)
def test_eof_states(self):
# GH 10728 and 10548
# With skip_blank_lines = True
expected = pd.DataFrame([[4, 5, 6]], columns=['a', 'b', 'c'])
# GH 10728
# WHITESPACE_LINE
data = 'a,b,c\n4,5,6\n '
result = self.read_csv(StringIO(data))
tm.assert_frame_equal(result, expected)
# GH 10548
# EAT_LINE_COMMENT
data = 'a,b,c\n4,5,6\n#comment'
result = self.read_csv(StringIO(data), comment='#')
tm.assert_frame_equal(result, expected)
# EAT_CRNL_NOP
data = 'a,b,c\n4,5,6\n\r'
result = self.read_csv(StringIO(data))
tm.assert_frame_equal(result, expected)
# EAT_COMMENT
data = 'a,b,c\n4,5,6#comment'
result = self.read_csv(StringIO(data), comment='#')
tm.assert_frame_equal(result, expected)
# SKIP_LINE
data = 'a,b,c\n4,5,6\nskipme'
result = self.read_csv(StringIO(data), skiprows=[2])
tm.assert_frame_equal(result, expected)
# With skip_blank_lines = False
# EAT_LINE_COMMENT
data = 'a,b,c\n4,5,6\n#comment'
result = self.read_csv(
StringIO(data), comment='#', skip_blank_lines=False)
expected = pd.DataFrame([[4, 5, 6]], columns=['a', 'b', 'c'])
tm.assert_frame_equal(result, expected)
# IN_FIELD
data = 'a,b,c\n4,5,6\n '
result = self.read_csv(StringIO(data), skip_blank_lines=False)
expected = pd.DataFrame(
[['4', 5, 6], [' ', None, None]], columns=['a', 'b', 'c'])
tm.assert_frame_equal(result, expected)
# EAT_CRNL
data = 'a,b,c\n4,5,6\n\r'
result = self.read_csv(StringIO(data), skip_blank_lines=False)
expected = pd.DataFrame(
[[4, 5, 6], [None, None, None]], columns=['a', 'b', 'c'])
tm.assert_frame_equal(result, expected)
# Should produce exceptions
# ESCAPED_CHAR
data = "a,b,c\n4,5,6\n\\"
self.assertRaises(Exception, self.read_csv,
StringIO(data), escapechar='\\')
# ESCAPE_IN_QUOTED_FIELD
data = 'a,b,c\n4,5,6\n"\\'
self.assertRaises(Exception, self.read_csv,
StringIO(data), escapechar='\\')
# IN_QUOTED_FIELD
data = 'a,b,c\n4,5,6\n"'
self.assertRaises(Exception, self.read_csv,
StringIO(data), escapechar='\\')
class TestPythonParser(ParserTests, tm.TestCase):
def test_negative_skipfooter_raises(self):
text = """#foo,a,b,c
#foo,a,b,c
#foo,a,b,c
#foo,a,b,c
#foo,a,b,c
#foo,a,b,c
1/1/2000,1.,2.,3.
1/2/2000,4,5,6
1/3/2000,7,8,9
"""
with tm.assertRaisesRegexp(ValueError,
'skip footer cannot be negative'):
df = self.read_csv(StringIO(text), skipfooter=-1)
def read_csv(self, *args, **kwds):
kwds = kwds.copy()
kwds['engine'] = 'python'
return read_csv(*args, **kwds)
def read_table(self, *args, **kwds):
kwds = kwds.copy()
kwds['engine'] = 'python'
return read_table(*args, **kwds)
def test_sniff_delimiter(self):
text = """index|A|B|C
foo|1|2|3
bar|4|5|6
baz|7|8|9
"""
data = self.read_csv(StringIO(text), index_col=0, sep=None)
self.assertTrue(data.index.equals(Index(['foo', 'bar', 'baz'])))
data2 = self.read_csv(StringIO(text), index_col=0, delimiter='|')
tm.assert_frame_equal(data, data2)
text = """ignore this
ignore this too
index|A|B|C
foo|1|2|3
bar|4|5|6
baz|7|8|9
"""
data3 = self.read_csv(StringIO(text), index_col=0,
sep=None, skiprows=2)
tm.assert_frame_equal(data, data3)
text = u("""ignore this
ignore this too
index|A|B|C
foo|1|2|3
bar|4|5|6
baz|7|8|9
""").encode('utf-8')
s = BytesIO(text)
if compat.PY3:
# somewhat False since the code never sees bytes
from io import TextIOWrapper
s = TextIOWrapper(s, encoding='utf-8')
data4 = self.read_csv(s, index_col=0, sep=None, skiprows=2,
encoding='utf-8')
tm.assert_frame_equal(data, data4)
def test_regex_separator(self):
data = """ A B C D
a 1 2 3 4
b 1 2 3 4
c 1 2 3 4
"""
df = self.read_table(StringIO(data), sep='\s+')
expected = self.read_csv(StringIO(re.sub('[ ]+', ',', data)),
index_col=0)
self.assertIsNone(expected.index.name)
tm.assert_frame_equal(df, expected)
def test_1000_fwf(self):
data = """
1 2,334.0 5
10 13 10.
"""
expected = [[1, 2334., 5],
[10, 13, 10]]
df = read_fwf(StringIO(data), colspecs=[(0, 3), (3, 11), (12, 16)],
thousands=',')
tm.assert_almost_equal(df.values, expected)
def test_1000_sep_with_decimal(self):
data = """A|B|C
1|2,334.01|5
10|13|10.
"""
expected = DataFrame({
'A': [1, 10],
'B': [2334.01, 13],
'C': [5, 10.]
})
df = self.read_csv(StringIO(data), sep='|', thousands=',')
tm.assert_frame_equal(df, expected)
df = self.read_table(StringIO(data), sep='|', thousands=',')
tm.assert_frame_equal(df, expected)
def test_comment_fwf(self):
data = """
1 2. 4 #hello world
5 NaN 10.0
"""
expected = [[1, 2., 4],
[5, np.nan, 10.]]
df = read_fwf(StringIO(data), colspecs=[(0, 3), (4, 9), (9, 25)],
comment='#')
tm.assert_almost_equal(df.values, expected)
def test_fwf(self):
data_expected = """\
2011,58,360.242940,149.910199,11950.7
2011,59,444.953632,166.985655,11788.4
2011,60,364.136849,183.628767,11806.2
2011,61,413.836124,184.375703,11916.8
2011,62,502.953953,173.237159,12468.3
"""
expected = self.read_csv(StringIO(data_expected), header=None)
data1 = """\
201158 360.242940 149.910199 11950.7
201159 444.953632 166.985655 11788.4
201160 364.136849 183.628767 11806.2
201161 413.836124 184.375703 11916.8
201162 502.953953 173.237159 12468.3
"""
colspecs = [(0, 4), (4, 8), (8, 20), (21, 33), (34, 43)]
df = read_fwf(StringIO(data1), colspecs=colspecs, header=None)
tm.assert_frame_equal(df, expected)
data2 = """\
2011 58 360.242940 149.910199 11950.7
2011 59 444.953632 166.985655 11788.4
2011 60 364.136849 183.628767 11806.2
2011 61 413.836124 184.375703 11916.8
2011 62 502.953953 173.237159 12468.3
"""
df = read_fwf(StringIO(data2), widths=[5, 5, 13, 13, 7], header=None)
tm.assert_frame_equal(df, expected)
# From <NAME>: apparently some non-space filler characters can
# be seen, this is supported by specifying the 'delimiter' character:
# http://publib.boulder.ibm.com/infocenter/dmndhelp/v6r1mx/index.jsp?topic=/com.ibm.wbit.612.help.config.doc/topics/rfixwidth.html
data3 = """\
201158~~~~360.242940~~~149.910199~~~11950.7
201159~~~~444.953632~~~166.985655~~~11788.4
201160~~~~364.136849~~~183.628767~~~11806.2
201161~~~~413.836124~~~184.375703~~~11916.8
201162~~~~502.953953~~~173.237159~~~12468.3
"""
df = read_fwf(
StringIO(data3), colspecs=colspecs, delimiter='~', header=None)
tm.assert_frame_equal(df, expected)
with tm.assertRaisesRegexp(ValueError, "must specify only one of"):
read_fwf(StringIO(data3), colspecs=colspecs, widths=[6, 10, 10, 7])
with tm.assertRaisesRegexp(ValueError, "Must specify either"):
read_fwf(StringIO(data3), colspecs=None, widths=None)
def test_fwf_colspecs_is_list_or_tuple(self):
with tm.assertRaisesRegexp(TypeError,
'column specifications must be a list or '
'tuple.+'):
pd.io.parsers.FixedWidthReader(StringIO(self.data1),
{'a': 1}, ',', '#')
def test_fwf_colspecs_is_list_or_tuple_of_two_element_tuples(self):
with tm.assertRaisesRegexp(TypeError,
'Each column specification must be.+'):
read_fwf(StringIO(self.data1), [('a', 1)])
def test_fwf_colspecs_None(self):
# GH 7079
data = """\
123456
456789
"""
colspecs = [(0, 3), (3, None)]
result = read_fwf(StringIO(data), colspecs=colspecs, header=None)
expected = DataFrame([[123, 456], [456, 789]])
tm.assert_frame_equal(result, expected)
colspecs = [(None, 3), (3, 6)]
result = read_fwf(StringIO(data), colspecs=colspecs, header=None)
expected = DataFrame([[123, 456], [456, 789]])
tm.assert_frame_equal(result, expected)
colspecs = [(0, None), (3, None)]
result = read_fwf(StringIO(data), colspecs=colspecs, header=None)
expected = DataFrame([[123456, 456], [456789, 789]])
tm.assert_frame_equal(result, expected)
colspecs = [(None, None), (3, 6)]
result = read_fwf(StringIO(data), colspecs=colspecs, header=None)
expected = DataFrame([[123456, 456], [456789, 789]])
tm.assert_frame_equal(result, expected)
def test_fwf_regression(self):
# GH 3594
# turns out 'T060' is parsable as a datetime slice!
tzlist = [1, 10, 20, 30, 60, 80, 100]
ntz = len(tzlist)
tcolspecs = [16] + [8] * ntz
tcolnames = ['SST'] + ["T%03d" % z for z in tzlist[1:]]
data = """ 2009164202000 9.5403 9.4105 8.6571 7.8372 6.0612 5.8843 5.5192
2009164203000 9.5435 9.2010 8.6167 7.8176 6.0804 5.8728 5.4869
2009164204000 9.5873 9.1326 8.4694 7.5889 6.0422 5.8526 5.4657
2009164205000 9.5810 9.0896 8.4009 7.4652 6.0322 5.8189 5.4379
2009164210000 9.6034 9.0897 8.3822 7.4905 6.0908 5.7904 5.4039
"""
df = read_fwf(StringIO(data),
index_col=0,
header=None,
names=tcolnames,
widths=tcolspecs,
parse_dates=True,
date_parser=lambda s: datetime.strptime(s, '%Y%j%H%M%S'))
for c in df.columns:
res = df.loc[:, c]
self.assertTrue(len(res))
def test_fwf_for_uint8(self):
data = """1421302965.213420 PRI=3 PGN=0xef00 DST=0x17 SRC=0x28 04 154 00 00 00 00 00 127
1421302964.226776 PRI=6 PGN=0xf002 SRC=0x47 243 00 00 255 247 00 00 71"""
df = read_fwf(StringIO(data),
colspecs=[(0, 17), (25, 26), (33, 37),
(49, 51), (58, 62), (63, 1000)],
names=['time', 'pri', 'pgn', 'dst', 'src', 'data'],
converters={
'pgn': lambda x: int(x, 16),
'src': lambda x: int(x, 16),
'dst': lambda x: int(x, 16),
'data': lambda x: len(x.split(' '))})
expected = DataFrame([[1421302965.213420, 3, 61184, 23, 40, 8],
[1421302964.226776, 6, 61442, None, 71, 8]],
columns=["time", "pri", "pgn", "dst", "src", "data"])
expected["dst"] = expected["dst"].astype(object)
tm.assert_frame_equal(df, expected)
def test_fwf_compression(self):
try:
import gzip
import bz2
except ImportError:
raise nose.SkipTest("Need gzip and bz2 to run this test")
data = """1111111111
2222222222
3333333333""".strip()
widths = [5, 5]
names = ['one', 'two']
expected = read_fwf(StringIO(data), widths=widths, names=names)
if compat.PY3:
data = bytes(data, encoding='utf-8')
comps = [('gzip', gzip.GzipFile), ('bz2', bz2.BZ2File)]
for comp_name, compresser in comps:
with tm.ensure_clean() as path:
tmp = compresser(path, mode='wb')
tmp.write(data)
tmp.close()
result = read_fwf(path, widths=widths, names=names,
compression=comp_name)
tm.assert_frame_equal(result, expected)
def test_BytesIO_input(self):
if not compat.PY3:
raise nose.SkipTest(
"Bytes-related test - only needs to work on Python 3")
result = pd.read_fwf(BytesIO("שלום\nשלום".encode('utf8')), widths=[
2, 2], encoding='utf8')
expected = pd.DataFrame([["של", "ום"]], columns=["של", "ום"])
tm.assert_frame_equal(result, expected)
data = BytesIO("שלום::1234\n562::123".encode('cp1255'))
result = pd.read_table(data, sep="::", engine='python',
encoding='cp1255')
expected = pd.DataFrame([[562, 123]], columns=["שלום", "1234"])
tm.assert_frame_equal(result, expected)
def test_verbose_import(self):
text = """a,b,c,d
one,1,2,3
one,1,2,3
,1,2,3
one,1,2,3
,1,2,3
,1,2,3
one,1,2,3
two,1,2,3"""
buf = StringIO()
sys.stdout = buf
try:
# it works!
df = self.read_csv(StringIO(text), verbose=True)
self.assertEqual(
buf.getvalue(), 'Filled 3 NA values in column a\n')
finally:
sys.stdout = sys.__stdout__
buf = StringIO()
sys.stdout = buf
text = """a,b,c,d
one,1,2,3
two,1,2,3
three,1,2,3
four,1,2,3
five,1,2,3
,1,2,3
seven,1,2,3
eight,1,2,3"""
try:
# it works!
df = self.read_csv(StringIO(text), verbose=True, index_col=0)
self.assertEqual(
buf.getvalue(), 'Filled 1 NA values in column a\n')
finally:
sys.stdout = sys.__stdout__
def test_float_precision_specified(self):
# Should raise an error if float_precision (C parser option) is
# specified
with tm.assertRaisesRegexp(ValueError, "The 'float_precision' option "
"is not supported with the 'python' engine"):
self.read_csv(StringIO('a,b,c\n1,2,3'), float_precision='high')
def test_iteration_open_handle(self):
if PY3:
raise nose.SkipTest(
"won't work in Python 3 {0}".format(sys.version_info))
with tm.ensure_clean() as path:
with open(path, 'wb') as f:
f.write('AAA\nBBB\nCCC\nDDD\nEEE\nFFF\nGGG')
with open(path, 'rb') as f:
for line in f:
if 'CCC' in line:
break
try:
read_table(f, squeeze=True, header=None, engine='c')
except Exception:
pass
else:
raise ValueError('this should not happen')
result = read_table(f, squeeze=True, header=None,
engine='python')
expected = Series(['DDD', 'EEE', 'FFF', 'GGG'], name=0)
tm.assert_series_equal(result, expected)
def test_iterator(self):
# GH 6607
# This is a copy which should eventually be merged into ParserTests
# when the issue with the C parser is fixed
reader = self.read_csv(StringIO(self.data1), index_col=0,
iterator=True)
df = self.read_csv(StringIO(self.data1), index_col=0)
chunk = reader.read(3)
tm.assert_frame_equal(chunk, df[:3])
last_chunk = reader.read(5)
tm.assert_frame_equal(last_chunk, df[3:])
# pass list
lines = list(csv.reader(StringIO(self.data1)))
parser = TextParser(lines, index_col=0, chunksize=2)
df = self.read_csv(StringIO(self.data1), index_col=0)
chunks = list(parser)
tm.assert_frame_equal(chunks[0], df[:2])
tm.assert_frame_equal(chunks[1], df[2:4])
tm.assert_frame_equal(chunks[2], df[4:])
# pass skiprows
parser = TextParser(lines, index_col=0, chunksize=2, skiprows=[1])
chunks = list(parser)
tm.assert_frame_equal(chunks[0], df[1:3])
# test bad parameter (skip_footer)
reader = self.read_csv(StringIO(self.data1), index_col=0,
iterator=True, skip_footer=True)
self.assertRaises(ValueError, reader.read, 3)
treader = self.read_table(StringIO(self.data1), sep=',', index_col=0,
iterator=True)
tm.assertIsInstance(treader, TextFileReader)
# stopping iteration when on chunksize is specified, GH 3967
data = """A,B,C
foo,1,2,3
bar,4,5,6
baz,7,8,9
"""
reader = self.read_csv(StringIO(data), iterator=True)
result = list(reader)
expected = DataFrame(dict(A=[1, 4, 7], B=[2, 5, 8], C=[
3, 6, 9]), index=['foo', 'bar', 'baz'])
tm.assert_frame_equal(result[0], expected)
# chunksize = 1
reader = self.read_csv(StringIO(data), chunksize=1)
result = list(reader)
expected = DataFrame(dict(A=[1, 4, 7], B=[2, 5, 8], C=[
3, 6, 9]), index=['foo', 'bar', 'baz'])
self.assertEqual(len(result), 3)
tm.assert_frame_equal(pd.concat(result), expected)
def test_single_line(self):
# GH 6607
# This is a copy which should eventually be merged into ParserTests
# when the issue with the C parser is fixed
# sniff separator
buf = StringIO()
sys.stdout = buf
# printing warning message when engine == 'c' for now
try:
# it works!
df = self.read_csv(StringIO('1,2'), names=['a', 'b'],
header=None, sep=None)
tm.assert_frame_equal(DataFrame({'a': [1], 'b': [2]}), df)
finally:
sys.stdout = sys.__stdout__
def test_malformed(self):
# GH 6607
# This is a copy which should eventually be merged into ParserTests
# when the issue with the C parser is fixed
# all
data = """ignore
A,B,C
1,2,3 # comment
1,2,3,4,5
2,3,4
"""
try:
df = self.read_table(
StringIO(data), sep=',', header=1, comment='#')
self.assertTrue(False)
except Exception as inst:
self.assertIn('Expected 3 fields in line 4, saw 5', str(inst))
# skip_footer
data = """ignore
A,B,C
1,2,3 # comment
1,2,3,4,5
2,3,4
footer
"""
try:
df = self.read_table(
StringIO(data), sep=',', header=1, comment='#',
skip_footer=1)
self.assertTrue(False)
except Exception as inst:
self.assertIn('Expected 3 fields in line 4, saw 5', str(inst))
# first chunk
data = """ignore
A,B,C
skip
1,2,3
3,5,10 # comment
1,2,3,4,5
2,3,4
"""
try:
it = self.read_table(StringIO(data), sep=',',
header=1, comment='#', iterator=True, chunksize=1,
skiprows=[2])
df = it.read(5)
self.assertTrue(False)
except Exception as inst:
self.assertIn('Expected 3 fields in line 6, saw 5', str(inst))
# middle chunk
data = """ignore
A,B,C
skip
1,2,3
3,5,10 # comment
1,2,3,4,5
2,3,4
"""
try:
it = self.read_table(StringIO(data), sep=',', header=1,
comment='#', iterator=True, chunksize=1,
skiprows=[2])
df = it.read(1)
it.read(2)
self.assertTrue(False)
except Exception as inst:
self.assertIn('Expected 3 fields in line 6, saw 5', str(inst))
# last chunk
data = """ignore
A,B,C
skip
1,2,3
3,5,10 # comment
1,2,3,4,5
2,3,4
"""
try:
it = self.read_table(StringIO(data), sep=',',
header=1, comment='#', iterator=True, chunksize=1,
skiprows=[2])
df = it.read(1)
it.read()
self.assertTrue(False)
except Exception as inst:
self.assertIn('Expected 3 fields in line 6, saw 5', str(inst))
def test_skip_footer(self):
# GH 6607
# This is a copy which should eventually be merged into ParserTests
# when the issue with the C parser is fixed
data = """A,B,C
1,2,3
4,5,6
7,8,9
want to skip this
also also skip this
"""
result = self.read_csv(StringIO(data), skip_footer=2)
no_footer = '\n'.join(data.split('\n')[:-3])
expected = self.read_csv(StringIO(no_footer))
tm.assert_frame_equal(result, expected)
result = self.read_csv(StringIO(data), nrows=3)
tm.assert_frame_equal(result, expected)
# skipfooter alias
result = self.read_csv(StringIO(data), skipfooter=2)
no_footer = '\n'.join(data.split('\n')[:-3])
expected = self.read_csv(StringIO(no_footer))
tm.assert_frame_equal(result, expected)
def test_decompression_regex_sep(self):
# GH 6607
# This is a copy which should eventually be moved to ParserTests
# when the issue with the C parser is fixed
try:
import gzip
import bz2
except ImportError:
raise nose.SkipTest('need gzip and bz2 to run')
data = open(self.csv1, 'rb').read()
data = data.replace(b',', b'::')
expected = self.read_csv(self.csv1)
with tm.ensure_clean() as path:
tmp = gzip.GzipFile(path, mode='wb')
tmp.write(data)
tmp.close()
result = self.read_csv(path, sep='::', compression='gzip')
tm.assert_frame_equal(result, expected)
with tm.ensure_clean() as path:
tmp = bz2.BZ2File(path, mode='wb')
tmp.write(data)
tmp.close()
result = self.read_csv(path, sep='::', compression='bz2')
tm.assert_frame_equal(result, expected)
self.assertRaises(ValueError, self.read_csv,
path, compression='bz3')
def test_read_table_buglet_4x_multiindex(self):
# GH 6607
# This is a copy which should eventually be merged into ParserTests
# when the issue with multi-level index is fixed in the C parser.
text = """ A B C D E
one two three four
a b 10.0032 5 -0.5109 -2.3358 -0.4645 0.05076 0.3640
a q 20 4 0.4473 1.4152 0.2834 1.00661 0.1744
x q 30 3 -0.6662 -0.5243 -0.3580 0.89145 2.5838"""
# it works!
df = self.read_table(StringIO(text), sep='\s+')
self.assertEqual(df.index.names, ('one', 'two', 'three', 'four'))
# GH 6893
data = ' A B C\na b c\n1 3 7 0 3 6\n3 1 4 1 5 9'
expected = DataFrame.from_records([(1, 3, 7, 0, 3, 6), (3, 1, 4, 1, 5, 9)],
columns=list('abcABC'), index=list('abc'))
actual = self.read_table(StringIO(data), sep='\s+')
tm.assert_frame_equal(actual, expected)
def test_line_comment(self):
data = """# empty
A,B,C
1,2.,4.#hello world
#ignore this line
5.,NaN,10.0
"""
expected = [[1., 2., 4.],
[5., np.nan, 10.]]
df = self.read_csv(StringIO(data), comment='#')
tm.assert_almost_equal(df.values, expected)
def test_empty_lines(self):
data = """\
A,B,C
1,2.,4.
5.,NaN,10.0
-70,.4,1
"""
expected = [[1., 2., 4.],
[5., np.nan, 10.],
[-70., .4, 1.]]
df = self.read_csv(StringIO(data))
tm.assert_almost_equal(df.values, expected)
df = self.read_csv(StringIO(data.replace(',', ' ')), sep='\s+')
tm.assert_almost_equal(df.values, expected)
expected = [[1., 2., 4.],
[np.nan, np.nan, np.nan],
[np.nan, np.nan, np.nan],
[5., np.nan, 10.],
[np.nan, np.nan, np.nan],
[-70., .4, 1.]]
df = self.read_csv(StringIO(data), skip_blank_lines=False)
tm.assert_almost_equal(list(df.values), list(expected))
def test_whitespace_lines(self):
data = """
\t \t\t
\t
A,B,C
\t 1,2.,4.
5.,NaN,10.0
"""
expected = [[1, 2., 4.],
[5., np.nan, 10.]]
df = self.read_csv(StringIO(data))
tm.assert_almost_equal(df.values, expected)
class TestFwfColspaceSniffing(tm.TestCase):
def test_full_file(self):
# File with all values
test = '''index A B C
2000-01-03T00:00:00 0.980268513777 3 foo
2000-01-04T00:00:00 1.04791624281 -4 bar
2000-01-05T00:00:00 0.498580885705 73 baz
2000-01-06T00:00:00 1.12020151869 1 foo
2000-01-07T00:00:00 0.487094399463 0 bar
2000-01-10T00:00:00 0.836648671666 2 baz
2000-01-11T00:00:00 0.157160753327 34 foo'''
colspecs = ((0, 19), (21, 35), (38, 40), (42, 45))
expected = read_fwf(StringIO(test), colspecs=colspecs)
tm.assert_frame_equal(expected, read_fwf(StringIO(test)))
def test_full_file_with_missing(self):
# File with missing values
test = '''index A B C
2000-01-03T00:00:00 0.980268513777 3 foo
2000-01-04T00:00:00 1.04791624281 -4 bar
0.498580885705 73 baz
2000-01-06T00:00:00 1.12020151869 1 foo
2000-01-07T00:00:00 0 bar
2000-01-10T00:00:00 0.836648671666 2 baz
34'''
colspecs = ((0, 19), (21, 35), (38, 40), (42, 45))
expected = read_fwf(StringIO(test), colspecs=colspecs)
tm.assert_frame_equal(expected, read_fwf(StringIO(test)))
def test_full_file_with_spaces(self):
# File with spaces in columns
test = '''
Account Name Balance CreditLimit AccountCreated
101 <NAME> 9315.45 10000.00 1/17/1998
312 <NAME> 90.00 1000.00 8/6/2003
868 <NAME> 0 17000.00 5/25/1985
761 Jada Pinkett-Smith 49654.87 100000.00 12/5/2006
317 <NAME> 789.65 5000.00 2/5/2007
'''.strip('\r\n')
colspecs = ((0, 7), (8, 28), (30, 38), (42, 53), (56, 70))
expected = read_fwf(StringIO(test), colspecs=colspecs)
tm.assert_frame_equal(expected, read_fwf(StringIO(test)))
def test_full_file_with_spaces_and_missing(self):
# File with spaces and missing values in columsn
test = '''
Account Name Balance CreditLimit AccountCreated
101 10000.00 1/17/1998
312 <NAME> 90.00 1000.00 8/6/2003
868 5/25/1985
761 <NAME>-Smith 49654.87 100000.00 12/5/2006
317 <NAME> 789.65
'''.strip('\r\n')
colspecs = ((0, 7), (8, 28), (30, 38), (42, 53), (56, 70))
expected = read_fwf(StringIO(test), colspecs=colspecs)
tm.assert_frame_equal(expected, read_fwf(StringIO(test)))
def test_messed_up_data(self):
# Completely messed up file
test = '''
Account Name Balance Credit Limit Account Created
101 10000.00 1/17/1998
312 <NAME> 90.00 1000.00
761 <NAME> 49654.87 100000.00 12/5/2006
317 <NAME> 789.65
'''.strip('\r\n')
colspecs = ((2, 10), (15, 33), (37, 45), (49, 61), (64, 79))
expected = read_fwf(StringIO(test), colspecs=colspecs)
tm.assert_frame_equal(expected, read_fwf(StringIO(test)))
def test_multiple_delimiters(self):
test = r'''
col1~~~~~col2 col3++++++++++++++++++col4
~~22.....11.0+++foo~~~~~~~~~~<NAME>
33+++122.33\\\bar.........<NAME>
++44~~~~12.01 baz~~<NAME>
~~55 11+++foo++++<NAME>-Smith
..66++++++.03~~~bar <NAME>
'''.strip('\r\n')
colspecs = ((0, 4), (7, 13), (15, 19), (21, 41))
expected = read_fwf(StringIO(test), colspecs=colspecs,
delimiter=' +~.\\')
tm.assert_frame_equal(expected, read_fwf(StringIO(test),
delimiter=' +~.\\'))
def test_variable_width_unicode(self):
if not compat.PY3:
raise nose.SkipTest(
'Bytes-related test - only needs to work on Python 3')
test = '''
שלום שלום
ום שלל
של ום
'''.strip('\r\n')
expected = pd.read_fwf(BytesIO(test.encode('utf8')),
colspecs=[(0, 4), (5, 9)], header=None, encoding='utf8')
tm.assert_frame_equal(expected, read_fwf(BytesIO(test.encode('utf8')),
header=None, encoding='utf8'))
class CParserTests(ParserTests):
""" base class for CParser Testsing """
def test_buffer_overflow(self):
# GH9205
# test certain malformed input files that cause buffer overflows in
# tokenizer.c
malfw = "1\r1\r1\r 1\r 1\r" # buffer overflow in words pointer
malfs = "1\r1\r1\r 1\r 1\r11\r" # buffer overflow in stream pointer
malfl = "1\r1\r1\r 1\r 1\r11\r1\r" # buffer overflow in lines pointer
for malf in (malfw, malfs, malfl):
try:
df = self.read_table(StringIO(malf))
except Exception as cperr:
self.assertIn(
'Buffer overflow caught - possible malformed input file.', str(cperr))
def test_buffer_rd_bytes(self):
# GH 12098
# src->buffer can be freed twice leading to a segfault if a corrupt
# gzip file is read with read_csv and the buffer is filled more than
# once before gzip throws an exception
data = '\x1F\x8B\x08\x00\x00\x00\x00\x00\x00\x03\xED\xC3\x41\x09' \
'\x00\x00\x08\x00\xB1\xB7\xB6\xBA\xFE\xA5\xCC\x21\x6C\xB0' \
'\xA6\x4D' + '\x55' * 267 + \
'\x7D\xF7\x00\x91\xE0\x47\x97\x14\x38\x04\x00' \
'\x1f\x8b\x08\x00VT\x97V\x00\x03\xed]\xefO'
for i in range(100):
try:
_ = self.read_csv(StringIO(data),
compression='gzip',
delim_whitespace=True)
except Exception as e:
pass
class TestCParserHighMemory(CParserTests, tm.TestCase):
def read_csv(self, *args, **kwds):
kwds = kwds.copy()
kwds['engine'] = 'c'
kwds['low_memory'] = False
return read_csv(*args, **kwds)
def read_table(self, *args, **kwds):
kwds = kwds.copy()
kwds['engine'] = 'c'
kwds['low_memory'] = False
return read_table(*args, **kwds)
def test_compact_ints(self):
if compat.is_platform_windows():
raise nose.SkipTest(
"segfaults on win-64, only when all tests are run")
data = ('0,1,0,0\n'
'1,1,0,0\n'
'0,1,0,1')
result = read_csv(StringIO(data), delimiter=',', header=None,
compact_ints=True, as_recarray=True)
ex_dtype = np.dtype([(str(i), 'i1') for i in range(4)])
self.assertEqual(result.dtype, ex_dtype)
result = read_csv(StringIO(data), delimiter=',', header=None,
as_recarray=True, compact_ints=True,
use_unsigned=True)
ex_dtype = np.dtype([(str(i), 'u1') for i in range(4)])
self.assertEqual(result.dtype, ex_dtype)
def test_parse_dates_empty_string(self):
# #2263
s = StringIO("Date, test\n2012-01-01, 1\n,2")
result = self.read_csv(s, parse_dates=["Date"], na_filter=False)
self.assertTrue(result['Date'].isnull()[1])
def test_usecols(self):
raise nose.SkipTest(
"Usecols is not supported in C High Memory engine.")
def test_line_comment(self):
data = """# empty
A,B,C
1,2.,4.#hello world
#ignore this line
5.,NaN,10.0
"""
expected = [[1., 2., 4.],
[5., np.nan, 10.]]
df = self.read_csv(StringIO(data), comment='#')
tm.assert_almost_equal(df.values, expected)
# check with delim_whitespace=True
df = self.read_csv(StringIO(data.replace(',', ' ')), comment='#',
delim_whitespace=True)
tm.assert_almost_equal(df.values, expected)
# check with custom line terminator
df = self.read_csv(StringIO(data.replace('\n', '*')), comment='#',
lineterminator='*')
tm.assert_almost_equal(df.values, expected)
def test_comment_skiprows(self):
data = """# empty
random line
# second empty line
1,2,3
A,B,C
1,2.,4.
5.,NaN,10.0
"""
expected = [[1., 2., 4.],
[5., np.nan, 10.]]
# this should ignore the first four lines (including comments)
df = self.read_csv(StringIO(data), comment='#', skiprows=4)
tm.assert_almost_equal(df.values, expected)
def test_skiprows_lineterminator(self):
# GH #9079
data = '\n'.join(['SMOSMANIA ThetaProbe-ML2X ',
'2007/01/01 01:00 0.2140 U M ',
'2007/01/01 02:00 0.2141 M O ',
'2007/01/01 04:00 0.2142 D M '])
expected = pd.DataFrame([['2007/01/01', '01:00', 0.2140, 'U', 'M'],
['2007/01/01', '02:00', 0.2141, 'M', 'O'],
['2007/01/01', '04:00', 0.2142, 'D', 'M']],
columns=['date', 'time', 'var', 'flag',
'oflag'])
# test with the three default lineterminators LF, CR and CRLF
df = self.read_csv(StringIO(data), skiprows=1, delim_whitespace=True,
names=['date', 'time', 'var', 'flag', 'oflag'])
tm.assert_frame_equal(df, expected)
df = self.read_csv(StringIO(data.replace('\n', '\r')),
skiprows=1, delim_whitespace=True,
names=['date', 'time', 'var', 'flag', 'oflag'])
tm.assert_frame_equal(df, expected)
df = self.read_csv(StringIO(data.replace('\n', '\r\n')),
skiprows=1, delim_whitespace=True,
names=['date', 'time', 'var', 'flag', 'oflag'])
tm.assert_frame_equal(df, expected)
def test_trailing_spaces(self):
data = "A B C \nrandom line with trailing spaces \nskip\n1,2,3\n1,2.,4.\nrandom line with trailing tabs\t\t\t\n \n5.1,NaN,10.0\n"
expected = pd.DataFrame([[1., 2., 4.],
[5.1, np.nan, 10.]])
# this should ignore six lines including lines with trailing
# whitespace and blank lines. issues 8661, 8679
df = self.read_csv(StringIO(data.replace(',', ' ')),
header=None, delim_whitespace=True,
skiprows=[0, 1, 2, 3, 5, 6], skip_blank_lines=True)
tm.assert_frame_equal(df, expected)
df = self.read_table(StringIO(data.replace(',', ' ')),
header=None, delim_whitespace=True,
skiprows=[0, 1, 2, 3, 5, 6], skip_blank_lines=True)
tm.assert_frame_equal(df, expected)
# test skipping set of rows after a row with trailing spaces, issue
# #8983
expected = pd.DataFrame({"A": [1., 5.1], "B": [2., np.nan],
"C": [4., 10]})
df = self.read_table(StringIO(data.replace(',', ' ')),
delim_whitespace=True,
skiprows=[1, 2, 3, 5, 6], skip_blank_lines=True)
tm.assert_frame_equal(df, expected)
def test_comment_header(self):
data = """# empty
# second empty line
1,2,3
A,B,C
1,2.,4.
5.,NaN,10.0
"""
expected = [[1., 2., 4.],
[5., np.nan, 10.]]
# header should begin at the second non-comment line
df = self.read_csv(StringIO(data), comment='#', header=1)
tm.assert_almost_equal(df.values, expected)
def test_comment_skiprows_header(self):
data = """# empty
# second empty line
# third empty line
X,Y,Z
1,2,3
A,B,C
1,2.,4.
5.,NaN,10.0
"""
expected = [[1., 2., 4.],
[5., np.nan, 10.]]
# skiprows should skip the first 4 lines (including comments), while
# header should start from the second non-commented line starting
# with line 5
df = self.read_csv( | StringIO(data) | pandas.compat.StringIO |
from pathlib import Path
import numpy as np
import pandas as pd
# Project Imports
from slam.common.utils import assert_debug, check_tensor
def delimiter():
"""
The column delimiter in pandas csv
"""
return ","
def write_poses_to_disk(file_path: str, poses: np.ndarray):
"""
Writes an array of poses to disk
Parameters
----------
file_path : str
poses : np.ndarray [N, 4, 4]
"""
check_tensor(poses, [-1, 4, 4])
path = Path(file_path)
assert_debug(path.parent.exists())
poses_to_df(poses).to_csv(file_path, sep=delimiter(), index=False)
def read_poses_from_disk(file_path: str, _delimiter: str = delimiter()) -> np.ndarray:
"""
Reads an array of poses from disk
Returns
----------
poses : np.ndarray [N, 4, 4]
"""
path = Path(file_path)
assert_debug(path.exists() and path.is_file())
return df_to_poses(pd.read_csv(path, sep=_delimiter, index_col=None))
def df_to_poses(df: pd.DataFrame) -> np.ndarray:
"""
Converts a pd.DataFrame to a [N, 4, 4] array of poses read from a dataframe
Parameters
----------
df : pd.DataFrame
A DataFrame of size [N, 12] with the 12 values of the first 3 rows of the pose matrix
"""
array = df.to_numpy(dtype=np.float32)
assert_debug(array.shape[1] == 12)
num_rows = array.shape[0]
poses = array.reshape([num_rows, 3, 4])
last_row = np.concatenate((np.zeros((num_rows, 3)), np.ones((num_rows, 1))), axis=1)
last_row = np.expand_dims(last_row, axis=1)
poses = np.concatenate((poses, last_row), axis=1)
return poses
def poses_to_df(poses_array: np.ndarray):
"""
Converts an array of pose matrices [N, 4, 4] to a DataFrame [N, 12]
"""
shape = poses_array.shape
assert_debug(len(shape) == 3)
assert_debug(shape[1] == 4 and shape[2] == 4)
nrows = shape[0]
reshaped = poses_array[:, :3, :].reshape([nrows, 12])
df = | pd.DataFrame(reshaped) | pandas.DataFrame |
#!/usr/bin/env python
# coding: utf-8
import re
from nameparser import HumanName
import pandas as pd
import itertools
from itertools import chain,product
from fuzzywuzzy import fuzz
from fuzzywuzzy import process
import bibmatch.clean_data as clean_data
import enchant
d = enchant.Dict('en_US')
#get_ipython().run_cell_magic('bash', '', 'jupyter nbconvert match_utilities.ipynb --to script')
#creating dataframe to store author information based on last name candidates for crawled authors
def get_wos_records(nobel_winner_wiki_information,author_df):
author_new_df=None
count=0
for crawled_file,v in nobel_winner_wiki_information.items():
preferred_name=v['preferred_name']
print(preferred_name)
personality_name=clean_data.strip_accents(preferred_name)
name=HumanName(personality_name)
if (name.title):
personality_name = personality_name.replace(name.title,'')
personality_name=personality_name.replace(",","")
personality_name = re.sub('Jr\.$', '', personality_name)
personality_name=personality_name.replace("(",'"').replace(")",'"')
personality_name=personality_name.strip("\n").strip("\t").strip(" ")
last_word=personality_name.split(" ")[-1]
first_name=personality_name.split(" ")[0]
if "-" in last_word:
last_words=last_word.split("-")
last_word=last_words[-1]
a=None
b=None
c=None
if last_word==name.last:
b=author_df.loc[(author_df['LastName'] == name.last) | (author_df['LastName'] == name.last.upper()) ][['FullName','AuthorDAIS','AuthorOrder','ArticleID','LastName','FirstName']]
else:
b=author_df.loc[(author_df['LastName'] == name.last) | (author_df['LastName'] == name.last.upper())|(author_df['LastName'] == last_word)| (author_df['LastName'] == last_word.upper())][['FullName','AuthorDAIS','AuthorOrder','ArticleID','LastName','FirstName']]
if b.empty:
if not d.check(personality_name):
b=author_df.loc[(author_df['LastName'] == first_name)][['FullName','AuthorDAIS','AuthorOrder','ArticleID','LastName','FirstName']]
if count==0:
author_new_df=b
else :
author_new_df= | pd.concat([author_new_df,b]) | pandas.concat |
"""Module grouping tests for the interpretaties search module."""
import pandas as pd
from owslib.fes import PropertyIsEqualTo
from pandas import DataFrame
from pydov.search.interpretaties import GecodeerdeLithologieSearch
from pydov.types.interpretaties import GecodeerdeLithologie
from tests.abstract import AbstractTestSearch
location_md_metadata = \
'tests/data/types/interpretaties/gecodeerde_lithologie/' \
'md_metadata.xml'
location_fc_featurecatalogue = \
'tests/data/types/interpretaties/gecodeerde_lithologie/' \
'fc_featurecatalogue.xml'
location_wfs_describefeaturetype = \
'tests/data/types/interpretaties/gecodeerde_lithologie/' \
'wfsdescribefeaturetype.xml'
location_wfs_getfeature = \
'tests/data/types/interpretaties/gecodeerde_lithologie/' \
'wfsgetfeature.xml'
location_wfs_feature = \
'tests/data/types/interpretaties/gecodeerde_lithologie/feature.xml'
location_dov_xml = \
'tests/data/types/interpretaties/gecodeerde_lithologie' \
'/gecodeerde_lithologie.xml'
location_xsd_base = \
'tests/data/types/interpretaties/gecodeerde_lithologie/xsd_*.xml'
class TestGecodeerdeLithologieSearch(AbstractTestSearch):
search_instance = GecodeerdeLithologieSearch()
datatype_class = GecodeerdeLithologie
valid_query_single = PropertyIsEqualTo(propertyname='Proefnummer',
literal='kb22d56w-B165')
inexistent_field = 'onbestaand'
wfs_field = 'Proefnummer'
xml_field = 'grondsoort'
valid_returnfields = ('pkey_interpretatie',
'betrouwbaarheid_interpretatie')
valid_returnfields_subtype = (
'pkey_interpretatie', 'diepte_laag_van', 'diepte_laag_tot')
valid_returnfields_extra = ('pkey_interpretatie', 'gemeente')
df_default_columns = ['pkey_interpretatie', 'pkey_boring',
'betrouwbaarheid_interpretatie', 'x', 'y',
'diepte_laag_van', 'diepte_laag_tot',
'hoofdnaam1_grondsoort', 'hoofdnaam2_grondsoort',
'bijmenging1_plaatselijk', 'bijmenging1_hoeveelheid',
'bijmenging1_grondsoort', 'bijmenging2_plaatselijk',
'bijmenging2_hoeveelheid', 'bijmenging2_grondsoort',
'bijmenging3_plaatselijk', 'bijmenging3_hoeveelheid',
'bijmenging3_grondsoort']
def test_search_nan(self, mp_wfs, mp_get_schema,
mp_remote_describefeaturetype, mp_remote_md,
mp_remote_fc, mp_remote_wfs_feature, mp_dov_xml):
"""Test the search method with only the query parameter.
Test whether the result is correct.
Parameters
----------
mp_wfs : pytest.fixture
Monkeypatch the call to the remote GetCapabilities request.
mp_get_schema : pytest.fixture
Monkeypatch the call to a remote OWSLib schema.
mp_remote_describefeaturetype : pytest.fixture
Monkeypatch the call to a remote DescribeFeatureType.
mp_remote_md : pytest.fixture
Monkeypatch the call to get the remote metadata.
mp_remote_fc : pytest.fixture
Monkeypatch the call to get the remote feature catalogue.
mp_remote_wfs_feature : pytest.fixture
Monkeypatch the call to get WFS features.
mp_dov_xml : pytest.fixture
Monkeypatch the call to get the remote XML data.
"""
self.search_instance.search(
query=self.valid_query_single)
def test_search_customreturnfields(self, mp_get_schema,
mp_remote_describefeaturetype,
mp_remote_wfs_feature, mp_dov_xml):
"""Test the search method with custom return fields.
Test whether the output dataframe is correct.
Parameters
----------
mp_get_schema : pytest.fixture
Monkeypatch the call to a remote OWSLib schema.
mp_remote_describefeaturetype : pytest.fixture
Monkeypatch the call to a remote DescribeFeatureType .
mp_remote_wfs_feature : pytest.fixture
Monkeypatch the call to get WFS features.
mp_dov_xml : pytest.fixture
Monkeypatch the call to get the remote XML data.
"""
df = self.search_instance.search(
query=self.valid_query_single,
return_fields=('pkey_interpretatie', 'pkey_boring'))
assert isinstance(df, DataFrame)
assert list(df) == ['pkey_interpretatie', 'pkey_boring']
assert not | pd.isnull(df.pkey_boring[0]) | pandas.isnull |
"""
Module which contain basic trainer class with all basic variables definitions,
calculations and logic. Inherit from this class each time when you want to add
new trainer class. DO NOT use this class to train models, use 'child' classes.
"""
import copy
import json
import ntpath
import operator
import os
import uuid
import zipfile
from collections import OrderedDict
from time import gmtime, strftime, time
import numpy
import pandas
import shap
from keras.callbacks import ModelCheckpoint
from keras.models import load_model
from scipy import sparse, spatial
from scipy.linalg import inv
from sklearn import model_selection
from sklearn.decomposition import PCA
from sklearn.ensemble import ExtraTreesRegressor, IsolationForest
from sklearn.externals import joblib
from sklearn.feature_selection import (
SelectKBest, f_classif, VarianceThreshold, f_regression
)
from sklearn.neighbors import KernelDensity
from sklearn.preprocessing import RobustScaler, StandardScaler, MinMaxScaler
from xhtml2pdf import pisa
from MLLogger import BaseMLLogger
from general_helper import (
DENSITY_MODEL_FILENAME, TRAIN_MEAN_FILENAME, SCALER_FILENAME, get_distance,
DISTANCE_MATRIX_FILENAME, TMP_from_numpy_by_field_name, make_directory,
post_data_to_blob, get_multipart_object, coeff_determination,
single_fold_selector, K_MEANS_FILENAME
)
from learner.algorithms import (
ALGORITHM, OPTIMIZER_FUNCTION, CLASSIC, MULTI_REGRESSOR,
algorithm_code_by_name, CLASSIFIER, REGRESSOR, algorithm_name_by_code,
model_type_by_name, TRAIN_FUNCTION, ADDITIONAL_ARGUMENTS, DNN,
HYPERPARAMETERES_HYPEROPT, HYPERPARAMETERES_SKOPT, MULTI_CLASSIFIER,
algorithm_method_by_name
)
from learner.folds import (
BaseCVFolds, ClassicClassifierCVFolds, ClassicMultiClassifierCVFolds,
ClassicMultiRegressorCVFolds, ClassicRegressorCVFolds, DNNRegressorCVFolds,
DNNClassifierCVFolds, DNNMultiClassifierCVFolds, DNNMultiRegressorCVFolds
)
from learner.models import (
class_weight_to_dict, onehot_encoded, train_dnn_multi_valid, optimizer
)
from learner.plotters import (
REGRESSION_RESULT_TEST, REGRESSION_RESULT_TRAIN, ROC_PLOT, CONFUSION_MATRIX
)
from messages import trained_model_info_message
from report_helper.TMP_text import (
QMRF_REPORT, TRAINING_CSV_METRICS, report_text_classifier,
report_text_regressor
)
from report_helper.html_render import create_report_html, QMRF_TEMPLATE
from report_helper.qmrf_report_constants import (
make_initial_context, update_user_context, make_model_context
)
LOGGER = BaseMLLogger(log_name='model_trainer', log_file_name='model_trainer')
SKOPT_OPTIMIZERS = ['forest', 'gbrt', 'gauss']
NOT_SKOPT_OPTIMIZERS = ['parzen']
class Trainer:
def __init__(
self, filename, prediction_target, dataframe, scale=None,
test_set_size=0.2, fptypes=None, n_split=4, output_path=None,
sub_folder=None, seed=7, pca=None, var_threshold=None, k_best=None,
z_score=None, outliers_from_test=None, outliers_from_train=None,
manual_test_set=None, subsample_size=1.0, hyperopt_optimize=False,
n_iter_optimize=100, opt_method='default', dnn_layers=None,
dnn_nodes=None
):
"""
Initialize any model trainer class with general training parameters
:param filename:
:param prediction_target: name of trained property
:param dataframe: prepared dataframe, using to training model
:param scale: scaler type name
It should be 'robust', 'standard', 'minmax' or None
:param test_set_size: size of test set should be in interval [0, 1)
:param fptypes: fingerprints set
:param n_split:
:param output_path:
:param sub_folder: folder path to write trained model files to
:param seed:
:param pca:
:param var_threshold:
:type filename: str
:type prediction_target: str
:type scale: str
:type test_set_size: float
:type fptypes: list
:type n_split: int
:type output_path: str
:type sub_folder: str
"""
self.n_iter_optimize = n_iter_optimize
self.opt_method = opt_method
self.manual_test_set = manual_test_set
self.prediction_target = prediction_target
self.n_split = n_split
self.seed = seed
self.fptypes = fptypes
self.scale = scale
self.pca = pca
self.threshold = var_threshold
self.test_size = test_set_size
self.train_size = 1 - test_set_size
self.metrics = {}
self.path_to_scaler = None
self.path_to_density_model = None
self.path_to_distance_matrix = None
self.path_to_train_mean = None
self.path_to_k_means = None
self.subsample_size = subsample_size
self.hyperopt_optimize = hyperopt_optimize
self.n_iter_optimize = n_iter_optimize
self.model_type = self.model_type or CLASSIFIER
self.dataframe = self.apply_dataframe(dataframe)
self.parameter_dataframe = TMP_from_numpy_by_field_name(
self.dataframe, 'name', [prediction_target]
).reshape(self.dataframe.shape[0], 1)
self.filename = ntpath.basename(filename)
self.template_tags = self.make_template_tags()
self.sub_folder = self.make_sub_folder(sub_folder, output_path)
self.bins = self.get_bins_number()
self.x_train = numpy.array([])
self.x_test = numpy.array([])
self.y_train = numpy.array([])
self.y_test = numpy.array([])
self.y_valid = numpy.array([])
self.x_valid = numpy.array([])
self.mean_centroid = 0
self.vi_file_path = str()
# prepare dataset indexes for stratified K-fold split or single fold
self.cv = self.make_stratified_k_fold()
self.cv_valid_ids = []
self.csv_formatter = '{:.04f}'.format
self.plots = dict()
self.density_mean = 0
self.density_std = 0
self.distance_mean = 0
self.distance_std = 0
self.train_mean = 0.0
self.train_shape = 0
self.modi = 0.0
self.linspace_size = 5
self.manual_test_set = manual_test_set
self.cv_model = BaseCVFolds()
self.correct_dataframe_with_z_score(z_score)
self.correct_data_features_values(k_best)
self.update_template_tags()
self.split_dataframe_by_subsample_size()
self.split_dataframes()
self.apply_outliers(outliers_from_train, 'x_train', 'y_train')
self.apply_outliers(outliers_from_test, 'x_test', 'y_test')
self.correct_by_threshold()
self.correct_by_pca()
self.apply_cross_validation()
self.path_to_scaler = self.apply_scaler()
self.model_name = 'no model name'
self.model_method = 'no model method'
def train_model(self, algorithm_code):
"""
Basic train model method. Train model with given parameters by
algorithm code, check training time int minutes, save model to file.
Returns training metrics such as model object, path to model file,
training time and trained model name
Expand it in child class
:param algorithm_code: code of algorithm
:type algorithm_code: str
:return: basic model training metrics
:rtype: dict
"""
# get model name by code
self.model_name = algorithm_name_by_code(algorithm_code)
self.model_method = algorithm_method_by_name(self.model_name)
# get all folds training time
training_time_minutes = self.train_folds_models()
# save all folds models to files
self.store_folds_trainings_data(training_time_minutes)
# calculate mean metrics and each fold metrics
self.calculate_metrics()
return self.cv_model
def make_training_function(self, optimal_parameters):
training_function = ALGORITHM[TRAIN_FUNCTION][self.model_name](
optimal_parameters)
return training_function
def make_training_parameters_grid(self):
if self.opt_method == 'default':
training_parameters_grid = ALGORITHM[OPTIMIZER_FUNCTION][self.model_name](self)
elif self.opt_method in NOT_SKOPT_OPTIMIZERS:
training_parameters_grid = ALGORITHM[HYPERPARAMETERES_HYPEROPT][self.model_name]
elif self.opt_method in SKOPT_OPTIMIZERS:
training_parameters_grid = ALGORITHM[HYPERPARAMETERES_SKOPT][self.model_name]
else:
raise ValueError(
'unknown optimizer: {}'.format(self.opt_method))
return training_parameters_grid
def make_optimal_parameters(self, training_parameters_grid):
if self.opt_method != 'default':
optimal_parameters = optimizer(
self, ALGORITHM[TRAIN_FUNCTION][self.model_name],
training_parameters_grid
)
else:
optimal_parameters = training_parameters_grid
return optimal_parameters
def train_folds_models(self):
"""
Method to train models fold by fold.
Update cv_model attribute with trained cv model folds.
Return time spent to train all folds.
:return: training time (minutes)
:rtype: float
"""
# get model name from algorithm code
self.cv_model.model_name = self.model_name
self.cv_model.model_type = model_type_by_name(self.model_name)
# train model with timer
start_training = time()
training_parameters_grid = self.make_training_parameters_grid()
optimal_parameters = self.make_optimal_parameters(
training_parameters_grid)
training_function = self.make_training_function(optimal_parameters)
arguments = ALGORITHM[ADDITIONAL_ARGUMENTS][self.model_name](self)
self.train_k_fold_models(
training_function, arguments, optimal_parameters)
return (time() - start_training) / 60
def store_folds_trainings_data(self, training_time_minutes):
"""
Method to dump (save to file) trained folds model (*.sav or *.h5) files
:param training_time_minutes: time spent to train model (minutes)
:type training_time_minutes: float
"""
# write trained models data to files
for number, model in enumerate(self.cv_model.models):
model_filename = self.make_model_filename(number + 1)
path_to_model = os.path.join(self.sub_folder, model_filename)
joblib.dump(model.model, path_to_model)
model.path_to_model_file = path_to_model
model.training_time = training_time_minutes
model.model_name = self.model_name
def calculate_metrics(self):
"""
Method to calculate folds metrics, mean metrics for trainer model
Store calculated metrics at 'metrics' class attribute
"""
# define CV model attributes
self.cv_model.prediction_target = self.prediction_target
self.cv_model.make_dataframes(self)
self.cv_model.sub_folder = self.sub_folder
# write classification metrics
self.metrics[self.model_name] = self.cv_model.calculate_metrics()
def train_k_fold_models(
self, training_method, arguments, optimal_parameters
):
"""
Method for train all folds of chosen model training method
:param training_method: model training function
:param arguments: additional model arguments for "fit"
:param optimal_parameters: optimal parameters for training
:type arguments: dict
"""
for train_ids, valid_ids in self.cv_valid_ids:
# define using subdataframes
x_train = self.x_train[train_ids]
y_train = self.y_train[train_ids]
x_valid = self.x_train[valid_ids]
y_valid = self.y_train[valid_ids]
# copy training method to avoid chain "fit"
model = copy.copy(training_method).fit(
x_train['value'], y_train['value'], **arguments
)
# define trained model object
trained_model = self.cv_model.fold_class(
model=model, model_type=self.cv_model.model_type,
x_test=self.x_test, y_test=self.y_test,
x_train=x_train, y_train=y_train,
x_valid=x_valid, y_valid=y_valid,
prediction_target=self.prediction_target,
sub_folder=self.sub_folder
)
self.cv_model.models.append(trained_model)
def make_model_dict(self, body):
"""
Method which make prepared model data for POST request.
:param body: input with train model command rabbitmq message
:type body: dict
:return: prepared model data
:rtype: dict
"""
# make model data dict
model_data_dict = {
'ModelInfo': json.dumps(trained_model_info_message(body, self)),
'FileType': 'MachineLearningModel',
'SkipOsdrProcessing': 'true',
'correlationId': body['CorrelationId']
}
return model_data_dict
def post_model(self, body, oauth):
"""
Method which POST basic model train data, such as model object
Expand it in child class
:param body: body of message received from RabbitMQ queue
:param oauth: using in ml service OAuth2Session object
:type body: dict
:return: POST response
"""
# model data dict
model_data_dict = self.make_model_dict(body)
path_to_archive = self.cv_model.compress_models()
path_to_archive = self.compress_additional_files(path_to_archive)
# make model multipart encoded object
multipart_model = get_multipart_object(
body, path_to_archive, 'application/x-spss-sav',
additional_fields=model_data_dict
)
# send, http POST request to blob storage api with model data
response_model = post_data_to_blob(oauth, multipart_model)
return response_model
def post_applicability_domain(self, body, oauth):
"""
Method which make and POST applicability domain values,
matrixes and models
:param body: body of message received from RabbitMQ queue
:param oauth: using in ml service OAuth2Session object
:type body: dict
"""
# calculate all values, matrixes and models of applicability domain
self.make_applicability_domain()
# POST density model to blob storage
density_model_response = self.post_density_model(body, oauth)
# POST distance matrix to blob storage
distance_matrix_response = self.post_distance_matrix(body, oauth)
# POST train mean vector as file to blob storage
train_mean_response = self.post_train_mean(body, oauth)
# save all blob ids
density_model_blob_id = None
if density_model_response:
density_model_blob_id = density_model_response.json()[0]
body['DensityModelBlobId'] = density_model_blob_id
distance_matrix_blob_id = None
if distance_matrix_response:
distance_matrix_blob_id = distance_matrix_response.json()[0]
body['DistanceMatrixBlobId'] = distance_matrix_blob_id
train_mean_blob_id = None
if train_mean_response:
train_mean_blob_id = train_mean_response.json()[0]
body['TrainMeanBlobId'] = train_mean_blob_id
def post_distance_matrix(self, body, oauth):
"""
Method for POST distance matrix to blob storage.
Return POST response
:param body: body of message received from RabbitMQ queue
:param oauth: using in ml service OAuth2Session object
:type body: dict
:return: POST response
"""
path_to_distance_matrix = self.path_to_distance_matrix
if not path_to_distance_matrix:
return None
distance_matrix_info = {
'ParentId': body['CurrentModelId'],
'SkipOsdrProcessing': 'true',
'FileInfo': json.dumps({
'fileType': 'Distance_matrix'
})
}
multipart_distance_matrix = get_multipart_object(
body, path_to_distance_matrix, 'application/x-spss-sav',
additional_fields=distance_matrix_info
)
response_distance_matrix = post_data_to_blob(
oauth, multipart_distance_matrix)
return response_distance_matrix
def post_train_mean(self, body, oauth):
"""
Method for POST train mean vector as file to blob storage.
Return POST response
:param body: body of message received from RabbitMQ queue
:param oauth: using in ml service OAuth2Session object
:type body: dict
:return: POST response
"""
path_to_train_mean = self.path_to_train_mean
if not path_to_train_mean:
return None
# prepare metadata
train_mean_info = {
'ParentId': body['CurrentModelId'],
'SkipOsdrProcessing': 'true',
'FileInfo': json.dumps({
'fileType': 'Train_mean'
})
}
# prepare file with metadata as multipart object
multipart_train_mean = get_multipart_object(
body, path_to_train_mean, 'application/x-spss-sav',
additional_fields=train_mean_info
)
# send train mean with metadata
response_train_mean = post_data_to_blob(
oauth, multipart_train_mean)
return response_train_mean
def post_density_model(self, body, oauth):
"""
Method for POST density model to blob storage.
Return POST response
:param body: body of message received from RabbitMQ queue
:param oauth: using in ml service OAuth2Session object
:type body: dict
:return: POST response
"""
path_to_density_model = self.path_to_density_model
if not path_to_density_model:
return None
# prepare metadata
density_model_info = {
'ParentId': body['CurrentModelId'],
'SkipOsdrProcessing': 'true',
'FileInfo': json.dumps({
'fileType': 'Density_model'
})
}
# prepare file with metadata as multipart object
multipart_density_model = get_multipart_object(
body, path_to_density_model, 'application/x-spss-sav',
additional_fields=density_model_info
)
# send density model with metadata
response_density_model = post_data_to_blob(
oauth, multipart_density_model)
return response_density_model
def make_applicability_domain(self):
"""
Method for calculate applicability domain for current trainer.
Save calculation results to files and add files paths to
trainer attributes
"""
self.estimate_density()
self.estimate_distance()
self.k_mean_clusters()
self.calculate_trainer_modi()
def correct_by_pca(self):
"""
Procedure that performs simple dimensionality reduction of the feature
vector using Principle Components Analysis.
"""
if self.pca:
pc = PCA(n_components=self.pca)
pc.fit(self.x_train)
self.x_train = pc.transform(self.x_train)
if self.test_size > 0:
self.x_test = pc.transform(self.x_test)
self.bins = self.pca
def correct_by_threshold(self):
"""
Procedure that discards low-variance features
(within a certain threshold) from the feature vector
"""
if not self.threshold:
return
selector = VarianceThreshold(threshold=self.threshold)
selector = selector.fit(self.x_train)
self.x_train = selector.transform(self.x_train)
if self.test_size != 0:
self.x_test = selector.transform(self.x_test)
self.bins = self.x_train.shape[1]
threshold_selector_filename = '{}_var_threshold_selector.sav'.format(
self.filename.split('.')[0])
path_to_threshold_selector = os.path.join(
self.sub_folder, threshold_selector_filename
)
joblib.dump(selector, path_to_threshold_selector)
def correct_dataframe_with_z_score(self, z_score):
"""
Procedure that discards observations from the data
by performing z-score test of the end-point value (Y - vector)
"""
if not z_score:
return
valuename = self.prediction_target
mean_value = self.dataframe[valuename].mean()
numerator = self.dataframe[valuename] - mean_value
denominator = self.dataframe[valuename].std(ddof=0)
drop_index = self.dataframe[numerator / denominator >= z_score].index
self.dataframe = self.dataframe.drop(drop_index)
def apply_scaler(self):
"""
Method that applies chosen scaler to the feature vectors of the dataset
:return: path to scaler object
:rtype: str
"""
if not self.scale or self.scale == 'not use scaler values':
return None
if self.scale == 'robust':
scaler = RobustScaler()
elif self.scale == 'standard':
scaler = StandardScaler()
elif self.scale == 'minmax':
scaler = MinMaxScaler()
else:
raise TypeError('Unknown scale: {}'.format(self.scale))
scaler = scaler.fit(self.x_train['value'])
tmp_x_train = scaler.transform(self.x_train['value'])
for row in range(0, self.x_train.shape[0]):
for column in range(0, self.x_train.shape[1]):
self.x_train[row][column]['value'] = tmp_x_train[row][column]
if self.test_size != 0 or self.manual_test_set is not None:
tmp_x_test = scaler.transform(self.x_test['value'])
for row in range(0, self.x_test.shape[0]):
for column in range(0, self.x_test.shape[1]):
self.x_test[row][column]['value'] = tmp_x_test[row][
column]
path_to_scaler = os.path.join(self.sub_folder, SCALER_FILENAME)
return joblib.dump(scaler, path_to_scaler)[0]
def post_scaler(self, body, oauth):
"""
Method for POST scaler model to blob storage.
Add scaler model blob id to body
:param body: body of message received from RabbitMQ queue
:param oauth: using in ml service OAuth2Session object
:type body: dict
"""
scaler_path = self.path_to_scaler
if not scaler_path:
return None
# prepare scaler metadata
scaler_info = {
'ParentId': body['CurrentModelId'],
'SkipOsdrProcessing': 'true',
'FileInfo': json.dumps({
'fileType': 'Scaler'
})
}
# prepare scaler with metadata as multipart object
multipart_scaler = get_multipart_object(
body, scaler_path, 'application/x-spss-sav',
additional_fields=scaler_info
)
# send scaler with metadata to OSDR blob storage
response_scaler = post_data_to_blob(oauth, multipart_scaler)
scaler_blob_id = None
if response_scaler:
scaler_blob_id = response_scaler.json()[0]
body['ScalerBlobId'] = scaler_blob_id
def make_sub_folder(self, sub_folder, output_path):
"""
Method which make subfolder (which contain model's files) if not exist
Use child's class subfolder name creator. Return subfolder full path
:param sub_folder: subfolder name or None, trainer init argument
:param output_path: output path or None, trainer init argument
:type sub_folder: str
:type output_path: str
:return: subfolder full path
:rtype: str
"""
if not sub_folder:
folder_path = self.make_sub_folder_path()
else:
folder_path = sub_folder
if output_path:
folder_path = os.path.join(output_path, folder_path)
make_directory(folder_path)
return folder_path
def make_perfomance_csv(self):
"""
Method which make csv file with all needed metrics for model and
write it to csv file
:return: path to csv file with metrics
:rtype: str
"""
# format trained models metrics
self.apply_metrics_formatter()
# for fold_number, fold_metrics in self.metrics.items():
# get model perfomance metrics
reformatted_metrics = OrderedDict()
for metric_name, fold_metrics in self.metrics.items():
for fold_name, fold_metric in fold_metrics.items():
header_fold_name = '{} CV fold {}'.format(
metric_name, fold_name)
if fold_name == 'mean':
header_fold_name = '{} CV {}'.format(
metric_name, fold_name)
reformatted_key = '{} {}'.format(metric_name, fold_name)
reformatted_metrics[reformatted_key] = fold_metric
if fold_name == 'mean':
reformatted_metrics.move_to_end(
reformatted_key, last=False)
# add metrics header
reformatted_metrics[reformatted_key].update({
('Dataset', 'Evaluation metrics'): header_fold_name
})
# sort rows
model_performance = pandas.DataFrame.from_dict(
reformatted_metrics
).rename(
index={'Dataset': '0', 'train': '1', 'test': '3',
'validation': '2'}
).sort_index().rename(
index={'1': 'Train', '3': 'Test', '2': 'Validation',
'0': 'Dataset'}
)
# format model perfomance metrics
self.template_tags['metrics'] += model_performance.to_html(
header=False
).replace(
'th>', 'td>'
).replace(
'<th', '<td'
).replace(
'style="text-align: right;"', ''
).replace(
'valign="top"', ''
)
# write perfomance metrics to file
csv_file_name = '{}_{}.csv'.format(
self.cv_model.model_name, self.filename.split('.')[0])
path_to_csv = os.path.join(self.sub_folder, csv_file_name)
model_performance.to_csv(path_to_csv)
return path_to_csv
def post_performance(self, body, oauth):
"""
Method for write training metrics to csv file and
POST csv file to blob storage.
Return path to created csv file
:param body: body of message received from RabbitMQ queue
:param oauth: using in ml service OAuth2Session object
:type body: dict
:return: path to csv file with training metrics
:rtype: str
"""
csv_file_path = self.make_perfomance_csv()
# prepare metrics metadata
csv_metrics_info = {
'FileInfo': json.dumps({
'modelName': self.cv_model.model_name,
'fileType': TRAINING_CSV_METRICS
}),
'ParentId': body['CurrentModelId']
}
# prepare training metrics with metadata as multipart object
multipart_csv = get_multipart_object(
body, csv_file_path, 'text/csv',
additional_fields=csv_metrics_info
)
# send training metrics with metadata to OSDR blob storage
response = post_data_to_blob(oauth, multipart_csv)
body['NumberOfGenericFiles'] += 1
LOGGER.info(
'CSV sended with status code: {} blob id: {}'.format(
response.status_code, response.json()[0])
)
return csv_file_path
def apply_metrics_formatter(self):
"""
Apply needed formatter to float numbers for all metrics
Redefine self.csv_formatter in childs if wont to change float format
"""
for fold_metrics in self.metrics.values():
for metrics_set in fold_metrics.values():
for metric_name, metric_value in metrics_set.items():
metrics_set[metric_name] = self.csv_formatter(metric_value)
def post_qmrf_report(self, body, oauth):
"""
Method which create and POST to blob storage training QMRF report
:param body: body of message received from RabbitMQ queue
:param oauth: oauth object
:type body: dict
:return: POST response
"""
# generate QMRF report pdf file and get path to that file
path_to_pdf_qmrf_report = self.make_qmrf_report(oauth, body)
# define QMRF report file metadata
qmrf_report_info = {
'FileInfo': json.dumps({
'modelName': self.cv_model.model_name,
'fileType': QMRF_REPORT
}),
'ParentId': body['CurrentModelId']
}
# make QMRF pdf report multipart encoded object
multipart_qmrf_report = get_multipart_object(
body, path_to_pdf_qmrf_report, 'application/pdf',
additional_fields=qmrf_report_info
)
# POST http request to blob storage api with QMRF report
response = post_data_to_blob(oauth, multipart_qmrf_report)
body['NumberOfGenericFiles'] += 1
return response
def make_qmrf_report(self, oauth, body):
"""
Method which make training QMRF pdf report
:param oauth: body of message received from RabbitMQ queue
:param body: oauth object
:type body: dict
:return: path to QMRF report pdf file
:rtype: str
"""
# make QMRF report as HTML and get path
qmrf_context = make_initial_context()
if oauth and body:
update_user_context(oauth, body['UserId'], qmrf_context)
if body:
make_model_context(self, qmrf_context, body)
formatted_model_name = '_'.join(self.cv_model.model_name.split())
html_report_path = os.path.join(
self.sub_folder, '{}_{}'.format(
formatted_model_name, QMRF_TEMPLATE)
)
path_to_html_qmrf_report = create_report_html(
qmrf_context, QMRF_TEMPLATE, html_report_path)
# convert HTML report content to pdf and write to file
pdf_report_path = os.path.join(
self.sub_folder, '{}_QMRF_report.pdf'.format(formatted_model_name))
pisa.CreatePDF(
open(path_to_html_qmrf_report, 'r'), open(pdf_report_path, 'wb'),
path=os.path.abspath(self.sub_folder)
)
path_to_pdf_qmrf_report = os.path.abspath(pdf_report_path)
return path_to_pdf_qmrf_report
def apply_dataframe(self, dataframe):
"""
Remove nan values from initial dataframe
nan values can come from bad fingerprints/descroptors or bad molecules
:param dataframe: almost prepared dataset which have applied
all fingerprints\descriptors, radius and size
:return: dataframe with cleared nan values
:type dataframe: numpy.ndarray
:rtype: numpy.ndarray
"""
return dataframe[~numpy.isnan(dataframe['value']).any(axis=1)]
def apply_cross_validation(self):
"""
Method for split dataframe train sets (x and y) to folds by ids
Update trainer attribute with splitted ids
"""
# indexes for new train dataset depends on model type
if self.model_type == MULTI_REGRESSOR:
bins = numpy.linspace(0, self.y_train.shape[0], self.linspace_size)
if self.manual_test_set is not None:
y_train = numpy.digitize(self.y_train, bins)[:, 0]
else:
y_train = numpy.digitize(self.y_train, bins)[:, 0]
elif (
self.model_type == CLASSIFIER or
self.model_type == MULTI_CLASSIFIER
):
y_train = self.y_train[:, 0]['value']
elif self.model_type == REGRESSOR:
bins = numpy.linspace(0, self.y_train.shape[0], self.linspace_size)
y_train = numpy.digitize(self.y_train['value'], bins)[:, 0]
else:
raise ValueError(
'Unknow model type: {}'.format(self.model_type))
# split dataframe by folds
for train_id, valid_id in self.cv(self.x_train['value'], y_train):
self.cv_valid_ids.append([train_id.tolist(), valid_id.tolist()])
def make_stratified_k_fold(self):
"""
Method for define stratified K fold function, using training parameters
:return: stratified K fold function
"""
# single fold training
if self.n_split == 1:
k_fold_function = single_fold_selector
# multiple folds training
else:
k_fold_function = model_selection.StratifiedKFold(
shuffle=True, n_splits=self.n_split, random_state=0
).split
return k_fold_function
def apply_outliers(self, outlier, x_attribute, y_attribute):
"""
Experimental function that discards outliers
(feature vector - based) from the data
using Isolation Forest anomaly detection method.
:param outlier:
:param x_attribute:
:param y_attribute:
"""
# TODO review the code
if not outlier:
return
iso_for = IsolationForest().fit(self.x_train)
outliers_train = []
x_value = getattr(self, x_attribute)
y_value = getattr(self, y_attribute)
for i in range(x_value.shape[0]):
if iso_for.predict(x_value[i, :].reshape(1, -1)) == -1:
outliers_train.append(i)
x_value = numpy.delete(x_value, outliers_train, axis=0)
y_value = numpy.delete(y_value, outliers_train, axis=0)
setattr(self, x_attribute, x_value)
setattr(self, y_attribute, y_value)
def make_centroid(self):
"""
:return: mean - centroid of train data, VI - inverted covariance matrix
"""
# TODO make docstring there
self.mean_centroid = numpy.mean(self.x_train, axis=0)
vi_filename = '{}/{}_vi_matrix'.format(self.sub_folder, uuid.uuid1())
covariance = numpy.cov(self.x_train.T)
vi = inv(covariance)
vi.tofile(vi_filename)
self.vi_file_path = vi_filename
def make_template_tags(self):
"""
Method which make basic template_tags for trainer
Expand it on 'child' class
:return: template_tags with basic keys
:rtype: dict
"""
template_tags = dict()
template_tags['bin_plots'] = []
template_tags['dataset'] = 'Parameter {} from dataset file {}'.format(
self.prediction_target, self.filename)
template_tags['dataset_info'] = []
template_tags['metrics'] = ''
return template_tags
def make_sub_folder_path(self):
"""
Method which make basic subfolder path, which contain all model's files
Expand that method in child class
:return: datetime string as basic subfolder name
:rtype: str
"""
date_time = '{}_{}'.format(
uuid.uuid1(), strftime('%Y_%m_%d__%H_%M_%S', gmtime())
)
return date_time
def make_model_filename(self, k_fold_number):
"""
Method which make basic filename for new trained model
:return: filename for new trained model
:rtype: str
"""
model_splited_filename = '_'.join(self.model_name.split())
return '{}_k_fold_{}.sav'.format(model_splited_filename, k_fold_number)
def get_bins_number(self):
"""
Method which calculate and return bins number
:return: bins number
:rtype: int
"""
return self.dataframe.shape[1] - 1
def split_dataframes(self):
"""
Method to split dataframe to test/train subdataframes. It splits
x dataframes correspond to y dataframes by indexes. It depends on
test dataset size and manual test set value.
For example test_size=0.2 mean that test set would contain 200
molecules, train set 800 molecules when initial dataset contain 1000
molecules. Test set size does not matter if manual test set exists.
It uses manual test set fully, independ of test set size
"""
# x values from source dataframe
initial_x_dataframe = self.dataframe[:, 0:self.bins]
# no tests sets, only train sets (fully source dataframe)
if self.manual_test_set is None and self.test_size == 0:
self.x_train = initial_x_dataframe
self.y_train = self.parameter_dataframe
# test set from source dataframe (molecules count * test_size)
# train set from source dataframe (molecules count * (1 - test_size))
elif self.manual_test_set is None and self.test_size != 0:
self.x_train, self.x_test, self.y_train, self.y_test = model_selection.train_test_split(
initial_x_dataframe,
self.parameter_dataframe,
train_size=self.train_size,
test_size=self.test_size,
random_state=self.seed,
shuffle=True
)
# test set from manual test set dataframe (fully)
# train set from source dataframe (fully source dataframe)
elif self.manual_test_set is not None:
self.manual_test_set = self.manual_test_set[~numpy.isnan(self.manual_test_set['value']).any(axis=1)]
self.y_train = self.parameter_dataframe
self.x_train = initial_x_dataframe
self.y_test = TMP_from_numpy_by_field_name(
self.manual_test_set, 'name', [self.prediction_target]
).reshape(self.manual_test_set.shape[0], 1)
self.x_test = self.manual_test_set[:, 0:self.bins]
else:
raise ValueError(
'Wrong choice. Test size: {} Manual test set: {}'.format(
self.test_size, self.manual_test_set)
)
def split_dataframe_by_subsample_size(self):
"""
this functions finds and removes part of major class examples
in order to balance dataset true\false ratio
change name to drop_major_subsample
"""
# Randomly remove a fraction of major class samples
if self.subsample_size and 0 <= self.subsample_size <= 1:
all_indexes = self.dataframe[:, 0]['molecule_number']
remove_indexes = numpy.random.choice(
numpy.array(all_indexes),
int(all_indexes.shape[0] * (1. - self.subsample_size)),
replace=False
)
self.dataframe = numpy.delete(self.dataframe, remove_indexes, 0)
self.parameter_dataframe = numpy.delete(
self.parameter_dataframe, remove_indexes, 0)
else:
raise ValueError(
'subsample of {} is impossible'.format(self.subsample_size))
def post_plots(self, body, oauth):
"""
Implement this method in child class
:param body: body of message received from RabbitMQ queue
:param oauth: oauth object
"""
pass
def make_report_text(self):
"""
Implement this method in child class
"""
pass
def correct_data_features_values(self, k_best):
"""
Implement this method in child class
"""
pass
def update_template_tags(self):
"""
Implement this method in child class
"""
pass
def estimate_density(self):
"""
Build model for mutivariate kernel density estimation.
Takes x_train dataframe as input, builds a kernel density model
with optimised parameters for input vectors,
and computes density for all input vectors.
"""
if self.scale is None:
bandwidth = numpy.logspace(-1, 2, 20)
else:
bandwidth = numpy.linspace(0.1, 0.5, 5)
x_train = self.x_train['value']
# find best parameters for KD
grid = model_selection.GridSearchCV(
KernelDensity(), {'bandwidth': bandwidth}, cv=3)
grid.fit(x_train)
# compute KD for x_train
bw = grid.best_params_
dens_model = KernelDensity(bw['bandwidth']).fit(x_train)
samples = dens_model.score_samples(x_train)
dens_mean = numpy.mean(samples)
dens_std = numpy.std(samples)
path_to_model = os.path.join(self.sub_folder, DENSITY_MODEL_FILENAME)
joblib.dump(dens_model, path_to_model)
self.path_to_density_model = path_to_model
self.density_mean = dens_mean
self.density_std = dens_std
def estimate_distance(self):
"""
Takes x_train dataframe as input,
calculates Mahalonobis distance between whole input
dataset and each input vector from the dataset
"""
x_train = self.x_train['value']
centroid = x_train - numpy.tile(
numpy.mean(x_train, axis=0), (x_train.shape[0], 1)
)
train_mean = numpy.mean(x_train, axis=0)
self.train_shape = x_train.shape[0] - 1
x_train = numpy.asarray(x_train)
dist_list = numpy.apply_along_axis(
get_distance, 1, x_train, centroid=centroid, train_mean=train_mean,
train_shape=self.train_shape
)
dist_mean = numpy.mean(dist_list)
dist_std = numpy.std(dist_list)
matrix_file_path = os.path.join(
self.sub_folder, DISTANCE_MATRIX_FILENAME)
train_mean_file_path = os.path.join(
self.sub_folder, TRAIN_MEAN_FILENAME)
numpy.savetxt(train_mean_file_path, train_mean)
centroid = sparse.csr_matrix(
numpy.asarray(centroid).astype(dtype='float32'))
sparse.save_npz(matrix_file_path, centroid)
self.path_to_distance_matrix = matrix_file_path
self.path_to_train_mean = train_mean_file_path
self.distance_mean = dist_mean
self.distance_std = dist_std
def k_mean_clusters(self, n=50):
"""
use kmeans to clusterise dataset
:param n: number of clusters
"""
means = shap.kmeans(self.x_train['value'], n)
file_path = os.path.join(self.sub_folder, K_MEANS_FILENAME)
joblib.dump(means, file_path)
self.path_to_k_means = file_path
def calculate_trainer_modi(self):
pass
def compress_additional_files(self, path_to_archive):
"""
Method to compress additional files (such as scaler, train mean vector,
density model, distance matrix) to archive with model folds
:param path_to_archive: path to folds archive to add additional files
:return: path to archive with folds and additional files
:type path_to_archive: str
:rtype: str
"""
# set archive path file to append files
archive_file = zipfile.ZipFile(path_to_archive, 'a')
# add scaler
archive_file.write(
self.path_to_scaler, self.path_to_scaler.split('/')[-1],
compress_type=zipfile.ZIP_DEFLATED
)
# add train mean
archive_file.write(
self.path_to_train_mean,
self.path_to_train_mean.split('/')[-1],
compress_type=zipfile.ZIP_DEFLATED
)
# add density model
archive_file.write(
self.path_to_density_model,
self.path_to_density_model.split('/')[-1],
compress_type=zipfile.ZIP_DEFLATED
)
# add distance matrix
archive_file.write(
self.path_to_distance_matrix,
self.path_to_distance_matrix.split('/')[-1],
compress_type=zipfile.ZIP_DEFLATED
)
# add k means
archive_file.write(
self.path_to_k_means,
self.path_to_k_means.split('/')[-1],
compress_type=zipfile.ZIP_DEFLATED
)
archive_file.close()
return path_to_archive
def make_info_json(self):
"""
Method to generate json file, using in models uploader
Create json file in model folder
Using to simplify models metadata generation after training
"""
info_dict = {
'ModelName': None,
'SourceFileName': None,
'SourceBlobId': None,
'SourceBucket': None,
'ModelBucket': None,
'Method': algorithm_code_by_name(self.cv_model.model_name),
'MethodDisplayName': '{}, {}'.format(
self.cv_model.model_name, self.model_type.capitalize()),
'ClassName': self.prediction_target,
'SubSampleSize': None,
'TestDatasetSize': self.test_size,
'KFold': self.n_split,
'Fingerprints': self.fptypes,
'UserId': None,
'ModelType': self.model_type,
'ModelId': str(uuid.uuid1()),
'Bins': self.bins,
'Scaler': self.scale,
'DensityMean': float(self.density_mean),
'DensityStd': float(self.density_std),
'DistanceMean': float(self.distance_mean),
'DistanceStd': float(self.distance_std),
'TrainShape': self.train_shape,
'Modi': self.modi,
'Dataset': {
'Title': None,
'Description': None
},
'Property': {
'Category': None,
'Name': None,
'Units': None,
'Description': None
}
}
json_file_path = '{}/{}.json'.format(
self.sub_folder, '_'.join(self.cv_model.model_name.split())
)
json_file = open(json_file_path, 'w')
json_file.write(json.dumps(info_dict))
json_file.close()
class ClassicClassifier(Trainer):
def __init__(
self, filename, classname, dataframe, test_set_size=0.2, seed=7,
subsample_size=1.0, n_split=4, fptype=None, output_path=None,
sub_folder=None, k_best=None, scale=None, pca=None, z_score=None,
var_threshold=None, outliers_from_test=None, manual_test_set=None,
outliers_from_train=None, hyperopt_optimize=False,
opt_method='default', n_iter_optimize=100
):
self.model_type = CLASSIFIER
super().__init__(
filename, classname, dataframe, output_path=output_path, seed=seed,
test_set_size=test_set_size, fptypes=fptype, n_split=n_split,
scale=scale, sub_folder=sub_folder, pca=pca, z_score=z_score,
var_threshold=var_threshold, outliers_from_test=outliers_from_test,
k_best=k_best, outliers_from_train=outliers_from_train,
manual_test_set=manual_test_set, subsample_size=subsample_size,
hyperopt_optimize=hyperopt_optimize, opt_method=opt_method,
n_iter_optimize=n_iter_optimize
)
self.cv_model = ClassicClassifierCVFolds()
self.class_weight_train = list()
self.class_weight_test = list()
self.make_class_weights()
def post_plots(self, body, oauth):
"""
Method which make plots, then POST plots to blob storage
:param body: rabbitmq message body
:type body: dict
:param oauth: OAuth2 object
"""
# make needed for model plots
self.plots = self.cv_model.make_plots()
for k_fold_number, plots in self.plots.items():
# make ROC plot multipart encoded object
roc_info = {
'FileInfo': json.dumps({
'modelName': self.cv_model.model_name,
'fileType': ROC_PLOT
}),
'ParentId': body['CurrentModelId']
}
multipart_roc = get_multipart_object(
body, plots['roc_plot_path'], 'image/png',
additional_fields=roc_info
)
# send, http POST request to blob storage api with ROC plot
post_data_to_blob(oauth, multipart_roc)
body['NumberOfGenericFiles'] += 1
# make confusion matrix multipart encoded object
confusion_matrix_info = {
'FileInfo': json.dumps({
'modelName': self.cv_model.model_name,
'fileType': CONFUSION_MATRIX
}),
'ParentId': body['CurrentModelId']
}
multipart_cm = get_multipart_object(
body, plots['cm_plot_path'], 'image/png',
additional_fields=confusion_matrix_info
)
# send, http POST request to blob storage api with confusion matrix
post_data_to_blob(oauth, multipart_cm)
body['NumberOfGenericFiles'] += 1
# update template tags with model's plots
self.template_tags['confusion_matrixes'].append(
plots['cm_plot_path'])
self.template_tags['roc_plots'].append(
plots['roc_plot_path'])
def calculate_trainer_modi(self):
# TODO make docstring there
n_act = 0
n_n_act = 0
n_act_same = 0
n_n_act_same = 0
dataframe = self.dataframe['value']
for row_1 in dataframe:
row_1 = numpy.nan_to_num(row_1)
tmp_dist_list = []
tmp_rows_dict = {}
counter = 0
for row_2 in dataframe:
row_2 = numpy.nan_to_num(row_2)
if numpy.array_equal(row_1, row_2):
continue
else:
dist = spatial.distance.euclidean(row_1[:-1], row_2[:-1])
tmp_dist_list.append(dist)
tmp_rows_dict[counter] = row_2
counter += 1
ind = tmp_dist_list.index(min(tmp_dist_list))
nearest_neighbour = tmp_rows_dict[ind]
if row_1[-1] == 1:
n_act += 1
if nearest_neighbour[-1] == 1:
n_act_same += 1
else:
n_n_act += 1
if nearest_neighbour[-1] == 0:
n_n_act_same += 1
self.modi = 0.5 * ((n_act_same / n_act) + (n_n_act_same / n_n_act))
def make_class_weights(self):
"""
I dont think we even need to set_class weight for test
but i will put a dummy just for now
"""
# TODO check this module
class_weight_train_dict = class_weight_to_dict(
self.y_train[:, 0]['value'])
for index in self.y_train[:, 0]['value']:
self.class_weight_train.append(class_weight_train_dict[index])
if self.test_size != 0:
class_weight_test_dict = class_weight_to_dict(
self.y_test[:, 0]['value'])
for index in self.y_test[:, 0]['value']:
self.class_weight_test.append(class_weight_test_dict[index])
def correct_data_features_values(self, k_best):
"""
Function that performs feature selection based on the importance of the features
Very controversial feature selection technique.
:param k_best: amount of the best features to retain
"""
if k_best:
test = SelectKBest(score_func=f_classif, k=k_best)
test.fit(self.df_features, self.parameter_dataframe)
self.df_features = test.transform(self.df_features)
self.dataframe = self.df_features.join(
self.parameter_dataframe, on=None, how='left',
lsuffix='', rsuffix='', sort=False
)
def make_sub_folder_path(self):
"""
Method which make sub folder path for classifier, based on init
parameters, which will contain all model training data.
Path will contain datetime and fingerprint data.
:return: path to sub folder
:rtype: str
"""
# get current datetime value
date_time = super().make_sub_folder_path()
# convert used fingerprints parameters to string
if self.fptypes:
all_fptypes_parameters = []
for fptype in self.fptypes:
fptype_parameters = '_'.join(map(str, list(fptype.values())))
all_fptypes_parameters.append(fptype_parameters)
fptype_parameters_as_string = '_'.join(all_fptypes_parameters)
else:
fptype_parameters_as_string = ''
# construct full sub folder path
folder_path = 'classification_{}_{}_{}'.format(
self.filename.split('.')[0], date_time,
fptype_parameters_as_string
)
return folder_path
def update_template_tags(self):
"""
Method which update basic template tags with keys needed for classifier
trainer
"""
self.template_tags['radar_plots'] = []
self.template_tags['confusion_matrixes'] = []
self.template_tags['roc_plots'] = []
self.template_tags['dataset'] += ' for classifier model training'
def make_report_text(self):
"""
Method which call report text generator for classifier.
Generator will update classifier template tags with needed for
training report parameters
"""
report_text_classifier(self)
class ClassicRegressor(Trainer):
def __init__(
self, filename, valuename, dataframe, manual_test_set=None,
test_set_size=0.2, n_split=4, seed=0, fptype=None, scale=None,
outliers_from_test=None, k_best=None, outliers_from_train=None,
output_path=None, sub_folder=None, log=False, top_important=None,
pca=None, var_threshold=None, z_score=None, subsample_size=1.0,
hyperopt_optimize=False, n_iter_optimize=100, opt_method='default'
):
self.top_important = top_important
self.outliers_from_test = outliers_from_test
self.model_type = REGRESSOR
super().__init__(
filename, valuename, dataframe, output_path=output_path, seed=seed,
test_set_size=test_set_size, fptypes=fptype, n_split=n_split,
scale=scale, sub_folder=sub_folder, pca=pca, z_score=z_score,
var_threshold=var_threshold, outliers_from_test=outliers_from_test,
k_best=k_best, outliers_from_train=outliers_from_train,
manual_test_set=manual_test_set, subsample_size=subsample_size,
hyperopt_optimize=hyperopt_optimize, opt_method=opt_method,
n_iter_optimize=n_iter_optimize
)
self.cv_model = ClassicRegressorCVFolds()
self.log = log
self.correct_by_top_important()
self.correct_by_log()
self.csv_formatter = '{:.4E}'.format
def calculate_trainer_modi(self):
self.modi = 0.75
def correct_by_log(self):
"""
Procedure that turns all the end-point values (Y) to
logY.
"""
if self.log:
self.y_train = numpy.log(self.y_train)
self.y_test = numpy.log(self.y_test)
def correct_by_top_important(self):
"""
Another controversial feature selection procedure,
based on the regression decision trees.
"""
if not self.top_important:
return
model = ExtraTreesRegressor()
model.fit(self.x_train, self.y_train)
rating_dict = {}
feat_imp = model.feature_importances_
for i in range(0, len(feat_imp)):
rating_dict[i] = feat_imp[i]
rating_list = sorted(rating_dict.items(), key=operator.itemgetter(1))
rating_list.reverse()
indices_list = [x[0] for x in rating_list[:self.top_important]]
self.x_train = self.x_train[:, indices_list]
if self.test_size != 0:
self.x_test = self.x_test[:, indices_list]
self.bins = self.top_important
joblib.dump(
model, '{}/{}_top_important.sav'.format(
self.sub_folder, self.filename.split('.')[0]
)
)
def correct_data_features_values(self, k_best):
"""
Clone.
"""
if k_best:
model = SelectKBest(score_func=f_regression, k=k_best)
model = model.fit(self.x_train, self.y_train)
self.x_train = model.transform(self.x_train)
self.x_test = model.transform(self.x_test)
self.bins = k_best
def make_sub_folder_path(self):
"""
Method which make sub folder path for regressor, based on init
parameters, which will contain all model training data.
Path will contain datetime, fingerprint, scaled, top important,
outliers and pca parametrs data.
:return: path to sub folder
:rtype: str
"""
# get current datetime value
date_time = super().make_sub_folder_path()
# convert used fingerprints parameters to string
if self.fptypes:
all_fptypes_parameters = []
for fptype in self.fptypes:
fptype_parameters = '_'.join(map(str, list(fptype.values())))
all_fptypes_parameters.append(fptype_parameters)
fptype_parameters_string = '_'.join(all_fptypes_parameters)
else:
fptype_parameters_string = ''
# convert other used parameters to string
scaled = 'scaled' if self.scale else ''
top = 'top_{}'.format(self.top_important) if self.top_important else ''
outliers = 'outliers' if self.outliers_from_test else ''
pca = 'pca_{}'.format(self.pca) if self.pca else ''
# construct full sub folder path
folder_path = 'regression_{}_{}_{}_{}_{}_{}_{}'.format(
self.filename.split('.')[0], date_time, fptype_parameters_string,
scaled, top, outliers, pca
)
return folder_path
def update_template_tags(self):
"""
Method which update basic template tags with keys needed for regressor
trainer
"""
self.template_tags['distribution_plots'] = []
self.template_tags['dataset'] += ' for regression model training'
self.template_tags['regression_result_test'] = []
self.template_tags['regression_result_train'] = []
def make_report_text(self):
"""
Method which call report text generator for regressor.
Generator will update regressor template tags with needed for
training report parameters
"""
report_text_regressor(self)
def post_plots(self, body, oauth):
"""
Method which make plots for model, then POST plots to blob storage
:param body: rabbitmq message body
:param oauth: OAuth2 object
:type body: dict
"""
# make needed for model plots
self.plots = self.cv_model.make_plots()
for k_fold_number, plots in self.plots.items():
# make test regression results plot multipart encoded object
regression_results_test_info = {
'FileInfo': json.dumps({
'modelName': self.cv_model.model_name,
'fileType': REGRESSION_RESULT_TEST
}),
'ParentId': body['CurrentModelId']
}
regression_results_test = get_multipart_object(
body, plots['regression_results_test'], 'image/png',
additional_fields=regression_results_test_info
)
# POST to blob storage api with test regression results
post_data_to_blob(oauth, regression_results_test)
body['NumberOfGenericFiles'] += 1
# make train regression results plot multipart encoded object
regression_results_train_info = {
'FileInfo': json.dumps({
'modelName': self.cv_model.model_name,
'fileType': REGRESSION_RESULT_TRAIN
}),
'ParentId': body['CurrentModelId']
}
regression_results_train = get_multipart_object(
body, plots['regression_results_train'], 'image/png',
additional_fields=regression_results_train_info
)
# POST to blob storage api with train regression results
post_data_to_blob(oauth, regression_results_train)
body['NumberOfGenericFiles'] += 1
# update template tags with model's plots
self.template_tags['regression_result_test'].append(
plots['regression_results_test'])
self.template_tags['regression_result_train'].append(
plots['regression_results_train'])
class DNNClassifier(ClassicClassifier):
def __init__(
self, filename, classname, dataframe, test_set_size=0.2, seed=7,
subsample_size=1.0, n_split=4, fptype=None, output_path=None,
sub_folder=None, k_best=None, scale=None, opt_method='default',
manual_test_set=None, n_iter_optimize=100
):
self.model_type = CLASSIFIER
super().__init__(
filename, classname, dataframe, test_set_size=test_set_size,
seed=seed, subsample_size=subsample_size, n_split=n_split,
fptype=fptype, output_path=output_path, sub_folder=sub_folder,
k_best=k_best, scale=scale, manual_test_set=manual_test_set,
opt_method=opt_method, n_iter_optimize=n_iter_optimize
)
self.cv_model = DNNClassifierCVFolds()
def store_folds_trainings_data(self, training_time_minutes):
"""
Method to dump (save to file) trained folds model (*.sav or *.h5) files
:param training_time_minutes: time spent to train model (minutes)
:type training_time_minutes: float
"""
# write trained models data to files
for number, model in enumerate(self.cv_model.models):
model.training_time = training_time_minutes
model.model_name = self.model_name
def train_k_fold_models(
self, training_function, arguments, optimal_parameters
):
"""
Method for train all folds of chosen model
:param training_function: model training function
:param arguments: additional model arguments for "fit"
:param optimal_parameters: optimal parameters for training
:type arguments: dict
"""
fold_number = 1
for train_ids, valid_ids in self.cv_valid_ids:
# define using subdataframes
x_train = self.x_train[train_ids]
y_train = self.y_train[train_ids]
x_valid = self.x_train[valid_ids]
y_valid = self.y_train[valid_ids]
# change validation data type if used
if 'validation_data' in arguments.keys():
arguments['validation_data'] = (
x_valid['value'], y_valid['value']
)
# set path to save best DNN model of current fold
path_to_model = os.path.join(
self.sub_folder, 'TMP_CLASSIFIER_DNN_FOLD_{}.h5'.format(
fold_number
)
)
checkpointer = ModelCheckpoint(
filepath=path_to_model, verbose=1, save_best_only=True)
arguments['callbacks'].append(checkpointer)
training_function_copy = self.make_training_function(
optimal_parameters)
# copy training method to avoid chain "fit"
training_function_copy.fit(
x_train['value'], y_train['value'], **arguments
)
model = load_model(
path_to_model,
custom_objects={'coeff_determination': coeff_determination}
)
# define trained model object
trained_model = self.cv_model.fold_class(
model=model, model_type=self.cv_model.model_type,
x_test=self.x_test, y_test=self.y_test,
x_train=x_train, y_train=y_train,
x_valid=x_valid, y_valid=y_valid,
prediction_target=self.prediction_target,
sub_folder=self.sub_folder
)
trained_model.path_to_model_file = path_to_model
self.cv_model.models.append(trained_model)
fold_number += 1
arguments['callbacks'].remove(checkpointer)
del training_function_copy
del model
def make_sub_folder_path(self):
"""
Method which make sub folder path for classifier, based on init
parameters, which will contain all model training data.
Path will contain datetime and fingerprint data.
:return: path to sub folder
:rtype: str
"""
classifying_folder_path = super().make_sub_folder_path()
folder_path = 'DNN_{}'.format(classifying_folder_path)
return folder_path
class DNNRegressor(ClassicRegressor):
def __init__(
self, filename, valuename, dataframe, manual_test_set=None,
test_set_size=0.2, n_split=4, seed=0, fptype=None, scale=None,
outliers_from_test=None, k_best=None, outliers_from_train=None,
output_path=None, sub_folder=None, log=False, top_important=None,
pca=None, var_threshold=None, z_score=None, subsample_size=1.0,
n_iter_optimize=100, opt_method='default'
):
self.model_type = REGRESSOR
super().__init__(
filename, valuename, dataframe, manual_test_set=manual_test_set,
test_set_size=test_set_size, n_split=n_split, seed=seed, pca=pca,
fptype=fptype, scale=scale, outliers_from_test=outliers_from_test,
k_best=k_best, outliers_from_train=outliers_from_train, log=log,
output_path=output_path, sub_folder=sub_folder, z_score=z_score,
top_important=top_important, var_threshold=var_threshold,
subsample_size=subsample_size, opt_method=opt_method,
n_iter_optimize=n_iter_optimize
)
self.cv_model = DNNRegressorCVFolds()
def store_folds_trainings_data(self, training_time_minutes):
"""
Method to dump (save to file) trained folds model (*.sav or *.h5) files
:param training_time_minutes: time spent to train model (minutes)
:type training_time_minutes: float
"""
# write trained models data to files
for number, model in enumerate(self.cv_model.models):
model.training_time = training_time_minutes
model.model_name = self.model_name
def train_k_fold_models(
self, training_function, arguments, optimal_parameters
):
"""
Method for train all folds of chosen model
:param training_function: model training function
:param arguments: additional model arguments for "fit"
:param optimal_parameters: optimal parameters for training
:type arguments: dict
"""
fold_number = 1
for train_ids, valid_ids in self.cv_valid_ids:
# define using subdataframes
x_train = self.x_train[train_ids]
y_train = self.y_train[train_ids]
x_valid = self.x_train[valid_ids]
y_valid = self.y_train[valid_ids]
# change validation data type if used
if 'validation_data' in arguments.keys():
arguments['validation_data'] = (
x_valid['value'], y_valid['value']
)
# set path to save best DNN model of current fold
path_to_model = os.path.join(
self.sub_folder, 'TMP_REGRESSION_DNN_FOLD_{}.h5'.format(
fold_number
)
)
checkpointer = ModelCheckpoint(
filepath=path_to_model, monitor='val_loss', verbose=1,
save_best_only=True
)
arguments['callbacks'].append(checkpointer)
training_function_copy = self.make_training_function(
optimal_parameters)
# copy training method to avoid chain "fit"
training_function_copy.fit(
x_train['value'], y_train['value'], **arguments
)
model = load_model(
path_to_model,
custom_objects={'coeff_determination': coeff_determination}
)
# define trained model object
trained_model = self.cv_model.fold_class(
model=model, model_type=self.cv_model.model_type,
x_test=self.x_test, y_test=self.y_test,
x_train=x_train, y_train=y_train,
x_valid=x_valid, y_valid=y_valid,
prediction_target=self.prediction_target,
sub_folder=self.sub_folder
)
trained_model.path_to_model_file = path_to_model
self.cv_model.models.append(trained_model)
fold_number += 1
arguments['callbacks'].remove(checkpointer)
del training_function_copy
del model
def make_sub_folder_path(self):
"""
Method which make sub folder path for regressor, based on init
parameters, which will contain all model training data.
Path will contain datetime, fingerprint, scaled, top important,
outliers and pca parametrs data.
:return: path to sub folder
:rtype: str
"""
regression_folder_path = super().make_sub_folder_path()
folder_path = 'DNN_{}'.format(regression_folder_path)
return folder_path
class ClassicMultiClassifier(Trainer):
def __init__(
self, filename, classname, dataframe, test_set_size=0.2, seed=7,
major_subsample=0.2, n_split=4, fptype=None, output_path=None,
sub_folder=None, k_best=None, scale=None
):
super().__init__(
filename, classname, dataframe, output_path=output_path, seed=seed,
test_set_size=test_set_size, fptypes=fptype, n_split=n_split,
scale=scale, sub_folder=sub_folder
)
self.cv_model = ClassicMultiClassifierCVFolds()
def post_plots(self, body, oauth):
"""
Method which make plots, then POST plots to blob storage
:param body: rabbitmq message body
:param oauth: OAuth2 object
"""
# make needed for model plots
self.plots = self.cv_model.make_plots()
for k_fold_number, plots in self.plots.items():
# make ROC plot multipart encoded object
roc_info = {
'FileInfo': json.dumps({
'modelName': self.cv_model.model_name,
'fileType': ROC_PLOT
}),
'ParentId': body['CurrentModelId']
}
multipart_roc = get_multipart_object(
body, plots['roc_plot_path'], 'image/png',
additional_fields=roc_info
)
# send, http POST request to blob storage api with ROC plot
post_data_to_blob(oauth, multipart_roc)
body['NumberOfGenericFiles'] += 1
# make confusion matrix multipart encoded object
confusion_matrix_info = {
'FileInfo': json.dumps({
'modelName': self.cv_model.model_name,
'fileType': CONFUSION_MATRIX
}),
'ParentId': body['CurrentModelId']
}
multipart_cm = get_multipart_object(
body, plots['cm_plot_path'], 'image/png',
additional_fields=confusion_matrix_info
)
# send, http POST request to blob storage api with confusion matrix
post_data_to_blob(oauth, multipart_cm)
body['NumberOfGenericFiles'] += 1
# update template tags with model's plots
self.template_tags['confusion_matrixes'].append(
plots['cm_plot_path'])
self.template_tags['roc_plots'].append(
plots['roc_plot_path'])
def correct_data_features_values(self, k_best):
"""
another clone.
:param k_best:
"""
if k_best:
test = SelectKBest(score_func=f_classif, k=k_best)
test.fit(self.df_features, self.parameter_dataframe)
self.df_features = pandas.DataFrame(
test.transform(self.df_features))
self.dataframe = self.df_features.join(
self.parameter_dataframe, on=None, how='left',
lsuffix='', rsuffix='', sort=False
)
def make_sub_folder_path(self):
"""
Method which make sub folder path for classifier, based on init
parameters, which will contain all model training data.
Path will contain datetime and fingerprint data.
:return: path to sub folder
:rtype: str
"""
# get current datetime value
date_time = super().make_sub_folder_path()
# convert used fingerprints parameters to string
if self.fptypes:
all_fptypes_parameters = []
for fptype in self.fptypes:
fptype_parameters = '_'.join(map(str, list(fptype.values())))
all_fptypes_parameters.append(fptype_parameters)
fptype_parameters_as_string = '_'.join(all_fptypes_parameters)
else:
fptype_parameters_as_string = ''
# construct full sub folder path
folder_path = 'classification_{}_{}_{}'.format(
self.filename.split('.')[0], date_time,
fptype_parameters_as_string
)
return folder_path
def update_template_tags(self):
"""
Method which update basic template tags with keys needed for classifier
trainer
"""
self.template_tags['radar_plots'] = []
self.template_tags['confusion_matrixes'] = []
self.template_tags['roc_plots'] = []
self.template_tags['dataset'] += ' for classifier model training'
def make_report_text(self):
"""
Method which call report text generator for classifier.
Generator will update classifier template tags with needed for
training report parameters
"""
report_text_classifier(self)
class ClassicMultiRegressor(Trainer):
def __init__(
self, filename, valuename, dataframe, manual_test_set=None,
test_set_size=0.2, n_split=4, seed=0, fptype=None, scale=None,
outliers_from_test=None, k_best=None, outliers_from_train=None,
output_path=None, sub_folder=None, log=False, top_important=None,
pca=None, var_threshold=None, z_score=None
):
self.top_important = top_important
self.outliers_from_test = outliers_from_test
self.pca = pca
super().__init__(
filename, valuename, dataframe, output_path=output_path, seed=seed,
test_set_size=test_set_size, fptypes=fptype, n_split=n_split,
scale=scale, sub_folder=sub_folder
)
self.cv_model = ClassicMultiRegressorCVFolds()
self.model_type = MULTI_REGRESSOR
self.model_algorithm = CLASSIC
self.manual_test_set = manual_test_set
self.threshold = var_threshold
self.log = log
self.sub_folder = self.make_sub_folder(sub_folder, output_path)
make_directory(self.sub_folder)
self.update_template_tags()
# self.correct_dataframe_with_z_score(z_score)
self.sub_dataframe_value = numpy.vstack(
(self.dataframe[self.prediction_target],)
).T
self.bins = dataframe.shape[1] - len(valuename)
self.split_dataframes()
self.csv_formatter = '{:.4E}'.format
self.apply_cross_validation()
self.path_to_scaler = self.apply_scaler()
def correct_by_log(self):
"""
another clone.
"""
if self.log:
self.y_train = numpy.log(self.y_train)
self.y_test = numpy.log(self.y_test)
def correct_by_top_important(self):
"""
another clone
"""
if not self.top_important:
return
model = ExtraTreesRegressor()
model.fit(self.x_train, self.y_train)
rating_dict = {}
feat_imp = model.feature_importances_
for i in range(0, len(feat_imp)):
rating_dict[i] = feat_imp[i]
rating_list = sorted(rating_dict.items(), key=operator.itemgetter(1))
rating_list.reverse()
indices_list = [x[0] for x in rating_list[:self.top_important]]
self.x_train = self.x_train[:, indices_list]
if self.test_size != 0:
self.x_test = self.x_test[:, indices_list]
self.bins = self.top_important
joblib.dump(
model, '{}/{}_top_important.sav'.format(
self.sub_folder, self.filename.split('.')[0]
)
)
def correct_data_features_values(self, k_best):
"""
clone
"""
# TODO MAKE DOCSTRINGS THERE
if k_best:
model = SelectKBest(score_func=f_regression, k=k_best)
model = model.fit(self.x_train, self.y_train)
self.x_train = model.transform(self.x_train)
self.x_test = model.transform(self.x_test)
self.bins = k_best
def apply_outliers(self, outlier, x_attribute, y_attribute):
"""
another clone
:param outlier:
:param x_attribute:
:param y_attribute:
"""
if not outlier:
return
iso_for = IsolationForest().fit(self.x_train)
outliers_train = []
x_value = getattr(self, x_attribute)
y_value = getattr(self, y_attribute)
for i in range(x_value.shape[0]):
if iso_for.predict(x_value[i, :].reshape(1, -1)) == -1:
outliers_train.append(i)
x_value = numpy.delete(x_value, outliers_train, axis=0)
y_value = numpy.delete(y_value, outliers_train, axis=0)
setattr(self, x_attribute, x_value)
setattr(self, y_attribute, y_value)
def split_dataframes(self):
"""
"""
# TODO MAKE DOCSTRINGS THERE
if self.test_size == 0:
self.x_train = pandas.DataFrame(self.dataframe.ix[:, 0:(self.bins)])#.as_matrix())
self.y_train = | pandas.DataFrame(self.sub_dataframe_value) | pandas.DataFrame |
"""
Copyright 2020 The Google Earth Engine Community Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
from absl import app
from absl import logging
import h5py
import numpy as np
import pandas as pd
import os
meta_variables = (
'cover',
'pai',
'fhd_normal',
'pgap_theta',
'beam',
'shot_number',
'l2b_quality_flag',
'algorithmrun_flag',
'selected_rg_algorithm',
'selected_l2a_algorithm',
'sensitivity',
'geolocation/degrade_flag',
'geolocation/delta_time',
'geolocation/lat_lowestmode',
'geolocation/lon_lowestmode',
'geolocation/local_beam_azimuth',
'geolocation/local_beam_elevation',
'geolocation/solar_azimuth',
'geolocation/solar_elevation',
)
cover_names = [f'cover_z{d}' for d in range(30)]
pai_names = [f'pai_z{d}' for d in range(30)]
pavd_names = [f'pavd_z{d}' for d in range(30)]
# pylint:disable=line-too-long
def extract_values(input_path, output_path):
"""Extracts all relative height values from all algorithms and some qa flags.
Args:
input_path: string, GEDI L2B file path
output_path: string, csv output file path
"""
basename = os.path.basename(input_path)
if not basename.startswith('GEDI') or not basename.endswith('.h5'):
logging.error('Input path is not a GEDI filename: %s', input_path)
return
with h5py.File(input_path, 'r') as hdf_fh:
with open(output_path, 'w') as csv_fh:
write_csv(hdf_fh, csv_fh)
def write_csv(hdf_fh, csv_file):
"""Writes a single CSV file based on the contents of HDF file."""
is_first = True
# Iterating over metrics using a height profile defined for 30 slices.
for k in hdf_fh.keys():
if not k.startswith('BEAM'):
continue
print('\t', k)
df = pd.DataFrame()
for v in meta_variables:
if v.startswith('#'):
continue
name = v.split('/')[-1]
ds = hdf_fh[f'{k}/{v}']
df[name] = ds[:]
df[name].replace([np.inf, -np.inf], np.nan, inplace=True)
if ds.attrs.get('_FillValue') is not None:
# We need to use pd.NA that works with integer types (np.nan does not)
df[name].replace(ds.attrs.get('_FillValue'), pd.NA, inplace=True)
ds = hdf_fh[f'{k}/cover_z']
cover_z = pd.DataFrame(ds, columns=cover_names)
cover_z.replace(ds.attrs.get('_FillValue'), np.nan, True)
ds = hdf_fh[f'{k}/pai_z']
pai_z = pd.DataFrame(ds, columns=pai_names)
pai_z.replace(ds.attrs.get('_FillValue'), np.nan, True)
ds = hdf_fh[f'{k}/pavd_z']
pavd_z = pd.DataFrame(ds, columns=pavd_names)
pavd_z.replace(ds.attrs.get('_FillValue'), np.nan, True)
df = pd.concat((df, cover_z), axis=1)
df = | pd.concat((df, pai_z), axis=1) | pandas.concat |
"""Remotely control your Binance account via their API : https://binance-docs.github.io/apidocs/spot/en"""
import re
import json
import hmac
import hashlib
import time
import requests
import base64
import sys
import math
import pandas as pd
import numpy as np
from numpy import floor
from datetime import datetime, timedelta
from requests.auth import AuthBase
from requests import Request, Session
from models.helper.LogHelper import Logger
from urllib.parse import urlencode
DEFAULT_MAKER_FEE_RATE = 0.0015 # added 0.0005 to allow for price movements
DEFAULT_TAKER_FEE_RATE = 0.0015 # added 0.0005 to allow for price movements
DEFAULT_TRADE_FEE_RATE = 0.0015 # added 0.0005 to allow for price movements
DEFAULT_GRANULARITY = "1h"
SUPPORTED_GRANULARITY = ["1m", "5m", "15m", "1h", "6h", "1d"]
MULTIPLIER_EQUIVALENTS = [1, 5, 15, 60, 360, 1440]
FREQUENCY_EQUIVALENTS = ["T", "5T", "15T", "H", "6H", "D"]
DEFAULT_MARKET = "BTCGBP"
class AuthAPIBase:
def _isMarketValid(self, market: str) -> bool:
p = re.compile(r"^[A-Z0-9]{5,12}$")
if p.match(market):
return True
return False
def convert_time(self, epoch: int = 0):
if math.isnan(epoch) is False:
epoch_str = str(epoch)[0:10]
return datetime.fromtimestamp(int(epoch_str))
class AuthAPI(AuthAPIBase):
def __init__(
self,
api_key: str = "",
api_secret: str = "",
api_url: str = "https://api.binance.com",
order_history: list = [],
recv_window: int = 5000,
) -> None:
"""Binance API object model
Parameters
----------
api_key : str
Your Binance account portfolio API key
api_secret : str
Your Binance account portfolio API secret
api_url
Binance API URL
"""
# options
self.debug = False
self.die_on_api_error = False
valid_urls = [
"https://api.binance.com",
"https://api.binance.us",
"https://testnet.binance.vision",
]
# validate Binance API
if api_url not in valid_urls:
raise ValueError("Binance API URL is invalid")
# validates the api key is syntactically correct
p = re.compile(r"^[A-z0-9]{64,64}$")
if not p.match(api_key):
self.handle_init_error("Binance API key is invalid")
# validates the api secret is syntactically correct
p = re.compile(r"^[A-z0-9]{64,64}$")
if not p.match(api_secret):
self.handle_init_error("Binance API secret is invalid")
self._api_key = api_key
self._api_secret = api_secret
self._api_url = api_url
# order history
self.order_history = order_history
# api recvWindow
self.recv_window = recv_window
def handle_init_error(self, err: str) -> None:
if self.debug:
raise TypeError(err)
else:
raise SystemExit(err)
def _dispatch_request(self, method: str):
session = Session()
session.headers.update(
{
"Content-Type": "application/json; charset=utf-8",
"X-MBX-APIKEY": self._api_key,
}
)
return {
"GET": session.get,
"DELETE": session.delete,
"PUT": session.put,
"POST": session.post,
}.get(method, "GET")
def createHash(self, uri: str = ""):
return hmac.new(
self._api_secret.encode("utf-8"), uri.encode("utf-8"), hashlib.sha256
).hexdigest()
def getTimestamp(self):
return int(time.time() * 1000)
def getAccounts(self) -> pd.DataFrame:
"""Retrieves your list of accounts"""
# GET /api/v3/account
try:
resp = self.authAPI(
"GET", "/api/v3/account", {"recvWindow": self.recv_window}
)
# unexpected data, then return
if len(resp) == 0 or "balances" not in resp:
return pd.DataFrame()
if isinstance(resp["balances"], list):
df = pd.DataFrame.from_dict(resp["balances"])
else:
df = pd.DataFrame(resp["balances"], index=[0])
# unexpected data, then return
if len(df) == 0:
return pd.DataFrame()
# exclude accounts that are locked
df = df[df.locked != 0.0]
df["locked"] = df["locked"].astype(bool)
# reset the dataframe index to start from 0
df = df.reset_index()
df["id"] = df["index"]
df["hold"] = 0.0
df["profile_id"] = None
df["available"] = df["free"]
df["id"] = df["id"].astype(object)
df["hold"] = df["hold"].astype(object)
# exclude accounts with a nil balance
df = df[df.available != "0.00000000"]
df = df[df.available != "0.00"]
# inconsistent columns, then return
if len(df.columns) != 8:
return | pd.DataFrame() | pandas.DataFrame |
"""dev_env_for_beta_app"""
code='dev_env_for_beta_app'
from elasticsearch import Elasticsearch
es = Elasticsearch([{'host': 'elastic-helm-elasticsearch-coordinating-only'}])
sample_user_id='607077a405164b0001e72f69'
log='https://apibeta.bighaat.com/crop/api/logerror/create-recommendation-error-log?message={}&api-version=1.0'
"""local_beta_app"""
#code='local_app_beta'
#from elasticsearch import Elasticsearch
#es = Elasticsearch([{'host': 'localhost', 'port': 9200}])
#sample_user_id='607077a405164b0001e72f69'
#log='https://apibeta.bighaat.com/crop/api/logerror/create-recommendation-error-log?message={}&api-version=1.0'
"""local_prod_app"""
#code='local_app_prod'
#from elasticsearch import Elasticsearch
#es = Elasticsearch([{'host': 'localhost', 'port': 9200}])
#sample_user_id='5fb0ced5cd15bf00013f68d0'
#log='https://api.bighaat.com/crop/api/logerror/create-recommendation-error-log?message={}&api-version=1.0'
"""beta_env_for_prod_app"""
#code='beta_env_for_prod_app'
#from elasticsearch import Elasticsearch
#es = Elasticsearch([{'host': 'elastic-helm-elasticsearch-coordinating-only'}])
#sample_user_id='5fb0ced5cd15bf00013f68d0'
#log='https://api.bighaat.com/crop/api/logerror/create-recommendation-error-log?message={}&api-version=1.0'
"""prod_env_for_prod_app"""
#code='prod_env_for_prod_app'
#from elasticsearch import Elasticsearch
#es = Elasticsearch([{'host': 'elastic-helm-elasticsearch-coordinating-only'}])
#sample_user_id='5fb0ced5cd15bf00013f68d0'
#log='https://api.bighaat.com/crop/api/logerror/create-recommendation-error-log?message={}&api-version=1.0'
auth={'apiKey': '135BE3F9-B1D8-4A14-A999-303286C32275'}
from flask import Flask
app = Flask(__name__)
from pandas.io.json import json_normalize
#import numpy as np
import pandas as pd
from nltk.corpus import stopwords
#import random
import time
#from datetime import datetime,timedelta
STOP_WORDS=stopwords.words('english')
#es = Elasticsearch('https://prodelastic.bighaat.cf/')
#es = Elasticsearch([{'host': 'elastic-helm-elasticsearch-coordinating-only'}])
#es = Elasticsearch("https://elastic:[email protected]:9200/", verify_certs=False, connection_class=RequestsHttpConnection)
from flask import request
import warnings
warnings.filterwarnings("ignore")
from elasticsearch.helpers import scan
import requests
import datetime
def logger(message):
message_dict={
'code':code,
'message':message}
r=requests.post(log.format(str(message_dict)),headers=auth)
return r.text
def big_read(index):
es_response = scan(
es,
index=index,
doc_type='_doc',
query={"query": { "match_all" : {}}}
)
return es_response
#global_user={}
#res = es.search(index="users_sync", body={"size":10000,"query":{"match_all":{}}})
#users = json_normalize(res['hits']['hits'])
def cropDocRecommend(u):
try:
logger("CropDoc started for user:"+u)
userId=u
b={
'query':{
'match':{"_id": userId}
}
}
res = es.search(index="crop_doc_disease", body=b)
q=res['hits']['hits'][0]['_source']['0']
if q==None:
logger("Exit CropDoc for user:"+u+"with 0 results")
return {'total_cd':[]}
"""3 latest disease searched by user in crop doc"""
# q=",".join(q[-3:])
q=q.split(",")
if ' ' in q:
q.remove(' ')
q=q[-3:]
#q='Vkasetu'
q1=[w for w in q if not w in STOP_WORDS]
should1=[]
for i in q1:
should1.append({
"fuzzy":{"title": {"value":i,"fuzziness":10}}
})
b1={
"query": {
"bool": {
"should": should1,
"must":{'match':{'isDeleted':False }}
}
}
}
post_dict_list=[]
res1= es.search(index='posts_search_sync',body=b1)
print("Keyword Search:\n")
for hit in res1['hits']['hits']:
# print(str(hit['_score']) + "\t" + hit['_source']['title'])
post_dict_list.append({'score_post':hit['_score'],'postId':hit['_id'],'postTitle_post':hit['_source']['title']})
q2=[w for w in q if not w in STOP_WORDS]
should2=[]
for i in q2:
should2.append({
"fuzzy":{"comment": {"value":i,"fuzziness":10}}
})
b2={
"query": {
"bool": {
"should": should2,
"must":{'match':{'isDeleted':False }}
}
}
}
comment_dict_list=[]=[]
res2= es.search(index='comments_sync',body=b2)
for hit in res2['hits']['hits']:
# print(str(hit['_score']) + "\t" + hit['_source']['postId']+"\t" + hit['_source']['comment'] )
b={
'query':{
'match':{"_id":hit['_source']['postId'] }
}
}
try:
p=es.search(index='posts_sync',body=b)['hits']['hits'][0]['_source']['title']
comment_dict_list.append({'score_comment':hit['_score'],'postId':hit['_source']['postId'],'postTitle_comment':p,'comment':hit['_source']['comment']})
except:
print("Comment's post is deleted")
q3=[w for w in q if not w in STOP_WORDS]
should3=[]
for i in q3:
should3.append({
"fuzzy":{"description": {"value":i,"fuzziness":10}}
})
b3={
"query": {
"bool": {
"should": should3,
"must":{'match':{'isDeleted':False }}
}
}
}
description_dict_list=[]
res3= es.search(index='posts_search_sync',body=b3)
# print("Keyword Search:\n")
for hit in res3['hits']['hits']:
# print(str(hit['_score']) + "\t" + hit['_source']['title'])
description_dict_list.append({'score_description':hit['_score'],'postId':hit['_id'],'postTitle_description':hit['_source']['title'],'description':hit['_source']['description']})
if len(post_dict_list)!=0:
df1=pd.DataFrame(post_dict_list)
else:
df1=pd.DataFrame(columns=['score_post', 'postId', 'postTitle_post'])
if len(description_dict_list)!=0:
df2=pd.DataFrame(description_dict_list)
else:
df2=pd.DataFrame(columns=['score_description', 'postId', 'postTitle_description','description'])
if len(comment_dict_list)!=0:
df3=pd.DataFrame(comment_dict_list)
else:
df3=pd.DataFrame(columns=['score_comment', 'postId', 'postTitle_comment', 'comment'])
combo_pcd=df1.merge(df2,how='inner',on='postId').merge(df3,how='inner',on='postId')
combo_pd=df1.merge(df2,how='inner',on='postId')
combo_pc=df1.merge(df3,how='inner',on='postId')
combo_cd=df2.merge(df3,how='inner',on='postId')
id_top=list(combo_pcd['postId'])+list(combo_pd['postId'])+list(combo_pc['postId'])+list(combo_cd['postId'])
combo=pd.concat([combo_pcd,combo_pd,combo_pc,combo_cd])
df1=df1[df1['postId'].apply(lambda x: x not in id_top)]
df2=df2[df2['postId'].apply(lambda x: x not in id_top)]
df3=df3[df3['postId'].apply(lambda x: x not in id_top)]
final=pd.concat([combo,df1,df2,df3])
# final=final[start:fraction_size]
# print(final['postId'].tolist(),'cropdoc')
logger("Exit CropDoc for user:"+u+"with"+str(len(final['postId']))+" "+str(final['postId']))
return {'total_cd':final['postId'].tolist()}
except Exception as e:
logger("Some error in corpdoc "+str(e))
def user_profile_activity(posts_vec,u):
try:
logger("Started Profile_activity recom for usser"+u)
user_id=u
# logger(str(total_cd))
b={
'query':{
'match':{"_id": user_id}
}
}
vec_user=es.search(body=b,index='users_profile_vec')['hits']['hits'][0]['_source']
vec_user_activity=es.search(body=b,index='users_activity_vec')['hits']['hits'][0]['_source']
b={
'query':{
'match':{"_id": "aabab"}
}
}
col_names=es.search(index="cols", body=b)['hits']['hits'][0]['_source']
language=col_names['language'].split(",")
crop_names=col_names['crop_names'].split(",")
for i in vec_user:
pass
vec_user[i]=[vec_user[i]]
lan=pd.DataFrame.from_dict(vec_user)[language]
if lan.sum().sum()!=0:
lan=lan.div(lan.sum(axis=1),axis=0)
crops=pd.DataFrame.from_dict(vec_user)[crop_names]
if crops.sum().sum()!=0:
crops=crops.div(crops.sum(axis=1),axis=0)
vec_user=pd.concat([pd.DataFrame.from_dict(vec_user)[['x','y']],lan,crops],axis=1)
for i in vec_user_activity:
pass
vec_user_activity[i]=[vec_user_activity[i]]
lan= | pd.DataFrame.from_dict(vec_user_activity) | pandas.DataFrame.from_dict |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu June 7 22:33:07 2019
@author: bruce
"""
import pandas as pd
import numpy as np
from scipy import fftpack
from scipy import signal
from scipy import stats
import matplotlib.pyplot as plt
import os
# set saving path
path_result_freq = "/home/bruce/Dropbox/Project/5.Result/5.Result_Nov/2.freq_domain/"
def correlation_matrix(corr_mx, cm_title):
fig = plt.figure()
ax1 = fig.add_subplot(111)
#cmap = cm.get_cmap('jet', 30)
cax = ax1.matshow(corr_mx, cmap='gray')
#cax = ax1.imshow(df.corr(), interpolation="nearest", cmap=cmap)
fig.colorbar(cax)
ax1.grid(False)
plt.title(cm_title)
#plt.title('cross correlation of test and retest')
ylabels = ['T1','T2','T3','T4','T6','T7','T8','T9', 'T11', 'T12', 'T13', 'T14',
'T15', 'T16', 'T17', 'T18', 'T19', 'T20', 'T21', 'T22', 'T23', 'T25']
xlabels = ['R1','R2','R3','R4','R6','R7','R8','R9', 'R11', 'R12', 'R13', 'R14',
'R15', 'R16', 'R17', 'R18', 'R19', 'R20', 'R21', 'R22', 'R23', 'R25']
ax1.set_xticks(np.arange(len(xlabels)))
ax1.set_yticks(np.arange(len(ylabels)))
ax1.set_xticklabels(xlabels,fontsize=6)
ax1.set_yticklabels(ylabels,fontsize=6)
# Add colorbar, make sure to specify tick locations to match desired ticklabels
#fig.colorbar(cax, ticks=[.75,.8,.85,.90,.95,1])
plt.show()
def correlation_matrix_01(corr_mx, cm_title):
# find the maximum in each row
# input corr_mx is a dataframe
# need to convert it into a array first
# otherwise it is not working
temp = np.asarray(corr_mx)
output = (temp == temp.max(axis=1)[:,None]) # along rows
fig = plt.figure()
ax1 = fig.add_subplot(111)
# cmap = cm.get_cmap('jet', 30)
cax = ax1.matshow(output, cmap='binary')
# cax = ax1.imshow(df.corr(), interpolation="nearest", cmap=cmap)
# fig.colorbar(cax)
ax1.grid(False)
plt.title(cm_title)
ylabels=['T1','T2','T3','T4','T6','T7','T8','T9', 'T11', 'T12', 'T13', 'T14',
'T15', 'T16', 'T17', 'T18', 'T19', 'T20', 'T21', 'T22', 'T23', 'T25']
xlabels=['R1','R2','R3','R4','R6','R7','R8','R9', 'R11', 'R12', 'R13', 'R14',
'R15', 'R16', 'R17', 'R18', 'R19', 'R20', 'R21', 'R22', 'R23', 'R25']
ax1.set_xticks(np.arange(len(xlabels)))
ax1.set_yticks(np.arange(len(ylabels)))
ax1.set_xticklabels(xlabels,fontsize=6)
ax1.set_yticklabels(ylabels,fontsize=6)
plt.show()
def correlation_matrix_min_01_comb(corr_mx1 ,corr_mx2, cm_title1, cm_title2):
# find the minimum in each row
# input corr_mx is a dataframe
# need to convert it into a array first
# otherwise it is not working
temp = np.asarray(corr_mx1)
output1 = (temp == temp.min(axis=1)[:,None]) # along rows
temp = np.asarray(corr_mx2)
output2 = (temp == temp.min(axis=1)[:,None]) # along rows
fig, (ax1, ax2) = plt.subplots(1, 2)
# figure 1
im1 = ax1.matshow(output1, cmap='binary')
#fig.colorbar(im1, ax1)
ax1.grid(False)
ax1.set_title(cm_title1)
ylabels=['T1','T2','T3','T4','T6','T7','T8','T9', 'T11', 'T12', 'T13', 'T14',
'T15', 'T16', 'T17', 'T18', 'T19', 'T20', 'T21', 'T22', 'T23', 'T25']
xlabels=['R1','R2','R3','R4','R6','R7','R8','R9', 'R11', 'R12', 'R13', 'R14',
'R15', 'R16', 'R17', 'R18', 'R19', 'R20', 'R21', 'R22', 'R23', 'R25']
ax1.set_xticks(np.arange(len(xlabels)))
ax1.set_yticks(np.arange(len(ylabels)))
ax1.set_xticklabels(xlabels,fontsize=6)
ax1.set_yticklabels(ylabels,fontsize=6)
# figure 2
im2 = ax2.matshow(output2, cmap='binary')
#fig.colorbar(im2, ax2)
ax2.grid(False)
ax2.set_title(cm_title2)
ylabels=['T1','T2','T3','T4','T6','T7','T8','T9', 'T11', 'T12', 'T13', 'T14',
'T15', 'T16', 'T17', 'T18', 'T19', 'T20', 'T21', 'T22', 'T23', 'T25']
xlabels=['R1','R2','R3','R4','R6','R7','R8','R9', 'R11', 'R12', 'R13', 'R14',
'R15', 'R16', 'R17', 'R18', 'R19', 'R20', 'R21', 'R22', 'R23', 'R25']
ax2.set_xticks(np.arange(len(xlabels)))
ax2.set_yticks(np.arange(len(ylabels)))
ax2.set_xticklabels(xlabels,fontsize=6)
ax2.set_yticklabels(ylabels,fontsize=6)
plt.show()
def correlation_matrix_tt_01(corr_mx, cm_title):
# find the maximum in each row
# input corr_mx is a dataframe
# need to convert it into a array first
# otherwise it is not working
temp = np.asarray(corr_mx)
output = (temp == temp.max(axis=1)[:,None]) # along rows
fig = plt.figure()
ax1 = fig.add_subplot(111)
#cmap = cm.get_cmap('jet', 30)
cax = ax1.matshow(output, cmap='gray')
#cax = ax1.imshow(df.corr(), interpolation="nearest", cmap=cmap)
fig.colorbar(cax)
ax1.grid(False)
plt.title(cm_title)
ylabels=['T1','T2','T3','T4','T6','T7','T8','T9', 'T11', 'T12', 'T13', 'T14',
'T15', 'T16', 'T17', 'T18', 'T19', 'T20', 'T21', 'T22', 'T23', 'T25']
xlabels=['T1','T2','T3','T4','T6','T7','T8','T9', 'T11', 'T12', 'T13', 'T14',
'T15', 'T16', 'T17', 'T18', 'T19', 'T20', 'T21', 'T22', 'T23', 'T25']
ax1.set_xticks(np.arange(len(xlabels)))
ax1.set_yticks(np.arange(len(ylabels)))
ax1.set_xticklabels(xlabels, fontsize=6)
ax1.set_yticklabels(ylabels, fontsize=6)
plt.show()
def correlation_matrix_rr_01(corr_mx, cm_title):
# find the maximum in each row
# input corr_mx is a dataframe
# need to convert it into a array first
#otherwise it is not working
temp = np.asarray(corr_mx)
output = (temp == temp.max(axis=1)[:,None]) # along rows
fig = plt.figure()
ax1 = fig.add_subplot(111)
# cmap = cm.get_cmap('jet', 30)
cax = ax1.matshow(output, cmap='gray')
# cax = ax1.imshow(df.corr(), interpolation="nearest", cmap=cmap)
fig.colorbar(cax)
ax1.grid(False)
plt.title(cm_title)
ylabels=['R1','R2','R3','R4','R6','R7','R8','R9', 'R11', 'R12', 'R13', 'R14',
'R15', 'R16', 'R17', 'R18', 'R19', 'R20', 'R21', 'R22', 'R23', 'R25']
xlabels=['R1','R2','R3','R4','R6','R7','R8','R9', 'R11', 'R12', 'R13', 'R14',
'R15', 'R16', 'R17', 'R18', 'R19', 'R20', 'R21', 'R22', 'R23', 'R25']
ax1.set_xticks(np.arange(len(xlabels)))
ax1.set_yticks(np.arange(len(ylabels)))
ax1.set_xticklabels(xlabels,fontsize=6)
ax1.set_yticklabels(ylabels,fontsize=6)
plt.show()
# eg: plot_mag_db(df_as_85_vsc, 1, "Subject")
def fig_mag_db(signal_in, subject_number = 'subject_number', title = 'title', filename = 'filename'):
plt.figure()
plt.subplot(2,1,1)
plt.plot(signal_in.iloc[2*(subject_number-1), :48030], '-')
plt.plot(signal_in.iloc[2*(subject_number-1)+1, :48030], '-')
plt.ylabel('magnitude')
plt.legend(('Retest', 'Test'), loc='upper right')
plt.title(title)
# plt.subplot(2,1,2)
# plt.plot(signal_in.iloc[2*(subject_number-1), :48030].apply(f_dB), '-')
# plt.plot(signal_in.iloc[2*(subject_number-1)+1, :48030].apply(f_dB), '-')
# plt.xlabel('Frequency(Hz)')
# plt.ylabel('dB')
# plt.xlim(0,10000)
# plt.legend(('Retest', 'Test'), loc='lower right')
plt.show()
plt.savefig(filename)
# plot time domain signal in one figure
def fig_time_in_1(signal_in, title = 'title'):
plt.figure()
sub_title = ['1', '2', '3', '4', '6', '7', '8', '9', '11', '12',\
'13', '14', '15', '16', '17', '18', '19', '20', '21',\
'22', '23', '25']
for i in range(22):
plt.subplot(11,2,i+1)
x_label = np.arange(0, 1024, 1)
plt.plot(x_label, signal_in.iloc[2*i, :1024], '-')
plt.plot(x_label, signal_in.iloc[2*i+1, :1024], '-')
plt.ylabel(sub_title[i])
plt.legend(('Retest', 'Test'), loc='upper right', fontsize='xx-small')
plt.suptitle(title) # add a centered title to the figure
plt.show()
def fig_sameday_time_in_1(signal_in, title = 'title'):
plt.figure()
sub_title = ['1', '2', '3', '4', '6', '7', '8', '9', '11', '12',\
'13', '14', '15', '16', '17', '18', '19', '20', '21',\
'22', '23', '25']
for i in range(22):
plt.subplot(11,2,i+1)
x_label = np.arange(0, 1024, 1)
plt.plot(x_label, signal_in.iloc[2*i, :1024], '-')
plt.plot(x_label, signal_in.iloc[2*i+1, :1024], '-')
pcc, p_value = stats.pearsonr(signal_in.iloc[2*i, :1024], signal_in.iloc[2*i+1, :1024])
if pcc > 0.1:
plt.ylabel(sub_title[i] + "\n%.3f" % pcc)
print (sub_title[i] + " %.3f" % pcc)
else:
plt.ylabel(sub_title[i] + "\n%.3f" % pcc, color='r')
#plt.text(1000, -0.2, "PCC is %.3f" % pcc, ha='right', va='top')
plt.legend(('no.1', 'no.2'), loc='upper right', fontsize='xx-small')
# print ("subject number:" , sub_title[i] , " PCC:" , pcc)
plt.suptitle(title) # add a centered title to the figure
plt.show()
# plot frequency domain signal in one figure
def fig_mag_in_1(signal_in, title = 'title'):
plt.figure()
sub_title = ['1', '2', '3', '4', '6', '7', '8', '9', '11', '12',\
'13', '14', '15', '16', '17', '18', '19', '20', '21',\
'22', '23', '25']
for i in range(22):
plt.subplot(11,2,i+1)
x_label = np.arange(0, 4803, 0.1)
plt.plot(x_label, signal_in.iloc[2*i, :48030], '-')
plt.plot(x_label, signal_in.iloc[2*i+1, :48030], '-')
plt.ylabel(sub_title[i])
plt.xlim(0,1300)
plt.legend(('Retest', 'Test'), loc='upper right', fontsize='xx-small')
plt.suptitle(title) # add a centered title to the figure
plt.show()
def fig_sameday_mag_in_1(signal_in, title = 'title'):
plt.figure()
sub_title = ['1', '2', '3', '4', '6', '7', '8', '9', '11', '12',\
'13', '14', '15', '16', '17', '18', '19', '20', '21',\
'22', '23', '25']
for i in range(22):
plt.subplot(11,2,i+1)
x_label = np.arange(0, 4803, 0.1)
plt.plot(x_label, signal_in.iloc[2*i, :48030], '-')
plt.plot(x_label, signal_in.iloc[2*i+1, :48030], '-')
pcc, p_value = stats.pearsonr(signal_in.iloc[2*i, :13000], signal_in.iloc[2*i+1, :13000])
if pcc >0.5:
plt.ylabel(sub_title[i]+ "\n%.3f" % pcc)
print (sub_title[i]+ " %.3f" % pcc)
else:
plt.ylabel(sub_title[i]+ "\n%.3f" % pcc, color='r')
plt.xlim(0,1300)
# plt.ylim(top=100)
plt.legend(('no.1', 'no.2'), loc='upper right', fontsize='xx-small')
plt.suptitle(title) # add a centered title to the figure
plt.show()
def snr_peak_ratio (signal_in, num_peak=7):
# input -> amplitude spectrum
# divide (peak +_15Hz range) by the rest signal
signal_in = np.asarray(signal_in)
snr_numerator= 0
snr_denominator= 0
for j in range (num_peak):
snr_numerator = snr_numerator + (signal_in[1000*j+850:1000*j+1150]**2).sum()
snr_denominator = snr_denominator + (signal_in[1000*j+150:1000*j+850]**2).sum()
snr_numerator = snr_numerator - (signal_in[(1000*num_peak):(1000*num_peak+150)]**2).sum()
snr_numerator = snr_numerator/(300*(num_peak-1)+150)
snr_denominator = snr_denominator + (signal_in[0:150]**2).sum()
snr_denominator = snr_denominator/(700*(num_peak-1)+850)
snr_ratio = snr_numerator/snr_denominator
return snr_ratio
def fig_sameday_as_SNR_in_1(signal_in, title = 'title'):
plt.figure()
sub_title = ['1', '2', '3', '4', '6', '7', '8', '9', '11', '12',\
'13', '14', '15', '16', '17', '18', '19', '20', '21',\
'22', '23', '25']
for i in range(22):
plt.subplot(11,2,i+1)
x_label = np.arange(0, 4803, 0.1)
snr_ratio_1 = snr_peak_ratio(signal_in.iloc[2*i, :48030], num_peak=7)
snr_ratio_2 = snr_peak_ratio(signal_in.iloc[2*i+1, :48030], num_peak=7)
plt.plot(x_label, signal_in.iloc[2*i, :48030], '-', label='no.1 SNR: %.4f' % snr_ratio_1)
plt.plot(x_label, signal_in.iloc[2*i+1, :48030], '-', label='no.2 SNR: %.4f' % snr_ratio_2)
# select the peak with 30Hz width
if snr_ratio_1 > 9.7253 or snr_ratio_1 > 9.7253 :
plt.ylabel(sub_title[i])
print (sub_title[i])
else:
plt.ylabel(sub_title[i], color='r')
plt.xlim(0,1300)
# plt.ylim(top=100)
#plt.legend(('no.1 %.4f', 'no.2%.4f') %(snr_ratio_1, snr_ratio_2), loc='upper right', fontsize='xx-small')
plt.legend(loc='upper right', fontsize='xx-small')
plt.suptitle(title) # add a centered title to the figure
plt.show()
def fig_sameday_as_SNR_in_1_avg_8(signal_in, title = 'title'):
plt.figure()
sub_title = ['1', '2', '3', '4', '6', '7', '8', '9', '11', '12',\
'13', '14', '15', '16', '17', '18', '19', '20', '21',\
'22', '23', '25']
for i in range(22):
snr_sum=[]
for j in range(8):
snr_ratio_1 = snr_peak_ratio(signal_in.iloc[44*j+2*i, :48030], num_peak=7)
snr_ratio_2 = snr_peak_ratio(signal_in.iloc[44*j+2*i+1, :48030], num_peak=7)
snr_sum.append(snr_ratio_1)
snr_sum.append(snr_ratio_2)
snr_avg = sum(snr_sum)/len(snr_sum)
plt.subplot(11,2,i+1)
x_label = np.arange(0, 4803, 0.1)
snr_ratio_1 = snr_peak_ratio(signal_in.iloc[2*i, :48030], num_peak=7)
snr_ratio_2 = snr_peak_ratio(signal_in.iloc[2*i+1, :48030], num_peak=7)
plt.plot(x_label, signal_in.iloc[2*i, :48030], '-', label='no.1 SNR: %.4f' % snr_ratio_1)
plt.plot(x_label, signal_in.iloc[2*i+1, :48030], '-', label='no.2 SNR: %.4f' % snr_ratio_2)
# select the peak with 30Hz width
if snr_avg > 4:
plt.ylabel(sub_title[i] + "\n%.3f" % snr_avg)
print (sub_title[i] + " %.3f" % snr_avg)
else:
plt.ylabel(sub_title[i] + "\n%.3f" % snr_avg, color='r')
plt.xlim(0,1300)
# plt.ylim(top=100)
#plt.legend(('no.1 %.4f', 'no.2%.4f') %(snr_ratio_1, snr_ratio_2), loc='upper right', fontsize='xx-small')
plt.legend(loc='upper right', fontsize='xx-small')
plt.suptitle(title) # add a centered title to the figure
plt.show()
def fig_test_in_1(signal_in_1, signal_in_2, title = 'title', path = 'path', filename = 'filename'):
plt.figure()
sub_title = ['1', '2', '3', '4', '6', '7', '8', '9', '11', '12',\
'13', '14', '15', '16', '17', '18', '19', '20', '21',\
'22', '23', '25']
for i in range(22):
plt.subplot(11,2,i+1)
x_label = np.arange(0, 4803, 0.1)
plt.plot(x_label, signal_in_1.iloc[2*i, :48030], '-')
plt.plot(x_label, signal_in_2.iloc[2*i, :48030], '-')
plt.ylabel(sub_title[i])
plt.xlim(0,1000)
plt.legend(('no window', 'window'), loc='upper right', fontsize='xx-small')
plt.suptitle(title) # add a centered title to the figure
plt.show()
plt.savefig(os.path.join(path, filename), dpi=300)
def fig_retest_in_1(signal_in_1, signal_in_2, title = 'title', path = 'path', filename = 'filename'):
plt.figure()
sub_title = ['1', '2', '3', '4', '6', '7', '8', '9', '11', '12',\
'13', '14', '15', '16', '17', '18', '19', '20', '21',\
'22', '23', '25']
for i in range(22):
plt.subplot(11,2,i+1)
x_label = np.arange(0, 4803, 0.1)
plt.plot(x_label, signal_in_1.iloc[2*i+1, :48030], '-')
plt.plot(x_label, signal_in_2.iloc[2*i+1, :48030], '-')
plt.ylabel(sub_title[i])
plt.xlim(0,1000)
plt.legend(('no window', 'window'), loc='upper right', fontsize='xx-small')
plt.suptitle(title) # add a centered title to the figure
plt.show()
plt.savefig(os.path.join(path, filename), dpi=300)
def distance_mx(sig_in):
# freq_range -> from 0 to ???
freq_range = 13000
matrix_temp = np.zeros((22, 22))
matrix_temp_square = np.zeros((22, 22))
for i in range(22):
for j in range(22):
temp = np.asarray(sig_in.iloc[2*i, 0:freq_range] - sig_in.iloc[2*j+1, 0:freq_range])
temp_sum = 0
temp_square_sum = 0
for k in range(freq_range):
#test_t3 = (abs(temp_series[k]))**2
#print(test_t3)
temp_sum = temp_sum + abs(temp[k])
temp_square_sum = temp_square_sum + (abs(temp[k]))**2
matrix_temp[i][j] = temp_sum
matrix_temp_square[i][j] = temp_square_sum
output_1 = pd.DataFrame(matrix_temp)
output_2 = pd.DataFrame(matrix_temp_square)
# output 1 is similar with euclidian diatance eg. x1+jy1 -> sqrt(x1**2 + y1**2)
# output 1 is square result eg. x1+jy1 -> x1**2 + y1**2
return output_1, output_2
def complex_coherence_mx(input_signal):
# compute the magnitude squared coherence based on signal.coherence
# then create the matrix with values
# higher value -> better coherence value
sig_in = input_signal.copy()
matrix_temp = np.zeros((22, 22))
for i in range(22):
for j in range(22):
# temp here is the
temp_sum = 0
sig_in_1 = np.array(sig_in.iloc[2*i, :])
sig_in_2 = np.array(sig_in.iloc[2*j+1, :])
# signal 9606Hz length 106.6ms window length 10ms -> nperseg=96
f, temp_Cxy = signal.coherence(sig_in_1, sig_in_2, fs=9606, nperseg=96)
# delete values lower than 0.01
for l in range(len(temp_Cxy)):
if temp_Cxy[l] < 0.1:
temp_Cxy[l] = 0
# delete finish
# test
'''
if i ==0 and j == 0:
plt.figure()
plt.semilogy(f, temp_Cxy)
plt.title("test in complex_coherence_mx")
plt.show()
'''
# test finish
for k in range(len(temp_Cxy)):
#test_t3 = (abs(temp_series[k]))**2
#print(test_t3)
temp_sum = temp_sum + abs(temp_Cxy[k])
matrix_temp[i][j] = temp_sum
output_3 = pd.DataFrame(matrix_temp)
return output_3
def fig_coherence_in_1(signal_in, threshold_Cxy = None, title = 'title', title2 = 'title2'):
# threshold_Cxy is used for setting minimum value
Cxy_sum = pd.DataFrame()
plt.figure()
sub_title = ['1', '2', '3', '4', '6', '7', '8', '9', '11', '12',\
'13', '14', '15', '16', '17', '18', '19', '20', '21',\
'22', '23', '25']
for i in range(22):
sig_in_1 = signal_in.iloc[i, :]
sig_in_2 = signal_in.iloc[i+22, :]
# signal 9606Hz length 106.6ms window length 10ms -> nperseg=96
# no zero padding
# f, temp_Cxy = signal.coherence(sig_in_1, sig_in_2, fs=9606, nperseg=128)
# with zero padding
f, temp_Cxy = signal.coherence(sig_in_1, sig_in_2, fs = 9606, nperseg=512, nfft=19210)
# print("shape of temp_Cxy is")
# print (temp_Cxy.shape)
# delete value lower than 0.05
if (threshold_Cxy != None):
for l in range(len(temp_Cxy)):
if temp_Cxy[l] < threshold_Cxy:
temp_Cxy[l] = 0
# delete finish
Cxy_sum = Cxy_sum.append(pd.DataFrame(np.reshape(temp_Cxy, (1,9606))), ignore_index=True)
plt.subplot(11,2,i+1)
plt.plot(f, temp_Cxy)
plt.ylabel(sub_title[i])
plt.xlim(0,2000)
plt.legend(('Retest', 'Test'), loc='upper right', fontsize='xx-small')
plt.suptitle(title) # add a centered title to the figure
plt.show()
# plot aveerage of 22 subjects
plt.figure()
plt.subplot(1,1,1)
Cxy_avg = Cxy_sum.mean(axis=0)
plt.plot(f, Cxy_avg)
plt.title('average of 22 subjects based on '+ title2)
plt.xlim(0,2000)
plt.show()
#################################
f_dB = lambda x : 20 * np.log10(np.abs(x))
# import the pkl file
# for linux
df_EFR=pd.read_pickle('/home/bruce/Dropbox/Project/4.Code for Linux/df_EFR.pkl')
# for mac
# df_EFR=pd.read_pickle('/Users/bruce/Dropbox/Project/4.Code for Linux/df_EFR.pkl')
# remove DC offset
df_EFR_detrend = pd.DataFrame()
for i in range(1408):
# combine next two rows later
df_EFR_detrend_data = pd.DataFrame(signal.detrend(df_EFR.iloc[i: i+1, 0:1024], type='constant').reshape(1,1024))
df_EFR_label = pd.DataFrame(df_EFR.iloc[i, 1024:1031].values.reshape(1,7))
df_EFR_detrend = df_EFR_detrend.append(pd.concat([df_EFR_detrend_data, df_EFR_label], axis=1, ignore_index=True))
# set the title of columns
df_EFR_detrend.columns = np.append(np.arange(1024), ["Subject", "Sex", "Condition", "Vowel", "Sound Level", "Num", "EFR/FFR"])
df_EFR_detrend = df_EFR_detrend.reset_index(drop=True)
df_EFR = df_EFR_detrend
# Time domain
# Define window function
win_kaiser = signal.kaiser(1024, beta=14)
win_hamming = signal.hamming(1024)
# average the df_EFR
df_EFR_win = pd.DataFrame()
# implement the window function
for i in range(1408):
temp_EFR_window = pd.DataFrame((df_EFR.iloc[i,:1024] * win_hamming).values.reshape(1,1024))
temp_EFR_label = pd.DataFrame(df_EFR.iloc[i, 1024:1031].values.reshape(1,7))
df_EFR_win = df_EFR_win.append(pd.concat([temp_EFR_window, temp_EFR_label], axis=1, ignore_index=True))
# set the title of columns
# df_EFR_avg.columns = np.append(np.arange(1024), ["Subject", "Sex", "Condition", "Vowel", "Sound Level", "Num", "EFR/FFR"])
# df_EFR_avg = df_EFR_avg.sort_values(by=["Condition", "Subject"])
# df_EFR_avg = df_EFR_avg.reset_index(drop=True)
df_EFR_win.columns = np.append(np.arange(1024), ["Subject", "Sex", "Condition", "Vowel", "Sound Level", "Num", "EFR/FFR"])
df_EFR_win = df_EFR_win.sort_values(by=["Condition", "Subject"])
df_EFR_win = df_EFR_win.reset_index(drop=True)
# average all the subjects , test and retest and keep one sound levels
# filter by 'a vowel and 85Db'
df_EFR_sorted = df_EFR.sort_values(by=["Sound Level", "Vowel","Condition", "Subject"])
df_EFR_sorted = df_EFR_sorted.reset_index(drop=True)
df_EFR_win_sorted = df_EFR_win.sort_values(by=["Sound Level", "Vowel","Condition", "Subject"])
df_EFR_win_sorted = df_EFR_win_sorted.reset_index(drop=True)
# filter55 65 75 sound levels and keep 85dB
# keep vowel condition and subject
df_EFR_85 = pd.DataFrame(df_EFR_sorted.iloc[1056:, :])
df_EFR_85 = df_EFR_85.reset_index(drop=True)
df_EFR_win_85 = pd.DataFrame(df_EFR_win_sorted.iloc[1056:, :])
df_EFR_win_85 = df_EFR_win_85.reset_index(drop=True)
##################################################
# Frequency Domain
# parameters
sampling_rate = 9606 # fs
# sampling_rate = 9596.623
n = 1024
k = np.arange(n)
T = n/sampling_rate # time of signal
frq = k/T
freq = frq[range(int(n/2))]
n2 = 96060
k2 = np.arange(n2)
T2 = n2/sampling_rate
frq2 = k2/T2
freq2 = frq2[range(int(n2/2))]
# zero padding
# for df_EFR
df_EFR_data = df_EFR.iloc[:, :1024]
df_EFR_label = df_EFR.iloc[:, 1024:]
df_EFR_mid = pd.DataFrame(np.zeros((1408, 95036)))
df_EFR_withzero = pd.concat([df_EFR_data, df_EFR_mid, df_EFR_label], axis=1)
# rename columns
df_EFR_withzero.columns = np.append(np.arange(96060), ["Subject", "Sex", "Condition", "Vowel", "Sound Level", "Num", "EFR/FFR"])
# for df_EFR_avg_85
df_EFR_85_data = df_EFR_85.iloc[:, :1024]
df_EFR_85_label = df_EFR_85.iloc[:, 1024:]
df_EFR_85_mid = pd.DataFrame(np.zeros((352, 95036)))
df_EFR_win_85_data = df_EFR_win_85.iloc[:, :1024]
df_EFR_win_85_label = df_EFR_85_label
df_EFR_win_85_mid = df_EFR_85_mid
df_EFR_85_withzero = pd.concat([df_EFR_85_data, df_EFR_85_mid, df_EFR_85_label], axis=1)
df_EFR_85_withzero.columns = np.append(np.arange(96060), ["Subject", "Sex", "Condition", "Vowel", "Sound Level", "Num", "EFR/FFR"])
df_EFR_win_85_withzero = pd.concat([df_EFR_win_85_data, df_EFR_85_mid, df_EFR_85_label], axis=1)
df_EFR_win_85_withzero.columns = np.append(np.arange(96060), ["Subject", "Sex", "Condition", "Vowel", "Sound Level", "Num", "EFR/FFR"])
# normalization
# normalize the dataframe by standard deviation
df_EFR_85_data_std = df_EFR_85_data.std(axis=1)
df_EFR_85_data_norm_std = (df_EFR_85_data.iloc[:, :1024]).div(df_EFR_85_data_std, axis=0)
df_EFR_85_vsc = pd.concat([df_EFR_85_data, df_EFR_85_label], axis=1).sort_values(by=["Vowel", "Subject", "Condition"]).reset_index(drop=True)
df_EFR_85_vsc_norm_std = pd.concat([df_EFR_85_data_norm_std, df_EFR_85_label], axis=1).sort_values(by=["Vowel", "Subject", "Condition"]).reset_index(drop=True)
df_EFR_85_cvs = pd.concat([df_EFR_85_data, df_EFR_85_label], axis=1).sort_values(by=["Condition", "Vowel", "Subject"]).reset_index(drop=True)
df_EFR_85_withzero_vsc = df_EFR_85_withzero.sort_values(by=["Vowel", "Subject", "Condition"]).reset_index(drop=True)
df_EFR_85_withzero_cvs = df_EFR_85_withzero.sort_values(by=["Condition", "Vowel", "Subject"]).reset_index(drop=True)
df_EFR_85_cvs_r = df_EFR_85_cvs.iloc[0:176, :].reset_index(drop=True)
df_EFR_85_cvs_t = df_EFR_85_cvs.iloc[176:352, :].reset_index(drop=True)
# calculate the avarage PCC
pcc_sum=[]
for i in range (176):
pcc_temp, p_value = stats.pearsonr(df_EFR_85_cvs.iloc[2*i, :1024], df_EFR_85_cvs.iloc[2*i+1, :1024])
pcc_sum.append(pcc_temp)
pcc_avg = sum(pcc_sum)/len(pcc_sum)
df_EFR_85_withzero_cvs_r = df_EFR_85_withzero_cvs.iloc[0:176, :].reset_index(drop=True)
df_EFR_85_withzero_cvs_t = df_EFR_85_withzero_cvs.iloc[176:352, :].reset_index(drop=True)
df_EFR_85_vsc_a = df_EFR_85_vsc.iloc[0:88, :1024]
df_EFR_85_vsc_e = df_EFR_85_vsc.iloc[88:176, :1024].reset_index(drop=True)
df_EFR_85_vsc_n = df_EFR_85_vsc.iloc[176:264, :1024].reset_index(drop=True)
df_EFR_85_vsc_u = df_EFR_85_vsc.iloc[264:352, :1024].reset_index(drop=True)
df_EFR_85_vsc_norm_std_a = df_EFR_85_vsc_norm_std.iloc[0:88, :1024]
df_EFR_85_vsc_norm_std_e = df_EFR_85_vsc_norm_std.iloc[88:176, :1024]
df_EFR_85_vsc_norm_std_n = df_EFR_85_vsc_norm_std.iloc[176:264, :1024]
df_EFR_85_vsc_norm_std_u = df_EFR_85_vsc_norm_std.iloc[264:352, :1024]
df_EFR_85_withzero_vsc_a = df_EFR_85_withzero_vsc.iloc[0:88, :19722]
df_EFR_85_withzero_vsc_e = df_EFR_85_withzero_vsc.iloc[88:176, :19722]
df_EFR_85_withzero_vsc_n = df_EFR_85_withzero_vsc.iloc[176:264, :19722]
df_EFR_85_withzero_vsc_u = df_EFR_85_withzero_vsc.iloc[264:352, :19722]
df_EFR_85_withzero_cvs_r_a = df_EFR_85_withzero_cvs_r.iloc[0:44, :19722]
df_EFR_85_withzero_cvs_r_a_label = df_EFR_85_withzero_cvs_r.iloc[0:44, 19722:]
df_EFR_85_withzero_cvs_r_e = df_EFR_85_withzero_cvs_r.iloc[44:88, :19722]
df_EFR_85_withzero_cvs_r_n = df_EFR_85_withzero_cvs_r.iloc[88:132, :19722]
df_EFR_85_withzero_cvs_r_u = df_EFR_85_withzero_cvs_r.iloc[132:176, :19722]
df_EFR_85_withzero_cvs_t_a = df_EFR_85_withzero_cvs_t.iloc[0:44, :19722]
df_EFR_85_withzero_cvs_t_e = df_EFR_85_withzero_cvs_t.iloc[44:88, :19722]
df_EFR_85_withzero_cvs_t_n = df_EFR_85_withzero_cvs_t.iloc[88:132, :19722]
df_EFR_85_withzero_cvs_t_u = df_EFR_85_withzero_cvs_t.iloc[132:176, :19722]
df_EFR_85_cvs_r_a = df_EFR_85_cvs_r.iloc[0:44, :].reset_index(drop=True)
df_EFR_85_cvs_r_a_label = df_EFR_85_cvs_r.iloc[0:44, 1024:]
df_EFR_85_cvs_r_e = df_EFR_85_cvs_r.iloc[44:88, :].reset_index(drop=True)
df_EFR_85_cvs_r_n = df_EFR_85_cvs_r.iloc[88:132, :].reset_index(drop=True)
df_EFR_85_cvs_r_u = df_EFR_85_cvs_r.iloc[132:176, :].reset_index(drop=True)
df_EFR_85_cvs_t_a = df_EFR_85_cvs_t.iloc[0:44, :].reset_index(drop=True)
df_EFR_85_cvs_t_e = df_EFR_85_cvs_t.iloc[44:88, :].reset_index(drop=True)
df_EFR_85_cvs_t_n = df_EFR_85_cvs_t.iloc[88:132, :].reset_index(drop=True)
df_EFR_85_cvs_t_u = df_EFR_85_cvs_t.iloc[132:176, :].reset_index(drop=True)
# frequency domain
# for df_EFR_avg_vcs_withzero
df_as_85_no0= pd.DataFrame()
df_as_85= | pd.DataFrame() | pandas.DataFrame |
# -*- coding: utf-8 -*-
"""
Created 23 April 2019
mean_traces.py
Version 1
The purpose of this script is to pull all of the mean trace files that were
saved from the initial analysis. These traces are mean subtracted and filtered
and comprise the entire 6 s of recording. The idea here is to open the files
individually, extract the data, save it to a dataframe and compile all of the
files of the same genotype into a dataframe. Then take the mean. Then plot the
means vs. all traces for both OMP and Gg8.
"""
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import os
import platform
''' ################## Define file structure on server #################### '''
# home_dir will depend on the OS, but the rest will not
# query machine identity and set home_dir from there
machine = platform.uname()[0]
if machine == 'Darwin':
home_dir = '/Volumes/Urban'
elif machine == 'Linux':
home_dir = '/run/user/1000/gvfs/smb-share:server=192.168.3.11,share=urban'
elif machine == 'Windows':
home_dir = os.path.join('N:', os.sep, 'urban')
else:
print("OS not recognized. \nPlease see Nate for correction.")
project_dir = os.path.join(home_dir, 'Huang', 'OSN_OMPvGg8_MTC')
figure_dir = os.path.join(project_dir, 'figures')
table_dir = os.path.join(project_dir, 'tables')
data_dir = os.path.join(project_dir, 'data')
''' ##########################################################################
This is all the analysis, figures, saving
Read in file metadata, open file from igor, convert to pandas
##############################################################################
'''
# grab all files in table_dir
file_list = os.listdir(table_dir)
trace_files = []
cell_ids = []
for file in file_list:
if 'timeseries' in file:
trace_files.append(file)
cell_id = file.split('_')[1] + '_' + file.split('_')[2]
cell_ids.append(cell_id)
else:
continue
traces_df = pd.DataFrame({'file name': trace_files, 'cell id': cell_ids})
# grab data_notes to select out by cell type
analyzed_data_notes = pd.read_csv(os.path.join(table_dir +'analyzed_data_notes.csv'), index_col=0)
mc_df = analyzed_data_notes[analyzed_data_notes['Cell type'] == 'MC']
# pull out gg8 cells
mc_gg8_df = mc_df[mc_df['Genotype'] == 'Gg8']
mc_gg8_list = mc_gg8_df['Cell name'].to_list()
mc_gg8_list = [name.split('_')[0] + '_' + name.split('_')[1] for name in mc_gg8_list]
mc_gg8_df = pd.DataFrame(mc_gg8_list, columns=['cell id'])
# pull out omp cells
mc_omp_df = mc_df[mc_df['Genotype'] == 'OMP']
mc_omp_list = mc_omp_df['Cell name'].to_list()
mc_omp_list = [name.split('_')[0] + '_' + name.split('_')[1] for name in mc_omp_list]
mc_omp_df = pd.DataFrame(mc_omp_list, columns=['cell id'])
# make list of Gg8 MCs
gg8_mcs = pd.merge(traces_df, mc_gg8_df)
gg8_mc_list = gg8_mcs['file name'].to_list()
# make list of OMP MCs
omp_mcs = pd.merge(traces_df, mc_omp_df)
omp_mc_list = omp_mcs['file name'].to_list()
# create empty dataframes for gg8 and omp cells
gg8_cells = pd.DataFrame()
omp_cells = | pd.DataFrame() | pandas.DataFrame |
# Utility data handling,
# - Convert parquet to csv dataframes.
# - Consolidate parquet data files.
# - load parquet
import sys
#import glob
import pprint
import re
import string
import time
from pathlib import Path
ROOT_PATH = Path('D:/OneDrive - Microsoft/data/20news') # /20news-bydate-train/train_clean'
import pyarrow
import pandas as pd
def cnvt2csv(path):
'path = path to the train_clean directory'
try:
adf = pd.read_parquet(path)
print(path, ': ', adf.shape)
new_name = Path(path.parent) / Path(path.stem + '.csv')
# create strings from txt lists
msg_col = adf['msg']
msg_col = msg_col.apply(flatten_msg)
item_col = adf['item']
item_col = item_col.apply(lambda x: Path(x).name)
adf['msg'] = msg_col
adf['item'] = item_col
adf.to_csv(new_name)
except Exception as e:
print(f"for file {new_name} got exception {e}.")
print('wrote ', new_name)
def flatten_msg(msg):
'Concatenate lines to form a single string, removing punctuation.'
# Convert array to one text string.
txt = ' '.join(list(msg))
# Remove punct.
txt =''.join([k for k in txt if k not in string.punctuation])
return txt
def consolidate_parquet(path):
'Combine all parquet files into one df'
full_df = pd.DataFrame()
globpath = Path(path)
for a_file in globpath.glob('*.parquet'):
try:
adf = pd.read_parquet(a_file)
except Exception as e:
print(f"for file {a_file} got exception {e}.")
full_df = | pd.concat([full_df, adf]) | pandas.concat |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.