Natuurlijk! Hier is een overzicht en een voorbeeld van hoe je een LangChain-agent kunt ontwikkelen die je stapsgewijze begeleiding biedt bij het voorbereiden van je gegevens voor AI-projecten, inclusief gegevensopschoning, transformatie, validatie, anomalie-detectie en kwaliteitsborging. --- ## Overzicht van de aanpak 1. **Agent structuur**: Een LangChain-agent die interactief vragen stelt en instructies geeft. 2. **Stapsgewijze begeleiding**: - Data inlezen - Opschoning (bijv. ontbrekende waarden, duplicaten) - Transformatie (bijv. normalisatie, codering) - Validatie (bijv. gegevensconsistentie) - Anomalieën detecteren - Gegevenskwaliteit waarborgen 3. **Technieken**: - Pandas voor gegevensbewerking - Scikit-learn voor anomalie-detectie - Validatie met Pandas en custom checks 4. **Voorbeeldworkflow en codefragmenten**: - Voorbeeld code voor elke stap - Integratie met gegevensbestand `Verkoop_Data.csv` --- ## Vereisten - Python 3.8+ - Pandas - Scikit-learn - LangChain ```bash pip install pandas scikit-learn langchain ``` --- ## Voorbeeld code: LangChain-agent voor gegevensvoorbereiding ```python from langchain.agents import create_openai_agent from langchain.chat_models import ChatOpenAI import pandas as pd from sklearn.ensemble import IsolationForest # Functie voor inladen gegevens def laad_gegevens(bestandsnaam): df = pd.read_csv(bestandsnaam) return df # Functie voor opschonen def opschonen(df): # Verwijder duplicaten df = df.drop_duplicates() # Vul ontbrekende waarden in (bijvoorbeeld met de mediaan voor numerieke kolommen) for col in df.select_dtypes(include=['float64', 'int64']).columns: df[col].fillna(df[col].median(), inplace=True) # Voor categorische kolommen, vul ontbrekende waarden met mode for col in df.select_dtypes(include=['object']).columns: df[col].fillna(df[col].mode()[0], inplace=True) return df # Functie voor transformatie def transformatie(df): # Voorbeeld: encode categorische data df = pd.get_dummies(df, drop_first=True) # Normaliseer numerieke data indien nodig # (bijvoorbeeld min-max schaling) return df # Validatie def valideer(df): # Controleer bijvoorbeeld op negatieve waarden waar dat niet mag # Hier is een voorbeeld if (df.select_dtypes(include=['float64', 'int64']) < 0).any().any(): print("Waarschuwing: negatieve waarden gevonden.") # Voeg meer checks toe als nodig return True # Anomalie detectie def detecteer_anomalieën(df): model = IsolationForest(contamination=0.01) numerieke_cols = df.select_dtypes(include=['float64', 'int64']).columns model.fit(df[numerieke_cols]) df['anomalie_score'] = model.decision_function(df[numerieke_cols]) df['is_anomalie'] = model.predict(df[numerieke_cols]) # -1 betekent anomalie anomalieën = df[df['is_anomalie'] == -1] return anomalieën # Integratie in LangChain-agent def gegevens_voorbereiden(bestandsnaam): df = laad_gegevens(bestandsnaam) print("Gegevens ingeladen.") df = opschonen(df) print("Opschoning voltooid.") df = transformatie(df) print("Transformatie voltooid.") valideer(df) print("Validatie voltooid.") anomalieën = detecteer_anomalieën(df) print(f"Aantal anomalieën gedetecteerd: {len(anomalieën)}") return df, anomalieën # Voorbeeld van een eenvoudige interactie if __name__ == "__main__": # Initieer de LLM llm = ChatOpenAI(model="gpt-3.5-turbo") # Maak een eenvoudige prompt prompt = "Help me bij het voorbereiden van mijn verkoopgegevens voor een AI-model. Start met het inladen van 'Verkoop_Data.csv' en begeleid me door opschoning, transformatie, validatie en anomalie-detectie." # Eenvoudige uitvoering van de pipeline df, anomalieën = gegevens_voorbereiden('Verkoop_Data.csv') print("Gegevensvoorbereiding voltooid.") print("Samenvatting van anomalieën:") print(anomalieën) ``` --- ## Samenvatting en verdere integratie - **Vereisten**: Zorg dat je gegevensbestand `Verkoop_Data.csv` in de juiste locatie staat. - **Uitbreiding**: Je kunt deze functies verder aanpassen met meer geavanceerde opschonings- en validatietechnieken. - **Agent**: Voor een interactief systeem kun je de functies integreren in een LangChain-agent die vragen kan beantwoorden en begeleiding biedt tijdens elke stap. --- Mocht je verdere hulp nodig hebben bij het integreren in een volledige LangChain-omgeving of het aanpassen van de workflows, laat het gerust weten!

