Från Excel-kaos till tydliga data: Omvandla och driftsätt med Python och AWS

Datatransformation är avgörande för att kunna utnyttja flera Excel-filer som källor för prognosmodeller, maskininlärningsmodeller eller programvaruapplikationer. Det här inlägget utforskar hur man effektivt transformerar data med hjälp av Python och Pandas, vilket säkerställer att dina data är rena, välstrukturerade och redo för distribution. Inlägget kommer också att behandla hur man distribuerar sin transformationskod till AWS med hjälp av en Serverless Application Model (SAM) och konfigurerar en CI/CD-pipeline för automatisk distribution när ny kod distribueras till GitHub.

Innan vi går in på det tekniska, låt oss förstå varför datatransformation är avgörande:

Konsekvens : Säkerställer att data från olika källor följer en enhetlig struktur.

Kvalitet : Rengör och filtrerar bort eventuella inkonsekvenser eller fel.

Kompatibilitet : Gör data redo för olika prognos- eller maskininlärningsmodeller eller för användning i programvaruapplikationer.

Verktyg för handeln: Python och Pandor

Innan du börjar, se till att du har följande installerat:

Python 3.x
Pandas-bibliotek ( pip install pandas )
AWS CLI (pip install awscli)
AWS SAM CLI ( pip install aws-sam-cli )

Steg 1: Läsa och kombinera Excel-filer

Låt oss anta att vi har flera Excel-filer. Om filerna har liknande strukturer kan vi läsa dem direkt in i en enda Pandas DataFrame. Men om de har olika strukturer måste vi hantera varje fil enligt dess unika schema innan vi kombinerar dem.

Hantera filer med liknande struktur

import pandas as pd
import glob

# Define the path to the Excel files
file_path = '<path>/*.xlsx'

# Use glob to get all file paths
excel_files = glob.glob(file_path)

# Initialize an empty DataFrame
combined_df = pd.DataFrame()

# Loop through each file and append to the combined DataFrame
for file in excel_files:
    df = pd.read_excel(file)
    combined_df = pd.concat([combined_df, df], ignore_index=True)

# Display the combined DataFrame
print(combined_df.head())

Hantera filer med olika strukturer

Om filerna har olika strukturer, följ dessa steg:

Identifiera gemensamma kolumner : Bestäm vilka kolumner som är gemensamma för alla filer.
Normalisera strukturer : Standardisera strukturen för varje fil så att den matchar ett vanligt format.
Kombinera data : Sammanfoga de standardiserade DataFrames.

import pandas as pd
import glob

# Define the path to the Excel files
file_path = '<path>/*.xlsx'

# Use glob to get all file paths
excel_files = glob.glob(file_path)

# Define a function to normalize each DataFrame
def normalize_df(df):
    # Select common columns and fill missing columns with NaN
    common_columns = ['CommonColumn1', 'CommonColumn2', 'CommonColumn3']
    for column in common_columns:
        if column not in df.columns:
            df[column] = pd.NA
    return df[common_columns]

# Initialize an empty DataFrame
combined_df = pd.DataFrame()

# Loop through each file, normalize, and append to the combined DataFrame
for file in excel_files:
    df = pd.read_excel(file)
    df = normalize_df(df)
    combined_df = pd.concat([combined_df, df], ignore_index=True)

# Display the combined DataFrame
print(combined_df.head())

Steg 2: Datarensning och validering

Nu när vi har en kombinerad DataFrame, låt oss rensa och validera informationen för att säkerställa att den uppfyller kvalitetsstandarder. Varje process har sina egna specifika regler, men här är några av de vanligaste metoderna.

Datarensning

Ta bort onödiga kolumner

# Drop unnecessary columns columns_to_drop = ['UnwantedColumn1', 'UnwantedColumn2'] cleaned_df = combined_df.drop(columns=columns_to_drop)

Hantera saknade värden

# Handle missing values cleaned_df = cleaned_df.fillna(method='ffill') # Forward fill missing values

Datavalidering

Kontrollera om det finns dubbletter

# Remove duplicate rows cleaned_df = cleaned_df.drop_duplicates()

Validera datatyper

# Convert data types if necessary cleaned_df['DateColumn'] = pd.to_datetime(cleaned_df['DateColumn']) cleaned_df['NumericColumn'] = cleaned_df['NumericColumn'].astype(float)

Konsekvenskontroller

# Ensure no negative values in a specific column cleaned_df = cleaned_df[cleaned_df['NumericColumn'] >= 0]

Steg 3: Datatransformation

