Рубрика: AI

Zuckerberg might have just infused life into the Metaverse—by ‘life,’ we mean literally. He recently appeared on a podcast with Lex Fridman, and guess what? It was the first interview to happen in the Metaverse.

13 months of progress fueled by Zuck’s unstoppable desire to prove the haters wrong. pic.twitter.com/p2DvWDLWpG

— Ryan Delk (@delk) September 29, 2023

The most fascinating thing about the podcast was that the avatars of Fridman and Zuckerbrg were not cartoons but photorealistic. Gone are the days of cartoon avatars in the Metaverse.

“Mark and I are hundreds of miles apart in physical space, but it feels like we’re in the same room because we appear to each other as photorealistic,” exclaimed Fridman.

One might wonder, how was this made possible? These photorealistic avatars were created using Codec Avatars technology. Meta started working on Codec avatars in 2019 as part of a Reality Labs (RL) Research project .

These are created by capturing the user’s facial expressions and body movements using cameras and sensors.This data is then compressed and transmitted to another device, where it is decoded and used to create a digital avatar of the user. The avatars can be used to interact with other users in VR or AR environments.

Fridman was at a loss for words to describe the Codec avatars in 3D. “It’s hard to put into words how awesome this was for someone like me who values the intimacy of in-person conversation”.

“With spatial audio this technology is incredible. I think it’s the future of how human beings connect to each other in a deeply meaningful way on the internet,” he added.

Emotion Matters

“These avatars can capture many of the nuances of facial expressions” beamed Fridman. The idea of the Metaverse was always to connect people living far away from each other. The problem was that, with cartoon avatars, one couldn’t really express their emotions.

However, these new avatars are capable of capturing human emotions by projecting small nuances, from the movement of the eyes to the twitching of the eyebrows.

“Eyes are a huge part of it; I mean, there are all the studies that show most communication happens through non-verbal cues, such as expressions. So, we try to capture that with the classical expressive avatar system,” said Zuckerberg.

Furthermore, Zuckerberg added that Meta is also working on a quick and easy way to generate an avatar using your mobile phone, what he calls Instant Codec Avatars.

Codec avatars have the potential to change the way humans interact. First, they can provide people with the opportunity to socialize with others in a virtual environment, even if they are not physically close to each other. This can be especially beneficial for people who live in isolated areas or who have difficulty leaving their homes.

Furthermore it can help people to feel more connected to others by allowing them to see and hear each other in real time. This can create a more personal and engaging experience than traditional text-based or audio-based communication. “My family lives across five countries, and I can’t wait for this technology to be widely available.” said Martin Harbech, group director, Meta.

This will change the metaverse forever
Think of the implications: remote work, business travel, long-distance friends/family, maybe even medicine/therapy.
I have to admit … I didn't believe in metaverse until now.pic.twitter.com/EWSlGP0tyU

— Barsee (@heyBarsee) September 29, 2023

Additionally, Codec avatars can be used to create virtual worlds that are tailored to the individual’s interests.This can provide people with a place to go where they can feel comfortable and accepted, and where they can connect with others who share their interests.

New World

Imagine a world where digital and reality come together. Yes, with Meta AI characters in the Metaverse, it is very much possible to create a world where you would be occupying a space where AI-generated avatars and humans are present together in a shared environment. This idea goes well as Meta recently introduced new AI experiences across a family of apps like Instagram and WhatsApp, including 28 AI characters with unique interests and personalities.

Zuckerberg highly anticipates that in the near future, business meetings will be conducted in the metaverse alongside virtual AI characters. This seems to be the beginning of a newly simulated world.

“We will have meetings in the future where you’re basically sitting there physically, and then you have a couple of other people who are holograms. Then you have someone like Bob, the AI engineer on your team, who’s helping with things and can now be embodied as a realistic avatar and just join the meeting. I think that’s going to be pretty compelling.”

Jim Fan, Senior AI Scientist at NVIDIA, was thoroughly impressed with the podcast and aligned himself with the idea of the metaverse. “The ultimate vision is to realize the scenes in Matrix: full-body, real-time avatars of both humans and AI, sharing the same virtual space, interacting with objects in physically realistic ways, receiving rich multimodal feedback, and forgetting that the world is but a simulation.” he posted on X.

