DEV Community: Shawon Ashraf

Setting up your AMD GPU for Tensorflow in Ubuntu 20.04

Shawon Ashraf — Sun, 14 Jun 2020 23:21:46 +0000

If you've been working with Tensorflow for some time now and extensively use GPUs/TPUs to speed up your compute intensive tasks, you already know that Nvidia GPUs are your only option to get the job done in a cost effective manner. All you need to have is a GeForce GPU and you can get started crunching numbers in no time. But what about AMD GPUs? I mean, it's been some time that the Team Red has hitting back at the Team Green, they should be a viable option for compute intensive tasks like Deep Learning and such, right? The answer is complicated actually. You can, but not without going the extra mile.

ROCm

I'll keep it brief here since discussing on ROCm isn't the intent of this article and I don't want to open up a large can of worms. In short, ROCm is AMD's answer to Nvidia's CUDA. Thanks to this, you can now easily use various GPU dependent computation libraries and software with AMD GPUs which could previously be used with Nvidia GPUs only. You can read more about it here on their official page.

GPU support

Although ROCm opens up new possibilities for AMD GPUs, not all of them can support it. As of now, only Vega, Polaris, Fiji and Hawaii GPUs are supported. Despite being a recent and popular release, Navi wasn't included and nobody knows why! Check the full list here.

For this setup process I'm using a Radeon VII GPU.

OS Support

It's Linux only as of now. Even so, AMD has builds for only Ubuntu, RHEL and CentOS. As the title says, I'll be setting up ROCm on Ubuntu.

Setup

ROCm

Before you begin, make sure to have your system up to date. Run the following commands in Terminal.

sudo apt update
sudo apt dist-upgrade

Install the dependency libnuma-dev for ROCm.

sudo apt install libnuma-dev

Once libnuma-dev gets installed, add the official ROCm repos to apt

wget -qO - http://repo.radeon.com/rocm/apt/debian/rocm.gpg.key | sudo apt-key add -

echo 'deb [arch=amd64] http://repo.radeon.com/rocm/apt/debian/ xenial main' | sudo tee /etc/apt/sources.list.d/rocm.list

Install the ROCm kernel

    sudo apt update
    sudo apt install rocm-dkms

Add your user to the VIDEOGROUP

sudo usermod -a -G video $LOGNAME
sudo usermod -a -G render $LOGNAME

Open /etc/adduser.conf and add these lines

sudo nano /etc/adduser.conf

ADD_EXTRA_GROUPS=1
EXTRA_GROUPS="render,video"

Open /etc/udev/rules.d/70-kfd.rules and add the following

sudo nano /etc/udev/rules.d/70-kfd.rules

SUBSYSTEM=="kfd", KERNEL=="kfd", TAG+="uaccess", GROUP="video"

Install libtinfo5

sudo apt install libtinfo5

Add ROCm binaries to your path (bash or zsh whichever you use)

echo 'export PATH=$PATH:/opt/rocm/bin:/opt/rocm/profiler/bin:/opt/rocm/opencl/bin/' | sudo tee -a /etc/profile.d/rocm.sh

Test if your installation was successful or not. If your installation was successful, you should be able to see the supported GPUs installed on your system in the output.

sudo /opt/rocm/bin/rocminfo
sudo /opt/rocm/opencl/bin/clinfo

Tensorflow

Install the dependency packages

sudo apt install rocm-libs hipcub miopen-hip

Install rccl from source. The apt package no longer works.

sudo apt install cmake
git clone git@github.com:ROCmSoftwarePlatform/rccl.git
cd rccl
sudo ./install.sh -i

Create a virtualenv using python. (Use python3)

# cd into some dir
python3 -m venv ./env

# activate env
source env/bin/activate

Install Tensorflow ROCM

pip install tensorflow-rocm

You're all done now! Time to test this Tensorflow setup with some python code.

Testing the setup

Open up your favourite text editor and execute the following python script in the venv we created to install Tensorflow.

import tensorflow as tf


x = tf.Variable(3, name="x")
y = tf.Variable(4, name="y")
f = x*x + y*y + 2


tf.print(f)

Output should be something like this

