In diesem Tutorial erstellen wir einen selbstverifizierenden DataOps AIAgent, der Datenoperationen mithilfe lokaler Hugging Face-Modelle automatisch planen, ausführen und testen kann. Wir entwerfen den Agenten mit drei intelligenten Rollen: einem Planer, der eine Ausführungsstrategie erstellt, einem Executor, der Code mit Pandas schreibt und ausführt, und einem Tester, der die Ergebnisse auf Genauigkeit und Konsistenz validiert. Durch die lokale Verwendung des Phi-2-Modells von Microsoft in Google Colab stellen wir sicher, dass der Workflow effizient, reproduzierbar und datenschutzkonform bleibt, und demonstrieren gleichzeitig, wie LLMs komplexe Datenverarbeitungsaufgaben durchgängig automatisieren können. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

!pip set up -q transformers speed up bitsandbytes scipy
import json, pandas as pd, numpy as np, torch
from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline, BitsAndBytesConfig


MODEL_NAME = "microsoft/phi-2"


class LocalLLM:
   def __init__(self, model_name=MODEL_NAME, use_8bit=False):
       print(f"Loading mannequin: {model_name}")
       self.tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
       if self.tokenizer.pad_token is None:
           self.tokenizer.pad_token = self.tokenizer.eos_token
       model_kwargs = {"device_map": "auto", "trust_remote_code": True}
       if use_8bit and torch.cuda.is_available():
           model_kwargs("quantization_config") = BitsAndBytesConfig(load_in_8bit=True)
       else:
           model_kwargs("torch_dtype") = torch.float32 if not torch.cuda.is_available() else torch.float16
       self.mannequin = AutoModelForCausalLM.from_pretrained(model_name, **model_kwargs)
       self.pipe = pipeline("text-generation", mannequin=self.mannequin, tokenizer=self.tokenizer,
                            max_new_tokens=512, do_sample=True, temperature=0.3, top_p=0.9,
                            pad_token_id=self.tokenizer.eos_token_id)
       print("✓ Mannequin loaded efficiently!n")


   def generate(self, immediate, system_prompt="", temperature=0.3):
       if system_prompt:
           full_prompt = f"Instruct: {system_prompt}nn{immediate}nOutput:"
       else:
           full_prompt = f"Instruct: {immediate}nOutput:"
       output = self.pipe(full_prompt, temperature=temperature, do_sample=temperature>0,
                          return_full_text=False, eos_token_id=self.tokenizer.eos_token_id)
       outcome = output(0)('generated_text').strip()
       if "Instruct:" in outcome:
           outcome = outcome.break up("Instruct:")(0).strip()
       return outcome

Wir installieren die erforderlichen Bibliotheken und laden das Phi-2-Modell lokal mithilfe von Hugging Face Transformers. Wir erstellen eine LocalLLM-Klasse, die den Tokenizer und das Modell initialisiert, optionale Quantisierung unterstützt und eine Generiermethode definiert, um Textausgaben zu erzeugen. Wir stellen sicher, dass das Modell sowohl auf der CPU als auch auf der GPU reibungslos läuft, sodass es sich superb für den Einsatz auf Colab eignet. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

PLANNER_PROMPT = """You're a Information Operations Planner. Create an in depth execution plan as legitimate JSON.


Return ONLY a JSON object (no different textual content) with this construction:
{"steps": ("step 1","step 2"),"expected_output":"description","validation_criteria":("standards 1","standards 2")}"""


EXECUTOR_PROMPT = """You're a Information Operations Executor. Write Python code utilizing pandas.


Necessities:
- Use pandas (imported as pd) and numpy (imported as np)
- Retailer remaining end in variable 'outcome'
- Return ONLY Python code, no explanations or markdown"""


TESTER_PROMPT = """You're a Information Operations Tester. Confirm execution outcomes.


Return ONLY a JSON object (no different textual content) with this construction:
{"handed":true,"points":("any points discovered"),"suggestions":("recommendations")}"""


class DataOpsAgent:
   def __init__(self, llm=None):
       self.llm = llm or LocalLLM()
       self.historical past = ()


   def _extract_json(self, textual content):
       strive:
           return json.hundreds(textual content)
       besides:
           begin, finish = textual content.discover('{'), textual content.rfind('}')+1
           if begin >= 0 and finish > begin:
               strive:
                   return json.hundreds(textual content(begin:finish))
               besides:
                   cross
       return None