These Codec avatars might completely change the fate of the metaverse. Many internet users claim that the Metaverse is here to stay, and this time, it’s real. The fact that Zuckerberg didn’t abandon the Metaverse speaks volumes about his firm belief in his pet project. With Quest 3 on the horizon, an AR/VR headset, Meta might change the way we interact with others.

“I’m a big believer in the metaverse and always have been,” said Aleksa Gordic, formerly with Microsoft and Google DeepMind, who worked on this technology back in 2018-19 as part of the Microsoft HoloLens project.

The post Is Metaverse For Real? appeared first on Analytics India Magazine.

Image by Editor

AWS, or Amazon Web Services, is a cloud computing service used in many businesses for storage, analytics, applications, deployment services, and many others. It’s a platform utilizes several services to support business in a serverless way with pay-as-you-go schemes.

Machine learning modeling activity is also one of the activities that AWS supports. With several services, modeling activities can be supported, such as developing the model to making it into production. AWS has shown versatility, which is essential for any business that needs scalability and speed.

This article will discuss deploying a machine learning model in the AWS cloud into production. How could we do that? Let’s explore further.

Preparation

Before you start this tutorial, you need to create an AWS account, as we would need them to access all the AWS services. I assume that the reader would use the free tier to follow this article. Additionally, I assume the reader already knows how to use Python programming language and has basic knowledge of machine learning. Also, we will focus on the model deployment part and will not concentrate on other aspects of data science activity, such as data preprocessing and model evaluation.

With that in mind, we will start our journey of deploying your machine learning model in the AWS Cloud services.

Model Deployment on AWS

In this tutorial, we will develop a machine-learning model to predict churn from the given data. The training dataset is acquired from Kaggle, which you can download here.

After we have acquired the dataset, we would create an S3 bucket to store the dataset. Search the S3 in the AWS services and make the bucket.

Image by Author

In this article, I named the bucket “telecom-churn-dataset” and located in Singapore. You can change them if you want, but let’s go with this one for now.

After you have finished creating the bucket and uploading the data into your bucket, we will go to the AWS SageMaker service. In this service, we will use the Studio as our working environment. If you have never used the Studio, let’s create a domain and user before proceeding further.

First, choose the Domains within the Amazon SageMaker Admin configurations.

Image by Author

In the Domains, you would see a lot of buttons to select. In this screen, select the Create domain button.

Image by Author

Choose the quick setup if you want to speed up the creation process. After it’s finished, you should see a new domain created in the dashboard. Select the new domain you just created and then click the Add user button.

Image by Author

Next, you should name the user profile according to your preferences. For the execution role, you can leave it on default for now, as it’s the one that was created during the Domain creation process.

Image by Author

Just click next until the canvas setting. In this section, I turn off several settings that we don’t need, such as Time Series Forecasting.

After everything is set, go to the studio selection and select the Open studio button with the user name you just created.

Image by Author

Inside the Studio, navigate to the sidebar that looks like a folder icon and create a new notebook there. We can let them by default, like the image below.

Image by Author

With the new notebook, we would work to create a churn prediction model and deploy the model into API inferences that we can use in production.

First, let’s import the necessary package and read the churn data.

import boto3  import pandas as pd  import sagemaker    sagemaker_session = sagemaker.Session()  role = sagemaker.get_execution_role()    df = pd.read_csv('s3://telecom-churn-dataset/telecom_churn.csv')

Image by Author

Next, we would split the data above into training data and testing data with the following code.

from sklearn.model_selection import train_test_split    train, test = train_test_split(df, test_size = 0.3, random_state = 42)

We set the test data to be 30% of the original data. With our data split, we would upload them back into the S3 bucket.

bucket = 'telecom-churn-dataset'    train.to_csv(f's3://{bucket}/telecom_churn_train.csv', index = False)  test.to_csv(f's3://{bucket}/telecom_churn_test.csv', index = False)

You can see the data inside your S3 bucket, which currently consists of three different datasets.

Image by Author

With our dataset ready, we would now develop a churn prediction model and deploy them. In the AWS, we often use a script training method for machine learning training. That’s why we would develop a script before starting the training.

For the next step, we need to create an additional Python file, which I called train.py, in the same folder.

Image by Author

Inside this file, we would set our model development process to create the churn model. For this tutorial, I would adopt some code from Ram Vegiraju.

First, we would import all the necessary packages for developing the model.