2020-03-12 22:32:31.858480: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libhip_hcc.so
2020-03-12 22:32:31.909918: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1573] Found device 0 with properties:
pciBusID: 0000:05:00.0 name: Vega 20     ROCm AMD GPU ISA: gfx906
coreClock: 1.801GHz coreCount: 60 deviceMemorySize: 15.98GiB deviceMemoryBandwidth: -1B/s
2020-03-12 22:32:31.948506: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library librocblas.so
2020-03-12 22:32:31.949600: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libMIOpen.so
2020-03-12 22:32:31.950580: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library librocfft.so
2020-03-12 22:32:31.950766: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library librocrand.so
2020-03-12 22:32:31.950855: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1697] Adding visible gpu devices: 0
2020-03-12 22:32:31.951100: I tensorflow/core/platform/cpu_feature_guard.cc:142] Your CPU supports instructions that this TensorFlow binary was not compiled to use: SSE3 SSE4.1 SSE4.2 AVX AVX2 FMA
2020-03-12 22:32:31.955707: I tensorflow/core/platform/profile_utils/cpu_utils.cc:94] CPU Frequency: 3299240000 Hz
2020-03-12 22:32:31.956437: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x7b95380 initialized for platform Host (this does not guarantee that XLA will be used). Devices:
2020-03-12 22:32:31.956476: I tensorflow/compiler/xla/service/service.cc:176]   StreamExecutor device (0): Host, Default Version
2020-03-12 22:32:31.959003: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1573] Found device 0 with properties:
pciBusID: 0000:05:00.0 name: Vega 20     ROCm AMD GPU ISA: gfx906
coreClock: 1.801GHz coreCount: 60 deviceMemorySize: 15.98GiB deviceMemoryBandwidth: -1B/s
2020-03-12 22:32:31.959067: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library librocblas.so
2020-03-12 22:32:31.959094: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libMIOpen.so
2020-03-12 22:32:31.959118: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library librocfft.so
2020-03-12 22:32:31.959141: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library librocrand.so
2020-03-12 22:32:31.959285: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1697] Adding visible gpu devices: 0
2020-03-12 22:32:31.959398: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1096] Device interconnect StreamExecutor with strength 1 edge matrix:
2020-03-12 22:32:31.959421: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1102]      0
2020-03-12 22:32:31.959434: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1115] 0:   N
2020-03-12 22:32:31.959730: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1241] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 15306 MB memory) -> physical GPU (device: 0, name: Vega 20, pci bus id: 0000:05:00.0)
27

Done!

That's it! You can now use your AMD GPU with Tensorflow on your Ubuntu installation.

Tracking Download Progress with URLSessionDownloadDelegate

Shawon Ashraf — Fri, 20 Sep 2019 12:02:25 +0000

Downloading ....

You've this cool app that has to download something from the internet, be it images, data or pdf files or whatever. While your app downloads the required resources, your user has to wait. Now this isn't an issue if the resources are small or can be fetched really fast. What if the process isn't fast enough or the resource is very large (say size in MB in double or even triple digits!)? Your users will have to stare at a blank screen with a probably unresponsive app (depending on how you handled resource loading) which is a deal breaker and may lead users away from your app. You must do something to assure the users that the required resource is indeed loading and the app isn't stuck at some deadlock. Show them some progress. Animation, text, percentage labels - whatever goes with your app. Question is, how do you track the download progress to show to your users?

URLSessionDownloadDelegate

You can track download progress in your Swift app using URLSessionDownloadDelegate functions. What you have to do is -

Create an URLSession with a .default configuration
Using the created session, init a downloadTask
Track the progress of that downloadTask with URLSessionDownloadDelegate function -

func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didWriteData bytesWritten: Int64, totalBytesWritten: Int64, totalBytesExpectedToWrite: Int64)

Yes you've to implement the function
There's another function you'll have to implement, which fires up when your download task is complete -

func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didFinishDownloadingTo location: URL)

Let's start!

We start by creating a single view iOS application in Xcode. What this app is going to do is: download an image from a url, show the progress in a label with percentage and finally set the downloaded image to an image view (so that we can be sure that the image actually downloaded!). In the end it should look like this -

Interface