Wir definieren die Systemeingabeaufforderungen für die Rollen Planner, Executor und Tester unseres DataOps-Agenten. Anschließend initialisieren wir die DataOpsAgent-Klasse mit Hilfsmethoden und einem JSON-Extraktionsdienstprogramm, um strukturierte Antworten zu analysieren. Wir bereiten die Grundlage für die Argumentations- und Ausführungspipeline des Agenten. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

 def plan(self, process, data_info):
       print("n" + "="*60)
       print("PHASE 1: PLANNING")
       print("="*60)
       immediate = f"Activity: {process}nnData Info:n{data_info}nnCreate an execution plan as JSON with steps, expected_output, and validation_criteria."
       plan_text = self.llm.generate(immediate, PLANNER_PROMPT, temperature=0.2)
       self.historical past.append(("PLANNER", plan_text))
       plan = self._extract_json(plan_text) or {"steps":(process),"expected_output":"Processed knowledge","validation_criteria":("Consequence generated","No errors")}
       print(f"n Plan Created:")
       print(f"  Steps: {len(plan.get('steps', ()))}")
       for i, step in enumerate(plan.get('steps', ()), 1):
           print(f"    {i}. {step}")
       print(f"  Anticipated: {plan.get('expected_output', 'N/A')}")
       return plan


   def execute(self, plan, data_context):
       print("n" + "="*60)
       print("PHASE 2: EXECUTION")
       print("="*60)
       steps_text="n".be a part of(f"{i}. {s}" for i, s in enumerate(plan.get('steps', ()), 1))
       immediate = f"Activity Steps:n{steps_text}nnData out there: DataFrame 'df'n{data_context}nnWrite Python code to execute these steps. Retailer remaining end in 'outcome' variable."
       code = self.llm.generate(immediate, EXECUTOR_PROMPT, temperature=0.1)
       self.historical past.append(("EXECUTOR", code))
       if "```python" in code: code = code.break up("```python")(1).break up("```")(0)
       elif "```" in code: code = code.break up("```")(1).break up("```")(0)
       traces = ()
       for line in code.break up('n'):
           s = line.strip()
           if s and (not s.startswith('#') or 'import' in s):
               traces.append(line)
       code="n".be a part of(traces).strip()
       print(f"n Generated Code:n" + "-"*60)
       for i, line in enumerate(code.break up('n')(:15),1):
           print(f"{i:2}. {line}")
       if len(code.break up('n'))>15: print(f"    ... ({len(code.break up('n'))-15} extra traces)")
       print("-"*60)
       return code

Wir implementieren die Planungs- und Ausführungsphasen des Agenten. Wir lassen den Planer detaillierte Aufgabenschritte und Validierungskriterien erstellen, und dann generiert der Ausführende den entsprechenden Python-Code basierend auf Pandas, um die Aufgabe auszuführen. Wir visualisieren, wie der Agent autonom von der Argumentation zur Generierung umsetzbaren Codes übergeht. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

def check(self, plan, outcome, execution_error=None):
       print("n" + "="*60)
       print("PHASE 3: TESTING & VERIFICATION")
       print("="*60)
       result_desc = f"EXECUTION ERROR: {execution_error}" if execution_error else f"Consequence kind: {kind(outcome).__name__}n"
       if not execution_error:
           if isinstance(outcome, pd.DataFrame):
               result_desc += f"Form: {outcome.form}nColumns: {checklist(outcome.columns)}nSample:n{outcome.head(3).to_string()}"
           elif isinstance(outcome, (int,float,str)):
               result_desc += f"Worth: {outcome}"
           else:
               result_desc += f"Worth: {str(outcome)(:200)}"
       criteria_text="n".be a part of(f"- {c}" for c in plan.get('validation_criteria', ()))
       immediate = f"Validation Standards:n{criteria_text}nnExpected: {plan.get('expected_output', 'N/A')}nnActual Consequence:n{result_desc}nnEvaluate if outcome meets standards. Return JSON with handed (true/false), points, and suggestions."
       test_result = self.llm.generate(immediate, TESTER_PROMPT, temperature=0.2)
       self.historical past.append(("TESTER", test_result))
       test_json = self._extract_json(test_result) or {"handed":execution_error is None,"points":("Couldn't parse check outcome"),"suggestions":("Overview manually")}
       print(f"n✓ Check Outcomes:n  Standing: {' PASSED' if test_json.get('handed') else ' FAILED'}")
       if test_json.get('points'):
           print("  Points:")
           for problem in test_json('points')(:3):
               print(f"    • {problem}")
       if test_json.get('suggestions'):
           print("  Suggestions:")
           for rec in test_json('suggestions')(:3):
               print(f"    • {rec}")
       return test_json


   def run(self, process, df=None, data_info=None):
       print("n SELF-VERIFYING DATA-OPS AGENT (Native HF Mannequin)")
       print(f"Activity: {process}n")
       if data_info is None and df is just not None:
           data_info = f"Form: {df.form}nColumns: {checklist(df.columns)}nSample:n{df.head(2).to_string()}"
       plan = self.plan(process, data_info)
       code = self.execute(plan, data_info)
       outcome, error = None, None
       strive:
           local_vars = {'pd': pd, 'np': np, 'df': df}
           exec(code, local_vars)
           outcome = local_vars.get('outcome')
       besides Exception as e:
           error = str(e)
           print(f"n  Execution Error: {error}")
       test_result = self.check(plan, outcome, error)
       return {'plan': plan,'code': code,'outcome': outcome,'check': test_result,'historical past': self.historical past}

Wir konzentrieren uns auf die Check- und Verifizierungsphase unseres Workflows. Wir lassen den Agenten seine eigene Ausgabe anhand vordefinierter Validierungskriterien bewerten und das Ergebnis als strukturiertes JSON zusammenfassen. Anschließend integrieren wir alle drei Phasen, Planung, Ausführung und Check, in einer einzigen selbstverifizierenden Pipeline, die eine vollständige Automatisierung gewährleistet. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

def demo_basic(agent):
   print("n" + "#"*60)
   print("# DEMO 1: Gross sales Information Aggregation")
   print("#"*60)
   df = pd.DataFrame({'product':('A','B','A','C','B','A','C'),
                      'gross sales':(100,150,200,80,130,90,110),
                      'area':('North','South','North','East','South','West','East')})
   process = "Calculate whole gross sales by product"
   output = agent.run(process, df)
   if output('outcome') is just not None:
       print(f"n Closing Consequence:n{output('outcome')}")
   return output


