Trending December 2023 # How We Built The Idb App – Part 1: Concept And Design # Suggested January 2024 # Top 13 Popular

You are reading the article How We Built The Idb App – Part 1: Concept And Design updated in December 2023 on the website We hope that the information we have shared is helpful to you. If you find the content interesting and meaningful, please share it with your friends and continue to follow and support us for the latest updates. Suggested January 2024 How We Built The Idb App – Part 1: Concept And Design

This is a guest post by Giulio Michelon, proud designer and CEO of Belka, the Italian studio that designed and developed the iDB app. We’ve asked Giulio to come here and share his experience developing the app, from the initial concept to the final product. In part 1, Giulio will talk about concept and design. Part 2, and 3 will be published over the next couple of weeks.

iDownloadBlog’s app started with a concept from Sebastien: he asked us to build an app to discover the latest news for his blog in a fast and convenient way. He mentioned us some example of the result he wanted to see: something similar to Tinder, but for news.

Starting with the design

Before actually building an app there’s a lot of work on the design side and I’m going to explain that in this post.

Most of the time, a designer doesn’t invent, but he rather combines existing elements in order to make an interface as clear and usable as possible for the user.

Paper prototyping

The first iteration was on paper prototyping inside Belka. We usually keep this as fast as possible, that’s why the paper is the best media for this kind of discussion: it’s fast, non-expensive, and it can be easily printed on, with whatever we have in mind to explain the concept.

In this part, the actual look of the app is not important. In fact, our sketching skills are pretty terrifying. The main goal here is to confront our ideas internally and to get as fast as possible to the next step with clear concepts.

The glamorous work of paper prototyping

Lo-fi prototype

After the paper prototyping, we moved to a lo-fi prototype to discuss it with Sebastien. A lo-fi prototype is a graphically basic version of the app (like the picture below) which is used to understand the sections and the interaction of the app between us and someone else.

This confrontational part can be done in very different ways depending on the client’s attitude. In this project Sebastien communicated with us mainly via email.

This was the best way to discuss considering two factors:

The 9-hour time difference between California and Italy

The daily iteration we had on the prototypes that led us work during the day and the morning after having a fresh design review

Every morning we had a revision of the content sent to Sebastien the day before via email. Based on Sebastien’s feedback, we discussed every interaction of the app in order to ship the best product we could build to iDB readers.

This is how simple iterations on some parts of a lo-fi design look like

Here’s an example of an iteration on our design’s proposal. We followed the Apple’s design guidelines and put a Status Bar on top, but Sebastien proposed to move everything to the bottom in order to have more screen estate available. This is a great idea so we modified that and now, as you can see from the app in production, this idea is live. We had a lot of this type of confrontation and disagreement during the design process over a lot of small details.

We discussed different proposals with Sebastien in order to clearly understand his needs and simplify the interaction between the user and the app as much as possible. He cared a lot about minimalism, so we focused on that.

In parallel with the lo-fi mockups, we designed a flow map in order to get a better idea of what the bigger picture should look like. That helped clarify the concepts between the two parts involved: us and iDB. Typically, one of the biggest problems while designing an app are the differences between the mental model of the designer and the mental model of the client. This flow map helps reduce the differences.

The flow map

Why not starting directly from a higher fidelity mockup? Because the devil is in the details. Starting with an higher level means defining the interaction and the aspect of the app, which are very different things, even if they are in the same field — which is design.

I will talk about the higher level in the next part, so stay tuned!

You're reading How We Built The Idb App – Part 1: Concept And Design

How To Use Android Wear Part 1: Navigating The Ui

Smartwatches don’t provide the screen space that smartphones do, so with its approach to the form factor, Google decided to create an experience that is fundamentally different. Android Wear devices are designed to supplement smartphone usage, not replace it. This means you won’t be able to do most of the things on your watch that they can do on your phone. This also means you can’t interact with it the same way either. Android Wear’s UI is an entirely different beast from regular Android, so here’s a primer on how to navigate your way around it.

1. Getting Started

When you first turn on your watch, naturally you’re presented with a watch face. I will refer to this as your home screen. It’s the one you’re going to see the most, and it’s the background against which many cards will appear.