Open up storyboard and add 3 controls - an imageview, a label and a button, using any constraints you like. (Constraints aren't necessary for our discussion at the moment) Take the image below for reference.

Create the necessary outlets and add an action for the button (ctrl + drag).

class ViewController: UIViewController, URLSessionDownloadDelegate {
    @IBOutlet weak var imageView: UIImageView!
    @IBOutlet weak var percentageLabel: UILabel!
    @IBOutlet weak var startButton: UIButton!

    override func viewDidLoad() {
        super.viewDidLoad()
    }

    // MARK: event handler
    @IBAction func startButtonTapped(_ sender: Any) {
       // code goes here
    }
}

We also have to set the content mode for imageview so that the downloaded image fits in properly. You can either do it from the storyboard or just with code inside viewDidLoad like I did.

override func viewDidLoad() {
    super.viewDidLoad()
    // fit image to the view
    imageView.contentMode = .scaleAspectFill
}

Now for the main course

Creating the downloadTask

Let's add a function named download to our ViewController class. It's going to take the url of the image as the only parameter.

// MARK: fetch image from url
func download(from url: URL) {
    let configuration = URLSessionConfiguration.default
    let operationQueue = OperationQueue()
    let session = URLSession(configuration: configuration, delegate: self, delegateQueue: operationQueue)

    let downloadTask = session.downloadTask(with: url)
    downloadTask.resume()
}

Let's check what we've done here. We've created a default config for the URLSession. Next we've created an OperationQueue so that our downloadTask can run asynchronously without locking up the app (i.e. causing a deadlock). (To know more, read on GCD in docs). This will ensure that the other parts of our app will be accessible to the users while the app downloads the image. Finally we're creating the download task using the session and asking it to resume / start operation. For image url, we're going to use this one - https://upload.wikimedia.org/wikipedia/commons/thumb/a/aa/Polarlicht_2.jpg/1920px-Polarlicht_2.jpg?1568971082971.

Now we have a slight problem. Our function requires an URL but we've that as String. So, we need to convert the string to a URL.

// MARK: prepare url from string
func getURLFromString(_ str: String) -> URL? {
    return URL(string: str)
}

Starting the download

We'll be calling the download function when a user taps the button.

// MARK: event handler
@IBAction func startButtonTapped(_ sender: Any) {
    let url = "https://upload.wikimedia.org/wikipedia/commons/thumb/a/aa/Polarlicht_2.jpg/1920px-Polarlicht_2.jpg?1568971082971"

    if let imageURL = getURLFromString(url) {
        download(from: imageURL)
    }
}

Where's the progress at?

We do have a progressLabel, and we can update its text property every time downloadTask makes progress. But the question is where do we update it? We've two delegate functions to implement right? Let's implement the first one and put the label updating code in there.

For download task, URLSessionDownloadDelegate lets you track the amount of bytes to be received and the amount of bytes being received currently. Using these two metrics, we can calculate the percentage.

// MARK: protocol stub for tracking download progress
func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didWriteData bytesWritten: Int64, totalBytesWritten: Int64, totalBytesExpectedToWrite: Int64) {

    let percentDownloaded = totalBytesWritten / totalBytesExpectedToWrite

    // update the percentage label
    DispatchQueue.main.async {
        self.percentageLabel.text = "\(percentDownloaded * 100)%"
    }
}

That'll take care of tracking download progress, what we've chasing so far. But wait, we're not done yet.

Side Concerns - download done, how to set the image then?

By default, resources downloaded with downloadTask end up in the documents bundle of the app which can be accessed using FileHandle. For that, we need the URL to the file, where do we get that? Remember the second protocol function? That'll give us the URL of the file.

// MARK: protocol stub for download completion tracking
func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didFinishDownloadingTo location: URL) {

    // get downloaded data from location

    // set image to imageview
}

Accessing downloaded data

We'll be adding a function readDownloadedData which reads the downloaded resource as raw data and returns it. The function returns an optional for safety.

// MARK: read downloaded data
func readDownloadedData(of url: URL) -> Data? {
    do {
        let reader = try FileHandle(forReadingFrom: url)
        let data = reader.readDataToEndOfFile()

        return data
    } catch {
        print(error)
        return nil
    }
}

Now that we've the raw data, we can use that to create a UIImage to set to our imageview.

UIImage from Data?

func getUIImageFromData(_ data: Data) -> UIImage? {
    return UIImage(data: data)
}

Setting the image

// MARK: set image to image view
func setImageToImageView(from data: Data?) {
    guard let imageData = data else { return }
    guard let image = getUIImageFromData(imageData) else { return }

    DispatchQueue.main.async {
        self.imageView.image = image
    }
}

Completing the protocol function