Zeker! Ik help je bij het ontwikkelen van een LangChain-agent voor gegevensvoorbereiding. Hier is een complete handleiding: ## 1. Vereisten en Installatie ```python # Vereiste packages pip install langchain langchain-community pandas numpy scikit-learn matplotlib seaborn openpyxl # Importeer benodigde libraries import pandas as pd import numpy as np from langchain.agents import AgentType, initialize_agent from langchain.tools import Tool from langchain.llms import OpenAI from langchain.chains import LLMChain from langchain.prompts import PromptTemplate import matplotlib.pyplot as plt import seaborn as sns from sklearn.ensemble import IsolationForest from sklearn.preprocessing import StandardScaler ``` ## 2. Data Loading Tool ```python class DataLoader: def __init__(self): self.data = None def load_csv(self, file_path): """Laad CSV-bestand met foutafhandeling""" try: self.data = pd.read_csv(file_path) return f"Data succesvol geladen. Vorm: {self.data.shape}" except Exception as e: return f"Fout bij laden: {str(e)}" def get_data_info(self): """Geef basisinformatie over de dataset""" if self.data is None: return "Geen data geladen" info = { 'vorm': self.data.shape, 'kolommen': list(self.data.columns), 'ontbrekende_waarden': self.data.isnull().sum().to_dict(), 'data_types': self.data.dtypes.to_dict() } return info data_loader = DataLoader() ``` ## 3. Data Cleaning Tools ```python class DataCleaner: def __init__(self, data_loader): self.data_loader = data_loader def remove_duplicates(self): """Verwijder dubbele rijen""" if self.data_loader.data is None: return "Geen data beschikbaar" original_shape = self.data_loader.data.shape self.data_loader.data = self.data_loader.data.drop_duplicates() new_shape = self.data_loader.data.shape removed = original_shape[0] - new_shape[0] return f"Duplicaten verwijderd: {removed} rijen. Nieuwe vorm: {new_shape}" def handle_missing_values(self, strategy='remove', columns=None): """Behandel ontbrekende waarden""" if self.data_loader.data is None: return "Geen data beschikbaar" if columns is None: columns = self.data_loader.data.columns result = [] for col in columns: missing_count = self.data_loader.data[col].isnull().sum() if strategy == 'remove': self.data_loader.data = self.data_loader.data.dropna(subset=[col]) result.append(f"Kolom {col}: {missing_count} ontbrekende waarden verwijderd") elif strategy == 'mean': if self.data_loader.data[col].dtype in ['float64', 'int64']: self.data_loader.data[col].fillna(self.data_loader.data[col].mean(), inplace=True) result.append(f"Kolom {col}: {missing_count} waarden gevuld met gemiddelde") elif strategy == 'mode': self.data_loader.data[col].fillna(self.data_loader.data[col].mode()[0], inplace=True) result.append(f"Kolom {col}: {missing_count} waarden gevuld met modus") return "\n".join(result) ``` ## 4. Anomalie Detectie ```python class AnomalyDetector: def __init__(self, data_loader): self.data_loader = data_loader def detect_outliers_iqr(self, column): """Detecteer uitbijters met IQR methode""" if self.data_loader.data is None: return "Geen data beschikbaar" Q1 = self.data_loader.data[column].quantile(0.25) Q3 = self.data_loader.data[column].quantile(0.75) IQR = Q3 - Q1 lower_bound = Q1 - 1.5 * IQR upper_bound = Q3 + 1.5 * IQR outliers = self.data_loader.data[ (self.data_loader.data[column] < lower_bound) | (self.data_loader.data[column] > upper_bound) ] return f"Uitbijters in {column}: {len(outliers)} rijen ({len(outliers)/len(self.data_loader.data)*100:.2f}%)" def detect_outliers_isolation_forest(self, columns, contamination=0.1): """Detecteer uitbijters met Isolation Forest""" if self.data_loader.data is None: return "Geen data beschikbaar" # Selecteer alleen numerieke kolommen numeric_data = self.data_loader.data[columns].select_dtypes(include=[np.number]) if numeric_data.empty: return "Geen numerieke kolommen beschikbaar voor analyse" # Schaal de data scaler = StandardScaler() scaled_data = scaler.fit_transform(numeric_data) # Pas Isolation Forest toe iso_forest = IsolationForest(contamination=contamination, random_state=42) outliers = iso_forest.fit_predict(scaled_data) outlier_count = np.sum(outliers == -1) return f"Anomalieën gedetecteerd: {outlier_count} rijen ({outlier_count/len(self.data_loader.data)*100:.2f}%)" ``` ## 5. Data Validatie ```python class DataValidator: def __init__(self, data_loader): self.data_loader = data_loader def validate_data_types(self, expected_types): """Valideer data types""" if self.data_loader.data is None: return "Geen data beschikbaar" issues = [] for col, expected_type in expected_types.items(): if col in self.data_loader.data.columns: actual_type = str(self.data_loader.data[col].dtype) if expected_type not in actual_type: issues.append(f"Kolom {col}: verwacht {expected_type}, kreeg {actual_type}") return "Geen type issues" if not issues else "\n".join(issues) def validate_ranges(self, column_ranges): """Valideer waarden binnen verwachte bereiken""" if self.data_loader.data is None: return "Geen data beschikbaar" issues = [] for col, (min_val, max_val) in column_ranges.items(): if col in self.data_loader.data.columns: out_of_range = self.data_loader.data[ (self.data_loader.data[col] < min_val) | (self.data_loader.data[col] > max_val) ] if len(out_of_range) > 0: issues.append(f"Kolom {col}: {len(out_of_range)} waarden buiten bereik [{min_val}, {max_val}]") return "Geen bereik issues" if not issues else "\n".join(issues) ``` ## 6. LangChain Agent Setup ```python # Initialiseer de LLM llm = OpenAI(temperature=0) # Vervang met je OpenAI API key # Maak tool instances data_loader = DataLoader() data_cleaner = DataCleaner(data_loader) anomaly_detector = AnomalyDetector(data_loader) data_validator = DataValidator(data_loader) # Definieer tools voor de agent tools = [ Tool( name="load_data", func=lambda file_path: data_loader.load_csv(file_path), description="Laad een CSV-bestand. Gebruik: load_data('bestandspad.csv')" ), Tool( name="get_data_info", func=lambda: data_loader.get_data_info(), description="Krijg informatie over de geladen dataset" ), Tool( name="remove_duplicates", func=lambda: data_cleaner.remove_duplicates(), description="Verwijder dubbele rijen uit de dataset" ), Tool( name="handle_missing_values", func=lambda strategy, columns=None: data_cleaner.handle_missing_values(strategy, columns), description="Behandel ontbrekende waarden. Strategieën: 'remove', 'mean', 'mode'" ), Tool( name="detect_outliers_iqr", func=lambda column: anomaly_detector.detect_outliers_iqr(column), description="Detecteer uitbijters met IQR methode voor een specifieke kolom" ), Tool( name="validate_data", func=lambda expected_types, column_ranges: data_validator.validate_data_types(expected_types) + "\n" + data_validator.validate_ranges(column_ranges), description="Valideer data types en bereiken" ) ] # Initialiseer de agent agent = initialize_agent( tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True ) ``` ## 7. Voorbeeld Workflow ```python # Voorbeeld workflow voor Verkoop_Data.csv def complete_data_preparation_workflow(): """Complete workflow voor data voorbereiding""" # Stap 1: Data laden print("=== STAP 1: Data Laden ===") result = agent.run("Laad het bestand Verkoop_Data.csv") print(result) # Stap 2: Data inspectie print("\n=== STAP 2: Data Inspectie ===") result = agent.run("Geef informatie over de geladen dataset") print(result) # Stap 3: Data opschonen print("\n=== STAP 3: Data Opschonen ===") result = agent.run("Verwijder eerst duplicaten en behandel dan ontbrekende waarden met de mean strategie voor numerieke kolommen") print(result) # Stap 4: Anomalie detectie print("\n=== STAP 4: Anomalie Detectie ===") result = agent.run("Detecteer uitbijters in de kolom 'omzet' met IQR methode") print(result) # Stap 5: Data validatie print("\n=== STAP 5: Data Validatie ===") result = agent.run("Valideer dat alle prijzen positief zijn en dat datums geldig zijn") print(result) # Voer de workflow uit complete_data_preparation_workflow() ``` ## 8. Data Format Vereisten voor Verkoop_Data.csv ```python # Vereiste kolommen en formaten voor verkoopdata EXPECTED_SALES_FORMAT = { "kolommen": [ "datum", # YYYY-MM-DD formaat "product_id", # String of integer "product_naam", # String "categorie", # String "aantal", # Integer, positief "eenheidsprijs", # Float, positief "omzet", # Float, positief "klant_id", # String of integer "regio" # String ], "data_types": { "datum": "datetime64", "product_id": "object", "product_naam": "object", "categorie": "object", "aantal": "int64", "eenheidsprijs": "float64", "omzet": "float64", "klant_id": "object", "regio": "object" }, "validatie_regels": { "aantal": (1, 1000), # Min 1, max 1000 "eenheidsprijs": (0.01, 10000), # Min €0.01, max €10.000 "omzet": (0.01, 1000000) # Min €0.01, max €1 miljoen } } ``` ## 9. Gebruik de Agent ```python # Interactie met de agent response = agent.run(""" Ik wil mijn Verkoop_Data.csv voorbereiden voor AI-analyse. Volg deze stappen: 1. Laad het bestand 2. Geef me basisinformatie 3. Verwijder duplicaten 4. Behandel ontbrekende waarden 5. Detecteer anomalieën in numerieke kolommen 6. Valideer de data Geef na elke stap een samenvatting. """) print(response) ``` ## Belangrijke Punten: 1. **Data Formaat**: Zorg dat `Verkoop_Data.csv` de verwachte kolommen bevat 2. **Foutafhandeling**: De agent bevat uitgebreide foutafhandeling 3. **Uitbreidbaar**: Voeg eenvoudig nieuwe tools toe voor specifieke behoeften 4. **Documentatie**: Elke tool heeft duidelijke beschrijvingen voor de LLM Deze agent biedt een gestructureerde aanpak voor data voorbereiding en kan worden uitgebreid met extra functionaliteit naar behoefte!