Forem: milindsoorya

How to build a simple CNN based Image classifier using Keras

milindsoorya — Wed, 01 Jun 2022 11:24:45 +0000

1 Introduction
- 1.1 What are Convolutional neural networks (CNN)?
- 1.2 The classification task
- 1.3 Problem statement
- 1.4 Approach
2 The Code
- 2.1 Import data manipulation packages
- 2.2 Load in the Data
- 2.3 Build the CNN
- 2.4 Training the CNN
- 2.4 Evaluating the performance of CNN
- 2.5 Saving the model
- 2.6 Load the model
- 2.7 Create Sample Submission
Related articles
References

1 Introduction

1.1 What are Convolutional neural networks (CNN)?

Convolutional neural network (CNN), are a class of artificial neural networks that has become dominant in various computer vision tasks, it is attracting interest across a variety of domains.

A convolutional neural network is composed of multiple building blocks, such as convolution layers, pooling layers, and fully connected layers, and is designed to automatically and adaptively learn spatial hierarchies of features through a back propagation algorithm.

CNN work well on computer vision tasks like image classification, object detection, image recognition, etc. Other Neural networks used for similar tasks includes recurrent neural networks (RNN), long short term memory (LSTM), artificial neural networks (ANN), etc.,

1.2 The classification task

In this article, I will be trying to solve the HP Unlocked challenge. It is challenge number four.

You can get the data from the above website, or you could also fork the files from my GitHub repository - Unlocked_Challenge_4 and start working on it directly.

1.3 Problem statement

This is a binary classification task. The challenge is to build a machine learning model to classify images of "La Eterna", a kind of flower.

1.4 Approach

I will use a CNN model to get a baseline score. On initial analysis, the dataset is quite small for a deep learning task. I will perform some image augmentations to increase the dataset.

I will also explore hyperparameter tuning and transfer learning using VGG19 in the upcoming articles.

2 The Code

I used a local Jupyter lab instance for running the code. The final code can be found here.

2.1 Import data manipulation packages

import pandas as pd
import numpy as np
import os
import cv2
import matplotlib.pyplot as plt
import warnings

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import keras_tuner as kt

print("Num GPUs Available: ", len(tf.config.list_physical_devices('GPU')))

# Set the seed value for experiment reproducibility.
seed = 1842
tf.random.set_seed(seed)
np.random.seed(seed)
# Turn off warnings for cleaner looking notebook
warnings.simplefilter('ignore')

2.2 Load in the Data

#define image dataset
# Data Augmentation
image_generator = ImageDataGenerator(
        rescale=1/255,
        rotation_range=10, # rotation
        width_shift_range=0.2, # horizontal shift
        height_shift_range=0.2, # vertical shift
        zoom_range=0.2, # zoom
        horizontal_flip=True, # horizontal flip
        brightness_range=[0.2,1.2],# brightness
        validation_split=0.2,)

#Train & Validation Split
train_dataset = image_generator.flow_from_directory(batch_size=32,
                                                 directory='data_cleaned/Train',
                                                 shuffle=True,
                                                 target_size=(224, 224),
                                                 subset="training",
                                                 class_mode='categorical')

validation_dataset = image_generator.flow_from_directory(batch_size=32,
                                                 directory='data_cleaned/Train',
                                                 shuffle=True,
                                                 target_size=(224, 224),
                                                 subset="validation",
                                                 class_mode='categorical')

#Organize data for our predictions
image_generator_submission = ImageDataGenerator(rescale=1/255)
submission = image_generator_submission.flow_from_directory(
                                                 directory='data_cleaned/scraped_images',
                                                 shuffle=False,
                                                 target_size=(224, 224),
                                                 class_mode=None)

2.3 Build the CNN

Don't worry about how the network is created. We can use hyperparameter tuning to better tune the layers and get a stable network. I will discuss it in the next article. If you would like to learn more about it, check out Keras documentation.

Make sure you don't mess up the input and output shapes. Here the input shape is (224, 224, 3). Meaning the height, width and the channels of the image are respectively 224, 224 and 3. (3 is the red, green and blue channels of a colour image).

model = keras.models.Sequential([
    keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape = [224, 224,3]),
    keras.layers.MaxPooling2D(),
    keras.layers.Conv2D(64, (2, 2), activation='relu'),
    keras.layers.MaxPooling2D(),
    keras.layers.Conv2D(64, (2, 2), activation='relu'),
    keras.layers.Flatten(),
    keras.layers.Dense(100, activation='relu'),
    keras.layers.Dense(2, activation ='softmax')
])

Now we can compile the prepared model. Note that we are also using a call back to stop the training early. In this case, the callback will be triggered if the validation loss is the same or increasing for more than 3 epochs.

model.compile(optimizer='adam',
             loss = 'binary_crossentropy',
             metrics=['accuracy'])

callback = keras.callbacks.EarlyStopping(monitor='val_loss',
                                            patience=3,
                                            restore_best_weights=True)

2.4 Training the CNN

model.fit(train_dataset, epochs=20, validation_data=validation_dataset, callbacks=callback)

2.4 Evaluating the performance of CNN

loss, accuracy = model.evaluate(validation_dataset)
print("Loss: ", loss)
print("Accuracy: ", accuracy)

2.5 Saving the model

model.save('cnn-model')

2.6 Load the model

model = keras.models.load_model('cnn-model')

2.7 Create Sample Submission

onlyfiles = [f.split('.')[0] for f in os.listdir(os.path.join('data_cleaned/scraped_images/image_files')) if os.path.isfile(os.path.join(os.path.join('data_cleaned/scraped_images/image_files'), f))]
submission_df = pd.DataFrame(onlyfiles, columns =['images'])
submission_df[['la_eterna', 'other_flower']] = model.predict(submission)
submission_df.head()

submission_df.to_csv('submission_file.csv', index = False)

References

Installing TensorFlow on M1 MacBook Air with GPU (Metal)

milindsoorya — Thu, 12 May 2022 23:53:48 +0000

You can now leverage Apple’s tensorflow-metal PluggableDevice in TensorFlow v2.5 for accelerated training on Mac GPUs directly with Metal. Learn more here.

OS Requirements