Android Wear provides a better way to view and interact with notifications than pulling out a smartphone time and time again. Thus, the UI is designed around switching between them. To do so, just swipe up and down. Swiping up will drag the next notification card onto the screen. Persistent swiping will continue to do so until there’s nothing new to see.

2. Notification Cards

To interact with any given card, tap on it. Depending on the item, this may or may not present additional information. In the case of Gmail, you can read the entire message on your watch. To interact with it, swipe from the right. When you swipe on the weather card, it presents a forecast of the next several days.

Swiping further to the right will present additional options one at a time. With messaging cards, you have the ability to reply or archive a message right from the watch. The last option is always to open the app on your phone instead.

Android Wear doesn’t have a keyboard, so if you want to reply to email, Hangouts, or text messages, you can only do so using voice dictation. As it turns out, speaking to your watch is a core part of the Android Wear experience.

3. Voice Commands And Opening Apps

In effect, Google Voice Search serves as your app drawer replacement. You can access the screen by tapping once on your watch face – the home screen – or saying “OK Google.” Here you can then speak a command, such as “Show me my steps” (to pull up pedometer information) or “Set an alarm for 11AM.” If you want to see some of the commands that the watch can respond to, swipe from the bottom of the search screen. This will pull up a list of suggestions that you can remember or tap to open instead.

At the bottom of this list are your alarms, settings, and a “Start…” option that opens a list of your installed watch apps.

This list functions similarly to an app drawer. You swipe up and down to get to the app you want and then tap it to open.

To back out of any screen or get rid of a card, just swipe from the left. This will fling the page or item away and return you to the home screen.

4. Muting Alerts And Checking Battery Life

You can prevent your phone from vibrating and stop the display from lighting up by swiping down from the home screen. If you pull slowly, you will draw down a screen that displays the date and your watch’s battery life.


Once you get the feel of things, Android Wear is fairly easy to navigate, and it does a good job of keeping relevant information front and center. These are still early days for the platform, so there’s no telling just what elements will change in the future. In the meantime, a few things are already customizable. In part 2 of this series, we will take a look at how to change the default settings and tweak things to your liking.

Bertel King, Jr.

Subscribe to our newsletter!

Our latest tutorials delivered straight to your inbox

Sign up for all newsletters.

By signing up, you agree to our Privacy Policy and European users agree to the data transfer policy. We will not share your data and you can unsubscribe at any time.

The Last Of Us Part 1 Pc Requirements And Features Revealed

The Last of Us Part 1 PC requirements and features revealed

Sony and Naughty Dog have formally released the requirements and specifications for The Last of Us Part 1.

Naughty Dog’s epic game of Joel and Ellie’s journey across post-apocalyptic America is finally arriving on PC later this month (March 23) and we now know what Sony thinks are the best PC specs for the quality levels on offer. The good news is that enjoyable gameplay is going to be attainable for many PC players, and the features are pretty fulsome, all of which is described extensively in a recent PlayStation blog post.

You can find the full list of specs below, to see how your machine might fare – or to see what you might be tempted to upgrade in time for the game’s release – below for Sony’s full recommendations and tech specifications.

The Last of Us Part 1 PC Specs & Requirements

Credit to PlayStation Blog

This version of the game was released on PS5 back in September 2023, but now it’s time for the post-apocalyptic epic to have it’s day on PC. The specs also show that you won’t necessarily need one of the best gaming laptops or best gaming PCs to enjoy the game. The base-level specs are very achievable and you’ll even be able to enjoy super-smooth 1080p gaming with the likes of a 2070 Super (a now near-four-year-old graphics card).

Minimum system requirements

With these minimum system requirement, players can expect to be running The Last Of Us Part 1 at 30 FPS and 720p resolution with low graphical settings.

CPU – AMD Ryzen 5 1500X / Intel Core i7 4770K

Graphics Card – AMD Radeon 470 (4GB) / Nvidia GeForce 1050 Ti (4GB)

RAM – 16GB

Recommended system requirements

Running The Last Of Us Part 1 with the recommended system requirements should yield 60 FPS at 1080p with high graphical settings.

CPU – AMD Ryzen 5 3600X / Intel Core i7-8700

Graphics Card – AMD Radeon RX 5800 or 6600 XT (8GB) / Nvidia Geforce RTX 2070 Super or RTX 3060 (8GB)