import argparse  import os  import io  import boto3  import json  import pandas as pd    from sklearn.ensemble import RandomForestClassifier  from sklearn.metrics import accuracy_score  import joblib

Next, we would use the parser method to control the variable that we can input into our training process. The overall code that we would put in our script to train our model is in the code below.

if __name__ == '__main__':            parser = argparse.ArgumentParser()        parser.add_argument('--estimator', type=int, default=10)      parser.add_argument('--sm-model-dir', type=str, default=os.environ.get('SM_MODEL_DIR'))      parser.add_argument('--model_dir', type=str)      parser.add_argument('--train', type=str, default=os.environ.get('SM_CHANNEL_TRAIN'))            args, _ = parser.parse_known_args()            estimator = args.estimator      model_dir = args.model_dir      sm_model_dir = args.sm_model_dir      training_dir = args.train        s3_client = boto3.client('s3')      bucket = 'telecom-churn-dataset'        obj = s3_client.get_object(Bucket=bucket, Key='telecom_churn_train.csv')      train_data = pd.read_csv(io.BytesIO(obj['Body'].read()))            obj = s3_client.get_object(Bucket=bucket, Key='telecom_churn_test.csv')      test_data = pd.read_csv(io.BytesIO(obj['Body'].read()))            X_train = train_data.drop('Churn', axis =1)      X_test = test_data.drop('Churn', axis =1)            y_train = train_data['Churn']      y_test = test_data['Churn']            rfc = RandomForestClassifier(n_estimators=estimator)      rfc.fit(X_train, y_train)      y_pred = rfc.predict(X_test)            print('Accuracy Score: ',accuracy_score(y_test, y_pred))            joblib.dump(rfc, os.path.join(args.sm_model_dir, "rfc_model.joblib"))

Lastly, we need to put four different functions that SageMaker requires to make inferences: model_fn, input_fn, output_fn, and predict_fn.

#Deserialized model to load them    def model_fn(model_dir):      model = joblib.load(os.path.join(model_dir, "rfc_model.joblib"))      return model  #The request input of the application  def input_fn(request_body, request_content_type):      if request_content_type == 'application/json':          request_body = json.loads(request_body)          inp_var = request_body['Input']          return inp_var      else:          raise ValueError("This model only supports application/json input")  #The prediction functions  def predict_fn(input_data, model):      return model.predict(input_data)    #The output function  def output_fn(prediction, content_type):      res = int(prediction[0])      resJSON = {'Output': res}      return resJSON

With our script ready, we would run the training process. In the next step, we would pass the script we created above into the SKLearn estimator. This estimator is a Sagemaker object that would handle the entire training process, and we would only need to pass all the parameters similar to the code below.

from sagemaker.sklearn import SKLearn    sklearn_estimator = SKLearn(entry_point='train.py',                             role=role,                            instance_count=1,                             instance_type='ml.c4.2xlarge',                            py_version='py3',                            framework_version='0.23-1',                            script_mode=True,                            hyperparameters={                                'estimator': 15})  sklearn_estimator.fit()

If the training is successful, you will end up with the following report.

Image by Author

If you want to check the Docker image for the SKLearn training and your model artifact location, you can access them using the following code.

model_artifact = sklearn_estimator.model_data  image_uri = sklearn_estimator.image_uri    print(f'The model artifact is saved at: {model_artifact}')  print(f'The image URI is: {image_uri}')

With the model in place, we would then deploy the model into an API endpoint that we can use for prediction. To do that, we can use the following code.

import time    churn_endpoint_name='churn-rf-model-'+time.strftime("%Y-%m-%d-%H-%M-%S", time.gmtime())    churn_predictor=sklearn_estimator.deploy(initial_instance_count=1,instance_type='ml.m5.large',endpoint_name=churn_endpoint_name)

If the deployment is successful, the model endpoint is created, and you can access it to create a prediction. You can also see the endpoint in the Sagemaker dashboard.

Image by Author

You can now make predictions with this endpoint. To do that, you can test the endpoint with the following code.

client = boto3.client('sagemaker-runtime')  content_type = "application/json"    #replace with your intended input data  request_body = {"Input": [[128,1,1,2.70,1,265.1,110,89.0, 9.87,10.0]]}    #replace with your endpoint name  endpoint_name = "churn-rf-model-2023-09-24-12-29-04"   #Data serialization  data = json.loads(json.dumps(request_body))  payload = json.dumps(data)    #Invoke the endpoint  response = client.invoke_endpoint(      EndpointName=endpoint_name,      ContentType=content_type,      Body=payload)  result = json.loads(response['Body'].read().decode())['Output']  result