macOS 12.0+ (latest beta)

Currently Not Supported

Multi-GPU support
Acceleration for Intel GPUs
V1 TensorFlow Networks

What is tensorflow?
What is miniforge?
What is miniconda?
Uninstalling existing anaconda/conda from macOS
1. Install the Anaconda-Clean package
2. Remove all Anaconda-related files
3. Remove entire anaconda installation directory
Step 1: Install Miniforge
1. Download and install Conda env
2. Create an anaconda environment
3. Activate the environment
Step 2: Install TensorFlow
1. Install TensorFlow dependencies
2. Install base TensorFlow
3. Install tensorflow-metal plugin
4. Install common Data Science packages
References
Related Articles

What is tensorflow?

TensorFlow is open source deep learning framework created by developers at Google and released in 2015. It is actively used at Google both for research and production needs.

Please check references if you would like to read more about TensorFlow and other popular deep learning libraries.

What is miniforge?

Miniforge is the community (conda-forge) driven
minimalistic conda installer. Subsequent package installations come thus from
conda-forge channel.

What is miniconda?

Miniconda is the Anaconda (company) driven minimalistic
conda installer. Subsequent package installations come from the anaconda
channels (default or otherwise).

Note: Uninstall Anaconda/Anaconda Navigator and other related previously installed version of conda-based installations. Anaconda and Miniforge cannot co-exist together.

Uninstalling existing anaconda/conda from macOS

Install the Anaconda-Clean package from Anaconda Prompt

conda install anaconda-clean

Remove all Anaconda-related files and directories without being prompted to delete each one

anaconda-clean --yes

Remove entire anaconda installation directory from macOS

which anaconda

After running above command you should see the directory where anaconda is installed.

now recursively remove that folder

rm -rf YOUR-ANACONDA-DIRECTORY

Step 1: Install Miniforge

Please note that this tutorial is for arm64 : Apple Silicon

Download and install Conda env

chmod +x ~/Downloads/Miniforge3-MacOSX-arm64.sh
sh ~/Downloads/Miniforge3-MacOSX-arm64.sh
source ~/miniforge3/bin/activate

Create an anaconda environment

conda create -n tf python=3.8

Activate the environment

conda activate tf

Step 2: Install TensorFlow

Install TensorFlow dependencies

conda install -c apple tensorflow-deps

Install base TensorFlow

python -m pip install tensorflow-macos

Install tensorflow-metal plugin

python -m pip install tensorflow-metal

Install common Data Science packages

pip install tensorflow-datasets pandas jupyterlab

References

Authentication Flow with React Navigation v5

milindsoorya — Wed, 23 Mar 2022 13:34:09 +0000

^{cover image by Darius Foroux}

Due to the recent update in react navigation some major changes have taken place and with that some notable changes can be made in the authentication flow.

“ Your best teacher is your last mistake ” — Ralph Nader

Prerequisite

In this tutorial I am going to assume that you have a basic understanding of react native, react navigation and expo. In case of any doubt or if you need an in depth tutorial do ask in the comments.😎

Overview

In this tutorial I will be building two screens i.e. a signup screen and a signin screen. I will only focus on the design aspect and the navigation and won’t go into detail of how to connect it to the database and authenticate, if you guys need to know just ask in the comments. So enough chit chat and lets start.🏎

Approach

Note : I am using react native elements to speed up the design process.

Install the required files using npm

Use expo to create a project

Expo init "_appName"_

Installing react navigation and its dependencies

npm install @react-navigation/native

expo install react-native-gesture-handler react-native-reanimated react-native-screens react-native-safe-area-context @react-native-community/masked-view

I am using a stack navigator for the signin and signup screens and a bottom tab navigator for the main part of the app. We need to separately install stack and tab navigator before using them.

npm install @react-navigation/bottom-tabs  
npm install @react-navigation/stack

Note: In the old version of react navigation a switch navigator was usually used to switch between signin and signup screens. React navigation now recommends using stack navigator in place of that. For more info read this 👉 upgrading from v4.

Install react native elements

npm install react-**native**-elements

Project structure

As react native is all about components and reusing them let’s create two components AuthForm and NavLink. AuthForm is helpful for giving that common UI as both signin and signup screen are pretty much identical. NavLink helps to give the bottom link to either of the pages. The spacer component is used for providing a uniform space between each view or text elements.

Spacer.js

import React from "react";

import { View, StyleSheet } from "react-native";

const Spacer = ({ children }) => {

return <View style={styles.spacer}>{children}</View>;

};

const styles = StyleSheet.create({

spacer: {

margin: 15,

},

});

export default Spacer;

AuthForm.js

Things to note: AuthForm is called with 4 properties, these properties help to modify this component to the screen (i.e signin or signup). What each of these properties do is pretty much evident from their names.

headerText => shows Signup page or Sigin page according to the context.
errorMessage => shows error and will become more useful when using the api and database requests.
onSubmit => uses the email and password to do the submit action.
submitButtonText => changes the button name accordingly (i.e signin or signup).

import React, { useState } from "react";

import { StyleSheet } from "react-native";

import { Text, Button, Input } from "react-native-elements";

import Spacer from "./Spacer";

const AuthForm = ({ headerText, errorMessage, onSubmit, submitButtonText }) => {

const [email, setEmail] = useState("");

const [password, setPassword] = useState("");

return (

<>

<Spacer>

<Text h3>{headerText}</Text>

</Spacer>

<Input

label="Email"

value={email}

onChangeText={setEmail}

autoCapitalize="none"

autoCorrect={false}

/>

<Spacer />

<Input

secureTextEntry

label="Password"

value={password}

onChangeText={setPassword}

autoCapitalize="none"

autoCorrect={false}

/>

{errorMessage ? (

<Text style={styles.errorMessage}>{errorMessage}</Text>

) : null}

<Spacer>

<Button

title={submitButtonText}

onPress={() => onSubmit({ email, password })}

/>

</Spacer>

</>

);

};

const styles = StyleSheet.create({

errorMessage: {

fontSize: 16,

color: "red",

marginLeft: 15,

marginTop: 15,

},

});

export default AuthForm;

NavLink.js