// MARK: protocol stub for download completion tracking
func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didFinishDownloadingTo location: URL) {

    // get downloaded data from location
    let data = readDownloadedData(of: location)

    // set image to imageview
    setImageToImageView(from: data)
}

And we're done! When you run the app in Simulator or your Device, expect to see similar results like the gif I showed earlier.

Aaaaand......

And that's how you track download progress in your Swift app using URLSessionDownloadDelegate without adding any extra dependencies to your app. You can also do the same thing with libs like Alamofire, with less code and headache but that'll add and extra dependency which you may or may not want!

Code - Where at?

You can find all the code for this post @URLSessionProgressTrackerExample

Swift - PAT or Generics?

Shawon Ashraf — Wed, 28 Aug 2019 12:19:55 +0000

PAT?

Before we begin, let me explain the terms here. PAT means Protocols with associated types. PATs can be generic, which means you can use any type with them, (You can refer to this post I wrote earlier on how Protocols in Swift can be used as generic types) add type constraints and so on. Let's see an example -

protocol PlayerDescriptorProtocol {
    func describeSpeciality()
}

Here we have a Protocol named PlayerDescriptorProtocol which has a function named getSpeciality. The type conforming to this protocol will have to supply in an implementation for this function to describe the speciality of a player. Which is fine till this point but we should be asking, what type of Player should conform to this protocol? Is it a Football player or a Tennis player? Or is it a Cricket player? Because to think of it in this way, players of different types will have different specialities, won't they?

So let's make this one a bit less ambiguous. We will be adding an associated type here.

protocol PlayerDescriptorProtocol {
    associatedtype PlayerType
    func describeSpeciality(of type:PlayerType)
}

Let's check with a conforming type. Before that, let's make a player type.

struct CricketPlayer {
    var name: String
    var age: Int
    var speciality: String
    var infoPage: String

    init(name: String, age: Int, speciality: String, infoPage: String) {
        self.name = name
        self.age = age
        self.speciality = speciality
        self.infoPage = infoPage
    }
}

let shaks = CricketPlayer(
    name: "Shakib Al Hasan",
    age: 32,
    speciality: "All-Rounder",
    infoPage: "http://www.espncricinfo.com/bangladesh/content/player/56143.html"
)

Now let's get a conforming type for our protocol.

struct CricketPlayerDescriptor: PlayerDescriptorProtocol {
    typealias PlayerType = CricketPlayer

    func describeSpeciality(of type: PlayerType) {
        print("\(type.speciality)")
    }
}

var cricketDescriptor = CricketPlayerDescriptor()
cricketDescriptor.describeSpeciality(of: shaks)

And we should be expecting the following output -

All-Rounder

All's fine now, right? I mean throwing in a FootballPlayer or TennisPlayer won't hurt now. But hold on dear Watson, we've things to discuss.

What can go wrong here?

Nothing actually unless you really care about low-level performance of your applications. How do you think the compiler figures out what type to use for the PAT? Sure, generic types work like that, the compiler will figure out the type to apply but the question is when does it figure it out?

Enter Dynamic Dispatch

For PATs, the compiler will have to figure out the type at runtime, which means it has to do it with dynamic dispatch. What is this thing actually? Dynamic Dispatch means to defer something until runtime instead of doing it all at compile time. Dynamic Dispatch is helpful in situations where the compiler doesn't know which type to apply to your function or objects immediately so it keeps them to be determined later (runtime).

Let's clear it up with an example. You're in an ice cream parlour. There are 3 new flavours today but you don't know how they taste! On top of that you happen to have the luxury to buy them all. So what you do is, buy them all and then find out how they taste. (Don't blame me if they taste bad). You just did a dynamic dispatch! Had you asked for testers at the counter and then bought the flavour you liked, that'd be static dispatch.

Static Dispatch

Static Dispatch is just the opposite. The compiler already knows what to do, has a clear idea about types in use, so it does everything during compile time.

Is Static Dispatch faster?

Comparatively, yes. But is it better than Dynamic Dispatch? You've to understand that both are for different tasks and your compiler is already designed to make them work pretty efficiently. What if, you can use both and now, you've to choose one?

Generics and Static Dispatch

Let's re-write the same code using generics. A bit differently.

protocol PlayerDescriptorProtocol {
    func describeSpeciality()
}

struct CricketPlayer : PlayerDescriptorProtocol {
    var name: String
    var age: Int
    var speciality: String
    var infoPage: String