def demo_advanced(agent):
   print("n" + "#"*60)
   print("# DEMO 2: Buyer Age Evaluation")
   print("#"*60)
   df = pd.DataFrame({'customer_id':vary(1,11),
                      'age':(25,34,45,23,56,38,29,41,52,31),
                      'purchases':(5,12,8,3,15,7,9,11,6,10),
                      'spend':(500,1200,800,300,1500,700,900,1100,600,1000)})
   process = "Calculate common spend by age group: younger (underneath 35) and mature (35+)"
   output = agent.run(process, df)
   if output('outcome') is just not None:
       print(f"n Closing Consequence:n{output('outcome')}")
   return output


if __name__ == "__main__":
   print(" Initializing Native LLM...")
   print("Utilizing CPU mode for optimum compatibilityn")
   strive:
       llm = LocalLLM(use_8bit=False)
       agent = DataOpsAgent(llm)
       demo_basic(agent)
       print("nn")
       demo_advanced(agent)
       print("n" + "="*60)
       print(" Tutorial Full!")
       print("="*60)
       print("nKey Options:")
       print("  • 100% Native - No API calls required")
       print("  • Makes use of Phi-2 from Microsoft (2.7B params)")
       print("  • Self-verifying 3-phase workflow")
       print("  • Runs on free Google Colab CPU/GPU")
   besides Exception as e:
       print(f"n Error: {e}")
       print("Troubleshooting:n1. pip set up -q transformers speed up scipyn2. Restart runtimen3. Attempt a distinct mannequin")

Wir haben zwei Demobeispiele erstellt, um die Fähigkeiten des Agenten anhand einfacher Verkaufs- und Kundendatensätze zu testen. Wir initialisieren das Modell, führen den Information-Ops-Workflow aus und beobachten den gesamten Zyklus von der Planung bis zur Validierung. Wir schließen das Tutorial mit einer Zusammenfassung der wichtigsten Vorteile ab und ermutigen zu weiteren Experimenten mit lokalen Modellen.

Zusammenfassend haben wir ein vollständig autonomes und selbstverifizierendes DataOps-System erstellt, das auf einem lokalen Hugging Face-Modell basiert. Wir erleben, wie jede Part – Planung, Ausführung und Exams – nahtlos zusammenwirkt, um zuverlässige Ergebnisse zu erzielen, ohne auf Cloud-APIs angewiesen zu sein. Dieser Workflow unterstreicht die Stärke lokaler LLMs wie Phi-2 für eine leichte Automatisierung und inspiriert uns, diese Architektur in Zukunft für fortschrittlichere Datenpipelines, Validierungsframeworks und Multi-Agenten-Datensysteme zu erweitern.

Schauen Sie sich das an VOLLSTÄNDIGE CODES hier. Schauen Sie sich gerne bei uns um GitHub-Seite für Tutorials, Codes und Notebooks. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser Publication. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Asif Razzaq ist CEO von Marktechpost Media Inc.. Als visionärer Unternehmer und Ingenieur setzt sich Asif dafür ein, das Potenzial der künstlichen Intelligenz für das soziale Wohl zu nutzen. Sein jüngstes Unterfangen ist die Einführung einer Medienplattform für künstliche Intelligenz, Marktechpost, die sich durch eine ausführliche Berichterstattung über maschinelles Lernen und Deep-Studying-Nachrichten auszeichnet, die sowohl technisch fundiert als auch für ein breites Publikum leicht verständlich ist. Die Plattform verfügt über mehr als 2 Millionen monatliche Aufrufe, was ihre Beliebtheit beim Publikum verdeutlicht.

Folgen Sie MARKTECHPOST: Fügen Sie uns als bevorzugte Quelle bei Google hinzu.

Unit -Checks sind Codesegmente, die zum Testen anderer Codeteile geschrieben wurden, typischerweise eine einzelne Funktion oder Methode, die wir als Einheit bezeichnen. Sie sind ein sehr wichtiger Bestandteil des Softwareentwicklungsprozesses, da sie dazu beitragen, sicherzustellen, dass der Code wie beabsichtigt funktioniert und Fehler frühzeitig fangen. Die Implementierung von Unit -Checks in Python ist auch eine bewährte Verfahren, die Zeit und Geld sparen kann, indem sie Probleme finden und beheben, bevor sie größere Probleme verursachen.

In diesem Artikel werden wir das Schreiben von Unit -Checks in Python vom Verständnis des Verständnisses abdecken assert Anweisung zur Verwendung eines Frameworks, das speziell für diese Artwork von Aufgabe entwickelt wurde – und nach Greatest Practices der Python -Unit -Checks.

Python verfügt über zwei Hauptrahmen, damit die Testen der Unit -Checks erleichtert werden: unittest Und PyTest. Der erste ist seit Python 2.1 Teil der Standardbibliothek von Python und das ist diejenige, auf die wir uns in diesem Artikel konzentrieren.

Um das Tutorial für das Unit -Check zu verfolgen, benötigen Sie kein erweitertes Wissen, aber wir erwarten, dass Sie ein grundlegendes Verständnis dafür haben, wie Python funktioniert und Klassen funktionieren.

Der assert Stellungnahme

Der assert Die Erklärung ist eine integrierte Aussage in Python, die wie der Title angegeben hat, ob eine bestimmte Bedingung wahr ist oder nicht. Wenn die Bedingung wahr ist, passiert nichts, aber wenn es nicht wahr ist, wird ein Fehler aufgeworfen. Obwohl es zunächst so aussehen kann wie das attempt Und besides Klauseln, sie sind völlig anders und assert sollte nicht für die Fehlerbehandlung verwendet werden, sondern aus Gründen des Debuggens und der Prüfung.

