K M Jawadur R. looks like a good fit?
We can organize an interview with Aldin or any of our 25,000 available candidates within 48 hours. How would you like to proceed?
Schedule Interview NowK M Jawadur R. - Fullstack Developer, Data Analysis, Data Mining
Being part of Softaims has allowed me to see the full spectrum of what technology can achieve when guided by empathy, discipline, and creativity. Each assignment, regardless of size, represents an opportunity to bring clarity to complexity and to turn ambitious ideas into tangible outcomes. I’ve come to realize that successful development isn’t just about writing code—it’s about listening carefully, understanding deeply, and designing thoughtfully. Every client brings unique challenges, and I make it a priority to align my work with their goals, ensuring that the end result is both effective and lasting. Softaims fosters an environment where collaboration is not optional—it’s essential. The collective expertise within the team pushes me to think beyond conventional boundaries, to question, refine, and innovate. I believe that this process of shared learning and experimentation is what makes our solutions resilient and impactful. My ultimate goal is to build technology that feels effortless to use yet powerful in function. I approach every task with the mindset that small details can make a big difference. Through continuous refinement and dedication, I aim to contribute to the kind of work that not only serves today’s needs but anticipates tomorrow’s possibilities.
Main technologies
Fullstack Developer
9 years
Computer Vision
1 Year
TensorFlow
5 Years
PyTorch
4 Years
Additional skills
- Computer Vision
- TensorFlow
- PyTorch
- Python
- Deep Learning
- SQL
- Microsoft Power BI
- Microsoft Excel
- Machine Learning
- Data Visualization
- Data Science
- Business Intelligence
- Google Cloud Platform
- Data Analysis
- Data Mining
Direct hire
Potentially possible
Experience Highlights
Power Sector Dashboards
Sample dashboards from the power sector project with public power sector companies in Bangladesh.
Covid-19 Simulation using Dash
A simple Covid-19 simulation application built using Plotly's Dash framework. This simulation is based on the analysis done in Tomas Peuyo's Medium article titled "Coronavirus: Why You Must Act Now", published on 10th March, 2020. It is known that there is a lag time before an infection gets reported as a confirmed case. So, a simulation model based on total number of deaths at present, fatality rate, days from infection to death, and case doubling rate has been used to estimate the actual true cases at present day. Number of cases that caused the deaths = Total deaths as of today / (Fatality rate (in %) / 100) Number of times cases have doubled = Days from infection to death / Case doubling time True cases today = Number of cases that caused the deaths * 2^(Number of times cases have doubled) True cases on Nth day from today = True cases today * 2^(Nth day number / Number of times cases have doubled) The default values of fatality rate, days from infection to death, and case doubling rate are sensible defaults determined by studies on actual data (more details in the article linked above), but feel free to tweak these values as well. Number of cases requiring hospitalizations, ICUs, ventilators have been adjusted by subtracting number of new cases from 10 days prior to account for cases that leave the hospital either due to recovery or death. Note that this is a very simple model that makes a lot of assumptions. Also, this model only shows the outbreak scenarios without accounting for containment, mitigation or other phases of intervention. Hence, the graphs only show infinitely increasing trends. However, this simulation (especially for N<=30 days) gives you an idea about how and when your hospital capacities might be pushed to their limits.
Oil Manufacturing Tracker Dashboard
Demo of an interactive dashboard built with Python, Plotly and Dash. Features include cross-chart interactions on hover, URL routing and multipage app using Single Page App (SPA) design pattern, metric drillthrough, and custom KPI colors based on ranges of calculated values.
Facial Keypoint Detection
Build a facial keypoint detection system that takes in any image with faces, and predicts the location of 68 distinguishing keypoints on each face. Facial keypoints include points around the eyes, nose, and mouth on a face and are used in many applications. These applications include: facial tracking, facial pose recognition, facial filters, and emotion recognition. The completed code looks at any image, detect faces, and predict the locations of facial keypoints on each face. Also, a basic facial filter module has also been implemented. Dataset: YouTube Faces Dataset Optimization and loss functions: I ran experiments using Stochastic Gradient Descent (SGD) and Adam optimization functions. Single epoch using SGD(lr=0.001) showed little or no noticeable change in loss over time. Then, increasing SGD's lr to 0.01 gave a little decrease in loss over the first epoch. When ran over 50 epochs, SGD was slowly able to lower the loss over time. However, replacing SGD with Adam optimizer (with default params) and keeping all else same, I found that the loss decreased much faster. Also, the training time for Adam was only slightly higher compared to SGD. Therefore, I used Adam optimizer since it takes less time to converge. I compared 3 loss functions which are all suitable for regression problems that produce continuous, numeric outputs, namely MSELoss, L1Loss and SmoothL1Loss. Since L1Loss and MSELoss use different formulas to calculate the loss (and SmoothL1Loss being a combination of the two), meaningful comparisons cannot be made by only looking at the loss numbers. So, instead I ran experiments using Adam optimizer, a batch size of 50 and for a total of 10 epochs for each of the 3 loss functions, and then looked at the output visualizations on test data. SmoothL1Loss gave the best outputs on test data (at least visually for a few batches) and it also took slightly less time to train compared to L1Loss and MSELoss. Network architecture: I brought the image down to reasonable size using combinations of Conv2d and MaxPool2d filter layers before using a series of Dense layers. It required 5 Conv2d+MaxPool2d layers to bring the image dimension down to 5-by-5. Doubling the number of filters at each such layer gave 32 * 2^4 = 512 filters before the first Dense layer. So, the first Dense layer consisted of 512*5*5 = 12800 nodes. I also used Dropoff between each layer in order to reduce overfitting (increasing the dropoff probability gradually in later layers). I only tested two architectures by only varying in_features of the second-last Dense layer. At first, I used 1000 nodes for the second-last Dense layer. However, I wanted to test how the loss trend and the output results differ if I increase in_features of the second-last layer from 1000 to 6400. Comparing these experiments by keeping everything else constant, I found that the variant with in_features=6400 in the second-last Dense layer resulted in a much lower training loss, and it only took slightly longer to train. Hence, I chose this architecture. Number of epochs and batch_size: For the batch size, I ran experiments using batch sizes of 10, 20 and 50. The loss fluctuates less over time for larger batch sizes, and the training time also decreased slightly. Otherwise, I could not identify any other significant differences for the limited number of experiments that I could run. I decided to go with batch size of 50 because a larger batch size gave much smoother loss trends over time, which made the loss curve a little easier to interpret, especially for initial experiments where I used lower number of epochs. Also, the computer faced no difficulties in performing the training steps when using batch size of 50. I initially ran quick experiments for combinations of different architectures, batch sizes, optimizer and loss functions using a single epoch. I used 50 epochs to select the final architecture. For my setup, the loss does not decrease much after about 100 epochs.
Image Captioning using Encoder-Decoder Model (PyTorch)
Implemented an Encoder-Decoder model in PyTorch, which can automatically generate captions from images. Dataset: Microsoft Common Objects in COntext (MS COCO) Rationale: I have chosen an Encoder-Decoder architecture. The Encoder module is a resnet50 model that was pretrained on ImageNet. This module enables us to extract features from images. The final layer of this module has been replaced with a fully-connected Linear layer to transform image features into embeddings. The Decoder module is based on an LSTM architecture. There is an embedding layer to transform captions into embeddings. Next comes the unidirectional LSTM layer. Lastly, I have a dropout layer for avoiding overfitting and a fully-connected linear layer to transform the output into vocabulary matrix. For my first attempt in training the model, I used batch_size = 64, vocab_threshold = 5, embed_size = 300, hidden_size = 128, num_epochs = 3. However, during inference my model was predicting the same sentence for all images. I resolved that issue by slightly modifying my model's sample method. The results were still not satisfying. Examining the output captions, it felt like my model was underfitting a bit. So, I decided to increase hidden_size and num_epochs. Also, I decreased vocab_thresold to allow a larger number of vocabulary keys. I also wanted to increase the batch_size to test whether the computing environment can handle a larger batch_size. Variable values - final selections: batch_size = 128 - This gave about 3000 steps per batch which seems reasonable to me. Also, the computing environment had enough memory to handle this batch_size. vocab_threshold = 3 - I wanted to allow more vocabulary keys as I was training my model for longer and with larger hidden_size in my second attempt. embed_size = 300 - Based on my previous readings on Natural Language Processing methods and on the discussion in one of the lessons in this course, I felt confident in choosing 300 as the final value for this project. hidden_size = 256 - Using a size of 128 did not seem to overfit my model. Judging from the model predictions, I definitely felt that I got much better results when using a size of 256. num_epochs = 5 - Training for 5 epochs took roughly 13 hours. Since the model weights are saved every epoch, I decided to run the training for 5 epochs from noon to midnight. If lower a number of epochs gives better results, I can always use those saved weights.
Education
North South University
Bachelor of Science (BS) in Electrical engineering
2011-01-01-2015-01-01
Udacity
Other in Computer Vision Nanodegree
2020-01-01-2020-01-01
Udacity
Other in Data Engineering Nanodegree
2021-01-01-2021-01-01
United International University
Master's degree in Computer Science and Engineering
2020-01-01-2023-01-01
University of the West of England
Master's degree in Data Science
2024-01-01-2025-01-01
Languages
- Bengali
- English
- French
- Hindi
Stackoverflow