Installing package managers (Homebrew and Miniforge)

1. Download and install Homebrew from https://brew.sh. Homebrew is a package manager that sets up a lot of useful things on your machine, including Command Line Tools for Xcode, you’ll need this to run things like git. The command to install Homebrew will look something like:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

It will explain what it’s doing and what you need to do as you go.

1. Download Miniforge3 for Apple silicon(minimal installer for Conda specific to conda-forge, Conda is another package manager and conda-forge is a Conda channel) from GitHub.

Clicking the link above will download a shell file called Miniforge3-MacOSX-arm64.sh to your Downloads folder (unless otherwise specified).

1. Open Terminal.
2. We’ve now got a shell file capable of installing Miniforge3, but to do so we’ll have to modify it’s permissions to make it executable.

We’ll then execute (run) the program using sh.

chmod +x ~/Downloads/Miniforge3-MacOSX-arm64.sh
sh ~/Downloads/Miniforge3-MacOSX-arm64.sh

1. This should install Miniforge3 into your home directory (~/ stands for "Home" on Mac).

To check this, we can try to activate the (base) environment, we can do so using the source command.

source ~/miniforge3/bin/activate

If it worked, you should see something like the following in your terminal window.

(base) chaitanya@Chaitanyas-MBP ~ %

1. We’ve just installed some new software and for it to fully work, we’ll need to restart terminal.

Creating a TensorFlow environment

Now we’ve got the package managers we need, it’s time to install TensorFlow.

Let’s setup a folder called dlbase (you can call this anything you want) and install everything in there to make sure it's working.

Note: An environment is like a virtual room on your computer. For example, you use the kitchen in your house for cooking because it’s got all the tools you need. It would be strange to have an oven in your bedroom. The same thing on your computer. If you’re going to be working on specific software, you’ll want it all in one place and not scattered everywhere else.

1. Make a directory called dlbase. This is the directory we're going to be storing our environment. And inside the environment will be the software tools we need to run TensorFlow.

We can do so with the mkdir command which stands for "make directory".

mkdir dlbase

2. Change into dlbase. For the rest of the commands we'll be running them inside the directory dlbase so we need to change into it.

We can do this with the cd command which stands for "change directory".

cd dlbase

3. Now we’re inside the dlbase directory, let's create a new Conda environment using the conda command (this command was installed when we installed Miniforge above).

We do so using conda create --prefix ./env which stands for "conda create an environment with the name file/path/to/this/folder/env". The . stands for "everything before".

For example, if I didn’t use the ./env, my file path looks like: /Users/chaitanya/dlbase/env

conda create --prefix ./env

4. Activate the environment. If conda created the environment correctly, you should be able to activate it using conda activate path/to/environment.

Short version:

conda activate ./env

Long version:

conda activate /Users/chaitanya/dlbase/env

Note: It’s important to activate your environment every time you’d like to work on projects that use the software you install into that environment. For example, you might have one environment for every different project you work on. And all of the different tools for that specific project are stored in its specific environment.

If activating your environment went correctly, your terminal window prompt should look something like:

(/Users/chaitanya/dlbase/env) chaitanya@Chaitanyas-MBP dlbase %

5. Now we’ve got a Conda environment setup, it’s time to install the software we need.

Note: If you want to install PyTorch instead of TensorFlow skip this part and go down to PyTorch section at the end.

Let’s start by installing various TensorFlow dependencies (TensorFlow is a large piece of software and depends on many other pieces of software).

Rather than list these all out, Apple have setup a quick command so you can install almost everything TensorFlow needs in one line.

conda install -c apple tensorflow-deps

The above stands for “hey conda install all of the TensorFlow dependencies from the Apple Conda channel” (-c stands for channel).

If it worked, you should see a bunch of stuff being downloaded and installed for you.

6. Now all of the TensorFlow dependencies have been installed, it’s time install base TensorFlow.

Apple have created a fork (copy) of TensorFlow specifically for Apple Macs. It has all the features of TensorFlow with some extra functionality to make it work on Apple hardware.

This Apple fork of TensorFlow is called tensorflow-macos and is the version we'll be installing:

python -m pip install tensorflow-macos

Depending on your internet connection the above may take a few minutes since TensorFlow is quite a large piece of software.