RAM – 16GB

Performance system requirements

Performance system requirements in The Last Of Us Part 1 at 60 FPS at a resolution of 1440p, with high graphical options.

CPU – AMD Ryzen 5 5600X / Intel Core i7-9700K

Graphics Card – AMD Radeon RX 6750XT / Nvidia GeForce RTX 2080 Ti

RAM – 32GB

Ultra system requirements

Ultra system requirements for The Last Of Us Part 1 will run the game at 60 FPS, 4K resolution, and the maximum graphical options.

CPU – AMD Ryzen 9 5900X / Intel Core i5-12600K

Graphics Card – AMD RX 7900XT (FSR quality) / Nvidia Geforce RTX 4080

RAM – 32GB

The Last of Us Part 1 PC features

PC folks will also be able to squeeze – and see – even more out of the game than those on console: the ultrawide support epitomises that beautifully, and in both 21:9 and 32:9 resolutions too. That makes people like yours truly very pleased as there’ll be even more post-apocalyptic landscapes and environments to soak up in every frame.

Other highlights on the feature front include compatibility with the DualSense including haptic feedback and adaptive triggers, as well as the DualShock 4 PlayStation controller – and those from other brands too – and full controller remapping, and the ability to mix between pad and M&K.

The Last of Us Part 1 PC features the base game, Left Behind DLC, and extra modes like Phoot Mode, and Permadeath Mode, and is available for pre-order (see below) and can be nabbed on both Steam and the Epic Games Store.

The Last of Us Part 1 PC pre order & editions

If you’re absolutely sold on this announcement – and why wouldn’t you be – then Green Man Gaming has you covered with some great The Last of Us PC pre order prices that you can see below:

The Last of Us Part 1 PC – Standard Edition – $53.99 / £44.99 at Green Man Gaming

The Last of Us Part 1 PC – Digital Deluxe Edition – $62.99 / £53.99 at Green Man Gaming

However, if you want to go big, and have been eyeing up the rather special Firefly Edition, then you’ll need to head over to PlayStation Direct:

The Last of Us Part 1 PC – Firefly Edition – $99.99 / £99.99 at PlayStation Direct

Reflections On Open Source Commerce, Part 1

It has been more than two years since the Yin and Yang article was published on LinuxPlanet, a long time in the information and communications technology world. The purpose of that article was to highlight the opportunity for greater entrepreneurial focus to gain broad, fast adoption of Linux and open source computing solutions. Absent significant market uptake on the personal computer (desktop and laptop) of Linux and/or open source products, goods, or services, those who measure market share will continue to ignore these as irrelevant to most users.

The process of gaining wide market share for Linux and open source solutions is challenging. The information technology (IT) market is littered with obstacles to success. Even well entrenched market leaders can be negatively impacted by these. The release of Microsoft Vista has shown that negative market forces can hold back even the heavy-weights of the IT game. A bad move, whether real or imagined can significantly alter the course of events. Bad press, or news of potential litigation can really place a damper on a product launch. Everyone who brings a product or service to market is subject to market forces that may exert a control that goes beyond that expected.

Much has changed in the IT world over the past two years. In this article we consider a few of the key developments over this period within the context of opportunity for getting the open source solution offering right to enable them to gain rapid market penetration. It is the author’s hope that the statistics and opinions presented here will inspire you to help create the personal computing future that you would wish for.

In the spirit of open reflection, your criticism is not only welcome, but is actively sought. No one has all the answers, but by working together we can achieve more that the sum of single contributions. How do you think the future of Linux and open source will evolve? Will Microsoft be toppled from the average personal computer user’s desktop? How? Who will make this happen?

The purpose of business is to make a profit, or at a minimum to be able to sustain operations from incoming cash flow. For the personal computing market this is particularly challenging. I invite you to consider why.

The holy grail of business is to sell stuff in acceptable volume at sufficient margin to be rewarding. The reward, or return, that justifies sustaining of the business depends on the goals and objectives of the organization. A not-for profit organization has entirely different objectives than a for profit business. In a market such as the information technology world, where component costs are falling rapidly and where consumers expect accelerated cost reduction and like to see increasing overall system performance , finding the right reward can be a vexing proposition.