Congratulation. You have now successfully deployed your model in the AWS Cloud. After you have finished the testing process, don’t forget to clean up the endpoint. You can use the following code to do that.

from sagemaker import Session    sagemaker_session = Session()  sagemaker_session.delete_endpoint(endpoint_name='your-endpoint-name')

Don’t forget to shut down the instance you use and clean up the S3 storage if you don’t need it anymore.

For further reading, you can read more about the SKLearn estimator and Batch Transform inferences if you prefer to not have an endpoint model.

Conclusion

AWS Cloud platform is a multi-purpose platform that many companies use to support their business. One of the services often used is for data analytic purposes, especially model production. In this article, we learn to use AWS SageMaker and how to deploy the model into the endpoint.
Cornellius Yudha Wijaya is a data science assistant manager and data writer. While working full-time at Allianz Indonesia, he loves to share Python and Data tips via social media and writing media.

More On This Topic

• Deploying Your First Machine Learning Model
• Feature Store Summit 2023: Practical Strategies for Deploying ML Models in…
• How to break a model in 20 days — a tutorial on production model analytics
• Tips & Tricks of Deploying Deep Learning Webapp on Heroku Cloud
• Deploying Your First Machine Learning API
• Deploying Serverless spaCy Transformer Model with AWS Lambda

After four months of intensive development and testing, Amazon Web Services (AWS) has made Amazon Bedrock, its suite of foundational models generally available. Since its debut, the tool has proven vital in supporting the complex demands of enterprise users.

This significant release comes on the heels of Bedrock’s debut, where it quickly proved its worth by meeting the demands of enterprise users. Moreover, in July, AWS upgraded the suite by including additional models, like Anthropic Claude 2 and Stability AI SDXL 1.0 models and the essential proprietary Titan Embeddings model.

Among the many things that AWS has improved in Amazon Bedrock is ensuring compliance with regulatory standards, with a particular focus on the European Union’s General Data Protection Regulation (GDPR). Vasi Philomin, the Vice President and General Manager for Generative AI at Amazon, has affirmed this compliance, highlighting the company’s commitment to safeguarding data privacy and protection.

A Hugging Face Competitor

Since it threw a ring in the generative AI space, AWS has emerged as a formidable contender to open-source providers. AWS is soon planning to integrate Meta’s next-generation LLM Llama 2 into Bedrock, along with models from AI21 Labs, Anthropic, Cohere, and Stability AI. While AWS claims itself to be the pioneer in offering Llama 2 (13-billion- and 70-billion-parameter versions) as a fully managed generative AI service, other cloud-hosted generative AI platforms, such as Google’s Vertex AI and Hugging Face, have already been providing this service for some time.

AWS’s models will be accessible through a managed API, optimised to deliver well within AWS infrastructure. This approach poses a challenge to Hugging Face, which has been the trusted host for these models since their debut. While pricing details for Llama 2 on Bedrock have not yet been disclosed, they are expected to be competitive with Hugging Face’s existing pricing structure.

When the models were first released by HF, several users faced issues in running the model. Moreover, they struggled to gain access to the models on the platform initially as well. The users got acceptance from Meta almost immediately while their approval remained from HuggingFace for weeks.

Despite the fact that AWS will be offering the same models as Hugging Face, it is unlikely that developers will readily shift to AWS. Hugging Face has successfully carved out a niche for itself as an inviting, engaging and comfortable space for developers, whereas AWS holds greater appeal among enterprise users. Interestingly, both companies are actively engaged in competition while simultaneously collaborating to democratise the field of AI development.

Collaborative necessity

Earlier this year, AWS and Hugging Face announced a strategic partnership aimed at offering LLMs and generative AI models on AWS’ ML platform. Through this collaboration the Hugging Face community now leverages AWS ML services and infrastructure, streamlining the processes of model training, fine-tuning, and deployment. The timing of these leaps by AWS is crucial, considering the shifting dynamics within the industry. Microsoft has the attention due to its exclusive partnership with OpenAI.

