def test_write_to_csv():
""" Test the write_to_csv function by checking whether the csv contains the
correct number of lines.
"""
with testing.postgresql.Postgresql() as postgresql:
# create an engine and generate a table with fake feature data
engine = create_engine(postgresql.url())
create_schemas(engine=engine,
features_tables=features_tables,
labels=labels,
states=states)
with TemporaryDirectory() as temp_dir:
planner = Planner(feature_start_time=datetime.datetime(
2010, 1, 1, 0, 0),
label_names=['booking'],
label_types=['binary'],
states=['state_one AND state_two'],
db_config=db_config,
matrix_directory=temp_dir,
user_metadata={},
engine=engine,
builder_class=builders.HighMemoryCSVBuilder)
# for each table, check that corresponding csv has the correct # of rows
for table in features_tables:
planner.builder.write_to_csv(
'''
select *
from features.features{}
'''.format(features_tables.index(table)), 'test_csv.csv')
reader = csv.reader(
planner.builder.open_fh_for_reading('test_csv.csv'))
assert (len([row for row in reader]) == len(table) + 1)
def test_make_entity_date_table():
""" Test that the make_entity_date_table function contains the correct
values.
"""
dates = [
datetime.datetime(2016, 1, 1, 0, 0),
datetime.datetime(2016, 2, 1, 0, 0),
datetime.datetime(2016, 3, 1, 0, 0)
]
# make a dataframe of entity ids and dates to test against
ids_dates = create_entity_date_df(labels=labels,
states=states,
as_of_dates=dates,
state_one=True,
state_two=True,
label_name='booking',
label_type='binary',
label_timespan='1 month')
with testing.postgresql.Postgresql() as postgresql:
# create an engine and generate a table with fake feature data
engine = create_engine(postgresql.url())
create_schemas(engine=engine,
features_tables=features_tables,
labels=labels,
states=states)
with TemporaryDirectory() as temp_dir:
planner = Planner(feature_start_time=datetime.datetime(
2010, 1, 1, 0, 0),
label_names=['booking'],
label_types=['binary'],
states=['state_one AND state_two'],
db_config=db_config,
matrix_directory=temp_dir,
user_metadata={},
engine=engine)
engine.execute(
'CREATE TABLE features.tmp_entity_date (a int, b date);')
# call the function to test the creation of the table
entity_date_table_name = planner.builder.make_entity_date_table(
as_of_times=dates,
label_type='binary',
label_name='booking',
state='state_one AND state_two',
matrix_uuid='my_uuid',
matrix_type='train',
label_timespan='1 month')
# read in the table
result = pd.read_sql(
"select * from features.{} order by entity_id, as_of_date".
format(entity_date_table_name), engine)
labels_df = pd.read_sql('select * from labels.labels', engine)
# compare the table to the test dataframe
test = (result == ids_dates)
assert (test.all().all())
def test_test_matrix(self):
with testing.postgresql.Postgresql() as postgresql:
# create an engine and generate a table with fake feature data
engine = create_engine(postgresql.url())
create_schemas(engine=engine,
features_tables=features_tables,
labels=labels,
states=states)
dates = [
datetime.datetime(2016, 1, 1, 0, 0),
datetime.datetime(2016, 2, 1, 0, 0),
datetime.datetime(2016, 3, 1, 0, 0)
]
with TemporaryDirectory() as temp_dir:
planner = Planner(feature_start_time=datetime.datetime(
2010, 1, 1, 0, 0),
label_names=['booking'],
label_types=['binary'],
states=['state_one AND state_two'],
db_config=db_config,
matrix_directory=temp_dir,
user_metadata={},
engine=engine)
matrix_dates = {
'first_as_of_time': datetime.datetime(2016, 1, 1, 0, 0),
'matrix_info_end_time':
datetime.datetime(2016, 3, 1, 0, 0),
'as_of_times': dates
}
feature_dictionary = {
'features0': ['f1', 'f2'],
'features1': ['f3', 'f4'],
}
matrix_metadata = {
'matrix_id': 'hi',
'state': 'state_one AND state_two',
'label_name': 'booking',
'end_time': datetime.datetime(2016, 3, 1, 0, 0),
'feature_start_time': datetime.datetime(2016, 1, 1, 0, 0),
'label_timespan': '1 month'
}
uuid = metta.generate_uuid(matrix_metadata)
planner.build_matrix(as_of_times=dates,
label_name='booking',
label_type='binary',
feature_dictionary=feature_dictionary,
matrix_directory=temp_dir,
matrix_metadata=matrix_metadata,
matrix_uuid=uuid,
matrix_type='test')
matrix_filename = os.path.join(temp_dir, '{}.csv'.format(uuid))
with open(matrix_filename, 'r') as f:
reader = csv.reader(f)
assert (len([row for row in reader]) == 6)
def test_train_matrix(self):
with testing.postgresql.Postgresql() as postgresql:
# create an engine and generate a table with fake feature data
engine = create_engine(postgresql.url())
create_schemas(
engine=engine,
features_tables=features_tables,
labels=labels,
states=states
)
dates = [datetime.datetime(2016, 1, 1, 0, 0),
datetime.datetime(2016, 2, 1, 0, 0),
datetime.datetime(2016, 3, 1, 0, 0)]
with TemporaryDirectory() as temp_dir:
planner = Planner(
beginning_of_time = datetime.datetime(2010, 1, 1, 0, 0),
label_names = ['booking'],
label_types = ['binary'],
states = ['state_one AND state_two'],
db_config = db_config,
matrix_directory = temp_dir,
user_metadata = {},
engine = engine
)
feature_dictionary = {
'features0': ['f1', 'f2'],
'features1': ['f3', 'f4'],
}
matrix_metadata = {
'matrix_id': 'hi',
'state': 'state_one AND state_two',
'label_name': 'booking',
'end_time': datetime.datetime(2016, 3, 1, 0, 0),
'beginning_of_time': datetime.datetime(2016, 1, 1, 0, 0),
'label_window': '1 month'
}
uuid = metta.generate_uuid(matrix_metadata)
planner.build_matrix(
as_of_times = dates,
label_name = 'booking',
label_type = 'binary',
feature_dictionary = feature_dictionary,
matrix_directory = temp_dir,
matrix_metadata = matrix_metadata,
matrix_uuid = uuid,
matrix_type = 'train'
)
matrix_filename = os.path.join(
temp_dir,
'{}.csv'.format(uuid)
)
with open(matrix_filename, 'r') as f:
reader = csv.reader(f)
assert(len([row for row in reader]) == 6)
def test_write_to_csv():
""" Test the write_to_csv function by checking whether the csv contains the
correct number of lines.
"""
with testing.postgresql.Postgresql() as postgresql:
# create an engine and generate a table with fake feature data
engine = create_engine(postgresql.url())
create_schemas(
engine=engine,
features_tables=features_tables,
labels=labels,
states=states
)
with TemporaryDirectory() as temp_dir:
planner = Planner(
beginning_of_time = datetime.datetime(2010, 1, 1, 0, 0),
label_names = ['booking'],
label_types = ['binary'],
states = ['state_one AND state_two'],
db_config = db_config,
matrix_directory = temp_dir,
user_metadata = {},
engine = engine,
builder_class = builders.LowMemoryCSVBuilder
)
# for each table, check that corresponding csv has the correct # of rows
for table in features_tables:
with NamedTempFile() as f:
planner.builder.write_to_csv(
'''
select *
from features.features{}
'''.format(features_tables.index(table)),
f.name
)
f.seek(0)
reader = csv.reader(f)
assert(len([row for row in reader]) == len(table) + 1)
def test_write_labels_data():
""" Test the write_labels_data function by checking whether the query
produces the correct labels
"""
# set up labeling config variables
dates = [datetime.datetime(2016, 1, 1, 0, 0),
datetime.datetime(2016, 2, 1, 0, 0)]
# make a dataframe of labels to test against
labels_df = pd.DataFrame(
labels,
columns = [
'entity_id',
'as_of_date',
'label_window',
'label_name',
'label_type',
'label'
]
)
labels_df['as_of_date'] = convert_string_column_to_date(labels_df['as_of_date'])
labels_df.set_index(['entity_id', 'as_of_date'])
# create an engine and generate a table with fake feature data
with testing.postgresql.Postgresql() as postgresql:
engine = create_engine(postgresql.url())
create_schemas(
engine,
features_tables,
labels,
states
)
with TemporaryDirectory() as temp_dir:
planner = Planner(
beginning_of_time = datetime.datetime(2010, 1, 1, 0, 0),
label_names = ['booking'],
label_types = ['binary'],
states = ['state_one AND state_two'],
db_config = db_config,
matrix_directory = temp_dir,
user_metadata = {},
engine = engine,
builder_class=builders.LowMemoryCSVBuilder
)
# make the entity-date table
entity_date_table_name = planner.builder.make_entity_date_table(
as_of_times=dates,
label_type='binary',
label_name='booking',
state = 'state_one AND state_two',
matrix_type='train',
matrix_uuid='my_uuid',
label_window='1 month'
)
csv_filename = planner.builder.write_labels_data(
label_name=label_name,
label_type=label_type,
label_window='1 month',
matrix_uuid='my_uuid',
entity_date_table_name=entity_date_table_name,
)
df = pd.DataFrame.from_dict({
'entity_id': [2, 3, 4, 4],
'as_of_date': ['2016-02-01', '2016-02-01', '2016-01-01', '2016-02-01'],
'booking': [0, 0, 1, 0],
}).set_index(['entity_id', 'as_of_date'])
result = pd.read_csv(csv_filename).set_index(['entity_id', 'as_of_date'])
test = (result == df)
assert(test.all().all())
def test_write_features_data():
dates = [datetime.datetime(2016, 1, 1, 0, 0),
datetime.datetime(2016, 2, 1, 0, 0)]
# make dataframe for entity ids and dates
ids_dates = create_entity_date_df(
labels=labels,
states=states,
as_of_dates=dates,
state_one=True,
state_two=True,
label_name='booking',
label_type='binary',
label_window='1 month'
)
features = [['f1', 'f2'], ['f3', 'f4']]
# make dataframes of features to test against
features_dfs = []
for i, table in enumerate(features_tables):
cols = ['entity_id', 'as_of_date'] + features[i]
temp_df = pd.DataFrame(
table,
columns = cols
)
temp_df['as_of_date'] = convert_string_column_to_date(temp_df['as_of_date'])
features_dfs.append(
ids_dates.merge(
right = temp_df,
how = 'left',
on = ['entity_id', 'as_of_date']
)
)
# create an engine and generate a table with fake feature data
with testing.postgresql.Postgresql() as postgresql:
engine = create_engine(postgresql.url())
create_schemas(
engine=engine,
features_tables=features_tables,
labels=labels,
states=states
)
with TemporaryDirectory() as temp_dir:
planner = Planner(
beginning_of_time = datetime.datetime(2010, 1, 1, 0, 0),
label_names = ['booking'],
label_types = ['binary'],
states = ['state_one AND state_two'],
db_config = db_config,
matrix_directory = temp_dir,
user_metadata = {},
engine = engine,
builder_class=builders.LowMemoryCSVBuilder
)
# make the entity-date table
entity_date_table_name = planner.builder.make_entity_date_table(
as_of_times=dates,
label_type='binary',
label_name='booking',
state = 'state_one AND state_two',
matrix_type='train',
matrix_uuid='my_uuid',
label_window='1 month'
)
feature_dictionary = dict(
('features{}'.format(i), feature_list) for i, feature_list in enumerate(features)
)
print(feature_dictionary)
features_csv_names = planner.builder.write_features_data(
as_of_times=dates,
feature_dictionary=feature_dictionary,
entity_date_table_name=entity_date_table_name,
matrix_uuid='my_uuid'
)
# get the queries and test them
for feature_csv_name, df in zip(sorted(features_csv_names), features_dfs):
df = df.fillna(0)
df = df.reset_index()
result = pd.read_csv(feature_csv_name).reset_index()
result['as_of_date'] = convert_string_column_to_date(result['as_of_date'])
test = (result == df)
assert(test.all().all())
def test_make_entity_date_table():
""" Test that the make_entity_date_table function contains the correct
values.
"""
dates = [datetime.datetime(2016, 1, 1, 0, 0),
datetime.datetime(2016, 2, 1, 0, 0),
datetime.datetime(2016, 3, 1, 0, 0)]
# make a dataframe of entity ids and dates to test against
ids_dates = create_entity_date_df(
labels=labels,
states=states,
as_of_dates=dates,
state_one=True,
state_two=True,
label_name='booking',
label_type='binary',
label_window='1 month'
)
with testing.postgresql.Postgresql() as postgresql:
# create an engine and generate a table with fake feature data
engine = create_engine(postgresql.url())
create_schemas(
engine=engine,
features_tables=features_tables,
labels=labels,
states=states
)
with TemporaryDirectory() as temp_dir:
planner = Planner(
beginning_of_time = datetime.datetime(2010, 1, 1, 0, 0),
label_names = ['booking'],
label_types = ['binary'],
states = ['state_one AND state_two'],
db_config = db_config,
matrix_directory = temp_dir,
user_metadata = {},
engine = engine
)
engine.execute(
'CREATE TABLE features.tmp_entity_date (a int, b date);'
)
# call the function to test the creation of the table
entity_date_table_name = planner.builder.make_entity_date_table(
as_of_times=dates,
label_type='binary',
label_name='booking',
state='state_one AND state_two',
matrix_uuid='my_uuid',
matrix_type='train',
label_window='1 month'
)
# read in the table
result = pd.read_sql(
"select * from features.{} order by entity_id, as_of_date".format(entity_date_table_name),
engine
)
labels_df = pd.read_sql('select * from labels.labels', engine)
# compare the table to the test dataframe
print("ids_dates")
for i, row in ids_dates.iterrows():
print(row.values)
print("result")
for i, row in result.iterrows():
print(row.values)
test = (result == ids_dates)
print(test)
assert(test.all().all())
def test_nullcheck(self):
f0_dict = {(r[0], r[1]): r for r in features0_pre}
f1_dict = {(r[0], r[1]): r for r in features1_pre}
features0 = sorted(f0_dict.values(), key=lambda x: (x[1], x[0]))
features1 = sorted(f1_dict.values(), key=lambda x: (x[1], x[0]))
features_tables = [features0, features1]
with testing.postgresql.Postgresql() as postgresql:
# create an engine and generate a table with fake feature data
engine = create_engine(postgresql.url())
create_schemas(engine=engine,
features_tables=features_tables,
labels=labels,
states=states)
dates = [
datetime.datetime(2016, 1, 1, 0, 0),
datetime.datetime(2016, 2, 1, 0, 0),
datetime.datetime(2016, 3, 1, 0, 0)
]
with TemporaryDirectory() as temp_dir:
planner = Planner(feature_start_time=datetime.datetime(
2010, 1, 1, 0, 0),
label_names=['booking'],
label_types=['binary'],
states=['state_one AND state_two'],
db_config=db_config,
matrix_directory=temp_dir,
user_metadata={},
engine=engine)
matrix_dates = {
'first_as_of_time': datetime.datetime(2016, 1, 1, 0, 0),
'matrix_info_end_time':
datetime.datetime(2016, 3, 1, 0, 0),
'as_of_times': dates
}
feature_dictionary = {
'features0': ['f1', 'f2'],
'features1': ['f3', 'f4'],
}
matrix_metadata = {
'matrix_id': 'hi',
'state': 'state_one AND state_two',
'label_name': 'booking',
'end_time': datetime.datetime(2016, 3, 1, 0, 0),
'feature_start_time': datetime.datetime(2016, 1, 1, 0, 0),
'label_timespan': '1 month'
}
uuid = metta.generate_uuid(matrix_metadata)
with self.assertRaises(ValueError):
planner.build_matrix(as_of_times=dates,
label_name='booking',
label_type='binary',
feature_dictionary=feature_dictionary,
matrix_directory=temp_dir,
matrix_metadata=matrix_metadata,
matrix_uuid=uuid,
matrix_type='test')