Beispielsweise ist die Bedingung in der folgenden Zeile wahr und daher nichts ausgibt oder zurückgibt:

assert 1 > 0

Wenn wir diese Bedingung jedoch ändern, sodass sie falsch wird, bekommen wir eine AssertionError:

assert 1 < 0

---------------------------------------------------------------------------
AssertionError                            Traceback (most up-to-date name final)
<ipython-input-2-2d19dbe67b58> in <module>
----> 1 assert 1 < 0

AssertionError: 

Beachten Sie, dass in der letzten Zeile der Fehlermeldung keine tatsächliche Nachricht danach keine Nachricht AssertionError:. Das liegt daran, dass der Benutzer diese Nachricht übergeben sollte. So wie: wie:

n = 0
assert 1 < n, 'The Situation is False'

---------------------------------------------------------------------------
AssertionError                            Traceback (most up-to-date name final)
<ipython-input-3-e335e3eb84ff> in <module>
      1 n = 0
----> 2 assert 1 < n, 'The Situation is False'

AssertionError: The Situation is False

Die grundlegende Syntax für die Verwendung assert ist die folgende:

assert <situation being examined>, <error message to be displayed>

assert ist sehr einfach zu bedienen. Das Verständnis für Testzwecke ist, wie wir in den folgenden Abschnitten sehen werden.

Der unittest Modul

Der unittest Modul ist ein Framework, das unser Leben beim Testen von Code erleichtert. Das Modul funktioniert auf einigen wichtigen objektorientierten Konzepten, und deshalb müssen Sie die Grundlagen von Klassen und Methoden in Python verstehen.

Ein Testfall wird als einzelne Testeinheit angesehen und durch die dargestellt TestCase Klasse. Unter den zahlreichen Instruments von unittest Dadurch können wir Code testen, diese Klasse ist eine der wichtigsten. Es wird als Basisklasse verwendet, um unsere eigenen Testfälle zu erstellen, mit denen wir mehrere Checks gleichzeitig durchführen können.

Obwohl wir die Bedeutung des Python gesehen haben assert Anweisung Im letzten Abschnitt wird es hier nicht verwendet. Das liegt daran, dass die TestCase Die Klasse liefert auch einige seiner eigenen Assert -Methoden, die genau wie die funktionieren assert Aussage, aber für bestimmte Arten von Behauptungen.

Zum Beispiel die assertEqual Nimmt zwei Elemente und Checks, wenn sie gleich sind, während sie gleich sind assertNotEqual Checks, wenn die Elemente unterschiedlich sind. Auch die assertTrue Methode nimmt ein Component und testet, wenn es wahr ist, während es wahr ist assertFalse Checks, wenn es falsch ist.

Hier ist eine Liste der am häufigsten verwendeten Assert -Methoden in der TestCase Klasse, bereitgestellt vom Beamten unittest Dokumentation:

Es ist wichtig zu sagen, dass alle Methoden in der TestCase Klasse nehmen auch a msg Argument, das als Fehlermeldung verwendet wird, falls der Check fehlschlägt.

Implementierung von Unit -Checks in Python

Implementieren wir additionally einen einfachen Satz von Unit -Checks. Zunächst müssen wir einen Code zum Testen haben. Dafür betrachten wir Folgendes Calculations Klasse, der sich im Inneren befindet my_calculations.py Datei in der checks Verzeichnis:

# undertaking/code/my_calculations.py

class Calculations:
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def get_sum(self):
        return self.a + self.b

    def get_difference(self):
        return self.a - self.b

    def get_product(self):
        return self.a * self.b

    def get_quotient(self):
        return self.a / self.b

Dies ist eine sehr einfache Klasse, die zwei Zahlen benötigt und vier Methoden zum Addieren, Subtrahieren, Multiplizieren und Teilen der ersten Zahl durch die zweite hinzufügen, subtrahieren, multiplizieren und teilen und das Ergebnis zurückgeben.

Jetzt möchten wir die Methoden in dieser Klasse testen. Dafür müssen wir eine Klasse basierend auf dem erstellen TestCase Klasse und diese Klasse enthält Methoden, die die Checks durchführen.

Nehmen wir an, wir haben die folgende Ordnerstruktur:

undertaking/
│
├── code/
│   ├── __initII.py
│   └── my_calculations
│
└── checks.py

# undertaking/check.py

import unittest
from code.my_calculations import Calculations

class TestCalculations(unittest.TestCase):

    def test_sum(self):
        calculation = Calculations(8, 2)
        self.assertEqual(calculation.get_sum(), 10, 'The sum is unsuitable.')

if __name__ == '__main__':
    unittest.important()

Der obige Code testet die get_sum Methode der Calculations Klasse. Um dies zu erreichen, mussten wir Folgendes tun:

1. Beide importieren unittests und die Calculations Klasse
2. Ein Objekt instanziieren, wenn die Calculations Klasse
3. Erstellen die TestCalculations Klasse und die test_sum Methode darin

Beachten Sie, dass wir verwenden assertEqual zu behaupten, ob die Ausgabe von get_sum ist gleich 10. Wir haben auch einen Meldung für den Fehler des Fehlers. Schließlich, wenn wir dieses Skript ausführen, unittest.important() leitet den Check aus. Dies ist die Ausgabe, die wir erhalten:

.
----------------------------------------------------------------------
Ran 1 check in 0.000s
OK

Wenn wir beispielsweise den erwarteten Wert von 10 auf 11 ändern, würde der Check fehlschlagen und wir hätten diese Ausgabe:

----------------------------------------------------------------------
Traceback (most up-to-date name final):
  File ".my_test.py", line 9, in test_sum
    self.assertEqual(calculation.get_sum(), 11, 'The sum is unsuitable.')
AssertionError: 10 != 11 : The sum is unsuitable.
----------------------------------------------------------------------
Ran 1 check in 0.001s

Beachten Sie, dass die The sum is unsuitable. Nachricht ist wie erwartet da.

Nach der gleichen Logik haben wir den Code unten, der alle vier Methoden in der testet Calculations Klasse:

import unittest
from code.my_calculations import Calculations

class TestCalculations(unittest.TestCase):

    def test_sum(self):
        calculation = Calculations(8, 2)
        self.assertEqual(calculation.get_sum(), 10, 'The sum is unsuitable.')

    def test_diff(self):
        calculation = Calculations(8, 2)
        self.assertEqual(calculation.get_difference(), 6, 'The distinction is unsuitable.')

    def test_product(self):
        calculation = Calculations(8, 2)
        self.assertEqual(calculation.get_product(), 16, 'The product is unsuitable.')

    def test_quotient(self):
        calculation = Calculations(8, 2)
        self.assertEqual(calculation.get_quotient(), 4, 'The quotient is unsuitable.')

if __name__ == '__main__':
    unittest.important()

Und alle Checks lagen:

....
----------------------------------------------------------------------
Ran 4 checks in 0.001s
OK

Übrigens ist es kein Unfall, dass alle Namen der Methoden mit dem Wort beginnen check. Dies ist eine Konvention, die wir verwenden, damit unittest kann die Checks identifizieren, die es durchführen soll. Beispielsweise werden im folgenden Code nur drei Checks ausgeführt:

import unittest
from code.my_calculations import Calculations

class TestCalculations(unittest.TestCase):

    def not_a_test_sum(self):
        calculation = Calculations(8, 2)
        self.assertEqual(calculation.get_sum(), 10, 'The sum is unsuitable.')

    def test_diff(self):
        calculation = Calculations(8, 2)
        self.assertEqual(calculation.get_difference(), 6, 'The distinction is unsuitable.')

    def test_product(self):
        calculation = Calculations(8, 2)
        self.assertEqual(calculation.get_product(), 16, 'The product is unsuitable.')

    def test_quotient(self):
        calculation = Calculations(8, 2)
        self.assertEqual(calculation.get_quotient(), 4, 'The quotient is unsuitable.')

if __name__ == '__main__':
    unittest.important()

...
----------------------------------------------------------------------
Ran 3 checks in 0.001s
OK

Die Ausgabe besagt, dass drei Checks ausgeführt wurden. Beachten Sie, dass die erste Methode aufgerufen wird not_a_test_sumUnd deshalb wurde es nicht ausgeführt.

Der setUp Verfahren

Jetzt, da wir die Grundlagen der Unit -Checks mit dem verstehen unittest Modul, optimieren wir unseren Code ein wenig. Sie haben wahrscheinlich bemerkt, dass wir in jedem Check ein Objekt der initialisiert haben Calculations Klasse, die getestet wird. Wir können dies jedoch vermeiden, indem wir a erstellen setUp Verfahren.

Der TestCase Klasse hat bereits eine setUp Methode, die vor jedem Check ausgeführt wird. Was wir additionally tun werden, wenn wir eine neue erstellen, ist die Standardmethode mit unserer eigenen. Dies ist der Code mit dieser neuen Methode implementiert:

import unittest
from code.my_calculations import Calculations

class TestCalculations(unittest.TestCase):

    def setUp(self):
        self.calculation = Calculations(8, 2)

    def test_sum(self):
        self.assertEqual(self.calculation.get_sum(), 10, 'The sum is unsuitable.')

    def test_diff(self):
        self.assertEqual(self.calculation.get_difference(), 6, 'The distinction is unsuitable.')

    def test_product(self):
        self.assertEqual(self.calculation.get_product(), 16, 'The product is unsuitable.')

    def test_quotient(self):
        self.assertEqual(self.calculation.get_quotient(), 4, 'The quotient is unsuitable.')

if __name__ == '__main__':
    unittest.important()

Dies bedeutet, dass die calculations Das Objekt wird initialisiert, bevor jeder Check ausgeführt wird. Eine andere Possibility ist die Verwendung setUpClass stattdessen. Die Idee ist gleich mit dem einzigen Unterschied, dass diese Methode nur einmal und nicht vor jedem Check ausgeführt wird. So wird diese Methode implementiert:

@classmethod
def setUpClass(self):
    self.calculation = Calculations(8, 2)

Ausführen von Checks aus der Befehlszeile

Im vorherigen Abschnitt haben wir festgestellt, dass es möglich ist, die Checks mit dem durchzuführen unittest.important() innen .py Datei. Eine weitere sehr nützliche Möglichkeit, Checks durchzuführen unittest direkt aus der Befehlszeile.

Durch die Verwendung der Befehlszeilenschnittstelle zum Ausführen von Unit-Checks können Sie Ihre Produktivität verbessern, da Sie mehrere Dateien gleichzeitig ausführen können:

>>>pyhon -m unittest

In der obigen Linie wird der Erkennungsmodus in ausgeführt unittest Das wird nach den Checks im aktuellen Verzeichnis suchen.

Damit die Checks ausgeführt werden müssen, müssen wir jedoch einigen Namenskonventionen folgen: Der Title jeder Datei mit Checks muss mit beginnen checkund alle Checks müssen Klassenmethoden sein, basierend auf der TestCase Klasse. Wie bereits erwähnt, müssen die Namen all dieser Methoden mit dem Wort beginnen check. Schließlich muss das Verzeichnis ein importierbares Modul sein, was bedeutet, dass es eine enthalten sollte init.py Datei.