Although OpenAI’s most powerful generative AI models are available through Microsoft Azure, access to these models remains highly restricted. Developers keen on using them must undergo a stringent application process, providing detailed use cases for consideration. Furthermore, even after gaining access, all solutions that deploy Azure OpenAI models must go through a use case review before being approved for production use. This cumbersome process stands in stark contrast to what AWS offers, making it a better choice for developers and the collaboration with Hugging Face further simplifies the process.

Given the heightened interest and attention surrounding LLMs, AWS’s partnership with Hugging Face was virtually inevitable. Cloud providers are forced to intensify their efforts to deliver scalable infrastructure and platform services, providing developers with options for their specific needs.

AWS is making concerted efforts to attract developers, launching a free, self-paced course called “Amazon Bedrock—Getting Started” to introduce users to the platform’s features and benefits. Additionally, AWS’s partnership with Hugging Face streamlines access to LLMs, making it a more accessible option for developers compared to Microsoft Azure’s stringent access policy and restrictions.

The post AWS Challenges Open Source with Bedrock appeared first on Analytics India Magazine.

Americal financial services giant PayPal’s approach to implementing and leveraging data science is driven by the growing demand for personalised customer experiences as it helps in predicting customer actions and streamlining payments, while data analytics provides valuable insights into behaviour and preferences, enabling tailored experiences.

“We put this through features such as faster checkouts, preferred modes and currencies, saved payment methods, real-time updates, and diverse pricing options that detect fraud and protect sensitive data,” said V. Chandramouliswaran, Vice President of Data & Site Leader for PayPal India, in an exclusive interaction with AIM.

PayPal originated from the birth of Confinity in December 1998 by Max Levchin, Peter Thiel, and Luke Nosek, initially focusing on security software for handheld devices. After an unsuccessful venture, Confinity shifted its emphasis to a digital wallet, launching the first version of PayPal in 1999.

In March 2000, Confinity merged with x.com, an online financial services company founded by Elon Musk in March 1999. Musk, optimistic about Confinity’s money transfer business, clashed with Bill Harris, who left the company in May 2000. Musk decided to refocus x.com on payments in October of that year, with Peter Thiel replacing him as CEO.

Renamed PayPal in June 2001, the company went public in 2002, generating over $61 million in its IPO listed under the ticker PYPL at $13 per share. Since then, the company has been heavily investing in cutting-edge technology to provide better solutions to customers.

Now Hiring

PayPal is seeking qualified individuals for three distinct roles within the team – data scientists in product analytics, paid marketing and data scientists (managers).

First, in the role of data scientists in product analytics, they will conduct comprehensive data analysis, delving into large, multi-dimensional datasets to derive valuable insights. The ideal candidate should possess three to five years of experience in this capacity and demonstrate proficiency in SQL, Excel, and visualization tools like Tableau or Qlikview.

Additionally, expertise in a statistical programming language such as R or Python is preferred. Specialised knowledge in payments or other consumer financial products, along with experience in product analytics and experimentation (A/B testing), is highly desirable.

Simultaneously, they are recruiting data scientists in paid marketing, seeking individuals with a background in analytics, data science, or management consulting, or an equivalent blend of analytical and project management expertise.

Candidates should have hands-on experience with Python, SQL, and BigQuery, and be accomplished contributors capable of managing high-performing data scientists and quantitative analysts. Specific experience in tracking and measurement within paid media is a key requirement for this role.

Finally, Data scientists and data scientist managers should have proven analytical skills, demonstrating proficiency in SQL and data visualisation. They should excel in leading cross-functional collaborations, and effectively coordinating among multiple stakeholders. Their expertise extends to understanding business considerations, enabling them to enhance decision-making methodologies.

What’s Cooking inside PayPal’s AI Kitchen

“We are developing AI models and generative AI products for both internal use and customers,” said Chandramouliswaran, boosting the daily operations. The company is committed to democratising financial services’ access to everyone by relying responsibly on AI and automation.

As for generative AI, PayPal is actively exploring various use cases such as leveraging co-pilots for faster software development, creating internal and external chatbots that use their own data ecosystem to predict customer needs, engaging in compliance-related activities for a deeper understanding of consumers and sellers, and strengthening defenses in both the risk and cyber space.

Acknowledging that generative AI presents both opportunities and challenges, especially in security programs enabling malicious actors to create fake identities and sophisticated malware, Chandramouliswaran commented, “On the flip side, firms can use generative AI to enhance defense by deploying automated threat detection systems and adaptive security protocols,”