This is used to change screen that is between signup screen or signin Screen

Things to note: Here I used useNavigation from react navigation to switch between the screen. Note that this method only works in a deeply nested child which is satisfied here. NavLink requires two parameters : text and routeName.

text => used to show the specific text.

routeName => it is the name of the route as specified in the App.js file

import React from "react";

import { Text, StyleSheet, TouchableOpacity } from "react-native";

import Spacer from "./Spacer";

import { useNavigation } from "@react-navigation/native";

const NavLink = ({ text, routeName }) => {

const navigation = useNavigation();

return (

<TouchableOpacity onPress={() => navigation.navigate(routeName)}>

<Spacer>

<Text style={styles.link}>{text}</Text>

</Spacer>

</TouchableOpacity>

);

};

const styles = StyleSheet.create({

link: {

color: "blue",

},

});

export default NavLink;

SigninScreen.js

Things to note: Don’t forget to import AuthForm and NavLink and to provide all the parameters.

import React from "react";

import { View, StyleSheet, Text } from "react-native";

import AuthForm from "../components/AuthForm";

import NavLink from "../components/NavLink";

const SigninScreen = () => {

return (

<View style={styles.container}>

<AuthForm

headerText="Sign In to your Acoount"

errorMessage=""

onSubmit={() => {}}

submitButtonText="Sign In"

/>

<NavLink

text="Dont have an account? Sign up instead"

routeName="Signup"

/>

</View>

);

};

const styles = StyleSheet.create({

container: {

flex: 1,

justifyContent: "center",

marginBottom: 200,

},

});

export default SigninScreen;

SignupScreen.js

Things to note: Don’t forget to import AuthForm and NavLink and to provide all the parameters.

import React, { useContext } from "react";

import { View, StyleSheet } from "react-native";

import { Context as AuthContext } from "../context/AuthContext";

import AuthForm from "../components/AuthForm";

import NavLink from "../components/NavLink";

const SignupScreen = ({ navigation }) => {

const { state, signup } = useContext(AuthContext);

return (

<View style={styles.container}>

<AuthForm

headerText="Sign Up for Tracker"

errorMessage={state.errorMessage}

submitButtonText="Sign Up"

onSubmit={signup}

/>

<NavLink

routeName="Signin"

text="Already Have an account? Sign in instead!"

/>

</View>

);

};

const styles = StyleSheet.create({

container: {

flex: 1,

justifyContent: "center",

marginBottom: 200,

},

});

export default SignupScreen;

App.js

Things to note: If you look in the App function you will see a isLoggedIn flag set to true, react navigation recommends this approach also keep in mind that this flag is only for the development phase and in the final build you can use JWT( json web token) for ensuring the user is logged in.

import React, { useContext } from "react";

import { NavigationContainer } from "@react-navigation/native";

import { createStackNavigator } from "@react-navigation/stack";

import { createBottomTabNavigator } from "@react-navigation/bottom-tabs";

import SigninScreen from "./src/screens/SigninScreen";

import SignupScreen from "./src/screens/SignupScreen";

const Stack = createStackNavigator();

const Tab = createBottomTabNavigator();

function mainFlow() {

return (

<Tab.Navigator>

<Tab.Screen name="tab1" component={tab1} />

<Tab.Screen name="tab2" component={tab2} />

<Tab.Screen name="tab3" component={tab2} />

</Tab.Navigator>

);

}

function App() {

const isLoggedIn = true;

return (

<NavigationContainer>

<Stack.Navigator>

{isLoggedIn ? (

<>

<Stack.Screen

name="Signup"

component={SignupScreen}

options={{ headerShown: false }}

/>

<Stack.Screen

name="Signin"

component={SigninScreen}

options={{ headerShown: false }}

/>

</>

) : (

<Stack.Screen

name="mainFlow"

component={mainFlow}

options={{ headerShown: false }}

/>

)}

</Stack.Navigator>

</NavigationContainer>

);

}

export default App;

Thank you very much for reading, liking and commenting on my articles. please consider following me. cheers 😊

👉🏼 checkout my website, milindsoorya.co.uk for more updates and getting in touch. cheers.

Critical Review on “OpenPose - Realtime Multi-Person 2D Pose Estimation using Part Affinity Fields”

milindsoorya — Wed, 23 Mar 2022 11:22:41 +0000

Introduction

This paper proposes a real-time approach to detect the 2D pose of multiple people in an image. OpenPose is an open- source multi-person detection system supporting the body, hand, foot, and facial key points. Human pose estimation is focused on finding individuals and their pose from an image. This problem is quite challenging and is quite complex to determine the number of people that can appear in an image. Moreover, the interferences caused due to contact or proximity between people makes the association of parts quite challenging.

The current state of the art techniques uses a top-down strategy that estimates the pose of each person on each of the detected region. This approach suffers from performance issues because the run time is directly proportional to the number of people in the image.

The method used in the paper uses a nonparametric representation called Part Affinity Fields (PAFs). This approach uses the location and orientation of body parts to encode unstructured pairwise relationships between the body parts of the individuals in the image. In the earlier version of the same paper, they refined both the confidence maps and the part affinity fields (PAFs) at each stage using a branched multistage Convolutional neural network (CNN) and this resulted in much more computation and time at each stage. [1]

This paper focused on refining the existing techniques and the architecture of the CNN [1]. They found that PAF refinement is crucial for maximising accuracy, while body part prediction refinement is not that important. In the paper, the author used the first 10 layers of the VGG-19 model as a baseline network to extract feature maps. These feature maps are input to the model to derive the PAFs that define the degree of association between the parts and the confidence maps, which are then refined using the greedy approach.

The paper OpenPose: Realtime Multi-Person 2D Pose Estimation using Part Affinity Fields is published by Zhe Cao, Student Member, IEEE, Gines Hidalgo, Student Member, IEEE, Tomas Simon, Shih-En Wei, and Yaser Sheikh under IEEE Transactions on Pattern Analysis and Machine Intelligence journal.

Summary of the work, results, and findings