Computer hardware vendors do battle with supply-chain and distribution-chain dynamics in a highly competitive world. This business environment results in extreme conservatism and reluctance to engage in products that may not move rapidly, or that may result in excessive post-sale support costs. Slow moving inventory is a sure recipe for financial loss where supply-side prices are constantly in rapid decline and where early obsolescence results in short product life cycles.

Sales of factory pre-installed Linux-based computer systems continue to be successful in the server market. The same cannot be said of desktop and laptop markets; these continue to be elusive, even in the explosive China market: “Although China’s Linux market as a whole doubled from 2003 to 2006 to $20 million per year, sales of Linux desktop software grew more slowly. In fact, the market share of Linux desktop software in China dropped from 16% to 12% in the same period” If China is the world’s fastest ICT growth market, how does this bode for the global market?

Published statistics for Linux-based market penetration by companies such as IDC are reported based on original equipment sales of pre-installed operating systems. Reliable statistics for the number of after-market installed Linux systems do not exist.

After-market installation of Linux results in a bias against original equipment manufacturer (OEM) involvement. All systems that are sold with an operating system other than Linux are already accounted for. Thus, after-market changes do not make a strong business case for the emerging Linux market segment. The result of after-market Linux installation is a negative inertia against OEMs taking a leading role in Linux adoption—something that shows no prospects for change in the immediate future. This counter-inertia is driven by the belief that when customers modify OEM equipment, it results in an increase in post-sale support costs that detracts from the real value of the original sale.

Some one I know purchased a laptop in late 2006. It came with MS Windows MCE pre-installed and had one of the famous Microsoft Vista Capable stickers on it. The owner upgraded his system to MS Windows Vista Premium and soon ran into hardware difficulties, so he contacted the vendor’s support facility only to be told that before returning the system for warranty support, he must restore the system to as sold condition because the vendor could not support systems that have been modified by the owner. This demonstrates how OEMs struggle to keep after-sales support costs under control and also demonstrates the problem of after-market installation and support for Linux.

One must therefore consider how OEMs view the actions of original device manufacturers who provide Linux drivers for components used in systems that are shipped from the factory exclusively with MS Windows installed. Should this be seen as a hostile activity that undermines the profitability of the sale of OEM systems? What about Linux distributions? Do they cause the loss of profitability in OEM systems? Will we soon see the day that all desktops and laptops are sold with technology that will prevent after-market installation of Linux?

My HP dv9010us laptop has Broadcom WiFi miniCard that does not work under OpenSUSE 10.3 Linux. In order to get WiFi support under Linux, I purchased a Gigabyte Atheros chipset-based WiFi miniCard, but the BIOS on my laptop refuses to boot while that card is installed. Apparently HP deliberately crippled the BIOS to impede the ability to install an after-market WiFi card. The laptop refuses to boot with an Error 104 so long as the new miniCard is installed. Whatever the reason, this behavior by the OEM interferes with my rights as the owner of this device and forces me to go to extra trouble if I decide that it is in my best interests to replace this component. This demonstrates the challenge faced by consumers who want to run after-market Linux on a laptop.

After-market Linux on systems present a problem for those who want to see public recognition of the more rapid adoption of Linux grow. After-market installation understates real adoption rates of Linux and open source software and over-states the installed base for competing systems.

The lack of concrete market share statistics for Linux and open source adoption at the desktop is depressing to some, yet considered to be irrelevant to others. Optimism and an expectation that desktop Linux and open source software will triumph despite apparent odds against it continues to abound from many quarters.

When the printing press was first invented few realized its potential and many saw it as just a novelty. The beginnings of WYSIWYG (what you see is what you get) desktop displays and printing capability likewise was not seen as a truly disruptive technology, but today we know otherwise. Of course, WYSIWYG displays coupled with the web has not completely displaced hard-copy printing, but the publishing industry is undeniably in a period of transition as a result of it.

The emergence of tools like Google and Yahoo have the potential to be highly disruptive to the desktop. Nicholas Carr’s book, The Big Switch: Rewiring the World, From Edison to Google, makes a strong case to reconsider our presuppositions regarding the future of corporate information processing systems. Edward Cone’s article provides stunning cause to question our assumptions about how users will interact with digital information over the next decade. If the data center gets displaced by disruptive technologies, what will become of the desktop as we know it? Will it too morph into a new technology that will become a commodity, low cost, household item?

