How to Create Azure ML Model Using Tensarflow, kerr and pytorch to model conversation and to train a model

Question

How to Create Azure ML Model Using Tensarflow, kerr and pytorch to model conversation and to train a model

SaiSekhar, MahasivaRavi (Philadelphia) 140

Hi Team,

Could you please provide a sample model as example code to create a Azure ML Algorithm using tensarflow, kerr and pytorch and how to build(train) and test and deploy (BOYML process) the model, it would really help us to do poc, could you please share the inputs why we use classification or regression model, please give share the whole process.

Prashanth Veeragoni 5,170 Microsoft External Staff Moderator

Hi @SaiSekhar, MahasivaRavi (Philadelphia)

Absolutely — I’ll guide you through a complete end-to-end Azure Machine Learning (Azure ML) project using TensorFlow, Keras, and PyTorch for building a conversational model, and explain the BOYML process (Build, Optimize, and Deploy ML models). will break this down and include code snippets as examples.

Use Case Overview: Conversational Model (Intent Classification)

Let’s assume you’re building a conversational assistant that detects the intent behind a user's message — a typical classification problem, not regression, because you're predicting categories (e.g., "greeting", "order", "cancel").

Why Classification (not Regression)?

· Classification: When the output is a category/label (e.g., spam/not spam, intent A/intent B).

· Regression: When the output is numeric (e.g., price prediction, temperature).

Since conversation modeling deals with recognizing categories of user intent, it’s a multi-class classification problem.

BOYML PROCESS: Build → Optimize → Deploy:

Full lifecycle using Azure ML Studio + SDK, for each framework: TensorFlow, Keras, and PyTorch.

Prerequisites:

Install Azure ML SDK in your local environment or cloud compute.

pip install azureml-sdk azureml-core azureml-train azureml-train-automl azureml-dataset-runtime

1.Build: Data + Model (with 3 Frameworks)

Common Steps - Create Workspace + Compute

from azureml.core import Workspace, Experiment, Environment, ScriptRunConfig, Dataset

# Connect to Azure ML Workspace
ws = Workspace.from_config()

# Create or attach an existing compute cluster
from azureml.core.compute import ComputeTarget, AmlCompute

compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_D2_V2', max_nodes=2)
compute_target = ComputeTarget.create(ws, "cpu-cluster", compute_config) compute_target.wait_for_completion()

Sample Data (Conversational Dataset)

# Sample data: intent classification
# Load or upload to Azure ML
import pandas as pd
data = pd.DataFrame({
    'text': ['hello', 'hi there', 'order pizza', 'cancel my order'],
    'intent': ['greeting', 'greeting', 'order', 'cancel']
})
data.to_csv("intent_data.csv", index=False)

# Upload data to datastore
from azureml.core import Datastore
datastore = ws.get_default_datastore()
datastore.upload_files(["intent_data.csv"], target_path='data/', overwrite=True)

A.Using TensorFlow:

train_tensorflow.py (Azure Script):

import tensorflow as tf
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences

# Load Data
df = pd.read_csv("intent_data.csv")
X, y = df['text'], df['intent']

# Tokenize text
tokenizer = Tokenizer(num_words=1000)
tokenizer.fit_on_texts(X)
X_seq = pad_sequences(tokenizer.texts_to_sequences(X), maxlen=10)

# Encode labels
le = LabelEncoder()
y_encoded = le.fit_transform(y)

# Train-test split
X_train, X_test, y_train, y_test = train_test_split(X_seq, y_encoded, test_size=0.2)

# Define model
model = tf.keras.Sequential([
    tf.keras.layers.Embedding(input_dim=1000, output_dim=16, input_length=10),
    tf.keras.layers.GlobalAveragePooling1D(),
    tf.keras.layers.Dense(16, activation='relu'),
    tf.keras.layers.Dense(len(set(y_encoded)), activation='softmax')
])

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))

model.save("intent_model_tf")

B.Using Keras (same as above, since Keras is part of TensorFlow)

Just separate out with:

from keras.models import Sequential
from keras.layers import Embedding, GlobalAveragePooling1D, Dense

C.Using PyTorch:

train_pytorch.py Example:

import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from torch.utils.data import DataLoader, Dataset
import pandas as pd

# Load Data
df = pd.read_csv("intent_data.csv")
X, y = df['text'], df['intent']
le = LabelEncoder()
y = le.fit_transform(y)

# Toy Tokenizer (word count)
vocab = {word: i+1 for i, word in enumerate(set(" ".join(X).split()))}
X_seq = [[vocab.get(w, 0) for w in text.split()] for text in X]
X_seq = [x + [0]*(10-len(x)) if len(x) < 10 else x[:10] for x in X_seq]

X_train, X_test, y_train, y_test = train_test_split(X_seq, y, test_size=0.2)