Nehmen wir an, wir haben Folgendes checks Verzeichnis:

checks/
├── init.py
├── check.py
└── test_str.py

Der test_str.py Die Datei enthält die folgenden Checks, die aus einem Beispiel in der untestesten Dokumentation gestellt wurden:

import unittest

class TestStringMethods(unittest.TestCase):

    def test_upper(self):
        self.assertEqual('foo'.higher(), 'FOO')

    def test_isupper(self):
        self.assertTrue('FOO'.isupper())
        self.assertFalse('Foo'.isupper())

    def test_split(self):
        s = 'whats up world'
        self.assertEqual(s.cut up(), ('whats up', 'world'))
        # test that s.cut up fails when the separator is just not a string
        with self.assertRaises(TypeError):
            s.cut up(2)

if __name__ == '__main__':
    unittest.important()

Wenn wir die Checks in beiden Dateien ausführen möchten, können wir die folgende Zeile verwenden:

>>>python -m unittest -v

Der -v Macht die Ausgabe etwas ausführlicher, was bei der Durchführung mehrerer Checks gleichzeitig nützlich sein kann:

test_diff (teste.check.TestCalculations) ... okay
test_product (teste.check.TestCalculations) ... okay
test_quotient (teste.check.TestCalculations) ... okay
test_sum (teste.check.TestCalculations) ... okay
test_isupper (teste.test_str.TestStringMethods) ... okay
test_split (teste.test_str.TestStringMethods) ... okay
test_upper (teste.test_str.TestStringMethods) ... okay
----------------------------------------------------------------------
Ran 7 checks in 0.002s
OK

Wir können auch eine einzelne Datei angeben, die ausgeführt werden soll:

>>>python -m unittest -v checks.check

In der obigen Linie, checks.check stellt sicher, dass nur die Datei checks.py ausgeführt wird. Mit derselben Logik geben wir die Testklasse und sogar eine einzelne Methode an, die wir ausführen möchten:

>>>python -m unittest -v checks.check.TestCalculations.test_diff

Die obige Linie wird nur die ausgeführt test_diff Methode, wie wir in der Ausgabe sehen können:

test_diff (teste.check.TestCalculations) ... okay
----------------------------------------------------------------------
Ran 1 check in 0.000s
OK

Abschluss

In der Lage zu sein, Unit -Checks in Python zu nutzen, ist für jeden Entwickler eine sehr wichtige Fähigkeit. In diesem Tutorial haben wir die Grundlagenkonzepte und die Implementierung einiger Unit -Checks und deren Greatest Practices unter Verwendung eines leistungsstarken Python -Frameworks untersucht.

Was wir in diesem Artikel jedoch gesehen haben, ist jedoch immer noch nur eine Einführung in was unittest kann für Sie tun. Dies ist ein sehr leistungsfähiges Werkzeug, und es gibt jetzt viel mehr zu lernen, da Sie die Grundlagen kennen.

Einführung

Wenn Sie jemals Daten mit integrierten T-Testfunktionen analysiert haben, wie z. Wenn Ihre Antwort Nein lautet – oder wenn Sie sich nicht einmal sicher sind, was dies bedeutet – ist dieser Weblog -Beitrag für Sie!

Der various Hypotheseparameter, der in der Statistik häufig als „Einschwanz“ im Vergleich zu „zweiseitig“ bezeichnet wird, definiert die erwartete Richtung der Differenz zwischen Kontroll- und Behandlungsgruppen. In einem zweiseitigen Take a look at beurteilen wir, ob es einen Unterschied in den Mittelwerten zwischen den Gruppen gibt, ohne eine Richtung anzugeben. Ein einseitiger Take a look at dagegen stellt eine bestimmte Richtung aus-ob der Mittelwert der Kontrollgruppe entweder geringer als oder größer ist als die der Behandlungsgruppe.

Die Wahl zwischen ein- und zweiseitigen Hypothesen scheint ein kleines Element zu sein, aber es wirkt sich auf jede Stufe der A/B-Exams aus: von der Testplanung bis zu Datenanalyse und Ergebnisinterpretation. Dieser Artikel baut eine theoretische Grundlage dafür auf, warum die Hypothesenrichtung wichtig ist und die Vor- und Nachteile jedes Ansatzes untersucht.

Einschwanzer gegen zweiseitige Hypothesentests: den Unterschied verstehen

Um zu verstehen, wie wichtig es ist, zwischen einseitigen und zweiseitigen Hypothesen zu wählen, lesen wir kurz die Grundlagen des T-Exams, die häufig verwendete Methode im A/B-Take a look at. Wie andere Hypothesentest Methoden, der T-Take a look at beginnt mit einer konservativen Annahme: Es gibt keinen Unterschied zwischen den beiden Gruppen (der Nullhypothese). Nur wenn wir starke Beweise gegen diese Annahme finden, können wir die Nullhypothese ablehnen und zu dem Schluss kommen, dass die Behandlung eine Wirkung hat.

Aber was qualifiziert sich als „starke Beweise“? Zu diesem Zweck wird eine Ablehnungsregion unter der Nullhypothese bestimmt, und alle Ergebnisse, die in diese Area fallen, gelten so unwahrscheinlich, dass wir sie als Beweis gegen die Machbarkeit der Nullhypothese betrachten. Die Größe dieser Ablehnungsregion basiert auf einer vorgegebenen Wahrscheinlichkeit, die als Alpha (α) bekannt ist, die die Wahrscheinlichkeit darstellt, die Nullhypothese falsch abzulehnen.

