Predicting Bitcoin Value in Actual-Time utilizing MLOps

To view how I’ve used the @step decorator, take a look at the GitHub hyperlink under (steps folder) to undergo the code for different steps of the pipeline i.e. information cleansing, characteristic engineering, information splitting, mannequin coaching, and mannequin analysis.

Step 5: Knowledge Cleansing

On this step, we’ll create completely different methods for cleansing the ingested information. We’ll drop the undesirable columns and lacking values within the information.

class DataPreprocessor:
    def __init__(self, information: pd.DataFrame):
        
        self.information = information
        logging.data("DataPreprocessor initialized with information of form: %s", information.form)

    def clean_data(self) -> pd.DataFrame:
        """
        Performs information cleansing by eradicating pointless columns, dropping columns with lacking values,
        and returning the cleaned DataFrame.

        Returns:
            pd.DataFrame: The cleaned DataFrame with pointless and missing-value columns eliminated.
        """
        logging.data("Beginning information cleansing course of.")

        # Drop pointless columns, together with '_id' if it exists
        columns_to_drop = [
            'UNIT', 'TYPE', 'MARKET', 'INSTRUMENT', 
            'FIRST_MESSAGE_TIMESTAMP', 'LAST_MESSAGE_TIMESTAMP', 
            'FIRST_MESSAGE_VALUE', 'HIGH_MESSAGE_VALUE', 'HIGH_MESSAGE_TIMESTAMP', 
            'LOW_MESSAGE_VALUE', 'LOW_MESSAGE_TIMESTAMP', 'LAST_MESSAGE_VALUE', 
            'TOTAL_INDEX_UPDATES', 'VOLUME_TOP_TIER', 'QUOTE_VOLUME_TOP_TIER', 
            'VOLUME_DIRECT', 'QUOTE_VOLUME_DIRECT', 'VOLUME_TOP_TIER_DIRECT', 
            'QUOTE_VOLUME_TOP_TIER_DIRECT', '_id'  # Adding '_id' to the list
        ]
        logging.data("Dropping columns: %s")
        self.information = self.drop_columns(self.information, columns_to_drop)

        # Drop columns the place the variety of lacking values is bigger than 0
        logging.data("Dropping columns with lacking values.")
        self.information = self.drop_columns_with_missing_values(self.information)

        logging.data("Knowledge cleansing accomplished. Knowledge form after cleansing: %s", self.information.form)
        return self.information

    def drop_columns(self, information: pd.DataFrame, columns: checklist) -> pd.DataFrame:
        """
        Drops specified columns from the DataFrame.

        Returns:
            pd.DataFrame: The DataFrame with the desired columns eliminated.
        """
        logging.data("Dropping columns: %s", columns)
        return information.drop(columns=columns, errors="ignore")

    def drop_columns_with_missing_values(self, information: pd.DataFrame) -> pd.DataFrame:
        """
        Drops columns with any lacking values from the DataFrame.

        Parameters:
            information: pd.DataFrame
                The DataFrame from which columns with lacking values will likely be eliminated.
        
        Returns:
            pd.DataFrame: The DataFrame with columns containing lacking values eliminated.
        """
        missing_columns = information.columns[data.isnull().sum() > 0]
        if not missing_columns.empty:
            logging.data("Columns with lacking values: %s", missing_columns.tolist())
        else:
            logging.data("No columns with lacking values discovered.")
        return information.loc[:, data.isnull().sum() == 0]

Step 6: Characteristic Engineering

This step takes the cleaned information from the sooner data_cleaning step. We’re creating new options like Easy Shifting Common (SMA), Exponential Shifting Common (EMA), and lagged and rolling statistics to seize traits, cut back noise, and make extra dependable predictions from time-series information. Moreover, we scale the options and goal variables utilizing Minmax scaling.

import joblib
import pandas as pd
from abc import ABC, abstractmethod
from sklearn.preprocessing import MinMaxScaler


# Summary class for Characteristic Engineering technique
class FeatureEngineeringStrategy(ABC):
    @abstractmethod
    def generate_features(self, df: pd.DataFrame) -> pd.DataFrame:
        cross