As the first stage, the feature maps of the input image are processed by passing it through a baseline network. In this paper, the author uses the first 10 layers of the VGG-19 model for generating the feature maps. Then the feature maps are processed with multiple stages of CNN to generate a set of Part Confidence Maps and a set of Part Affinity Fields. The system uses a multi-stage CNN. It consists of two types of stages. The first set of stages predicts part affinity fields i.e., degree of associations between the body parts the last set of stages predicts the confidence maps. By replacing each 7x7 convolutional kernel with 3 consecutive 3x3 kernels, the current model was able to preserve the receptive field while computation expense is reduced. Using an approach like DenseNet [11] the output of the 3 convolution kernels is concatenated. This approach tripled the non-linearity layers and helped the model to keep both higher and lower-level features.

A loss function is applied at the end of every step in both branches. Finally, the Confidence Maps and Part Affinity Fields are processed by a greedy algorithm where optimal partite graph matching is used to obtain the poses for each person in the image

The results and findings are presented, and the accuracy of the multi-person key point detection has been compared to the existing methods [2][3]. The real-time performance metric for the system has been specified by mentioning the number of frames it can process each second. All findings are visualized, and graphs are provided for better understanding. The author finds that the newly refined approach increased both the speed and accuracy by approximately 200% and 7% respectively.

The paper contributed to the field of foot detection by presenting an annotated foot dataset with 15K human foot instances that has been publicly released for further study and development. The author open-sourced their work and the OpenPose system provide easy-to-use pipelines with command-line interfaces, python API, Unity plugin. It has also been included in the OpenCV library for ease of access. The system runs on CPUs and GPUs such as CUDA and OpenCL. They also provide portable executable binaries which can easily be downloaded and run with minimal setup.

Pose-ShuffleNet is a lightweight multi-person pose estimation method developed by integrating the concepts of this paper [4]. This method is highly suited for resource-constrained scenarios. It is based on the building blocks of the ShuffleNet unit [5] for image analysis in place of VGG-19. An architecture of multi-stages with two branches, jointly learning parts detection and parts association has been used. Pose-ShuffleNet has a significantly lower resource (network size and FLOPs) consumption than some of the available leading methods. Using the concepts of OpenPose the research has been further extended to the 3D human pose estimation [6]. Further research on Intention Recognition of Pedestrians and Cyclists by 2D Pose Estimation has been carried out. Overall, the proposed pipeline provides promising results on the intention recognition of vulnerable road users. [7]

Pros and Cons of the paper:

Explanation with pictorial references clarifies the topic in a better way and was effective in clarifying relationships, simplifying complex topics and was one of the main key factors that had me inclined towards the paper. All the edge cases have been acknowledged and future actions that can mitigate the failure cases has also been suggested. The accuracy and performance of the combined model with body and foot key points is also an important contribution by the paper.

The generality of the method by applying it to the task of vehicle key point estimation and the use of the approach has contributed to the wide applications and competitive performance of the model. The paper also showcased three benchmarks performed on reputed and easily available datasets such as MPII [9], COCO [10] and a subset of COCO used as a foot dataset. And provide runtime analysis comparison against Mask R-CNN and Alpha-Pose to quantify the efficiency of the system and analyses the main failure cases.

The model performs up to 3 times faster on GPUs when compared to CPUs and in case of Body and foot model the performance difference is up to 30 times. Making the system more optimised on CPUs can help to make the model more accessible in smaller and less powerful systems and increase the use cases. [8]

Potential Advancement and Future Work

There have been many advancements in the field of pose estimation, and it is being used in various fields and applications, but at present, the practical applications are limited due to the challenges of crowded people and occluded body parts. A hybrid system of both top-down and bottom-up approaches along with Using anthropometric ratios for determining context can make the model more efficient [7]. Future developments can be made to generate a similar performance on CPUs using lightweight CNNs such as MobileNetV1, EfficientNet or a combination and can help the system be more efficient so that it is less reliant on GPUs and work on embedded systems. It can have various applications in security cameras, child monitors, automating warehouses, gesture control etc.

Data plays a key role in improving the robustness of the network. Adding complex scenarios of human poses along with samples of human statues and paintings would boost the accuracy by avoiding the problem of occluded body parts.

Improvement in the greedy approach can help to make the pose estimation more accurate. The greedy approach used in the current system suffers from limited structural context when subjects are occluded. Also, the Hungarian algorithm [8] employed is having a cubic complexity. By using a larger structural context of a subset of pre-assigned parts rather than using only the immediate predecessors as in [7], this time complexity can become linear in the number of candidates of any single part-class.

Refining the algorithm to reject less likely or complex poses and adding an animal dataset to train the system can have wide applications in pest control, animal farming, analysis of the bees as shown in Honeybee Detection and Pose Estimation using Convolutional Neural Networks [10].

References

[1] Cao, Zhe, et al. "Realtime multi-person 2d pose estimation using part affinity fields." Proceedings of the IEEE conference on computer vision and pattern recognition. 2017.

[2] Fang, Hao-Shu, et al. "Rmpe: Regional multi-person pose estimation." Proceedings of the IEEE international conference on computer vision. 2017.

[3] He, Kaiming, et al. "Mask r-cnn." Proceedings of the IEEE international conference on computer vision. 2017.

[4] Guan, Chen-zhi. "Realtime multi-person 2d pose estimation using shufflenet." 2019 14th International Conference on Computer Science & Education (ICCSE). IEEE, 2019.

[5] Zhang, Xiangyu, et al. "Shufflenet: An extremely efficient convolutional neural network for mobile devices." Proceedings of the IEEE conference on computer vision and pattern recognition. 2018.

[6] Schwarcz, Steven, and Thomas Pollard. "3d human pose estimation from deep multi-view 2d pose." 2018 24th International Conference on Pattern Recognition (ICPR). IEEE, 2018.

[7] Fang, Zhijie, and Antonio M. López. "Intention recognition of pedestrians and cyclists by 2d pose estimation." IEEE Transactions on Intelligent Transportation Systems 21.11 (2019): 4773-4783.

[8] Osokin, Daniil. "Real-time 2d multi-person pose estimation on cpu: Lightweight openpose." arXiv preprint arXiv:1811.12004 (2018).