Efter att ha rengjort och validerat data kan vi omvandla den så att den matchar vårt fördefinierade format, vilket gör den redo för maskininlärningsmodeller eller programvaruapplikationer. Här är flera vanliga omvandlingsmetoder:

Byta namn på kolumner

# Rename columns to match the predefined format
columns_rename = {
  'OldName1': 'NewName1',
  'OldName2': 'NewName2'
}
cleaned_df = cleaned_df.rename(columns=columns_rename)

Aggregering av data

Om din modell kräver aggregerade data (t.ex. veckovisa eller månatliga sammanfattningar) kan du utföra aggregeringen:

# Aggregate data by a time period, for example, monthly transformed_df = cleaned_df.resample('M', on='DateColumn').sum().reset_index()

Funktionsteknik

Att skapa nya funktioner kan förbättra dina modellers prediktiva kraft:

# Create new features transformed_df['NewFeature'] = transformed_df['NumericColumn'] * transformed_df['AnotherColumn']

Kodning av kategoriska variabler

Maskininlärningsmodeller kräver ofta att kategoriska variabler kodas som numeriska värden.

# One-hot encode categorical variables transformed_df = pd.get_dummies(cleaned_df, columns=['CategoricalColumn'])

Skalning av numeriska data

Skalning av numeriska data säkerställer att alla funktioner bidrar lika till modellen. Skalning omvandlar data så att de passar inom ett visst intervall eller en viss fördelning. Detta hjälper till med:

Normalisering : Skalning av data till ett intervall på [0, 1] eller [-1, 1].
Standardisering : Skalning av data så att medelvärdet är 0 och standardavvikelsen är 1.

from sklearn.preprocessing import StandardScaler # Scale numerical columns scaler = StandardScaler() transformed_df[['NumericColumn1', 'NumericColumn2']] = scaler.fit_transform(transformed_df[['NumericColumn1', 'NumericColumn2']])

Hantering av extremvärden

Extremvärden, eftersom datapunkter som skiljer sig signifikant från andra, kan snedvrida resultaten av en modell och kan behöva åtgärdas. Extremvärden är värden som ligger utanför det övergripande fördelningsmönstret. De kan orsakas av variation i data eller fel i mätningar. Att hantera extremvärden är viktigt för att:

Förhindra att de snedvrider analysen.
Se till att modellen är robust och pålitlig.

# Cap outliers def cap_outliers(series, lower_quantile=0.01, upper_quantile=0.99): lower_bound = series.quantile(lower_quantile) upper_bound = series.quantile(upper_quantile) return series.clip(lower_bound, upper_bound) transformed_df['NumericColumn'] = cap_outliers(transformed_df['NumericColumn'])

Steg 4: Implementera till AWS med SAM

AWS Serverless Application Model (SAM) låter oss distribuera vår transformationsmodul som en Lambda-funktion, vilket gör den skalbar och effektiv. Låt oss dyka djupare in i hur SAM fungerar och hur man konfigurerar det för vår datatransformationsmodul.

AWS SAM är ett ramverk med öppen källkod för att bygga serverlösa applikationer. Det tillhandahåller en enkel och tydlig syntax för att beskriva de resurser som behövs för din applikation. SAM utökar AWS CloudFormation för att förenkla installation och distribution av serverlösa funktioner, API:er, databaser och mappningar av händelsekällor.

Skapa en SAM-mall

En SAM-mall är skriven i YAML och definierar de resurser som krävs av serverlösa applikationer. Här är ett detaljerat exempel på en template.yaml- fil för vår Lambda-funktion för datatransformation.

AWSTemplateFormatVersion: '2010-09-09' Transform: 'AWS::Serverless-2016-10-31' Resources: DataTransformationFunction: Type: 'AWS::Serverless::Function' Properties: Handler: app.lambda_handler Runtime: python3.8 CodeUri: . Timeout: 900 MemorySize: 128 Policies: - AWSLambdaBasicExecutionRole Environment: Variables: VARIABLE_NAME: "value"

Paketera och driftsätt med SAM

För att paketera och distribuera din SAM-applikation, följ dessa steg:

Paketera applikationen

Det här steget laddar upp din kod till en S3-bucket och förbereder en paketerad mallfil för distribution.

sam package \
 - template-file template.yaml \
 - output-template-file packaged.yaml \
 - s3-bucket <your-s3-bucket>

Distribuera applikationen

Det här steget distribuerar den paketerade applikationen till AWS och skapar de nödvändiga resurser som definieras i din SAM-mall.

sam deploy \ - template-file packaged.yaml \ - stack-name DataTransformationStack \ - capabilities CAPABILITY_IAM