Interview Process

“The core to our hiring strategy for data science roles lies in functional skills and business acumen,” said Chandramouliswaran.

PayPal seeks candidates with strong problem-solving skills for real-world data science challenges. Key functional skills include expertise in machine learning, OpenCV, and deep learning, with a preference for experience in payments, banking, risk assessment, customer management, and marketing.

While a foundation in programming, statistics, economics, and mathematics is important, logical reasoning, data interpretation, and a programming-oriented mindset are crucial. The team values experience and exposure over specific educational backgrounds, as long as they understand the significance of their contributions and believe in a collaborative approach to work.

“Our aim is to bring in individuals who consistently challenge and inspire us, propelling us t innovate on a daily basis,” he commented.

When it comes to what the company will help the candidate with, they can expect an inclusive and diverse work culture where practical problem-solving skills, curiosity, understanding of business objectives, and teamwork are valued. Alongside, alignment with PayPal’s core values is essential for candidates, contributing to the company’s mission.

However, candidates often make a common mistake during their interviews –

Often they approach it with a narrow perspective, fixated on a specific tool or method, “a hammer and looking for a nail,” in the words of Chandramouliswaran. Instead, they should prioritise understanding the “why” behind a problem, and its significance, understanding the potential benefits for the company, and then strategically delving into the “how” to address it.

Responsibilities for data scientists include problem structuring, data preparation, model development, validation, and collaboration with business and product teams. Comfort with ambiguity is expected due to the complex nature of challenges, and the ability to define impactful problem statements is considered a differentiating factor.

Work Culture

PayPal’s Global Technology Centres in Bangalore, Chennai, and Hyderabad constitute the company’s largest facilities outside the US, with India-based employees playing a crucial role in advancing their global mission. Teams in India have made significant contributions across various domains, leading to over 300 patent applications.

The work culture prioritises the collective responsibility of employees in realising the company’s mission and culture. Innovation, a core value, is fostered by providing a secure environment for learning, skill enhancement, and experimentation.

The company is committed to creating an inclusive, diverse and engaging work environment by actively listening to employees, expanding the talent pipeline, crafting immersive experiences, and promoting well-being.

Employee Resource Groups (ERGs) connect diverse employees and allies, fostering cultural change while Community Impact Teams, locally-led, strengthen relationships between PayPal offices and their communities through volunteering and grantmaking.“We differentiate ourselves through this approach,” said Chandramouliswaran.

Another interesting pillar of PayPal promoting innovation is through their Global Innovation Tournament, aligned with their three-horizon approach. The tournament involves multiple phases, including business plan development, prototyping, and pitching to PayPal’s leadership. In the 2022 edition, nearly 540 submissions were received, with two of the top three finalists originating from India. The tournament serves as a learning platform, encouraging employees to hone new skills in a secure environment.

“PayPal’s global presence empowers businesses and individuals to give better control of their finances. Our success is driven by a purposeful mission and a commitment to developing its employees as a key competitive advantage,” concluded Chandramouliswaran.

Click here to apply.

The post Data Science Hiring Process at PayPal appeared first on Analytics India Magazine.

Introduction to PyTorch and PyTorch Lightning

PyTorch is a popular open-source machine learning framework based on Python and optimized for GPU-accelerated computing. Originally developed by developed by Meta AI in 2016 and now part of the Linux Foundation, PyTorch has quickly become one of the most widely used frameworks for deep learning research and applications.

Unlike some other frameworks like TensorFlow, PyTorch uses dynamic computation graphs which allow for greater flexibility and debugging capabilities. The key benefits of PyTorch include:

• Simple and intuitive Python API for building neural networks
• Broad support for GPU/TPU acceleration
• Built-in support for automatic differentiation
• Distributed training capabilities
• Interoperability with other Python libraries like NumPy

PyTorch Lightning is a lightweight wrapper built on top of PyTorch that further simplifies the process of researcher workflow and model development. With Lightning, data scientists can focus more on designing models rather than boilerplate code. Key advantages of Lightning include:

• Provides structure to organize PyTorch code
• Handles training loop boilerplate code
• Accelerates research experiments with hyperparameters tuning
• Simplifies model scaling and deployment