[9] Andriluka, Mykhaylo, et al. "2d human pose estimation: New benchmark and state of the art analysis." Proceedings of the IEEE Conference on computer Vision and Pattern Recognition. 2014.

[10] Rodríguez, I. F., et al. "Honeybee detection and pose estimation using convolutional neural networks." Congres Reconnaissance des Formes, Image, Apprentissage et Perception (RFIAP). 2018.

[11] Huang, Gao, et al. "Densely connected convolutional networks." Proceedings of the IEEE conference on computer vision and pattern recognition. 2017.

Run Ubuntu on M1 Macbook Air using UTM

milindsoorya — Mon, 14 Mar 2022 22:27:31 +0000

Introduction

Let's face it M1 mac's are the best laptop out there. With a perfect balance of power and batter life. For me the only thing holding it back was its OS. Mac OS is not as developer friendly as I expected. As i found out after using my M1 mac for a few months, some things are better suited for the OS it was designed to be run on.

This was not a problem in the intel mac era, as we could easily load a virtualisation software and run which ever OS we want, but with the new ARM chips its a different story. The only software that I could find which was free and had all the features was UTM.

UTM is an amazing piece of software and it does its job perfectly (mostly), I did face some challenges installing Ubuntu, but to be fair, it was more related to the Ubuntu kernal than UTM.

UTM also supports installing windows and many more OS. Check out all the available options here.

1. Installing UTM

Installing UTM is pretty straight forward, you can find the software here.

2. Downloading the OS Image

You have to download the Ubuntu server version, don't worry we can easily install GUI after installing the barebone OS. Download Ubuntu.

Please verify you are downloading the ARM version of the software

The steps to install are mentioned on the bottom of the UTM ubuntu webpage. They usually autofill the storage allocation as 64gigs, I would recommend making it to 20gigs as it is more than enough, but feel free to change it according to your use case.

3. Possible Install issues

Problems with Booting into Ubuntu
Due to a recent update in the Linux version, some might find it hard to boot into Ubuntu. You can bypass this problem by doing the following steps in the UTM options menu, located at the top right corner of the application.

Disabling the QMEU > use hypervisor option
Changing the display type to Console only
Boot into Linux, but it will be VERY slow because it is using emulation instead of virtualization.
Once inside, install the last version of Linux sudo apt install linux-image-5.4.0-100-generic
Shut down the VM, open VM settings and under QEMU -> Teaks, check "Use Hypervisor" to re-enable virtualization.
Start the VM and when the UTM logo shows up, hold "Shift" to enter the GRUB menu
Select "Advanced Options for Ubuntu"
Select "Ubuntu, with Linux 5.4.0-100-generic" (or anything lower than 5.4.0-104)
You can now boot into Ubuntu again. You may choose to uninstall 5.4.0-104 and temporarily mask it from being updated in the future: sudo apt-mark hold linux-image-$(uname -r)

Problems with internet connectivity
There is a solution in the bottom of the UTM page for Ubuntu, for this issue. If its not working try out the solution proposed in this discussion.

Conclusion

That's it.. Its really easy to run Linux or even Windows on your shiny new M1 macs. The possibilities are endless and the experiance is really seamless. During my usage I was able to get very good performance out of the system.

💡 Cool thing to note here is that, now Mac's are really good at running windows and that too for longer than a regular windows system.

please note that you might sometimes face issues while running some of the x86 softwares on an ARM chip but for me its been pretty smooth.

👉🏼 for more update, questions ping me on twitter.

👉🏼 checkout other articles on my blog.

Referneces

Many thanks to taitleaney for finding the workaround about changing the Linux version. You can follow the thread on github.

What is Web 3.0?

milindsoorya — Thu, 16 Dec 2021 20:01:31 +0000

Introduction

Web3, short for web 3.0, is a vision of the future of the Internet in which people operate on decentralized, quasi-anonymous platforms, rather than depend on tech giants like Google, Facebook and Twitter. There is no official definition for Web 3.0.

Before learning about web 3.0 let's recap what web 1.0 and web 2.0 is.

Web 1.0

Originated in the year 1991 and lasted till 2004.
Mainly static web pages.
No interactions, basically read-only, no signup etc.
Didn't support analytics, essentially was one big Wikipedia hyperlinked together
Users were consumers

Web 2.0

Originated around 2004 and is still prevalent now.
The web evolved and the biggest change was interactivity
Two-way information flow started to take place. Not only we were getting information from web pages, web pages also got information about us.
Google, Facebook, YouTube etc emerged and started collecting data about users so as to serve us better and in turn, make us stay on their site longer leading to better revenue
The data collection led to the age of targeted ads and along with it came the privacy issues.
One interesting story about the targeted ads is the story of a guy knowing he is about to become a father through ads. This might have happened because his girlfriend searched for her symptoms and the machine learning algorithms put all pieces together for them.

Web 3.0

Next phase of web development uses blockchain and the principles of decentralisation
In web 2.0 we were the product and our data didn't belong to us, but in web 3.0 we will be the owner of our content. We decide if it stays online or not.
Odysee is a blockchain alternative to YouTube. Users are able to post their content and get tokens(a kind of reward similar to bitcoin) when others like it, they download and share with others and the process continues, similar to how a torrent network works.
This will result in uncensored content on the internet and one potential downfall is a lot of illegal, immoral and hateful stuff being posted. But it would all be allowed.
Experts say that in the future every company will be run by a decentralised group called DAO (Decentralised Autonomous Organization). What this means is that there won't any more CEOs and presidents and the people having the most amount tokens will be able to vote on how the company is run.
Digital Identity is separated from the real identity, this means that we can browse, download and buy from the web without being tracked.

Conclusion

Web 3.0 will be gradual and might take a decade to fully implement. Big centralised organisations like Facebook, Google etc will be having DAOs at their helm. The freedom and power given to individuals can easily be misused.

Add anaconda to right-click menu in windows

milindsoorya — Mon, 01 Nov 2021 04:22:59 +0000

The problem

Anaconda prompt is my go-to solution for anything and everything python or data science-related. It is tailored for ease of use and reliability. In windows usually, we have to open the anaconda prompt and then navigate to the folder we want to do our project and then start working on our project. You see this is quite a tedious process and after some time you will get fed up.

