def test_get_backbone_network(self, mock_vars):
"""Test get_backbone_network."""
mock_net = TrainOneStepWithLossScaleCell()
mock_net.network = MagicMock()
mock_cell = {'_cells': {'key': mock_net}}
mock_vars.return_value = mock_cell
res = AnalyzeObject.get_backbone_network(MagicMock())
self.assertEqual(res, 'MagicMock')
def test_get_loss_fn_by_network(self, mock_vars):
"""Test get_loss_fn_by_network."""
mock_cell1 = {'_cells': {'key': SoftmaxCrossEntropyWithLogits(0.2)}}
mock_cell2 = {'_cells': {'opt': Optimizer(Tensor(0.1))}}
mock_cell3 = {'_cells': {'loss': SoftmaxCrossEntropyWithLogits(0.1)}}
mock_vars.side_effect = [mock_cell1, mock_cell2, mock_cell3]
res = AnalyzeObject.get_loss_fn_by_network(MagicMock())
self.assertEqual(res, mock_cell3['_cells']['loss'])
def test_get_optimizer_by_network(self, mock_vars):
"""Test get_optimizer_by_network."""
mock_optimizer = Optimizer(Tensor(0.1))
mock_cells = MagicMock()
mock_cells.items.return_value = [{'key': mock_optimizer}]
mock_vars.return_value = {'_cells': {'key': mock_optimizer}}
res = AnalyzeObject.get_optimizer_by_network(MagicMock())
self.assertEqual(res, mock_optimizer)
def test_get_file_path(self):
"""Test get_file_path method."""
model_ckpt = ModelCheckpoint(prefix='', directory='/path/to')
summary_step = SummaryStep(
MagicMock(full_file_name='/path/to/summary.log'))
list_callback = [model_ckpt, summary_step]
ckpt_file_path, _ = AnalyzeObject.get_file_path(list_callback)
self.assertEqual(ckpt_file_path, '/path/to/test_model.ckpt')
def test_get_backbone_network_with_loss_cell(self, mock_vars):
"""Test get_backbone_network with loss_cell."""
mock_cell = {
'_cells': {
'key':
WithLossCell(MagicMock(), SoftmaxCrossEntropyWithLogits(0.1))
}
}
mock_vars.return_value = mock_cell
res = AnalyzeObject.get_backbone_network(MagicMock())
self.assertEqual(res, 'MagicMock')
def test_get_file_size(self, os_get_size_mock):
"""Test get_file_size method."""
os_get_size_mock.return_value = 128
file_size = AnalyzeObject.get_file_size('/file/path')
self.assertEqual(file_size, 128)
def setUp(self):
"""SetUp config."""
self.analyzer = AnalyzeObject()
class TestAnalyzer(TestCase):
"""Test Analyzer class in model_lineage.py."""
def setUp(self):
"""SetUp config."""
self.analyzer = AnalyzeObject()
def test_analyze_optimizer(self):
"""Test analyze_optimizer method."""
optimizer = Optimizer(Tensor(0.12))
res = self.analyzer.analyze_optimizer(optimizer)
assert res == 0.12
def test_get_dataset_path(self):
"""Test get_dataset_path method."""
dataset = MindDataset(dataset_file='/path/to/mindrecord')
res = self.analyzer.get_dataset_path(dataset)
assert res == '/path/to/mindrecord'
def test_get_dataset_path_wrapped(self):
"""Test get_dataset_path_wrapped method."""
dataset = Dataset()
dataset.input.append(
MindDataset(dataset_size=10, dataset_file='/path/to/cifar10'))
res = self.analyzer.get_dataset_path_wrapped(dataset)
assert res == '/path/to/cifar10'
@mock.patch('mindinsight.lineagemgr.collection.model.model_lineage.'
'AnalyzeObject.get_dataset_path_wrapped')
def test_analyze_dataset(self, mock_get_path):
"""Test analyze_dataset method."""
mock_get_path.return_value = '/path/to/mindinsightset'
dataset = MindDataset(dataset_size=10,
dataset_file='/path/to/mindinsightset')
res1 = self.analyzer.analyze_dataset(dataset, {
'step_num': 10,
'epoch': 2
}, 'train')
res2 = self.analyzer.analyze_dataset(dataset, {'step_num': 5}, 'valid')
assert res1 == {
'step_num': 10,
'train_dataset_path': '/path/to',
'train_dataset_size': 50,
'epoch': 2
}
assert res2 == {
'step_num': 5,
'valid_dataset_path': '/path/to',
'valid_dataset_size': 50
}
def test_get_dataset_path_dataset(self):
"""Test get_dataset_path method with Dataset."""
dataset = Dataset(dataset_size=10, dataset_path='/path/to/cifar10')
with self.assertRaises(IndexError):
self.analyzer.get_dataset_path(output_dataset=dataset)
def test_get_dataset_path_mindrecord(self):
"""Test get_dataset_path method with MindDataset."""
dataset = MindDataset(dataset_file='/path/to/cifar10')
dataset_path = self.analyzer.get_dataset_path(output_dataset=dataset)
self.assertEqual(dataset_path, '/path/to/cifar10')
def test_get_file_path(self):
"""Test get_file_path method."""
model_ckpt = ModelCheckpoint(prefix='', directory='/path/to')
summary_step = SummaryStep(
MagicMock(full_file_name='/path/to/summary.log'))
list_callback = [model_ckpt, summary_step]
ckpt_file_path, _ = AnalyzeObject.get_file_path(list_callback)
self.assertEqual(ckpt_file_path, '/path/to/test_model.ckpt')
@mock.patch('os.path.getsize')
def test_get_file_size(self, os_get_size_mock):
"""Test get_file_size method."""
os_get_size_mock.return_value = 128
file_size = AnalyzeObject.get_file_size('/file/path')
self.assertEqual(file_size, 128)
@mock.patch('os.path.getsize')
def test_get_file_size_except(self, os_get_size_mock):
"""Test failed to get the size of file."""
os_get_size_mock.side_effect = OSError
analyzer = AnalyzeObject
with self.assertRaises(LineageGetModelFileError) as context:
analyzer.get_file_size('/file/path')
self.assertTrue(
'Error when get model file size:' in str(context.exception))
@mock.patch(
'mindinsight.lineagemgr.collection.model.model_lineage.AnalyzeObject.get_file_size'
)
def test_get_model_size(self, get_file_size_mock):
"""Test get_model_size method."""
get_file_size_mock.return_value = 128
analyzer = AnalyzeObject
file_size = analyzer.get_model_size(ckpt_file_path='/file/path')
self.assertEqual(file_size, 128)
@mock.patch(
'mindinsight.lineagemgr.collection.model.model_lineage.AnalyzeObject.get_file_size'
)
def test_get_model_size_no_ckpt(self, get_file_size_mock):
"""Test get_model_size method without ckpt file."""
get_file_size_mock.return_value = 0
analyzer = AnalyzeObject
file_size = analyzer.get_model_size(ckpt_file_path='')
self.assertEqual(file_size, 0)
@mock.patch('builtins.vars')
def test_get_optimizer_by_network(self, mock_vars):
"""Test get_optimizer_by_network."""
mock_optimizer = Optimizer(Tensor(0.1))
mock_cells = MagicMock()
mock_cells.items.return_value = [{'key': mock_optimizer}]
mock_vars.return_value = {'_cells': {'key': mock_optimizer}}
res = AnalyzeObject.get_optimizer_by_network(MagicMock())
self.assertEqual(res, mock_optimizer)
@mock.patch('builtins.vars')
def test_get_loss_fn_by_network(self, mock_vars):
"""Test get_loss_fn_by_network."""
mock_cell1 = {'_cells': {'key': SoftmaxCrossEntropyWithLogits(0.2)}}
mock_cell2 = {'_cells': {'opt': Optimizer(Tensor(0.1))}}
mock_cell3 = {'_cells': {'loss': SoftmaxCrossEntropyWithLogits(0.1)}}
mock_vars.side_effect = [mock_cell1, mock_cell2, mock_cell3]
res = AnalyzeObject.get_loss_fn_by_network(MagicMock())
self.assertEqual(res, mock_cell3['_cells']['loss'])
@mock.patch('builtins.vars')
def test_get_backbone_network_with_loss_cell(self, mock_vars):
"""Test get_backbone_network with loss_cell."""
mock_cell = {
'_cells': {
'key':
WithLossCell(MagicMock(), SoftmaxCrossEntropyWithLogits(0.1))
}
}
mock_vars.return_value = mock_cell
res = AnalyzeObject.get_backbone_network(MagicMock())
self.assertEqual(res, 'MagicMock')
@mock.patch('builtins.vars')
def test_get_backbone_network(self, mock_vars):
"""Test get_backbone_network."""
mock_net = TrainOneStepWithLossScaleCell()
mock_net.network = MagicMock()
mock_cell = {'_cells': {'key': mock_net}}
mock_vars.return_value = mock_cell
res = AnalyzeObject.get_backbone_network(MagicMock())
self.assertEqual(res, 'MagicMock')