Was hat das mit der Richtung der alternativen Hypothese zu tun? Eigentlich ziemlich. Während die Alpha -Ebene die Größe der Ablehnungsregion bestimmt, bestimmt die various Hypothese ihre Platzierung. In einem einseitigen Take a look at, bei dem wir eine bestimmte Differenzrichtung hypotheket, befindet sich die Abstoßungsregion nur in einem Schwanz der Verteilung. Für einen hypothetischen positiven Effekt (e..g. Dass die Behandlungsgruppe höher ist als der Mittelwert der Kontrollgruppe), würde die Ablehnungsregion im rechten Schwanz liegen und einen Take a look at mit rechtsschwächen erzeugen. Wenn wir umgekehrt einen negativen Effekt annehmen (z. B. dass die Behandlungsgruppe mit geringerem Mittelwert der Kontrollgruppe ist), würde der Ablehnungsbereich in den linken Schwanz platziert, was zu einem Take a look at mit dem linken Schwanz führt.

Im Gegensatz dazu ermöglicht ein zweiseitiger Take a look at die Erkennung eines Unterschieds in beide Richtungen, sodass der Abstoßungsbereich zwischen beiden Schwänzen der Verteilung aufgeteilt wird. Dies berücksichtigt die Möglichkeit, Extremwerte in beide Richtungen zu beobachten, unabhängig davon, ob der Effekt positiv oder negativ ist.

Um Instinct aufzubauen, visualisieren wir, wie die Ablehnungsregionen unter den verschiedenen Hypothesen erscheinen. Erinnern Sie sich daran, dass sich nach der Nullhypothese der Unterschied zwischen den beiden Gruppen um Null konzentrieren sollte. Dank des Central Restrict -Theorems wissen wir auch, dass diese Verteilung einer Normalverteilung entspricht. Folglich sehen die Ablehnungsbereiche, die der unterschiedlichen alternativen Hypothese entsprechen, so aus:

Warum macht es einen Unterschied?

Die Auswahl der Richtung für die various Hypothese wirkt sich auf den gesamten A/B -Testprozess aus, beginnend mit der Planungsphase – insbesondere bei der Bestimmung der Stichprobengröße. Die Stichprobengröße wird basierend auf der gewünschten Leistung des Exams berechnet. Dies ist die Wahrscheinlichkeit, einen echten Unterschied zwischen den beiden Gruppen zu erkennen, wenn man existiert. Um die Macht zu berechnen, untersuchen wir den Bereich unter der alternativen Hypothese, die der Ablehnungsregion entspricht (da die Macht die Fähigkeit widerspiegelt, die Nullhypothese abzulehnen, wenn die various Hypothese wahr ist).

Da die Richtung der Hypothese die Größe dieser Ablehnungsregion beeinflusst, ist die Leistung für eine zweiseitige Hypothese im Allgemeinen niedriger. Dies ist darauf zurückzuführen, dass die Ablehnungsregion auf beide Schwänze aufgeteilt wird, was es schwieriger macht, einen Effekt in eine eine Richtung zu erkennen. Das folgende Diagramm zeigt den Vergleich zwischen den beiden Arten von Hypothesen. Beachten Sie, dass der lila Bereich für die einseitige Hypothese im Vergleich zur zweiseitigen Hypothese größer ist:

Um das gewünschte Leistungsniveau aufrechtzuerhalten, kompensieren wir die reduzierte Leistung einer zweiseitigen Hypothese, indem wir die Stichprobengröße erhöhen (zunehmende Stichprobengröße erhöht die Leistung, obwohl die Mechanik dafür ein Thema für einen separaten Artikel sein kann). Somit beeinflusst die Wahl zwischen ein- und zweiseitigen Hypothesen die erforderliche Stichprobengröße für Ihren Take a look at direkt.

Über die Planungsphase hinaus wirkt sich die Auswahl der alternativen Hypothese direkt auf die Analyse und Interpretation von Ergebnissen aus. Es gibt Fälle, in denen ein Take a look at mit einem einseitigen Ansatz eine Bedeutung erreichen kann, jedoch nicht mit einem zweiseitigen und umgekehrt. Das Überprüfen des vorherigen Diagramms kann dazu beitragen, dies zu veranschaulichen: Zum Beispiel könnte ein Ergebnis des linken Schwanzes unter einer zweiseitigen Hypothese signifikant sein, jedoch nicht unter einer rechten Einschwanzhypothese. Umgekehrt könnten bestimmte Ergebnisse in die Ablehnungsregion eines rechten einseitigen Exams fallen, liegen jedoch in einem zweiseitigen Take a look at außerhalb des Ablehnungsbereichs.

Wie Sie sich zwischen einer einkötigen und zweiseitigen Hypothese entscheiden

Beginnen wir mit dem Fazit: Hier gibt es keine absolute richtige oder falsche Wahl. Beide Ansätze sind gültig, und die primäre Überlegung sollte Ihre spezifischen Geschäftsbedürfnisse sein. Um zu entscheiden, welche Choice Ihrem Unternehmen am besten geeignet ist, skizzieren wir die wichtigsten Vor- und Nachteile.