The Solution

We can easily overcome this problem by opening the anaconda prompt using the windows right-click menu.
Adding anaconda to the windows right-click menu is quite easy.

STEP - 1 Run regedit.exe

Press Windows key + r to open the run window and then type in regedit.exe
and press ok.

STEP - 2

Navigate to HKEY_CLASSES_ROOT > Directory > Background > shell

STEP - 3

Add a key named AnacondaPrompt and set its value to "Anaconda Prompt Here" (or anything you'd like it to appear as in the right-click context menu)

STEP - 4

Add a key under this key, called command, and set its value to



cmd.exe /K C:\Anaconda3\Scripts\activate.bat

(may have to change the activate.bat file to wherever your Anaconda is installed)

STEP - 5

Now you can open your anaconda prompt by right-clicking your desired location.

How to open sublime text from the windows command line

milindsoorya — Sat, 23 Oct 2021 05:36:48 +0000

Introduction

I am a very big fan of VS Code. I genuinely believe that it is the best IDE for web development. These days I am coding more in python and my interest has shifted towards python IDE's such as Pycharm and Sublime text.

Pycharm is the OG python IDE and it has all the features that you might want. But, it's a bit bulky and takes a lot of resources.

In some cases, I just want to quickly get up and going with as little friction as possible and Sublime text is the perfect answer for those scenarios.

Why open Sublime from cmd?

As I mentioned above, one of my favourite features of VS Code is that it can be opened from any directory using the command code . and VS code will open with all the files in that directory. This simple step has made me more productive.

In this article, I will show how to do the same thing using Sublime Text in windows.

STEP - 1: Search for Environment Variables in the windows search

STEP - 2: Select the environment variable option

STEP - 3: Click on the path and then edit

STEP - 4: Add path to your sublime installation

usually, it will be at C:\Program Files\Sublime Text 3.

After doing this click ok and exit.

STEP - 4: Open sublime from any location

Just go to your desired directory and open a command prompt and input this command.



subl .

That's it!! Thanks for reading.

Check out my website for more useful articles.

MNIST handwritten digit classification using CNN

milindsoorya — Sun, 17 Oct 2021 15:59:18 +0000

Introduction

I would highly recommend you check out Mnist handwritten digit classification using tensorflow before continuing with this article. In that article, I tackled the same MNIST handwritten digit classification using a simple neural network.

Convolutional Neural Networks (CNNs) are the current state-of-art architecture mainly used for the image classification tasks. They are also known as shift invariant or space invariant artificial neural networks, what this means is that even if the digit in the image is not in the exact spot as in the training we will still be able to correctly classify the image.

They have applications in image and video recognition, recommender systems, image classification, image segmentation, medical image analysis, natural language processing, brain-computer interfaces, and financial time series.

CNN's are regularized versions of multilayer perceptrons. Multilayer perceptrons usually mean fully connected networks, that is, each neuron in one layer is connected to all neurons in the next layer.

enough chit chat, let's dive right in

Importing the modules

Required packages are -

Tensorflow
matplotlib
numpy
jupyter
opencv

import tensorflow as tf

# Loading the dataset
mnist = tf.keras.datasets.mnist

# Divide into training and test dataset
(x_train, y_train),(x_test, y_test) = mnist.load_data()

x_train.shape
# (60000, 28, 28)

Hence training data contains 60,000 images. Each of these images is 28 pixels wide and 28 pixels high

import matplotlib.pyplot as plt
plt.imshow(x_train[0])
plt.show()

The image in the dataset is a colour image, we can convert it into greyscale using matplotlib's build-in colour map.

plt.imshow(x_train[0], cmap = plt.cm.binary)

Normalization

The original image is black and white but the value ranges from [0-255]. 0 being the absolute black and 255 being absolute white. But for training, we have to convert this into [0-1].

x_train = tf.keras.utils.normalize(x_train, axis = 1)
x_test = tf.keras.utils.normalize(x_test, axis = 1)
plt.imshow(x_train[0], cmap = plt.cm.binary)

# verify that there is a proper label for the image
print(y_train[0])
# 5

Resizing image for Convolution

You always have to give a 4D array as input to the CNN.

So input data has a shape of (batch_size, height, width, depth), where the first dimension represents the batch size of the image and the other three dimensions represent dimensions of the image which are height, width, and depth.

For some of you who are wondering what is the depth of the image, it’s nothing but the number of colour channels. For example, an RGB image would have a depth of 3, and the greyscale image would have a depth of 1.

In our case, as we are dealing with the greyscale images we can add a depth of 1.

import numpy as np
IMG_SIZE=28
# -1 is a shorthand, which returns the length of the dataset
x_trainr = np.array(x_train).reshape(-1, IMG_SIZE, IMG_SIZE, 1)
x_testr = np.array(x_test).reshape(-1, IMG_SIZE, IMG_SIZE, 1)
print("Training Samples dimension", x_trainr.shape)
print("Testing Samples dimension", x_testr.shape)
# Training Samples dimension (60000, 28, 28, 1)
# Testing Samples dimension (10000, 28, 28, 1)

Creating a Deep Neural Network

Sequential - A feedforward neural network
Dense - A typical layer in our model
Dropout - Is used to make the neural network more robust, by reducing overfitting
Flatten - It is used to flatten the data for use in the dense layer
Conv2d - We will be using a 2-Dimensional CNN
MaxPooling2D - Pooling mainly helps in extracting sharp and smooth features. It is also done to reduce variance and computations. Max-pooling helps in extracting low-level features like edges, points, etc. While Avg-pooling goes for smooth features.

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Activation, Flatten, Conv2D, MaxPooling2D

# Creating the network
model = Sequential() 

### First Convolution Layer
# 64 -> number of filters, (3,3) -> size of each kernal, 
model.add(Conv2D(64, (3,3), input_shape = x_trainr.shape[1:])) # For first layer we have to mention the size of input
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2,2)))

### Second Convolution Layer
model.add(Conv2D(64, (3,3))) 
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2,2)))

### Third Convolution Layer
model.add(Conv2D(64, (3,3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2,2)))

### Fully connected layer 1
model.add(Flatten())
model.add(Dense(64))
model.add(Activation("relu"))