    init(name: String, age: Int, speciality: String, infoPage: String) {
        self.name = name
        self.age = age
        self.speciality = speciality
        self.infoPage = infoPage
    }

    func describeSpeciality() {
        print(speciality)
    }
}

let shaks = CricketPlayer(
    name: "Shakib Al Hasan",
    age: 32,
    speciality: "All-Rounder",
    infoPage: "http://www.espncricinfo.com/bangladesh/content/player/56143.html"
)

// generic method
func describePlayer<PlayerType: PlayerDescriptorProtocol>(of type: PlayerType) {
    type.describeSpeciality()
}

Let's test it out!

describePlayer(of: shaks)

// output : All-Rounder

Both did the same job....

Yes they did. So, which one to choose then? Dynamic or Static? To make a verdict, we have to consider the following -

While generics will be faster due to Static Dispatch, it'll also be heavier on memory compared to PATs with dynamic types. Why? Because for each type, the compiler will push a new function to the stack whereas for PAT, due to the dynamic dispatch only the required function will be created.
What if you don't want the Player class to conform to the protocol and also want to keep separate definition for descriptor classes? You'll end up writing more code!

In my view, pick the one you need. If you don't mind sacrificing a bit more memory to get some extra performance from the compiler, then go for generics, else, choose the convenience of PATs. It's more like choosing between struct and class, since there's no absolute winner here, pick the one that does your job.

Swift - the curious genericness of Associated Types

Shawon Ashraf — Wed, 28 Aug 2019 00:25:17 +0000

Before we dig deep, Protocols!

Swift introduced this new paradigm called POP or Protocol Oriented Programming. For people new to Swift, especially those coming from an OOP heavy language like Java or C#, Protocols may seem somewhat like interfaces. At least that's what it seems from a quick look. Protocols are actually an entirely different kind of animal from Interfaces when it comes to implementation. (Not to mention the added benefits Protocols bring.)

Let's say you want to have a Protocol with a method that adds two numbers and returns the sum. For now, let's just consider that we'll be adding Int type numbers only.

protocol Adder {
    func add(a: Int, b: Int) -> Int
}

Now we need to add an implementation for this method, right? So how do we do it? We create a class that conforms to this protocol.

class IntAdder: Adder {
    func add(a: Int, b: Int) -> Int {
        return a + b
    }
}

Let's see if that works or not!

let adder = IntAdder()
print(adder.add(a: 55, b: 45)) // prints 100

Now what if we don't just want to add Int, rather add Float and Double type numbers as well? Hold on a second, I know you'll yell out generics. There's another way with Protocols. We can use Associated Types.

Chasing the wabbit.....What's an Associated Type?

We want our Protocol method to be generic, right? Which means we have to tell it to take some generic type in as well. But is that possible? The protocol we defined is by no means a generic one. I mean there's no special signature for it to be generic! Turns out to be the opposite actually. You can define a generic type inside the protocol. And associated types just let you do that. Let's see an example.

protocol Adder {
    associatedtype Number
    func add(a: Number, b: Number) -> Number
}

Notice the difference, we created a type out of nowhere and now our function can work with it!

What an associatedtype does is it actually tells the compiler that, listen dear compiler, my functions are a confused bunch of people who don't know whom they should let in, so pardon them for a while and I'm adding a type name or placeholder for these whom kinda people who're about to come in so that you can tag them later on.

In other words, associatedtype gives your imaginary type a name / id so that it doesn't get lost in the crowd.

A bit formal definition

In case you want to define and associatedtype in a formal way, as Apple did (I just shared this from Apple Books app) -

An associated type gives a placeholder name to a type that is used as part of the protocol. The actual type to use for that associated type isn’t specified until the protocol is adopted. Associated types are specified with the associatedtype keyword.

Excerpt From
The Swift Programming Language (Swift 4.2)
Apple Inc.
https://books.apple.com/us/book/the-swift-programming-language-swift-5-0/id881256329
This material may be protected by copyright.

Back to the matter at hand

Let's add an implementation for the protocol. This time, let's add Double type numbers. Before we do so, we got to ask this very important question - how do we tell our generic protocol method what type we're about to pass?

Typealias to the rescue!

We just need to add a typealias for the associatedtype in the class conforming to the protocol. Now how do we do that? Just assign the type you want the function to take in as the typealias. Okay, let's see some code again.

class DoubleAdder: Adder {
    typealias Number = Double
}

