Automating fraud detection is a critical application of machine learning in FinTech. Traditional rule-based systems often fall short when faced with evolving fraud tactics, but unsupervised learning algorithms can help identify unusual behavior in transaction data. In this challenge, you will use Python and scikit-learn's `IsolationForest` to detect anomalies within a set of transaction amounts. The `IsolationForest` algorithm works by isolating observations that are different from the majority—making it well-suited for flagging potentially fraudulent transactions without the need for labeled data. By integrating machine learning into fraud detection workflows, you can improve accuracy and adapt to new patterns of suspicious activity.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import sys
import io

class TestTask(unittest.TestCase):
    def test_returns_indices_of_anomalies(self):
        import user_code
        importlib.reload(user_code)
        # Known anomaly positions: 5 (500), 8 (2000)
        test_transactions = [50, 52, 48, 51, 49, 500, 53, 47, 2000, 54, 50, 48, 52, 49]
        result = user_code.detect_fraudulent_transactions(test_transactions)
        _dynamic_test(
            self,
            isinstance(result, list),
            "Function returns a list of anomaly indices",
            f"Expected list, got {type(result)}"
        )
        # These indices may change if IsolationForest behavior changes, but with random_state=42, should be stable
        expected = [5, 8]
        _dynamic_test(
            self,
            set(result) == set(expected) and len(result) == len(expected),
            "Correct indices for anomalies returned",
            f"Expected indices {expected}, got {result}"
        )

    def test_prints_number_of_anomalies(self):
        import user_code
        importlib.reload(user_code)
        test_transactions = [50, 52, 48, 51, 49, 500, 53, 47, 2000, 54, 50, 48, 52, 49]
        f = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = f
        user_code.detect_fraudulent_transactions(test_transactions)
        sys.stdout = sys_stdout
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "2" in output,
            "Prints correct number of anomalies (2)",
            f"Expected '2' in output, got: {output}"
        )

    def test_no_anomalies(self):
        import user_code
        importlib.reload(user_code)
        test_transactions = [10, 11, 12, 13, 10, 12, 11, 13, 12, 11]
        f = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = f
        result = user_code.detect_fraudulent_transactions(test_transactions)
        sys.stdout = sys_stdout
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) == 0,
            "Returns empty list if no anomalies detected",
            f"Expected empty list, got {result}"
        )
        _dynamic_test(
            self,
            "0" in output,
            "Prints 0 if no anomalies detected",
            f"Expected '0' in output, got: {output}"
        )

    def test_single_anomaly(self):
        import user_code
        importlib.reload(user_code)
        test_transactions = [100, 102, 101, 99, 103, 5000]
        f = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = f
        result = user_code.detect_fraudulent_transactions(test_transactions)
        sys.stdout = sys_stdout
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) == 1 and result[0] == 5,
            "Returns correct index for single anomaly",
            f"Expected [5], got {result}"
        )
        _dynamic_test(
            self,
            "1" in output,
            "Prints 1 for single anomaly detected",
            f"Expected '1' in output, got: {output}"
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

Explore how Python empowers FinTech solutions by automating financial analysis, modeling, and data-driven decision making. This course blends practical coding with real-world finance scenarios, guiding you through essential FinTech concepts and hands-on challenges.

Learn to analyze, manipulate, and visualize financial data using Python, focusing on core FinTech data workflows.

Apply Python to assess financial risk and optimize investment portfolios using statistical and mathematical techniques.

Apply machine learning techniques to financial data for prediction, classification, and decision support in FinTech applications.

Challenge: Detect Fraudulent Transactions

Oplossing

Challenge: Detect Fraudulent Transactions

Oplossing