### Fully connected layer 2
model.add(Dense(32))
model.add(Activation("relu"))

### Fully connected layer 3, output layer must be equal to number of classes
model.add(Dense(10))
model.add(Activation("softmax"))

we determine the number of filters based on the complexity of the task.

After each layer the filters increases. This is because of how CNN works. After each layer, more complex features are detected and for it, more filters are used.

For example - Taking the example of our MNIST dataset. In the first layer, the filter will be responsible for edge detection, then it can detect curves or circles, like this after each layer it goes on detecting bigger features.

In case of binary classification, sigmoid activated in recommended

Use the below piece of code to better understand the neural network.

model.summary()

Compile defines the loss function, the optimizer and the metrics.

model.compile(loss="sparse_categorical_crossentropy", optimizer="adam", metrics=['accuracy'])

Training the model

model.fit(x_trainr, y_train, epochs=5, validation_split = 0.3)

if validation accuracy < accuracy, then the model might be overfitting. So the aim is to make validation accuracy and accuracy almost similar. In case of overfitting, we should try adding dropout layers.

# Evaluating the accuracy on the test data
test_loss, test_acc = model.evaluate(x_testr, y_test)
print("Test Loss on 10,000 test samples", test_loss)
print("Test Accuracy on 10,000 test samples", test_acc)

predictions = model.predict([x_testr])
print(predictions)

plt.imshow(x_test[0])
print(np.argmax(predictions[0]))
# 7

Checking on our on input images

I created an image with number in windows paint.

import cv2
img = cv2.imread('three.png')
plt.imshow(img)

img.shape
# (28, 28, 3)

# Converting to grayscale
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gray.shape
# (28, 28)

# Resizing to a 28x28 image
# Please note my image was already in correct dimension
resized = cv2.resize(gray, (28,28), interpolation = cv2.INTER_AREA)
resized.shape
# (28, 28)

# 0-1 scaling
newimg = tf.keras.utils.normalize(resized, axis = 1)

# For kernal operations
newimg = np.array(newimg).reshape(-1, IMG_SIZE, IMG_SIZE, 1)

newimg.shape
# (1, 28, 28, 1)

predictions = model.predict(newimg)
print(np.argmax(predictions[0]))
# 3

Hence, our CNN model was able to correctly identify the number.

Saving the model

# Saving a Keras model:
model.save('path/to/location')

Inorder to use the saved model run the below code

# Loading the model back:
from tensorflow import keras
model = keras.models.load_model('path/to/location')

Conclusion

CNN classifier is really powerful. We were able to correctly identify the number. When compared to the MNIST using simple neural network we got much better accuracy and this model can handle a wide variety of input images too.

Thanks for reading.

Articles you might like

Sentiment analysis using python and NLTK

milindsoorya — Thu, 23 Sep 2021 10:38:33 +0000

Introduction

In this article, I will walk you through how to create a simple sentiment analysis project using python and NLTK.

What is Sentiment Analysis?

Sentiment analysis is the process of deducing the emotion from some media such as text, image or video. It is widely used in various fields. Most of the large political parties use
sentiment analysis to check the perception of their candidates among the public to estimate their win probability.

How to do sentiment analysis?

Sentiment analysis has become easy due to libraries like NLTk, using this library a lot of the pretraining and model generation can be bypassed as NLTK comes with many
pre-trained models that we can use.

In this example, I will be using a model called VADER(Valence Aware Dictionary for Sentiment Reasoning). It is trained on short texts similar to the ones we see on Twitter and
it is extremely powerful in identifying slang but will struggle when used with large text.

let's jump into the code

# sentiment.py
import nltk

text = "This is a very nice day"
nltk.download('vader_lexicon')
from nltk.sentiment.vader import SentimentIntensityAnalyzer
sid = SentimentIntensityAnalyzer()
score = ((sid.polarity_scores(str(text))))['compound']

if(score > 0):
    label = 'This sentence is positive'
elif(score == 0):
    label = 'This sentence is neutral'
else:
    label = 'This sentence is negative'

print(label)

now, you can run the above code by

python sentiment.py

Really simple right? You can play around with it by changing the text.

let's now deploy this using flask.

Deploy sentiment analysis model using flask

Flask is a micro-framework used to build websites really fast with very few lines of code. It is one of the popular and preferred mediums used by Data scientist's to
show their finding's to regular people.

this is how our finished web app will look

STEP - 1

Create a new folder to save the project. The files we need are

main.py - This is where the flask server and the VADER is initialised
templates/index.html - We can use custom HTML files along with flask to give the final webpage a nice look.

Step - 2 copy the code to the respective files

# main.py
import nltk
from flask import request
from flask import jsonify
from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def my_form():
    return render_template('index.html')

@app.route('/', methods=['POST'])
def my_form_post():
    text = request.form['text']
    nltk.download('vader_lexicon')
    from nltk.sentiment.vader import SentimentIntensityAnalyzer
    sid = SentimentIntensityAnalyzer()
    score = ((sid.polarity_scores(str(text))))['compound']

    if(score > 0):
        label = 'This sentence is positive'
    elif(score == 0):
        label = 'This sentence is neutral'
    else:
        label = 'This sentence is negative'

    return(render_template('index.html', variable=label))

if __name__ == "__main__":
    app.run(port='8088', threaded=False, debug=True)