You see, if the data center goes away, if the grid wins, if companies such as Google, Yahoo, etc. emerge as the sole keepers and processing engines of the worlds information, why will the desktop still be important? Would it not make sense to displace the desktop device with a tool that does not require constant updates and maintenance?

Imagine for a moment, what would happen if we could purchase a device from the local white goods store, one that has a battery life of over 48 hours or continuous use, can be read in bright sun light, and can be recharged from solar power. What if that device has fully embedded software that never needs to be modified or updated? What if Google or Yahoo could provide all the interface tools and applications the user would ever need? Would it not make Microsoft Windows (of any flavor) or Linux on the desktop totally irrelevant?

Carr says it all comes down to economics—that is what drives business decisions, but it also drives the consumer’s decisions. In March 2007, I spent two days in electronics stores to observe how consumers purchase desktop and laptop systems. I was stunned to hear customer after customer ask for a desktop or laptop computer without without Windows Vista. Many knew of the problems faced by early users of Vista. They knew about lack of driver support for printers, scanners, cameras, etc. and they wanted relief from early adopter pains. Who can blame them? But, more importantly, there are lessons we can learn from consumer reluctance to embrace something that is new, particularly if it is in any way disruptive. But there is another aspect that we must not ignore: eventually consumers overcome their hang-ups. What happens then?

Vista is well on its way to becoming a ubiquitous desktop platform. In the end, unless there are other mitigating circumstances, Microsoft has won. It may have cost a bit to get it there, but in the short term the consumer caved in. Why? Because the choice that is being offered by stores like Best Buy is Windows Vista or Mac OS. Many consumers believe that MacOS is a better platform than Microsoft Windows, but it costs more—much more!

Carr presents a compelling argument. He says “Whether you look at record companies, or newspapers, or increasingly at movie studios and television studios, you see what happens when all of this stuff gets very, very cheap. They’re competing against free products, sometimes, often products produced by amateurs or volunteers.” Ultimately, free is hard to beat if the quality is good enough.

Will Linux be the platform that delivers just good enough in time to create a paradigm shift from the desktop and laptop to the new-school ultra-mobile, wireless enabled, consumer device that will work transparently the world over providing previously unimaginable access to the all the information that will be sage-guarded, housed, processed, and delivered to you over the grid? We do not know. We just do not know! But we must consider what will become of those who will not, or can not, change their computing practices.

There will always be a transition market, and there will always be a residual market. This is perhaps the area that should be the target for Linux and open source solutions development, look at is as a training and preparation ground for the disruptive change that may follow. One question still begs an answer: How will all of this be delivered to the end user, the consumer?

This question, along with the current state of the server markets, will be examined in Part 2.

This article was first published on chúng tôi

Automated Machine Learning For Supervised Learning (Part 1)

This article was published as a part of the Data Science Blogathon                      

This article aims to demonstrate automated Machine Learning, also referred to as AutoML. To be specific, the AutoML will be applied to the problem statement requiring supervised learning, like regression and classification for tabular data. This article does not discuss other kinds of Machine Learning problems, such as clustering, dimensionality reduction, time series forecasting, Natural Language Processing, recommendation machine, or image analysis.

Understanding the problem statement and dataset

Before jumping to the AutoML, we will cover the basic knowledge of conventional Machine Learning workflow. After getting the dataset and understanding the problem statement, we need to identify the goal of the task. This article, as mentioned above, focuses on regression and classification tasks. So, make sure that the dataset is tabular. Other data formats, such as time series, spatial, image, or text, are not the main focus here.

Next, explore the dataset to understand some basic information, such as the:

Descriptive statistics (count, mean, standard deviation, minimum, maximum, and quartile) using .describe();

Data type of each feature using .info() or .dtypes;

Count of values using .value_counts();

Null value existance using .isnull().sum();

Correlation test using .corr();




After understanding the dataset, do the data pre-processing. This part is very important in that it will result in a training dataset for Machine Learning fitting. Data pre-processing can start with handling the missing data. Users should decide whether to remove the observation with missing data or apply data imputation. Data imputation means to fill the missing value with the average, median, constant, or most occurring value. Users can also pay attention to outliers or bad data to remove them so that they will not be the noise.