By combining the power and flexibility of PyTorch with the high-level APIs of Lightning, developers can quickly build scalable deep learning systems and iterate faster.

Step 1: Installation and Setup

To start using PyTorch and Lightning, you'll first need to install a few prerequisites:

• Python 3.6 or higher
• Pip package installer
• An NVidia GPU is recommended for accelerated operations (CPU-only setup possible but slower)

Installing Python and PyTorch

It's recommended to use Anaconda for setting up a Python environment for data science and deep learning workloads. Follow the steps below:

• Download and install Anaconda for your OS from here
• Create a Conda environment (or using another Python environment manager): conda create -n pytorch python=3.8
• Activate the environment: conda activate pytorch
• Install PyTorch: conda install pytorch torchvision torchaudio -c pytorch

Verify that PyTorch is installed correctly by running a quick test in Python:

import torch  x = torch.rand(3, 3)  print(x)

This will print out a random 3×3 tensor, confirming PyTorch is working properly.

Installing PyTorch Lightning

With PyTorch installed, we can now install Lightning using pip:

pip install lightning-ai

Let's confirm Lightning is set up correctly:

import lightning_ai  print(lightning_ai.__version__)

This should print out the version number, such as 0.6.0.

Now we're ready to start building deep learning models.

Step 2: Building a Model with PyTorch

PyTorch uses tensors, similar to NumPy arrays, as its core data structure. Tensors can be operated on by GPUs and support automatic differentiation for building neural networks.

Let's define a simple neural network for image classification:

import torch  import torch.nn as nn  import torch.nn.functional as F    class Net(nn.Module):      def __init__(self):          super(Net, self).__init__()          self.conv1 = nn.Conv2d(3, 6, 5)          self.pool = nn.MaxPool2d(2, 2)          self.conv2 = nn.Conv2d(6, 16, 5)          self.fc1 = nn.Linear(16 * 5 * 5, 120)          self.fc2 = nn.Linear(120, 84)          self.fc3 = nn.Linear(84, 10)        def forward(self, x):          x = self.pool(F.relu(self.conv1(x)))          x = self.pool(F.relu(self.conv2(x)))          x = torch.flatten(x, 1)          x = F.relu(self.fc1(x))          x = F.relu(self.fc2(x))          x = self.fc3(x)          return x    net = Net()

This defines a convolutional neural network with two convolutional layers and three fully connected layers for classifying 10 classes. The forward() method defines how data passes through the network.

We can now train this model on sample data using Lightning.

Step 3: Training the Model with Lightning

Lightning provides a LightningModule class to encapsulate PyTorch model code and the training loop boilerplate. Let's convert our model:

import pytorch_lightning as pl    class LitModel(pl.LightningModule):      def __init__(self):          super().__init__()          self.model = Net()            def forward(self, x):          return self.model(x)        def training_step(self, batch, batch_idx):          x, y = batch          y_hat = self.forward(x)          loss = F.cross_entropy(y_hat, y)          return loss        def configure_optimizers(self):          return torch.optim.Adam(self.parameters(), lr=0.02)            model = LitModel()

The training_step() defines the forward pass and loss calculation. We configure an Adam optimizer with learning rate 0.02.

Now we can train this model easily:

trainer = pl.Trainer()  trainer.fit(model, train_dataloader, val_dataloader)

The Trainer handles the epoch looping, validation, logging automatically. We can evaluate the model on test data:

result = trainer.test(model, test_dataloader)  print(result)

For comparison, here is the network and training loop code in pure PyTorch:

import torch  import torch.nn.functional as F  from torch.utils.data import DataLoader    # Assume Net class and train_dataloader, val_dataloader, test_dataloader are defined    class Net(torch.nn.Module):      # Define your network architecture here      pass    # Initialize model and optimizer  model = Net()  optimizer = torch.optim.Adam(model.parameters(), lr=0.02)    # Training Loop  for epoch in range(10):  # Number of epochs      for batch_idx, (x, y) in enumerate(train_dataloader):          optimizer.zero_grad()          y_hat = model(x)          loss = F.cross_entropy(y_hat, y)          loss.backward()          optimizer.step()    # Validation Loop  model.eval()  with torch.no_grad():      for x, y in val_dataloader:          y_hat = model(x)    # Testing Loop and Evaluate  model.eval()  test_loss = 0  with torch.no_grad():      for x, y in test_dataloader:          y_hat = model(x)          test_loss += F.cross_entropy(y_hat, y, reduction='sum').item()  test_loss /= len(test_dataloader.dataset)  print(f"Test loss: {test_loss}")  