class IntentDataset(Dataset):
    def __init__(self, X, y):
        self.X = torch.tensor(X, dtype=torch.long)
        self.y = torch.tensor(y, dtype=torch.long)

    def __len__(self): return len(self.X)
    def __getitem__(self, i): return self.X[i], self.y[i]

train_loader = DataLoader(IntentDataset(X_train, y_train), batch_size=2, shuffle=True)

class Model(nn.Module):
    def __init__(self, vocab_size, embed_size, output_size):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_size)
        self.fc1 = nn.Linear(embed_size * 10, 64)
        self.fc2 = nn.Linear(64, output_size)

    def forward(self, x):
        x = self.embedding(x).view(x.size(0), -1)
        return self.fc2(torch.relu(self.fc1(x)))

model = Model(vocab_size=len(vocab)+1, embed_size=8, output_size=len(set(y)))
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)

for epoch in range(10):
    for inputs, targets in train_loader:
        optimizer.zero_grad()
        output = model(inputs)
        loss = loss_fn(output, targets)
        loss.backward()
        optimizer.step()

torch.save(model.state_dict(), "intent_model_pytorch.pth")

2.Optimize & Train on Azure

Create Azure ScriptRunConfig:

from azureml.core import Environment, ScriptRunConfig, Experiment

env = Environment.from_conda_specification(name="tensorflow-env", file_path="env.yml")
src = ScriptRunConfig(source_directory='.',
                      script='train_tensorflow.py',
                      compute_target=compute_target,
                      environment=env)

exp = Experiment(workspace=ws, name="intent-classification")
run = exp.submit(src)
run.wait_for_completion(show_output=True)

env.yml:

name: tf-env
dependencies:
  - python=3.8
  - pip:
    - tensorflow
    - pandas
    - scikit-learn

3.Deploy Model on Azure

Register & Deploy:

from azureml.core.model import Model

model = Model.register(workspace=ws,
                       model_path="intent_model_tf", 
                       model_name="intent-classifier-tf")

from azureml.core.webservice import AciWebservice, Webservice
from azureml.core.model import InferenceConfig

inference_config = InferenceConfig(entry_script="score.py", environment=env)

deployment_config = AciWebservice.deploy_configuration(cpu_cores=1, memory_gb=1)

service = Model.deploy(workspace=ws,
                       name="intent-classifier-api",
                       models=[model],
                       inference_config=inference_config,
                       deployment_config=deployment_config)

service.wait_for_deployment(show_output=True)

score.py Example (for prediction):

import json
import tensorflow as tf
import numpy as np

def init():
    global model
    model = tf.keras.models.load_model("intent_model_tf")

def run(data):
    try:
        input_text = json.loads(data)["text"]
        # Preprocessing like tokenizer here...
        return json.dumps({"intent": "greeting"})  # Replace with actual prediction
    except Exception as e:
        return json.dumps({"error": str(e)})

Please refer to below documents:

Train a model in Azure Machine Learning: Train a model in Azure Machine Learning

Train TensorFlow models: Train TensorFlow models at scale with Azure Machine Learning

Train PyTorch models: Train PyTorch models at scale with Azure Machine Learning

Hope this helps. do let me know if you have any further queries.

Thank you!

Prashanth Veeragoni 5,170 Reputation points Microsoft External Staff Moderator

2025-04-08T14:37:26.3066667+00:00

Hi @SaiSekhar, MahasivaRavi (Philadelphia)

Following up to see if the above suggestion was helpful. And, if you have any further query do let me know.

Thank you!
Prashanth Veeragoni 5,170 Reputation points Microsoft External Staff Moderator

2025-04-09T14:04:26.1666667+00:00

Hi @SaiSekhar, MahasivaRavi (Philadelphia)

We haven’t heard from you on the last response and was just checking back to see if you have a resolution yet. In case if you have any resolution, please do share that same with the community as it can be helpful to others. Otherwise, will respond with more details and we will try to help.

Thank you!

Your answer

Prashanth Veeragoni 5,170 Reputation points Microsoft External Staff Moderator

2025-04-08T14:37:26.3066667+00:00

Hi @SaiSekhar, MahasivaRavi (Philadelphia)

Following up to see if the above suggestion was helpful. And, if you have any further query do let me know.

Thank you!
Prashanth Veeragoni 5,170 Reputation points Microsoft External Staff Moderator

2025-04-09T14:04:26.1666667+00:00

Hi @SaiSekhar, MahasivaRavi (Philadelphia)

We haven’t heard from you on the last response and was just checking back to see if you have a resolution yet. In case if you have any resolution, please do share that same with the community as it can be helpful to others. Otherwise, will respond with more details and we will try to help.

Thank you!

Share via

How to Create Azure ML Model Using Tensarflow, kerr and pytorch to model conversation and to train a model

Your answer