Feature scaling is a very important process in data preprocessing. Feature scaling aims to scale the value range in each feature so that features with higher values and small variance do not dominate other features with low values and high variance. Some examples of feature scaling are standardization, normalization, log normalization, etc.

Feature scaling is suitable to apply to gradient descent- and distance-based Machine Learning algorithms. Tree-based algorithms do not need feature scaling The following table shows the examples of algorithms.

Table 1 Examples of algorithms

Machine Learning Type Algorithms

Gradient descent-based Linear Regression, Ridge Regression, Lasso Regression, Elasticnet Regression, Neural Network (Deep Learning)

Distance-based K Nearest Neighbors, Support Vector Machine, K-means, Hierarchical clustering

Tree-based Decision Tree, Random Forest, Gradient Boosting Machine, Light GBM, Extreme Gradient Boosting,

Notice that there are also clustering algorithms in the table. K-means and hierarchical clustering are unsupervised learning algorithms.

Feature engineering: generation, selection, and extraction refer to the activities of creating new features (expected to help the prediction), removing low importance features or noises, and adding new features from extracting partial information of combined existing features respectively. This part is very important that adding new features or removing features can improve model accuracy. Cutting the number of features can also reduce the running time.

Creating model, hyperparameter-tuning, and model evaluation

The main part of Machine Learning is choosing an algorithm and build it. The algorithm needs training dataset features, a target or label feature, and some hyperparameters as the arguments. After the model is built, it is then used for predicting validation or test dataset to check the score. To improve the score, hyperparameter-tuning is performed. Hyperparameter-tuning is the activity of changing the hyperparameter(s) of each Machine Learning algorithms repeatedly until a satisfied model is obtained with a set of hyperparameters. The model is evaluated using scorer metrics, such Root Mean Squared Error, Mean Squared Error, or R2 for regression problems and accuracy, Area Under the ROC Curve, or F1-score for classification problems. The model score is evaluated using cross-validation. To read more about hyperparameter-tuning, please find this article.

After getting the optimum model with a set of hyperparameters, we may want to try other Machine Learning algorithms, along with the hyperparameter-tuning. There are many algorithms for regression and classification problems with their pros and cons. Different datasets have different Machine Learning algorithms to build the best prediction models. I have made notebooks containing a number of commonly used Machine Learning algorithms using the steps mentioned above. Please check it here:

The datasets are provided by Kaggle. The regression task is to predict house prices using the parameters of the houses. The notebook contains the algorithms: Linear Regression, Ridge Regression, Lasso Regression, Elastic-net Regression, K Nearest Neighbors, Support Vector Machine, Decision Tree, Random Forest, Gradient Boosting Machine (GBM), Light GBM, Extreme Gradient Boosting (XGBoost), and Neural Network (Deep Learning).

The binary classification task is to predict whether the Titanic passengers would survive or not. This is a newer dataset published just this April 2023 (not the old Titanic dataset for Kaggle newcomers). The goal is to classify each observation into class “survived” or not survived” without probability. If the classes are more than 2, it is called multi-class classification. However, the technics are similar. The notebook contains the algorithms: Logistic Regression, Naive Bayes, K Nearest Neighbors, Support Vector Machine, Decision Tree, Random Forest, Gradient Boosting Machine, Light GBM, Extreme Gradient Boosting, and Neural Network (Deep Learning). Notice that some algorithms can perform regression and classification works.

Another notebook I created is to predict binary classification with probability. It predicts whether each observation of location, date, and time was in high traffic or not with probability. If the probability of being high traffic is, for example, 0.8, the probability of not being high traffic is 0.2. There is also multi-label classification which predicts the probability of more than two classes.

If you have seen my notebooks from the hyperlinks above, there are many algorithms used to build the prediction models for the same dataset. But, which model should be used since the models predict different outputs. The simplest way is just picking the model with the best score (lowest RMSE or highest accuracy). Or, we can perform ensemble methods. Ensemble methods use multiple different machine learning algorithms for predicting the same dataset. The final output is determined by averaging the predicted outputs in regression or majority voting in classification. Actually, Random Forest, GBM, and XGBoost are also ensemble methods. But, they develop the same type of Machine Learning, which is a Decision Tree, from different subsets of the training data.

