convert DBNInference tests from unittest to pytest (pgmpy#3253)

**The following checklist is mandatory**

Your PR will be closed if you remove the checklist. Use of LLMs is
**strictly forbidden** for any part of this checklist (including for
improving language), and will result in a **ban** if we find any use of
LLMs.

### Your checklist for this pull request

- [x] Have you followed all the steps from our [Contributing
Guide](https://github.com/pgmpy/pgmpy/blob/dev/Contributing.md)?
- [x] Does the PR fully address the linked issue and is within its
defined scope? If you are still working on the PR, mark it as draft.
- [ ] Are all the GitHub Actions checks passing? If not, mark your PR as
draft while you fix it.

If you have used AI/LLMs for any assistance, please answer the following
questions. Please refer
[pgmpy#2622](pgmpy#2622) for an example of the
level of detail we expect:

- [x] Have you reviewed our [AI usage
policy](https://github.com/pgmpy/pgmpy/blob/dev/Contributing.md#ai-usage-policy)?
- [x] Are you able to fully explain your changes? We expect you to fully
understand the algorithm and take full responsibility for any changes in
this PR.

- Please describe in **detail** how and what you used AI assistance for?
Please outline your whole workflow with the AI tool.

 No, AI has been used.

- What steps have you taken to verify that the changes correctly address
the issue? What edge cases have you considered? Other than running
tests, what else have you verified?

-Ran the updated test file locally using pytest to ensure all tests
executed correctly.
-Verified that the outputs match the expected results from the original
unittest based tests.
-Ensured that the fixture correctly replaces the setUp method without
changing behavior.
-Checked that all test cases still cover the same scenarios (forward
inference, backward inference, with and without evidence).
-Verified that no logic changes were introduced and only the testing
framework was updated.

- Have you used AI for generating tests? Can you compress them into a
smaller number of tests without losing coverage?

 No AI has been used to generate tests.

### Issue number(s) that this pull request fixes
- Fixes 

### List of changes to the codebase in this pull request
-Removed unittest.TestCase inheritance
-Replaced setUp method with a pytest fixture defined outside the test
class
-Updated assertions from unittest style (self.assert) to plain assert
where applicable
-Updated test methods to accept fixtures as parameters instead of using
self
-Preserved original test logic and structure

Author: codejasleen

pgmpy/tests/test_inference/test_dbn_inference.py

@@ -1,7 +1,6 @@
-import unittest
-
 import numpy as np
 import numpy.testing as np_test
+import pytest
 from scipy.special import softmax
 
 from pgmpy.factors.discrete import TabularCPD
@@ -13,68 +12,77 @@
 # Huange Wang, Xiaoguang Gao, Chris P. Thompson
 
 
-class TestDBNInference(unittest.TestCase):
-    def setUp(self):
-        dbn_1 = DynamicBayesianNetwork()
-        dbn_1.add_edges_from([(("Z", 0), ("X", 0)), (("Z", 0), ("Y", 0)), (("Z", 0), ("Z", 1))])
-        cpd_start_z_1 = TabularCPD(("Z", 0), 2, [[0.8], [0.2]])
-        cpd_x_1 = TabularCPD(("X", 0), 2, [[0.9, 0.6], [0.1, 0.4]], [("Z", 0)], [2])
-        cpd_y_1 = TabularCPD(("Y", 0), 2, [[0.7, 0.2], [0.3, 0.8]], [("Z", 0)], [2])
-        cpd_trans_z_1 = TabularCPD(("Z", 1), 2, [[0.9, 0.1], [0.1, 0.9]], [("Z", 0)], [2])
-        dbn_1.add_cpds(cpd_start_z_1, cpd_trans_z_1, cpd_x_1, cpd_y_1)
-        dbn_1.initialize_initial_state()
-        self.dbn_inference_1 = DBNInference(dbn_1)
-        dbn_2 = DynamicBayesianNetwork()
-        dbn_2.add_edges_from([(("Z", 0), ("X", 0)), (("X", 0), ("Y", 0)), (("Z", 0), ("Z", 1))])
-        cpd_start_z_2 = TabularCPD(("Z", 0), 2, [[0.5], [0.5]])
-        cpd_x_2 = TabularCPD(("X", 0), 2, [[0.6, 0.9], [0.4, 0.1]], [("Z", 0)], [2])
-        cpd_y_2 = TabularCPD(("Y", 0), 2, [[0.2, 0.3], [0.8, 0.7]], [("X", 0)], [2])
-        cpd_z_2 = TabularCPD(("Z", 1), 2, [[0.4, 0.7], [0.6, 0.3]], [("Z", 0)], [2])
-        dbn_2.add_cpds(cpd_x_2, cpd_y_2, cpd_z_2, cpd_start_z_2)
-        dbn_2.initialize_initial_state()
-        self.dbn_inference_2 = DBNInference(dbn_2)
-
-    def test_forward_inf_single_variable(self):
-        query_result = self.dbn_inference_1.forward_inference([("X", 0)])
+@pytest.fixture
+def dbn_inference_instances():
+    dbn_1 = DynamicBayesianNetwork()
+    dbn_1.add_edges_from([(("Z", 0), ("X", 0)), (("Z", 0), ("Y", 0)), (("Z", 0), ("Z", 1))])
+    cpd_start_z_1 = TabularCPD(("Z", 0), 2, [[0.8], [0.2]])
+    cpd_x_1 = TabularCPD(("X", 0), 2, [[0.9, 0.6], [0.1, 0.4]], [("Z", 0)], [2])
+    cpd_y_1 = TabularCPD(("Y", 0), 2, [[0.7, 0.2], [0.3, 0.8]], [("Z", 0)], [2])
+    cpd_trans_z_1 = TabularCPD(("Z", 1), 2, [[0.9, 0.1], [0.1, 0.9]], [("Z", 0)], [2])
+    dbn_1.add_cpds(cpd_start_z_1, cpd_trans_z_1, cpd_x_1, cpd_y_1)
+    dbn_1.initialize_initial_state()
+    dbn_inference_1 = DBNInference(dbn_1)
+    dbn_2 = DynamicBayesianNetwork()
+    dbn_2.add_edges_from([(("Z", 0), ("X", 0)), (("X", 0), ("Y", 0)), (("Z", 0), ("Z", 1))])
+    cpd_start_z_2 = TabularCPD(("Z", 0), 2, [[0.5], [0.5]])
+    cpd_x_2 = TabularCPD(("X", 0), 2, [[0.6, 0.9], [0.4, 0.1]], [("Z", 0)], [2])
+    cpd_y_2 = TabularCPD(("Y", 0), 2, [[0.2, 0.3], [0.8, 0.7]], [("X", 0)], [2])
+    cpd_z_2 = TabularCPD(("Z", 1), 2, [[0.4, 0.7], [0.6, 0.3]], [("Z", 0)], [2])
+    dbn_2.add_cpds(cpd_x_2, cpd_y_2, cpd_z_2, cpd_start_z_2)
+    dbn_2.initialize_initial_state()
+    dbn_inference_2 = DBNInference(dbn_2)
+    return dbn_inference_1, dbn_inference_2
+
+
+class TestDBNInference:
+    def test_forward_inf_single_variable(self, dbn_inference_instances):
+        dbn_inference_1, _ = dbn_inference_instances
+        query_result = dbn_inference_1.forward_inference([("X", 0)])
         np_test.assert_array_almost_equal(query_result[("X", 0)].values, np.array([0.84, 0.16]))
 
-    def test_forward_inf_multiple_variable(self):
-        query_result = self.dbn_inference_1.forward_inference([("X", 0), ("Y", 0)])
+    def test_forward_inf_multiple_variable(self, dbn_inference_instances):
+        dbn_inference_1, _ = dbn_inference_instances
+        query_result = dbn_inference_1.forward_inference([("X", 0), ("Y", 0)])
         np_test.assert_array_almost_equal(query_result[("X", 0)].values, np.array([0.84, 0.16]))
         np_test.assert_array_almost_equal(query_result[("Y", 0)].values, np.array([0.6, 0.4]))
 
-    def test_forward_inf_single_variable_with_evidence(self):
-        query_result = self.dbn_inference_1.forward_inference([("Z", 1)], {("Y", 0): 0, ("Y", 1): 0})
+    def test_forward_inf_single_variable_with_evidence(self, dbn_inference_instances):
+        dbn_inference_1, dbn_inference_2 = dbn_inference_instances
+        query_result = dbn_inference_1.forward_inference([("Z", 1)], {("Y", 0): 0, ("Y", 1): 0})
         np_test.assert_array_almost_equal(query_result[("Z", 1)].values, np.array([0.95080214, 0.04919786]))
-        query_result = self.dbn_inference_2.forward_inference([("X", 2)], {("Y", 0): 1, ("Y", 1): 0, ("Y", 2): 1})
+        query_result = dbn_inference_2.forward_inference([("X", 2)], {("Y", 0): 1, ("Y", 1): 0, ("Y", 2): 1})
         np_test.assert_array_almost_equal(query_result[("X", 2)].values, np.array([0.76738736, 0.23261264]))
 
-    def test_forward_inf_multiple_variable_with_evidence(self):
-        query_result = self.dbn_inference_1.forward_inference([("Z", 1), ("X", 1)], {("Y", 0): 0, ("Y", 1): 0})
+    def test_forward_inf_multiple_variable_with_evidence(self, dbn_inference_instances):
+        dbn_inference_1, _ = dbn_inference_instances
+        query_result = dbn_inference_1.forward_inference([("Z", 1), ("X", 1)], {("Y", 0): 0, ("Y", 1): 0})
         np_test.assert_array_almost_equal(query_result[("Z", 1)].values, np.array([0.95080214, 0.04919786]))
 
         np_test.assert_array_almost_equal(query_result[("X", 1)].values, np.array([0.88524064, 0.11475936]))
 
-    def test_backward_inf_single_variable(self):
-        query_result = self.dbn_inference_2.backward_inference([("Y", 0)])
+    def test_backward_inf_single_variable(self, dbn_inference_instances):
+        _, dbn_inference_2 = dbn_inference_instances
+        query_result = dbn_inference_2.backward_inference([("Y", 0)])
         np_test.assert_array_almost_equal(query_result[("Y", 0)].values, np.array([0.225, 0.775]))
 
-    def test_backward_inf_multiple_variables(self):
-        query_result = self.dbn_inference_2.backward_inference([("X", 0), ("Y", 0)])
+    def test_backward_inf_multiple_variables(self, dbn_inference_instances):
+        _, dbn_inference_2 = dbn_inference_instances
+        query_result = dbn_inference_2.backward_inference([("X", 0), ("Y", 0)])
         np_test.assert_array_almost_equal(query_result[("X", 0)].values, np.array([0.75, 0.25]))
         np_test.assert_array_almost_equal(query_result[("Y", 0)].values, np.array([0.225, 0.775]))
 
-    def test_backward_inf_single_variable_with_evidence(self):
-        query_result = self.dbn_inference_2.backward_inference([("X", 0)], {("Y", 0): 0, ("Y", 1): 1, ("Y", 2): 1})
+    def test_backward_inf_single_variable_with_evidence(self, dbn_inference_instances):
+        dbn_inference_1, dbn_inference_2 = dbn_inference_instances
+        query_result = dbn_inference_2.backward_inference([("X", 0)], {("Y", 0): 0, ("Y", 1): 1, ("Y", 2): 1})
         np_test.assert_array_almost_equal(query_result[("X", 0)].values, np.array([0.66594382, 0.33405618]))
 
-        query_result = self.dbn_inference_1.backward_inference([("Z", 1)], {("Y", 0): 0, ("Y", 1): 0, ("Y", 2): 0})
+        query_result = dbn_inference_1.backward_inference([("Z", 1)], {("Y", 0): 0, ("Y", 1): 0, ("Y", 2): 0})
         np_test.assert_array_almost_equal(query_result[("Z", 1)].values, np.array([0.98048698, 0.01951302]))
 
-    def test_backward_inf_multiple_variables_with_evidence(self):
-        query_result = self.dbn_inference_2.backward_inference(
-            [("X", 0), ("X", 1)], {("Y", 0): 0, ("Y", 1): 1, ("Y", 2): 1}
-        )
+    def test_backward_inf_multiple_variables_with_evidence(self, dbn_inference_instances):
+        _, dbn_inference_2 = dbn_inference_instances
+        query_result = dbn_inference_2.backward_inference([("X", 0), ("X", 1)], {("Y", 0): 0, ("Y", 1): 1, ("Y", 2): 1})
         np_test.assert_array_almost_equal(query_result[("X", 0)].values, np.array([0.677533, 0.322467]))
         np_test.assert_array_almost_equal(query_result[("X", 1)].values, np.array([0.7621772, 0.2378228]))
 
@@ -184,7 +192,7 @@ def test_github_issue_1794(self):
         inference = DBNInference(dbn)
 
         # Basic sanity checks
-        self.assertIsNotNone(inference.start_bayesian_model)
-        self.assertIsNotNone(inference.one_and_half_model)
-        self.assertIsNotNone(inference.start_junction_tree)
-        self.assertIsNotNone(inference.one_and_half_junction_tree)
+        assert inference.start_bayesian_model is not None
+        assert inference.one_and_half_model is not None
+        assert inference.start_junction_tree is not None
+        assert inference.one_and_half_junction_tree is not None