7. Now we’ve got base TensorFlow installed, it’s time to install tensorflow-metal.

Why?

Machine learning models often benefit from GPU acceleration. And the M1, M1 Pro, M1 Max, M1 Ultra, M2, M2 Pro, M2 Max, M2 Ultra chips have quite powerful GPUs.

TensorFlow allows for automatic GPU acceleration if the right software is installed.

And Metal is Apple’s framework for GPU computing.

So Apple have created a plugin for TensorFlow (also referred to as a TensorFlow Pluggable Device) called tensorflow-metal to run TensorFlow on Mac GPUs.

We can install it using:

python -m pip install tensorflow-metal

If the above works, we should now be able to leverage our Mac’s GPU cores to speed up model training with TensorFlow.

8. (Optional) Install TensorFlow Datasets. Doing the above is enough to run TensorFlow on your machine. But if you’d like to run the benchmarks included in this repo, you’ll need TensorFlow Datasets.

TensorFlow Datasets provides a collection of common machine learning datasets to test out various machine learning code.

python -m pip install tensorflow-datasets

9. Install common data science packages. If you’d like to run the benchmarks above or work on other various data science and machine learning projects, you’re likely going to need Jupyter Notebooks, pandas for data manipulation, NumPy for numeric computing, matplotlib for plotting and Scikit-Learn for traditional machine learning algorithms and processing functions.

To install those in the current environment run:

conda install jupyter pandas numpy matplotlib scikit-learn tqdm seaborn scipy

10. Test it out. To see if everything worked, try starting a Jupyter Notebook and importing the installed packages.

# Start a Jupyter notebook
jupyter notebook

Once the notebook is started, in the first cell:

import numpy as np
import pandas as pd
import sklearn
import tensorflow as tf
import matplotlib.pyplot as plt
# Check for TensorFlow GPU access
print(tf.config.list_physical_devices())
# See TensorFlow version
print(tf.__version__)

If it all worked, you should see something like:

TensorFlow has access to the following devices:
[PhysicalDevice(name='/physical_device:CPU:0', device_type='CPU'),
PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]
TensorFlow version: 2.13.0

If you use PyTorch inplace of TensorFlow then you can swap out

1. Install the PyTorch 1.12.0+ default version for Mac with pip from the PyTorch getting started page.

pip3 install torch torchvision torchaudio

To install those in the current environment run:

conda install jupyter pandas numpy matplotlib scikit-learn tqdm seaborn scipy

2. Test it out. To see if everything worked, try starting a Jupyter Notebook and importing the installed packages.

# Start a Jupyter notebook
jupyter notebook

Create a new notebook by “New” -> “Notebook: Python 3 (ipykernel)” and run the following code to verify all the dependencies are available and check PyTorch version/GPU access.

import torch
import numpy as np
import pandas as pd
import sklearn
import matplotlib.pyplot as plt

print(f"PyTorch version: {torch.__version__}")

# Check PyTorch has access to MPS (Metal Performance Shader, Apple's GPU architecture)
print(f"Is MPS (Metal Performance Shader) built? {torch.backends.mps.is_built()}")
print(f"Is MPS available? {torch.backends.mps.is_available()}")

# Set the device      
device = "mps" if torch.backends.mps.is_available() else "cpu"
print(f"Using device: {device}")

If it all worked, you should see something like:

PyTorch version: 1.12.0
Is MPS (Metal Performance Shader) built? True
Is MPS available? True
Using device: mps

To use this environment as default for all your other projects that are not in this dlbase folder, install VS Code and open your desired folder in that code editor and select this conda environment under Select Kernel menu.

Introduction

Are you ready to embark on a journey to master Linux, the open-source operating system that powers a significant portion of the digital world? Whether you’re a complete beginner or have some experience, there are numerous ways to learn Linux effectively. In this article, I’ll be your guide, sharing eight of the best methods to help you become a Linux guru. From online courses to books, free resources to hands-on projects, there’s something for everyone.

1. Introduction to Linux (Free Code Camp)