Auf den ersten Blick scheint eine einseitige Different die klare Wahl zu sein, da sie häufig besser mit Geschäftszielen übereinstimmt. In Branchenanwendungen liegt der Schwerpunkt in der Regel auf der Verbesserung spezifischer Metriken, anstatt die Auswirkungen einer Behandlung in beide Richtungen zu untersuchen. Dies ist insbesondere bei A/B -Exams related, bei denen das Ziel häufig darin besteht, die Conversion -Raten zu optimieren oder den Umsatz zu steigern. Wenn die Behandlung nicht zu einer signifikanten Verbesserung führt, wird die untersuchte Änderung nicht umgesetzt.

Über diesen konzeptionellen Vorteil hinaus haben wir bereits einen Schlüsselvorteil einer einseitigen Hypothese erwähnt: Es erfordert eine kleinere Stichprobengröße. Durch die Auswahl einer einseitigen Different können Sie sowohl Zeit als auch Ressourcen sparen. Um diesen Vorteil zu veranschaulichen, zeigen die folgenden Grafiken die erforderlichen Stichprobengrößen für ein- und zweiseitige Hypothesen mit unterschiedlichen Leistungsniveaus (Alpha ist auf 5percenteingestellt).

In diesem Zusammenhang wird die Entscheidung zwischen ein- und zweiseitigen Hypothesen bei sequentiellen Exams besonders wichtig- eine Methode, die eine laufende Datenanalyse ermöglicht, ohne den Alpha-Spiegel zu verbessern. Durch die Auswahl eines einseitigen Exams kann die Dauer des Exams erheblich verringert werden, was eine schnellere Entscheidungsfindung ermöglicht, was in dynamischen Geschäftsumgebungen, in denen sofortige Antworten wesentlich sind, besonders wertvoll ist.

Seien Sie jedoch nicht zu schnell, um die zweiseitige Hypothese zu entlassen! Es hat seine eigenen Vorteile. In einigen geschäftlichen Kontexten ist die Fähigkeit, „adverse signifikante Ergebnisse“ zu erkennen, ein wesentlicher Vorteil. Als ein Kunde, der einst geteilt hatte, bevorzugte er adverse signifikante Ergebnisse gegenüber nicht schlüssigen Ergebnissen, da er wertvolle Lernmöglichkeiten bietet. Selbst wenn das Ergebnis nicht wie erwartet wäre, konnte er zu dem Schluss kommen, dass die Behandlung einen negativen Effekt hatte und Einblicke in das Produkt erhielt.

Ein weiterer Vorteil von zweiseitigen Exams ist die einfache Interpretation unter Verwendung von Konfidenzintervallen (CIS). Bei zweiseitigen Exams zeigt ein CI, der nicht direkt Null enthält, eine Bedeutung an, was es den Praktikern erleichtert, die Ergebnisse auf einen Blick zu interpretieren. Diese Klarheit ist besonders ansprechend, da die CIs in A/B -Testplattformen häufig verwendet werden. Umgekehrt könnte ein signifikantes Ergebnis bei Einschwanz-Exams immer noch Null in den CI enthalten, was möglicherweise zu Verwirrung oder Misstrauen in den Befunden führt. Obwohl einseitige Konfidenzintervalle mit einseitigen Exams verwendet werden können, ist diese Praxis weniger häufig.

Schlussfolgerungen

Durch Anpassen eines einzelnen Parameters können Sie Ihre A/B -Exams erheblich beeinflussen: Insbesondere die Stichprobengröße, die Sie sammeln müssen, und die Interpretation der Ergebnisse. Betrachten Sie bei der Entscheidung zwischen ein- und zweiseitigen Hypothesen Faktoren wie die verfügbare Stichprobengröße, die Vorteile der Erkennung negativer Effekte und die Bequemlichkeit, Konfidenzintervalle (CIs) mit Hypothesentests auszurichten. Letztendlich sollte diese Entscheidung nachdenklich getroffen werden, wobei berücksichtigt wird, was am besten zu Ihren Geschäftsanforderungen passt.

(Hinweis: Alle Bilder in diesem Beitrag wurden vom Autor erstellt)

So erstellen Sie zuverlässige und skalierbare GenAI-Agenten für reale Anwendungen

17 Min. gelesen

·

Vor 14 Stunden

Generative KI-Agenten verändern die Artwork und Weise, wie Unternehmen mit ihren Benutzern und Kunden interagieren. Von personalisierten Reisesucherlebnissen bis hin zu virtuellen Assistenten, die die Fehlerbehebung vereinfachen – diese intelligenten Systeme helfen Unternehmen dabei, schnellere, intelligentere und ansprechendere Interaktionen bereitzustellen. Ganz gleich, ob Alaska Airways Kundenbuchungen neu gestaltet oder ScottsMiracle-Gro maßgeschneiderte Gartenratschläge anbietet – KI-Agenten sind unverzichtbar geworden.

Der Einsatz dieser Agenten in dynamischen Umgebungen bringt jedoch eigene Herausforderungen mit sich. Häufige Aktualisierungen von Modellen, Eingabeaufforderungen und Instruments können die Funktionsweise dieser Agenten unerwartet beeinträchtigen. In diesem Blogbeitrag untersuchen wir, wie Unternehmen diese Herausforderungen meistern können, um sicherzustellen, dass ihre KI-Agenten zuverlässig und effektiv bleiben.

Dieser Beitrag konzentriert sich auf einen praktischen Rahmen für eine der wichtigsten Aufgaben, um GenAI-Agenten in die Produktion zu bringen: Sicherstellen, dass sie Werkzeuge effektiv auswählen können. Die Werkzeugauswahl ist von zentraler Bedeutung dafür, wie generative KI-Agenten Aufgaben ausführen, sei es das Abrufen…