Finally, we can save the model if it is satisfying. The saved model can be loaded again in other notebooks to do the same prediction.

Fig. 1 Machine Learning Workflow. Source: created by the author


Automated Machine Learning

The process to build Machine Learning models and choose the best model is very long. It takes many lines of code and much time to complete. However, Data Science and Machine Learning are associated with automation. Then, we have automated Machine learning or autoML. AutoML only needs a few lines to do most of the steps above, but not all of the steps. Figure 1 shows the workflow of Machine Learning. The autoML covers only the parts of data pre-processing, choosing model, and hyperparameter-tuning. The users still have to understand the goals, explore the dataset, and prepare the data.

There are many autoML packages for regression and classification tasks for structured tabular data, image, text, and other predictions. Below is the code of one of the autoML packages, named Auto-Sklearn. The dataset is Titanic Survival, still the same as in the previous notebooks. Auto-Sklearn was developed by Matthias Feurer, et al. (2023) in the paper “Efficient and Robust Automated Machine Learning”. Auto-Sklearn is available openly in python scripting. Yes, Sklearn or Scikit-learn is the common package for performing Machine Learning in Python language. Almost all of the algorithms in the notebooks above are from Sklearn.

# Install and import packages !apt install -y build-essential swig curl !pip install auto-sklearn from autosklearn.classification import AutoSklearnClassifier # Create the AutoSklearnClassifier sklearn = AutoSklearnClassifier(time_left_for_this_task=3*60, per_run_time_limit=15, n_jobs=-1) # Fit the training data, y_train) # Sprint Statistics print(sklearn.sprint_statistics()) # Predict the validation data pred_sklearn = sklearn.predict(X_val) # Compute the accuracy print('Accuracy: ' + str(accuracy_score(y_val, pred_sklearn)))


Dataset name: da588f6e-c217-11eb-802c-0242ac130202 Metric: accuracy Best validation score: 0.769936 Number of target algorithm runs: 26 Number of successful target algorithm runs: 7 Number of crashed target algorithm runs: 0 Number of target algorithms that exceeded the time limit: 19 Number of target algorithms that exceeded the memory limit: 0 Accuracy: 0.7710593242331447 # Prediction results print('Confusion Matrix') print(pd.DataFrame(confusion_matrix(y_val, pred_sklearn))) print(classification_report(y_val, pred_sklearn))


Confusion Matrix 0 1 0 8804 2215 1 2196 6052 precision recall f1-score support 0 0.80 0.80 0.80 11019 1 0.73 0.73 0.73 8248 accuracy 0.77 19267 macro avg 0.77 0.77 0.77 19267 weighted avg 0.77 0.77 0.77 19267

The code is set to run for 3 minutes with no single algorithm running for more than 30 seconds. See, with only a few lines, we can create a classification algorithm automatically. We do not even need to think about which algorithm to use or which hyperparameters to set. Even a beginner in Machine Learning can do it right away. We can just get the final result. The code above has run 26 algorithms, but only 7 of them are completed. The other 19 algorithms exceeded the set time limit. It can achieve an accuracy of 0.771. To find the process of finding the selected model, run this line


The following code is also Auto-Sklearn, but for regression work. It develops an autoML model to predict the House Prices dataset. It can find a model with RMSE of 28,130 from successful 16 algorithms out of the total 36 algorithms.

# Install and import packages !apt install -y build-essential swig curl !pip install auto-sklearn from autosklearn.regression import AutoSklearnRegressor # Create the AutoSklearnRegessor sklearn = AutoSklearnRegressor(time_left_for_this_task=3*60, per_run_time_limit=30, n_jobs=-1) # Fit the training data, y_train) # Sprint Statistics print(sklearn.sprint_statistics()) # Predict the validation data pred_sklearn = sklearn.predict(X_val) # Compute the RMSE rmse_sklearn=MSE(y_val, pred_sklearn)**0.5 print('RMSE: ' + str(rmse_sklearn))