Let’s start with a comprehensive course designed for beginners, “Introduction to Linux” offered by Free Code Camp. Free Code Camp is a non-profit organization dedicated to teaching coding skills for free, and they’ve had remarkable success in helping students land developer jobs. This six-hour course, taught by Bo Kearns, is perfect for those with limited or no prior exposure to Linux. Bo’s teaching style is engaging and effective, making it an excellent choice for beginners. Plus, it’s backed by the Linux Foundation, adding credibility to its quality.

check here: https://www.freecodecamp.org/news/introduction-to-linux/

2. “Linux Basics for Hackers” by No Starch Press

If you prefer learning from books, “Linux Basics for Hackers” by No Starch Press is a must-read. This book stands out because it doesn’t just cover the basics of the Linux command line but also delves into various other essential topics. From device management to file systems and even compiling software from C source code, it provides a well-rounded understanding of Linux. The book is approachable and filled with examples, making it an excellent resource for self-paced learning.

check here: https://nostarch.com/linuxbasicsforhackers

3. Linux Journey (linuxjourney.com)

For a unique and free learning experience, explore Linux Journey, an interactive platform with learning paths for different Linux topics. Linux Journey covers a wide range of Linux essentials and is particularly useful for those who prefer hands-on learning. Whether you’re interested in the command line, file systems, or system administration, you’ll find comprehensive resources here.

check here: https://linuxjourney.com/

4. “The Linux Command Line” by No Starch Press

Another gem from No Starch Press is “The Linux Command Line.” While “Linux Basics for Hackers” is more expansive, this book offers a concise yet thorough exploration of Linux. It’s perfect for those who want to get straight to the point and learn essential command-line skills efficiently.

Note: you can also checkout this author’s website for more fun (interesting) content. https://www.linuxcommand.org/

check here: https://www.amazon.com/Linux-Command-Line-2nd-Introduction-ebook/dp/B07J43H42Z

5. ChatGPT for Personalized Learning

Embrace the future of learning with ChatGPT. You can utilize the free GPT-3.5 version to create personalized Linux courses tailored to your level, interests, and time frame. Be detailed in your prompts, specifying your skill level (beginner, intermediate, or advanced), desired course duration, and any specific focus areas. ChatGPT will generate a customized curriculum and even challenge you with multiple-choice questions to test your knowledge.

check here: https://chat.openai.com/

6. Coursera’s Google IT Support Professional Certificate

Coursera offers an excellent opportunity to learn Linux through its Google IT Support Professional Certificate. This comprehensive program includes a module on operating systems that covers both Linux and Windows. Completing the course not only grants you a certificate but also earns you academic credits that can be transferred to select academic institutions. It’s an investment in your future.

check here: https://www.coursera.org/professional-certificates/google-it-support?irclickid=x0-Tqm1DcxyPWQLW3LynK2JJUkFU-KUp%3ATwKwk0&irgwc=1&utm_medium=partners&utm_source=impact&utm_campaign=1237683&utm_content=b2c

7. Raspberry Pi Projects

One of the most enjoyable and practical ways to learn Linux is by working on Raspberry Pi projects. Raspberry Pi is an affordable single-board computer that requires you to install the Linux operating system, making it a fantastic hands-on learning experience. You’ll use the command line, explore networking, and delve into various Linux aspects while building exciting projects. Raspberry Pi prices start as low as $15, making it a cost-effective learning tool.

check here: https://www.raspberrypi.com/for-home/

Conclusion

Learning Linux is an exciting journey that offers numerous benefits, from enhancing your IT skills to opening up career opportunities. With the eight methods I’ve shared in this article, you have a variety of options to choose from. Whether you prefer structured online courses, in-depth books, interactive platforms, personalized learning with ChatGPT, or hands-on Raspberry Pi projects, there’s a path that suits your style and goals. Embrace the world of Linux, and let your learning adventure begin!

Introduction

In the previous article, we introduced Streamlit and discussed why it’s a fantastic choice for building interactive web applications with Python. Now, it’s time to roll up our sleeves and dive into the practical aspects of creating your first Streamlit app. By the end of this tutorial, you’ll have a functional Streamlit app that you can share with others.

Prerequisites

Before we get started, ensure you have Streamlit installed. You can install it using pip:

pip install streamlit

Creating a Simple Streamlit App

Let’s start by building a straightforward Streamlit app that displays a customizable message.