# Concrete class for calculating SMA, EMA, RSI, and different options
class TechnicalIndicators(FeatureEngineeringStrategy):
    def generate_features(self, df: pd.DataFrame) -> pd.DataFrame:
        
        # Calculate SMA, EMA, and RSI
        df['SMA_20'] = df['CLOSE'].rolling(window=20).imply()
        df['SMA_50'] = df['CLOSE'].rolling(window=50).imply()
        df['EMA_20'] = df['CLOSE'].ewm(span=20, regulate=False).imply()
        
        # Value distinction options
        df['OPEN_CLOSE_diff'] = df['OPEN'] - df['CLOSE']
        df['HIGH_LOW_diff'] = df['HIGH'] - df['LOW']
        df['HIGH_OPEN_diff'] = df['HIGH'] - df['OPEN']
        df['CLOSE_LOW_diff'] = df['CLOSE'] - df['LOW']

        # Lagged options
        df['OPEN_lag1'] = df['OPEN'].shift(1)
        df['CLOSE_lag1'] = df['CLOSE'].shift(1)
        df['HIGH_lag1'] = df['HIGH'].shift(1)
        df['LOW_lag1'] = df['LOW'].shift(1)

        # Rolling statistics
        df['CLOSE_roll_mean_14'] = df['CLOSE'].rolling(window=14).imply()
        df['CLOSE_roll_std_14'] = df['CLOSE'].rolling(window=14).std()

        # Drop rows with lacking values (as a result of rolling home windows, shifts)
        df.dropna(inplace=True)

        return df
        
# Summary class for Scaling technique
class ScalingStrategy(ABC):
    @abstractmethod
    def scale(self, df: pd.DataFrame, options: checklist, goal: str):
        cross

# Concrete class for MinMax Scaling
class MinMaxScaling(ScalingStrategy):
    def scale(self, df: pd.DataFrame, options: checklist, goal: str):
        """
        Scales the options and goal utilizing MinMaxScaler.

        Parameters:
            df: pd.DataFrame
                The DataFrame containing the options and goal.
            options: checklist
                Checklist of characteristic column names.
            goal: str
                The goal column identify.

        Returns:
            pd.DataFrame, pd.DataFrame: Scaled options and goal
        """
        scaler_X = MinMaxScaler(feature_range=(0, 1))
        scaler_y = MinMaxScaler(feature_range=(0, 1))

        X_scaled = scaler_X.fit_transform(df[features].values)
        y_scaled = scaler_y.fit_transform(df[[target]].values)

        joblib.dump(scaler_X, 'saved_scalers/scaler_X.pkl')
        joblib.dump(scaler_y, 'saved_scalers/scaler_y.pkl')

        return X_scaled, y_scaled, scaler_y


# FeatureEngineeringContext: This can use the Technique Sample
class FeatureEngineering:
    def __init__(self, feature_strategy: FeatureEngineeringStrategy, scaling_strategy: ScalingStrategy):
        self.feature_strategy = feature_strategy
        self.scaling_strategy = scaling_strategy

    def process_features(self, df: pd.DataFrame, options: checklist, goal: str):
        # Generate options utilizing the supplied technique
        df_with_features = self.feature_strategy.generate_features(df)

        # Scale options and goal utilizing the supplied technique
        X_scaled, y_scaled, scaler_y = self.scaling_strategy.scale(df_with_features, options, goal)

        return df_with_features, X_scaled, y_scaled, scaler_y

Step 7: Knowledge Splitting

Now, we cut up the processed information into coaching and testing datasets within the ratio of 80:20.

import logging
from abc import ABC, abstractmethod
import numpy as np
from sklearn.model_selection import train_test_split