Dataset name: 71040d02-c21a-11eb-803f-0242ac130202 Metric: r2 Best validation score: 0.888788 Number of target algorithm runs: 36 Number of successful target algorithm runs: 16 Number of crashed target algorithm runs: 1 Number of target algorithms that exceeded the time limit: 15 Number of target algorithms that exceeded the memory limit: 4 RMSE: 28130.17557050461 # Scatter plot true and predicted values plt.scatter(pred_sklearn, y_val, alpha=0.2) plt.xlabel('predicted') plt.ylabel('true value') plt.text(100000, 400000, 'RMSE: ' + str(round(rmse_sklearn))) plt.text(100000, 350000, 'MAE: ' + str(round(mean_absolute_error(y_val, pred_sklearn)))) plt.text(100000, 300000, 'R: ' + str(round(np.corrcoef(pred_sklearn, y_val)[0,1],2)))


# Scatter plot true and predicted values plt.scatter(pred_sklearn, y_val, alpha=0.2) plt.xlabel('predicted') plt.ylabel('true value') plt.text(100000, 400000, 'RMSE: ' + str(round(rmse_sklearn))) plt.text(100000, 350000, 'MAE: ' + str(round(mean_absolute_error(y_val, pred_sklearn)))) plt.text(100000, 300000, 'R: ' + str(round(np.corrcoef(pred_sklearn, y_val)[0,1],2)))

Fig. 2 Scatter plot from autoSklearnRegressor. Source: created by the author

So, do you think that Machine Learning Scientists/Engineers are still needed?

There are still other autoML packages to discuss, like Hyperopt–Sklearn, Tree-based Pipeline Optimization Tool (TPOT), AuroKeras, MLJAR, and so on. But, we will discuss them in part 2.

About Author

Connect with me here.

The media shown in this article are not owned by Analytics Vidhya and are used at the Author’s discretion.


Yahoo Pipes: Analyzing Digg, Part 1: By Submitter

For those of you that like to follow social media sites such as Digg, an easy analysis tool may be of some use to you. Yahoo Pipes lets you very quickly put together a suite of tools to organize a web feed’s items. In this example, I’m going to to sort the Digg homepage RSS feed by the submitter of each story.

To do that, we need to manipulate some of the content of the Digg feed using the Yahoo Pipes Regex (regular expressions) module. Otherwise, all the information we need is in the feed.

I’m not going to get into an elaborate discussion of regexes. Instead, I’ll just list what I’ve used in the screencast video. (If you’re familiar with regexes already, bear with me.)

^ – caret – match the beginning of a string.

$ – dollar – match the end of a string.

.* – dot star – match any sequence of characters.

^.*$ – match the entire string.

(^.*$) – match the entire string and save it in parameter 1, aka $1.

The Digg home page RSS feed has a number of fields/ variables that we can access in Yahoo Pipes. In this example, I’ve only used one:


Within Yahoo Pipes, to access it, we place braces (curly brackets) around it:


These are the steps I take in the video below.

Grab the Digg home page feed.

Insert the digg username (of the story submitter) in the item.title field’s values, at the beginning of the title, surrounded by square brackets.

Do the same with the item.y:title field. (This is probably redundant, but it’s not a big deal.)

Replace the item.description fields with nothing – i.e., an empty string. For our analysis, getting rid of the description reduces visual clutter in the results. It’s just easier to see only the title and submitter.

Sort the resulting manipulated feed by the item.title.

What we’re doing is taking a story title such as

Paris’ Sob Story


[RainbowPhoenix] Paris’ Sob Story

for each home page story. The string in the square brackets is the name of the Digg member that submitted the article. So ^.*$ matches “Paris’ Sob Story”, and the () brackets assigns this string to $1. Thus the Regex replace rule (^.*$) for item.title takes the very same title and inserts the current digg username in square brackets in front of the title.

[${digg:submitter.digg:username}] $1

Other than getting rid of the story description, this all we’re really doing, followed by a sort on the title values.

Yahoo Pipes modules used:

Fetch Feed




You can take my Digg by Submitter pipe, clone and tweak it to your heart’s content. Or wait for the next one. In the next part of this mini-series, we’ll sort the Digg homepage by category (and prove an Apple bias for the home page).

Update the detailed information about How We Built The Idb App – Part 1: Concept And Design on the website. We hope the article's content will meet your needs, and we will regularly update the information to provide you with the fastest and most accurate information. Have a great day!