Testa lokalt med SAM Local

Innan du driftsätter till AWS kan du testa din Lambda-funktion lokalt med hjälp av sam local . Detta är särskilt användbart för felsökning och för att säkerställa att din funktion beter sig som förväntat.

För att se hur den presterar kan du anropa din Lambda-funktion lokalt med en testhändelse.

sam local invoke DataTransformationFunction - event event.json

Här är event.json en JSON-fil som innehåller en exempelnyttolast för en händelse.

Om din funktion utlöses via API Gateway kan du starta ett lokalt API för att testa den.

sam local start-api

Det här kommandot startar en lokal instans av API Gateway, och du kan skicka HTTP-förfrågningar till den på samma sätt som du skulle göra med det distribuerade API:et.

Konfigurera miljövariabler

Med miljövariabler kan du skicka konfigurationsinställningar till din Lambda-funktion. I template.yaml -filen kan du definiera miljövariabler under egenskapen Environment.

Environment: Variables: VARIABLE_NAME: "value"

Konfigurera IAM-roller och policyer

Din Lambda-funktion behöver behörighet för att utföra specifika åtgärder. Egenskapen Policies i SAM-mallen låter dig koppla hanterade policyer eller inline-policyer direkt till din Lambda-funktions exekveringsroll.

Policies:
  - AWSLambdaBasicExecutionRole
  - PolicyName: CustomPolicy
    PolicyDocument:
      Statement:
        - Effect: Allow
          Action:
            - s3:GetObject
            - s3:PutObject
          Resource: arn:aws:s3:::<your-s3-bucket>/*

Testa driftsättningen

Efter att du har driftsatt applikationen kan du testa din Lambda-funktion med hjälp av AWS Management Console, AWS CLI eller AWS SDK:er. Se till att funktionen körs som förväntat och bearbetar dina data korrekt.

Steg 5: Konfigurera CI/CD för automatisk distribution

För att automatisera distributionsprocessen kan vi konfigurera en CI/CD-pipeline med hjälp av GitHub Actions. Detta säkerställer att varje gång ny kod läggs till i repositoriet paketeras den automatiskt och distribueras till AWS.

Skapa ett GitHub Actions-arbetsflöde

Skapa en .github/workflows -mapp

mkdir -p .github/workflows

Skapa en deploy.yml -fil

name: CI/CD Pipeline

on:
  push:
    branches:
      - main

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: 3.8

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install awscli aws-sam-cli

      - name: Package application
        run: |
          sam package \
            --template-file template.yaml \
            --output-template-file packaged.yaml \
            --s3-bucket ${{ secrets.S3_BUCKET }}

      - name: Deploy application
        run: |
          sam deploy \
            --template-file packaged.yaml \
            --stack-name DataTransformationStack \
            --capabilities CAPABILITY_IAM
        env:
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          AWS_DEFAULT_REGION: ${{ secrets.AWS_DEFAULT_REGION }}

Förklaring av arbetsflödet

Utlösare : Arbetsflödet utlöses vid varje push till huvudgrenen.
Jobb : Bygg-och-distribuera-jobbet körs på en virtuell maskin med den senaste versionen av Ubuntu.
Kassakod : Kolla in koden från arkivet.
Konfigurera Python : Konfigurera Python 3.8.
Installera beroenden : Installerar awscli och aws-sam-cli .
Paketera applikation : Paketerar applikationen med SAM.
Distribuera applikation : Distribuerar applikationen till AWS med SAM.

För att hantera AWS-inloggningsuppgifter och annan känslig information på ett säkert sätt, använd GitHub Secrets. Lägg till följande hemligheter i ditt GitHub-arkiv:

AWS_ACCESS_KEY_ID
AWS_SECRET_ACCESS_KEY
AWS_DEFAULT_REGION
S3_BUCKET

Slutsats

Datatransformation från flera Excel-filer till ett fördefinierat format är ett viktigt steg för effektiva prognos- eller maskininlärningsmodeller och programvaruapplikationer. Genom att utnyttja Python, Pandas och AWS SAM kan du automatisera, versionskontrollera och skala din databehandlingspipeline effektivt. Dessutom säkerställer konfigurationen av en CI/CD-pipeline att din distributionsprocess är smidig och automatisk, vilket ökar produktiviteten och minskar manuella fel.

Känn dig fri att utforska och anpassa den medföljande koden och mallarna för att passa dina specifika behov. Lycka till med transformeringen!

Från Excel-kaos till dataklarhet: Transformera och driftsätt med Python och AWS