// index.html
<!DOCTYPE html>
<html>
  <head>
    <link
      rel="stylesheet"
      href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css"
      integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T"
      crossorigin="anonymous"
    />
    <script
      src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js"
      integrity="sha384-JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM"
      crossorigin="anonymous"
    ></script>
    <style>
      .centered {
        position: relative;
        text-align: center;
        display: grid;
        place-items: center;
        color: white;
      }

      .header {
        color: black;
      }

      p {
        color: #111;
        font-family: 'Helvetica Neue', sans-serif;
        font-size: 14px;
        line-height: 24px;
        margin: 0 0 24px;
        text-justify: inter-word;
      }

      h1 {
        color: #111;
        font-family: 'Helvetica Neue', sans-serif;
        font-size: 36px;
        font-weight: bold;
        letter-spacing: -1px;
        line-height: 1;
        text-align: center;
      }

      #demo {
        color: #111;
        font-family: 'Helvetica Neue', sans-serif;
        font-size: 22px;
        line-height: 24px;
        margin: 0 0 24px;
        text-justify: inter-word;
      }

      .form-div {
        display: flex;
        justify-content: space-around;
        align-items: center;
      }
    </style>
  </head>
  <body>
    <div class="container mt-5">
      <div class="centered">
        <div class="text-center text-white">
          <title>sentiment analysis app</title>
        </div>
        <h1 class="header">Sentiment Analysis App</h1>

        <p class="desc">
          Type a sentence, click on the submit button and wait for your prediction.
        </p>

        <form method="POST" onSubmit="return validate();" class="form">
          <div class="form-div">
            <input type="text" name="text" class="form-control mr-2" />
            <button type="submit" class="btn btn-outline-primary" onclick="this.form.submit();">
              Submit
            </button>
          </div>
        </form>
        <br />
        <br />

        <p id="demo">{{ variable }}</p>
      </div>
    </div>
  </body>
</html>

STEP - 3

You can now run the server by running the main file.

Visit the URL specified when you run the main file.

voila!! that's it, now as the next step you can host this in platforms such as heroku like any other website.

CSS to ignore parent padding in 4 lines

milindsoorya — Sat, 18 Sep 2021 17:13:44 +0000

Introduction

CSS is damn hard. It's these small problems that will take up your entire day and energy and the will to live. And one such notorious problem has been to make a child element break out of their parent's padding.

The problem

I recently tried to add a newsletter to my website (subscribe - shameless plug) and I wanted the form to extend to the side of the browser window, but there is a parent div with padding for getting that uniform look throughout the site.

how it looks with parent's padding -

how I wanted it to look -

this happens because the section containing newsletter is within the main div -

Yeah I know, It sound's really simple and there are many janky solutions out there to fix it too. (The solution down below is more or less jank, but in relative terms, I believe it is really elegant 😁).

Solution

Give this below piece of CSS to the element you wish to break out(pun Intended).



.full-width {
  width: 100vw;
  margin-left: 50%;
  transform: translateX(-50%);
  max-width: 100%;
}

The max-width is required because otherwise, you may find a horizontal scrollbar.

yeah, It's that simple.

UPDATE:
As I wanted the newsletter on every page I decided to move the section div one level up, so to the same level as the main. Hence, I don't have to do this hack.

Anaconda Cheatsheet

milindsoorya — Sat, 18 Sep 2021 04:41:52 +0000

What is anaconda?

Anaconda is a python package manager and it is really amazing, it is popular because it brings many of the tools used in data science and machine learning with just one install.

In a previous article I talked about how to create a virtual environment using anaconda, you can check it out here. 🐍

In this article, I will list out some of the important anaconda commands. Let's jump right in.

Here on out I will use conda to refer to anaconda

Check if conda is installed and in your PATH if not install from here

conda -V

Check if conda is up to date

conda update conda

Search for python versions in conda

conda search "^python$"

Use conda to create a barebone virtual environment

conda create -n yourenvname python

Use conda to create a virtual environment containing most of the popular data science tools

conda create -n yourenvname python=x.x anaconda

Activate your virtual environment in conda

# if you are using a UNIX operating system like ubuntu
source activate *yourenvname*

# if you are using windows
conda activate yourenvname

Install additional Python packages to a conda virtual environment.

Failure to specify “-n yourenvname” will install the package to the root Python installation.

conda install -n yourenvname [package]

Deactivate your conda virtual environment.

conda deactivate

List all conda virtual environments

conda env list

Delete a no longer needed conda virtual environment

conda remove -n yourenvname -all

Find where your conda virtual environment is stored

Before running the below code, make sure you activated your virtual environment

# on MacOS/Linux:
echo $CONDA_PREFIX

# on Windows:
echo %CONDA_PREFIX%

To find path of all conda environments

conda info --envs

That's it, thanks for reading, if you have some code to share please share in the comment section I will add it to the above list.

Don't forget to bookmark this page for future reference 🐱‍👤

Forem: milindsoorya

How to build a simple CNN based Image classifier using Keras

1 Introduction

1.1 What are Convolutional neural networks (CNN)?

1.2 The classification task

1.3 Problem statement

1.4 Approach

2 The Code

2.1 Import data manipulation packages

2.2 Load in the Data

2.3 Build the CNN

2.4 Training the CNN

2.4 Evaluating the performance of CNN

2.5 Saving the model

2.6 Load the model

2.7 Create Sample Submission

Related articles

References

Installing TensorFlow on M1 MacBook Air with GPU (Metal)

OS Requirements

Currently Not Supported

Table of contents

What is tensorflow?

What is miniforge?

What is miniconda?

Uninstalling existing anaconda/conda from macOS

Install the Anaconda-Clean package from Anaconda Prompt

Remove all Anaconda-related files and directories without being prompted to delete each one

Remove entire anaconda installation directory from macOS

Step 1: Install Miniforge

Download and install Conda env

Create an anaconda environment

Activate the environment

Step 2: Install TensorFlow

Install TensorFlow dependencies

Install base TensorFlow

Install tensorflow-metal plugin

Install common Data Science packages

References

Related Articles

Authentication Flow with React Navigation v5

Prerequisite

Overview

Approach

Project structure

Spacer.js

AuthForm.js

NavLink.js

SigninScreen.js

SignupScreen.js

App.js

You might also like:-

Critical Review on “OpenPose - Realtime Multi-Person 2D Pose Estimation using Part Affinity Fields”

Introduction

Summary of the work, results, and findings

Pros and Cons of the paper:

Potential Advancement and Future Work

References

Related Articles

Run Ubuntu on M1 Macbook Air using UTM

Introduction

1. Installing UTM

2. Downloading the OS Image

3. Possible Install issues

Conclusion

Referneces

What is Web 3.0?

Introduction

Web 1.0

Web 2.0

Web 3.0

Conclusion

Add anaconda to right-click menu in windows

The problem

The Solution

STEP - 1 Run regedit.exe

STEP - 2

STEP - 3

STEP - 4

STEP - 5