1. Import Streamlit: Begin by importing the Streamlit library at the top of your Python script.

import streamlit as st

2. Create the App Title: Set the title of your app using st.title()

st.title('My First Streamlit App')

3. Add Text: You can include text using st.write().

st.write('Welcome to my Streamlit app!')

Note: st.write() is one of the most important functions of streamlit. In later sections we will see why.

4. Display User Input: Let’s make it interactive by adding a text input widget that allows users to customize the displayed message.

user_input = st.text_input('Enter a custom message:', 'Hello, Streamlit!')

5. Display the Customized Message: Display the customized message using st.write().

st.write('Customized Message:', user_input)

Your complete script should look like this:

import streamlit as st 
# Set the app title 
st.title('My First Streamlit App') 
# Add a welcome message 
st.write('Welcome to my Streamlit app!') 
# Create a text input 
widgetuser_input = st.text_input('Enter a custom message:', 'Hello, Streamlit!') 
# Display the customized message 
st.write('Customized Message:', user_input)

Running Your Streamlit App

To run your Streamlit app, open your terminal or command prompt and navigate to the directory where your script is located. Then, execute the following command:

streamlit run your_script.py

Replace your_script.py with the name of your Python script.

Interact with Your App

Once your app is running, you can interact with it directly in your web browser. Try entering different custom messages in the text input field and observe how the displayed message updates in real-time.

Conclusion

Congratulations! You’ve successfully created your first Streamlit app. In this tutorial, we covered the basics of setting up a Streamlit app, adding text and user input widgets, and displaying dynamic content. In future tutorials, we’ll explore more advanced features of Streamlit, such as data visualization, integrating external libraries, and deploying your apps for sharing with others. Stay tuned for more Streamlit adventures!

Introduction

In this article, we’ll embark on a journey to discover Streamlit, a powerful and user-friendly framework for building web applications using Python. Whether you’re a data scientist, a machine learning engineer, or a developer, Streamlit provides an intuitive way to turn your data scripts into shareable, interactive web apps without the need for extensive web development expertise.

What is Streamlit?

Streamlit is an open-source Python library designed for creating web applications with minimal effort. It focuses on simplicity and efficiency, allowing you to turn data scripts into shareable web apps with just a few lines of code. With Streamlit, you can build interactive dashboards, data visualizations, and machine learning applications in a matter of minutes, making it an excellent choice for both beginners and experienced developers.

Why Streamlit?

1. Rapid Prototyping: Streamlit’s simple and declarative syntax enables rapid development. You can create functional prototypes and iterate quickly.
2. Python-Powered: If you’re already proficient in Python, you can leverage your existing knowledge and libraries, such as NumPy, pandas, and scikit-learn, within Streamlit apps.
3. Interactive Widgets: Streamlit provides a wide range of widgets for user interaction, including sliders, text inputs, and buttons, allowing you to create dynamic user experiences.
4. Data Integration: You can easily integrate data visualizations created with libraries like Matplotlib, Plotly, or Altair into your Streamlit apps.
5. Machine Learning: Streamlit is an excellent choice for showcasing machine learning models, enabling you to build user-friendly interfaces for your models.

Installation and Setup

Getting started with Streamlit is a breeze. First, ensure you have Python installed, and then install Streamlit using pip:

pip install streamlit

Once installed, you can create a simple Streamlit app with just a few lines of code:

import streamlit as st

# Title
st.title('My First Streamlit App')

# Text
st.write('Welcome to my app!')

# Data
data = st.slider('Select a value', 0, 100, 50)
st.write('You selected:', data)

Building Your First Streamlit App

In the code above, we import Streamlit as st, add a title, display some text, and create a slider widget. Running this script with streamlit run your_script.py will launch your first Streamlit app in your web browser.

Note: This is just the introductory part of the Getting Started with Streamlit don’t worry about the code up there, we will have a brief discussion in later articles

Conclusion

Streamlit is a game-changer in the world of data science and machine learning. It empowers data professionals and developers to create interactive web applications effortlessly. In upcoming articles, we’ll delve deeper into Streamlit’s features, building more complex applications and integrating data visualizations and machine learning models. So, stay tuned for an exciting journey into the world of Streamlit!