Now that's been dealt with, let's move on to the function itself.

func add(a: Double, b: Double) -> Double {
    return a + b
}

The complete DoubleAdder now looks like this.

class DoubleAdder: Adder {
    typealias Number = Double

    func add(a: Double, b: Double) -> Double {
        return a + b
    }
}

Testing again, the implementation passes out.

let adder = DoubleAdder()
print(adder.add(a: 34.67, b: 89.23)) // 123.9

So interfaces ugh, protocols can be generic eh?

Turns out to be so! Protocols with Associated Types can be used as generic types. But should you be using them instead of tested and proven existing generic types? I believe that will require some serious discussion and I shouldn't be making this post any longer. Let's keep that for a separate post, shall we? Great! See you until then and keep yourself dandy!

Loading Images from URLs in Swift without URLSession

Shawon Ashraf — Wed, 21 Aug 2019 16:22:01 +0000

Images and URLs

You're writing the front-end of a fancy website. You have to load images from a remote server and you have the url. What do you do? You take sip from your cup of coffee, grin and pull some HTML trickery. Just like this -

<img src="some_url" alt="some_image">

And that's it, the day (or, night) is saved, thanks to, the PowerPuff Girls! Oh wait, your image tag!

How's that for a mobile app dev?

App devs are an unlucky folk. They don't get to enjoy the niceties web developers have. It's a very melancholic way to put it, but their life isn't as straightforward as loading an image with an HTML tag.

Okay let's get back on topic

Let's say you want to have the same life of a front-end web dev, meaning you want to load images from remote servers in your image views without sacrificing a virgin (that's how it is actually), how do you do it?

Preparing

Create a Single View iOS project. Add an ImageView to your View and create an outlet for it (if you're a beginner, ctrl + click and drag it to create a variable). Add constraints if you feel necessary, though not mandatory for our discussion.

The hard way - URLSessionDataTask

For this, you need to init an URLSession, then create and start a datatask, add in an async handler for data task completion and then set the image. Oh wait! You can't use the main thread to set the image. You should fire up a separate thread via dispatchqueue to do so.

func fetchImage(from urlString: String, completionHandler: @escaping (_ data: Data?) -> ()) {
    let session = URLSession.shared
    let url = URL(string: image_url)

    let dataTask = session.dataTask(with: url!) { (data, response, error) in
        if error != nil {
            print("Error fetching the image! 😢")
            completionHandler(nil)
        } else {
            completionHandler(data)
        }
    }

    dataTask.resume()
}

And to set the image on an ImageView (finally!) -

@IBOutlet weak var imageView: UIImageView!

func setImageToImageView() {
    fetchImage { (imageData) in
        if let data = imageData {
            // referenced imageView from main thread
            // as iOS SDK warns not to use images from
            // a background thread
            DispatchQueue.main.async {
                self.imageView.image = UIImage(data: data)
            }
        } else {
                // show as an alert if you want to
            print("Error loading image");
        }
    }
}

All this, just to load an image eh?

The easy way

Yes, there's an easy way. What we've been doing all alone is that we're fetching resources from the network (images or whatever) as Data objects and then converting them according to our needs, be it an image or a large dump of json. Data has one initializer where you can create an object of it from the contents of an URL. This can make things a bit easier. Let's check it out.

func setImage(from url: String) {
    guard let imageURL = URL(string: url) else { return }

    // just not to cause a deadlock in UI!
    DispatchQueue.global().async {
        guard let imageData = try? Data(contentsOf: imageURL) else { return }

        let image = UIImage(data: imageData)

        DispatchQueue.main.async {
            self.imageView.image = image
        }
    }
}

Let's test it with an actual image url.

// call inside viewDidLoad() or add some event handler
setImage(from: "https://image.blockbusterbd.net/00416_main_image_04072019225805.png")

How does it look?

That does it, but wait

Everything comes at a cost, so does this easy approach. There's a reason people tend to use the hard way for network requests (which are not just for images, mind you). It's that, Swift lets you observe the progress of the network operations in real time if you choose to use URLSession and its delegates. Which comes in handy for larger network requests, where you can let the user know about the progress with fancy progress views or something else. For the easy approach above however, there's no way to do so unless you bite the metal and write things like that yourself. For simple image loading, our easy approach will do more than good. However, for sophisticated tasks, you better be using the hard way.

A song to cool off may be?