Lightning makes PyTorch model development incredibly fast and intuitive.

Step 4: Advanced Topics

Lightning provides many built-in capabilities for hyperparameter tuning, preventing overfitting, and model management.

Hyperparameter Tuning

We can optimize hyperparameters like learning rate using Lightning's tuner module:

tuner = pl.Tuner(trainer)  tuner.fit(model, train_dataloader)  print(tuner.results)

This performs a Bayesian search over the hyperparameter space.

Handling Overfitting

Strategies like dropout layers and early stopping can reduce overfitting:

model = LitModel()  model.add_module('dropout', nn.Dropout(0.2)) # Regularization    trainer = pl.Trainer(early_stop_callback=True) # Early stopping

Model Saving and Loading

Lightning makes it simple to save and reload models:

# Save  trainer.save_checkpoint("model.ckpt")     # Load  model = LitModel.load_from_checkpoint(checkpoint_path="model.ckpt")

This preserves the full model state and hyperparameters.

Step 5: Comparing PyTorch & PyTorch Lightning

Both PyTorch and PyTorch Lightning are powerful libraries for deep learning, but they serve different purposes and offer unique features. While PyTorch provides the foundational blocks for designing and implementing deep learning models, PyTorch Lightning aims to simplify the repetitive parts of model training, thereby accelerating the development process.

Key Differences

Here is a summary of the key differences between PyTorch and PyTorch Lightning:

Feature	PyTorch	PyTorch Lightning
Training Loop	Manually coded	Automated
Boilerplate Code	Required	Minimal
Hyperparameter Tuning	Manual setup	Built-in support
Distributed Training	Available but manual setup	Automated
Code Organization	No specific structure	Encourages modular design
Model Saving and Loading	Custom implementation needed	Simplified with checkpoints
Debugging	Advanced but manual	Easier with built-in logs
GPU/TPU Support	Available	Easier setup

Flexibility vs Convenience

PyTorch is renowned for its flexibility, particularly with dynamic computation graphs, which is excellent for research and experimentation. However, this flexibility often comes at the cost of writing more boilerplate code, especially for the training loop, distributed training, and hyperparameter tuning. On the other hand, PyTorch Lightning abstracts away much of this boilerplate while still allowing full customization and access to the lower-level PyTorch APIs when needed.

Speed of Development

If you're starting a project from scratch or conducting complex experiments, PyTorch Lightning can save you a lot of time. The LightningModule class streamlines the training process, automates logging, and even simplifies distributed training. This allows you to focus more on your model architecture and less on the repetitive aspects of model training and validation.

The Verdict

In summary, PyTorch offers more granular control and is excellent for researchers who need that level of detail. PyTorch Lightning, however, is designed to make the research-to-production cycle smoother and faster, without taking away the power and flexibility that PyTorch provides. Whether you choose PyTorch or PyTorch Lightning will depend on your specific needs, but the good news is that you can easily switch between the two or even use them in tandem for different parts of your project.

Moving Forward

In this article, we covered the basics of using PyTorch and PyTorch Lightning for deep learning:

• PyTorch provides a powerful and flexible framework for building neural networks
• PyTorch Lightning simplifies training and model development workflows
• Key features like hyperparameters optimization and model management accelerate deep learning research

With these foundations you can start building and training advanced models like CNNs, RNNs, GANs and more. The active open source community also offers Lightning support and additions like Bolt, a component and optimization library.

Happy deep learning!

Matthew Mayo (@mattmayo13) holds a Master's degree in computer science and a graduate diploma in data mining. As Editor-in-Chief of KDnuggets, Matthew aims to make complex data science concepts accessible. His professional interests include natural language processing, machine learning algorithms, and exploring emerging AI. He is driven by a mission to democratize knowledge in the data science community. Matthew has been coding since he was 6 years old.

More On This Topic

• Getting Started with Distributed Machine Learning with PyTorch and Ray
• Getting Started with PyTorch Lightning
• Getting Started with PyTorch Lightning
• Getting Started with Python Data Structures in 5 Steps
• Getting Started with SQL in 5 Steps
• Getting Started with Scikit-learn in 5 Steps