# Arrange logging configuration
logging.basicConfig(degree=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")

# Summary Base Class for Knowledge Splitting Technique
class DataSplittingStrategy(ABC):
    @abstractmethod
    def split_data(self, X: np.ndarray, y: np.ndarray):
        cross

# Concrete Technique for Easy Practice-Check Break up
class SimpleTrainTestSplitStrategy(DataSplittingStrategy):
    def __init__(self, test_size=0.2, random_state=42):
    
        self.test_size = test_size
        self.random_state = random_state

    def split_data(self, X: np.ndarray, y: np.ndarray):
    
        logging.data("Performing easy train-test cut up.")
        X_train, X_test, y_train, y_test = train_test_split(
            X, y, test_size=self.test_size, random_state=self.random_state
        )
        logging.data("Practice-test cut up accomplished.")
        return X_train, X_test, y_train, y_test

# Context Class for Knowledge Splitting
class DataSplitter:
    def __init__(self, technique: DataSplittingStrategy):
        
        self._strategy = technique

    def set_strategy(self, technique: DataSplittingStrategy):
        
        logging.data("Switching information splitting technique.")
        self._strategy = technique

    def cut up(self, X: np.ndarray, y: np.ndarray):
        
        logging.data("Splitting information utilizing the chosen technique.")
        return self._strategy.split_data(X, y)

Step 8: Mannequin Coaching

On this step, we practice the LSTM mannequin with early stopping to forestall overfitting, and by utilizing MLflow’s automated logging to trace our mannequin and experiments and save the skilled mannequin as lstm_model.keras.

import numpy as np
import logging
import mlflow
from tensorflow.keras.fashions import Sequential
from tensorflow.keras.layers import Enter, LSTM, Dropout, Dense
from tensorflow.keras.regularizers import l2
from tensorflow.keras.callbacks import EarlyStopping
from typing import Any

# Summary Base Class for Mannequin Constructing Technique
class ModelBuildingStrategy:
    
    def build_and_train_model(self, X_train: np.ndarray, y_train: np.ndarray, fine_tuning: bool = False) -> Any:
        cross

# Concrete Technique for LSTM Mannequin
class LSTMModelStrategy(ModelBuildingStrategy):
    def build_and_train_model(self, X_train: np.ndarray, y_train: np.ndarray, fine_tuning: bool = False) -> Any:
        """
        Trains an LSTM mannequin on the supplied coaching information.

        Parameters:
            X_train (np.ndarray): The coaching information options.
            y_train (np.ndarray): The coaching information labels/goal.
            fine_tuning (bool): Not relevant for LSTM, defaults to False.

        Returns:
            tf.keras.Mannequin: A skilled LSTM mannequin.
        """
        logging.data("Constructing and coaching the LSTM mannequin.")

        # MLflow autologging
        mlflow.tensorflow.autolog()

        logging.data(f"form of X_train:{X_train.form}")

        # LSTM Mannequin Definition
        mannequin = Sequential()
        mannequin.add(Enter(form=(X_train.form[1], X_train.form[2])))

        mannequin.add(LSTM(models=50, return_sequences=True, kernel_regularizer=l2(0.01)))
        mannequin.add(Dropout(0.3))
        mannequin.add(LSTM(models=50, return_sequences=False))
        mannequin.add(Dropout(0.2))
        mannequin.add(Dense(models=1))  # Regulate the variety of models primarily based in your output (e.g., regression or classification)

        # Compiling the mannequin
        mannequin.compile(optimizer="adam", loss="mean_squared_error")

        # Early stopping to keep away from overfitting
        early_stopping = EarlyStopping(monitor="val_loss", endurance=10, restore_best_weights=True)

        # Match the mannequin
        historical past = mannequin.match(
            X_train,
            y_train,
            epochs=50,
            batch_size=32,
            validation_split=0.1,
            callbacks=[early_stopping],
            verbose=1
        )

        mlflow.log_metric("final_loss", historical past.historical past["loss"][-1])

        # Saving the skilled mannequin
        mannequin.save("saved_models/lstm_model.keras")
        logging.data("LSTM mannequin skilled and saved.")

        return mannequin

# Context Class for Mannequin Constructing Technique
class ModelBuilder:
    def __init__(self, technique: ModelBuildingStrategy):
        self._strategy = technique

    def set_strategy(self, technique: ModelBuildingStrategy):
        self._strategy = technique

    def practice(self, X_train: np.ndarray, y_train: np.ndarray, fine_tuning: bool = False) -> Any:
        return self._strategy.build_and_train_model(X_train, y_train, fine_tuning)

Step 9: Mannequin Analysis

As it is a regression drawback, we’re utilizing analysis metrics like Imply Squared Error (MSE), Root Imply Squared Error (MSE), Imply Absolute Error (MAE), and R-squared.

import logging
import numpy as np
from abc import ABC, abstractmethod
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
from typing import Dict

# Setup logging configuration
logging.basicConfig(degree=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")

# Summary Base Class for Mannequin Analysis Technique
class ModelEvaluationStrategy(ABC):
    @abstractmethod
    def evaluate_model(self, mannequin, X_test, y_test, scaler_y) -> Dict[str, float]:
        cross

# Concrete Technique for Regression Mannequin Analysis
class RegressionModelEvaluationStrategy(ModelEvaluationStrategy):
    def evaluate_model(self, mannequin, X_test, y_test, scaler_y) -> Dict[str, float]:
        # Predict the info
        y_pred = mannequin.predict(X_test)

        # Guarantee y_test and y_pred are reshaped into 2D arrays for inverse transformation
        y_test_reshaped = y_test.reshape(-1, 1)
        y_pred_reshaped = y_pred.reshape(-1, 1)

        # Inverse rework the scaled predictions and true values
        y_pred_rescaled = scaler_y.inverse_transform(y_pred_reshaped)
        y_test_rescaled = scaler_y.inverse_transform(y_test_reshaped)

        # Flatten the arrays to make sure they're 1D
        y_pred_rescaled = y_pred_rescaled.flatten()
        y_test_rescaled = y_test_rescaled.flatten()

        # Calculate analysis metrics
        mse = mean_squared_error(y_test_rescaled, y_pred_rescaled)
        rmse = np.sqrt(mse)
        mae = mean_absolute_error(y_test_rescaled, y_pred_rescaled)
        r2 = r2_score(y_test_rescaled, y_pred_rescaled)

        # Logging the metrics
        logging.data("Calculating analysis metrics.")
        metrics = {
            "Imply Squared Error - MSE": mse,
            "Root Imply Squared Error - RMSE": rmse,
            "Imply Absolute Error - MAE": mae,
            "R-squared - R²": r2
        }

        logging.data(f"Mannequin Analysis Metrics: {metrics}")
        return metrics

# Context Class for Mannequin Analysis
class ModelEvaluator:
    def __init__(self, technique: ModelEvaluationStrategy):
        
        self._strategy = technique

    def set_strategy(self, technique: ModelEvaluationStrategy):
        
        logging.data("Switching mannequin analysis technique.")
        self._strategy = technique

    def consider(self, mannequin, X_test, y_test, scaler_y) -> Dict[str, float]:
        
        logging.data("Evaluating the mannequin utilizing the chosen technique.")
        return self._strategy.evaluate_model(mannequin, X_test, y_test, scaler_y)  

Now we will arrange all of the above steps right into a pipeline. Let’s create a brand new file training_pipeline.py.

from zenml import Mannequin, pipeline

@pipeline(
    mannequin=Mannequin(
        # The identify uniquely identifies this mannequin
        identify="bitcoin_price_predictor"
    ),
)
def ml_pipeline():
    # Knowledge Ingestion Step
    raw_data = ingest_data()  
    # Knowledge Cleansing Step
    cleaned_data = clean_data(raw_data)
    # Characteristic Engineering Step
    transformed_data, X_scaled, y_scaled, scaler_y = feature_engineering_step(
        cleaned_data
    )
    # Knowledge Splitting 
    X_train, X_test, y_train, y_test = data_splitter_step(X_scaled=X_scaled, y_scaled=y_scaled)
    # Mannequin Coaching
    mannequin = model_training_step(X_train, y_train)
    # Mannequin Analysis
    evaluator = model_evaluation_step(mannequin, X_test=X_test, y_test=y_test, scaler_y= scaler_y)

    return evaluator

Right here, @pipeline decorator is used to outline the operate ml_pipeline() as a pipeline in ZenML.

To view the dashboard for the coaching pipeline, merely run the run_pipeline.py script. Let’s create a run_pipeline.py file.

import click on
from pipelines.training_pipeline import ml_pipeline

@click on.command()
def essential():
    run = ml_pipeline()

if __name__=="__main__":
    essential()

Now we have now accomplished creating the pipeline. Run the command under to view the pipeline dashboard.

python run_pipeline.py

After operating the above command it’s going to return the monitoring dashboard URL, which seems like this.

The coaching pipeline seems like this within the dashboard, given under:

Step 10: Mannequin Deployment

Until now we have now constructed the mannequin and the pipelines. Now let’s push the pipeline into manufacturing the place customers could make predictions.

Steady Deployment Pipeline

from zenml.integrations.mlflow.steps import mlflow_model_deployer_step

@pipeline
def continuous_deployment_pipeline():
    trained_model = ml_pipeline()
    mlflow_model_deployer_step(employees=3,deploy_decision=True,mannequin=trained_model,)

This pipeline is chargeable for constantly deploying skilled fashions. It first runs the ml_pipeline() from the training_pipeline.py file to coach the mannequin, then makes use of the Mlflow Mannequin Deployer to deploy the skilled mannequin utilizing the continuous_deployment_pipeline().

Inference Pipeline

We use an inference pipeline to make predictions on the brand new information, utilizing the deployed mannequin. Let’s check out how we applied this pipeline in our venture.

@pipeline
def inference_pipeline(enable_cache=True):
    """Run a batch inference job with information loaded from an API."""
    batch_data = dynamic_importer()
    model_deployment_service = prediction_service_loader(
        pipeline_name="continuous_deployment_pipeline",
        step_name="mlflow_model_deployer_step",
    )
    predictor(service=model_deployment_service, input_data=batch_data)

Allow us to see about every of the features referred to as within the inference pipeline under:

dynamic_importer()

This operate masses the brand new information, performs information processing, and returns the info.

@step
def dynamic_importer() -> str:
    """Dynamically imports information for testing the mannequin with anticipated columns."""

    strive:
        information = {
            'OPEN': [0.98712925, 1.],'HIGH': [0.57191823, 0.55107652],'LOW': [1., 0.94728144],'VOLUME': [0.18186191, 0.],'SMA_20': [0.90819243, 1.],'SMA_50': [0.90214911, 1.],'EMA_20': [0.89735654, 1.],'OPEN_CLOSE_diff': [0.61751032, 0.57706902],'HIGH_LOW_diff': [0.01406254, 0.02980481],
            'HIGH_OPEN_diff': [0.13382262, 0.09172282],
            'CLOSE_LOW_diff': [0.14140073, 0.28523136],'OPEN_lag1': [0.64467168, 1.],
            'CLOSE_lag1': [0.98712925, 1.],
            'HIGH_lag1': [0.77019885, 0.57191823],
            'LOW_lag1': [0.64465093, 1.],
            'CLOSE_roll_mean_14': [0.94042809, 1.],'CLOSE_roll_std_14': [0.22060724, 0.35396897],
        }

        df = pd.DataFrame(information)
        data_array = df.iloc[0].values
        reshaped_data = data_array.reshape((1, 1, data_array.form[0]))  # Single pattern, 1 time step, 17 options

        logging.data(f"Reshaped Knowledge: {reshaped_data.form}")

        json_data = pd.DataFrame(reshaped_data.reshape((reshaped_data.form[0], reshaped_data.form[2]))).to_json(orient="cut up")

        return json_data

    besides Exception as e:
        logging.error(f"Error throughout importing information from dynamic importer: {e}")
        increase e

prediction_service_loader()

This operate is adorned with @step. We load the deployment service w.r.t the deployed mannequin primarily based on the pipeline_name, and step_name, the place our deployed mannequin is able to course of prediction queries for the brand new information.

The road existing_services=mlflow_model_deployer_component.find_model_server() searches for an accessible deployment service primarily based on the given parameters like pipeline identify and pipeline step identify. If no providers can be found, it signifies that the deployment pipeline has both not been carried out or encountered an issue with the deployment pipeline, so it throws a RuntimeError.

@step(enable_cache=False)
def prediction_service_loader(pipeline_name: str, step_name: str) -> MLFlowDeploymentService:
    model_deployer = MLFlowModelDeployer.get_active_model_deployer()

    existing_services = model_deployer.find_model_server(
        pipeline_name=pipeline_name,
        pipeline_step_name=step_name,
    )

    if not existing_services:
        increase RuntimeError(
            f"No MLflow prediction service deployed by the "
            f"{step_name} step within the {pipeline_name} "
            f"pipeline is at present "
            f"operating."
        )
    return existing_services[0]

predictor()

The operate takes within the MLFlow-deployed mannequin by way of the MLFlowDeploymentService and the brand new information. The information is processed additional to match the anticipated format of the mannequin to make real-time inferences.

@step(enable_cache=False)
def predictor(
    service: MLFlowDeploymentService,
    input_data: str,
) -> np.ndarray:

    service.begin(timeout=10)

    strive:
        information = json.masses(input_data)
        information.pop("columns", None)
        information.pop("index", None)

        if isinstance(information["data"], checklist):
            data_array = np.array(information["data"])
        else:
            increase ValueError("The information format is wrong, anticipated a listing beneath 'information'.")

        if data_array.form != (1, 1, 17):
            data_array = data_array.reshape((1, 1, 17))  # Regulate the form as wanted

        strive:
            prediction = service.predict(data_array)
        besides Exception as e:
            increase ValueError(f"Prediction failed: {e}")
        return prediction
    
    besides json.JSONDecodeError:
        increase ValueError("Invalid JSON format within the enter information.")
    besides KeyError as e:
        increase ValueError(f"Lacking anticipated key in enter information: {e}")
    besides Exception as e:
        increase ValueError(f"An error occurred throughout information processing: {e}")

To visualise the continual deployment and inference pipeline, we have to run the run_deployment.py script, the place the deployment and prediction configurations will likely be outlined. (Please examine the run_deployment.py code within the GitHub given under).

@click on.choice(
    "--config",
    sort=click on.Alternative([DEPLOY, PREDICT, DEPLOY_AND_PREDICT]),
    default=DEPLOY_AND_PREDICT,
    assist="Optionally you possibly can select to solely run the deployment "
    "pipeline to coach and deploy a mannequin (`deploy`), or to "
    "solely run a prediction in opposition to the deployed mannequin "
    "(`predict`). By default each will likely be run "
    "(`deploy_and_predict`).",
)

Now let’s run the run_deployment.py file to see the dashboard of the continual deployment pipeline and inference pipeline.

python run_deployment.py

Steady Deployment Pipeline – Output

Inference Pipeline – Output

After operating the run_deployment.py file you possibly can see the MLflow dashboard hyperlink which seems like this.

mlflow ui --backend-store-uri file:/root/.config/zenml/local_stores/cd1eb06a-179a-4f83-9bae-9b9a5b1bd27f/mlruns

Now it’s essential to copy and paste the above MLflow UI hyperlink in your command line and run it.

Right here is the MLflow dashboard, the place you possibly can see the analysis metrics and mannequin parameters:

Step 11: Constructing the Streamlit App

Streamlit is a tremendous open-source, Python-based framework, used to create interactive UI’s, we will use Streamlit to construct net apps shortly, with out understanding backend or frontend improvement. First, we have to set up Streamlit on our system.

#Set up streamlit in our native PC
pip set up streamlit

#To run the streamlit native net server
streamlit run app.py

Once more, you’ll find the code on GitHub for the Streamlit app.

Right here’s the GitHub Code and Video Clarification of the Challenge on your higher understanding.

Conclusion

On this article, we have now efficiently constructed an end-to-end, production-ready Bitcoin Value Prediction MLOps venture. From buying information by way of an API and preprocessing it to mannequin coaching, analysis, and deployment, our venture highlights the crucial function of MLOps in connecting improvement with manufacturing. We’re one step nearer to shaping the way forward for predicting Bitcoin costs in actual time. APIs present easy entry to exterior information, like Bitcoin value information from the CCData API, eliminating the necessity for a pre-existing dataset.

Key Takeaways

• APIs allow seamless entry to exterior information, like Bitcoin value information from CCData API, eliminating the necessity for a pre-existing dataset.
• ZenML and MLflow are strong instruments that facilitate the event, monitoring, and deployment of machine studying fashions in real-world functions.
• We’ve got adopted finest practices by correctly performing information ingestion, cleansing, characteristic engineering, mannequin coaching, and analysis.
• Steady deployment and inference pipelines are important for guaranteeing that fashions stay environment friendly and accessible in manufacturing environments.

The media proven on this article will not be owned by Analytics Vidhya and is used on the Writer’s discretion.

Steadily Requested Questions

Hello! I am Karthik Ponna, a Machine Studying Engineer at Antern. I am deeply keen about exploring the fields of AI and Knowledge Science, as they continuously evolve and form the long run. I consider writing blogs is an effective way to not solely improve my expertise and solidify my understanding but in addition to share my information and insights with others locally. This helps me join with like-minded people who share a curiosity for know-how and innovation.