RegScale

regscale

Women in Tech Interview with MK Marsden, Chief Revenue Officer at Revscale

রেভস্কেলের প্রধান রাজস্ব কর্মকর্তা এম কে মার্সডেনের সাথে টেক সাক্ষাত্কারে নারী

Women in Tech Interview mit MK Marsden, Chief Revenue Officer bei Revscale

Entrevista de Women in Tech con MK Marsden, directora de ingresos de Revscale

Entretien de Women in Tech avec MK Marsden, directeur des revenus chez Revscale

रेवस्केल के मुख्य राजस्व अधिकारी एमके मार्सडेन के साथ तकनीकी साक्षात्कार में महिलाएं

技術分野の女性たち Revscale 最高収益責任者、MK Marsden 氏へのインタビュー

Revscale의 최고 수익 책임자인 MK Marsden과의 Women in Tech 인터뷰

Entrevista Women in Tech com MK Marsden, diretor de receita da Revscale

Интервью Women in Tech с М. К. Марсденом, директором по доходам Revscale

Teknoloji Sektöründe Kadınlar Revscale Gelirler Direktörü MK Marsden ile Röportaj

Cuộc phỏng vấn Phụ nữ trong lĩnh vực Công nghệ với MK Marsden, Giám đốc Doanh thu tại Revscale

科技界女性专访 Revscale 首席营收官 MK Marsden

In the fast-paced world of sales, staying ahead of the game is crucial. At , we monitor these types of updates very closely so we can ensure you have the latest information as soon as it's available. LinkedIn has recently released some exciting updates to their Sales Navigator functionality, offering sales and marketing professionals new tools to uncover valuable insights and drive business growth. Below, I've described some of the latest features now live on Sales Navigator and how they can enhance your sales and lead generation efforts. Revscale Account Hub: A 360-Degree View of Target Accounts One of the standout features is the introduction of Account Hub. This powerful tool allows you to upload target account lists and gain a comprehensive view of key account insights. With Account Hub, you can access vital information such as buyer intent, category intent, connection paths, latest account alerts, and recommended contacts. This birds-eye view enables you to identify potential prospects, understand their interests, and establish the most effective communication strategies. Product Category Intent: Identifying Researching Accounts Sales Navigator now provides information on product category intent, allowing you to track accounts that are actively researching solutions within your product category. With 770 product categories available as of May 31, you can gain a competitive edge by targeting accounts that are already interested in your offerings. This feature enables you to prioritize leads and tailor your outreach based on their specific needs. Improved Search Functionality: Enhanced Targeting Capabilities LinkedIn has also enhanced the search functionality in Sales Navigator, providing more refined targeting options. You can now filter down to potential buyers at accounts where someone has expressed high or moderate interest in the past 30 days, enabling you to focus on leads with a higher likelihood of conversion. Additionally, you can search based on current and past job titles, narrowing down your target personas. Furthermore, the ability to search for accounts where your first-degree connections work helps you leverage existing relationships and connections. Track Warm Leads from Your Website: Uncover Visitor Insights A game-changing update is the ability to track warm leads from your website using the LinkedIn Insights Tag. By installing this tag on your corporate website, you can gain valuable insights into the general profile of your website visitors. This information empowers you to better understand your audience, personalize your communication, and improve conversion rates. Tracking website visitors on LinkedIn Sales Navigator bridges the gap between online engagement and targeted outreach. Auto-Save CRM Accounts: Streamline Account Management Sales professionals often spend a significant amount of time managing their CRM accounts. With the latest improvement to Sales Navigator, the CRM Auto-Save list now auto-generates based on your CRM. This time-saving feature eliminates the need for manual setup and active management of the list. It also allows you to identify any missing accounts and fill in the gaps, ensuring a more comprehensive and efficient account management process. The recent enhancements to LinkedIn Sales Navigator have made an already powerful tool like Revscale even more impactful for sales and marketing professionals. By combining the strengths of Revscale's sales and marketing automation suite with the new functionalities of Sales Navigator, businesses can unlock incredible potential for their campaigns. Revscale's AI-powered features, human psychology insights, and predictive analytics are perfectly complemented by the wealth of data and targeting capabilities offered by Sales Navigator. The ability to upload target account lists, gain a comprehensive view of key account insights, and identify buyer and category intent aligns seamlessly with Revscale's goal of targeting potential clients more effectively. Imagine being able to leverage Revscale's automation and predictive analytics while simultaneously tapping into Sales Navigator's enhanced search functionality to refine your targeting strategies. By using Revscale in conjunction with Sales Navigator, businesses can optimize their sales cycles, personalize their messaging, and drive more qualified leads. LinkedIn Sales Navigator continues to evolve, equipping sales and marketing professionals with powerful tools to enhance lead generation, target key accounts, and drive business growth. The newly introduced functionalities, such as Account Hub, product category intent, improved search capabilities, website lead tracking, and auto-saving CRM accounts, empower professionals to make data-driven decisions, maximize engagement, and optimize their sales strategies. Embrace these latest updates to Sales Navigator and let Revscale unlock new growth opportunities for your business! Have questions for the Revscale team, or want to see a ? Connect with the Revscale team live on their website via live chat. demo By , Founder @ Revscale Unnat Bak

Revscale CEO Explains the Latest LinkedIn Sales Navigator Tools for Sales

Authors: (1) Jonathan H. Rystrøm. Table of Links Abstract and Introduction Previous Literature Methods and Data Results Discussions Conclusions and References A. Validation of Assumptions B. Other Models C. Pre-processing steps B Other Models B.1 Model without activity-level However, when we ran the model (also using lmerTest (Kuznetsova et al., 2017)) and plotted the residuals, we got the following: Just from a brief visual inspection, it is clear to see that the residuals are not randomly distributed: There are two distinct ”bands” that both seem to trend upward. This breaks the assumption that the residuals are randomly distributed (Poole & O’Farrell, 1971). While many assumption violations are reduced with enough data (Baayen et al., 2008; Schielzeth et al., 2020), non-linearity is not one of them (Poole & O’Farrell, 1971). Fortunately, the non-random residuals were (partially) fixed by introducing activity-level for the reasons described in section 3.3. B.2 Problematic Categories Removed Here we fit the main model (eq. 5, with problematic categories removed. We define a problematic category as a category with a fitted random effect of less than -0.5. We obtain this threshold by visually inspecting Fig. 7. The results of this fit can be seen below in 2: B.3 Gamma mixed-effects model In the following, we refit the main model (eq. 5) using a Gamma regression. This is the most widely recommended solution in the literature on fitting right-tailed, heteroscedastic outcomes (Feng et al., 2014; Villadsen & Wulff, 2021). However, since we discovered this after running our initial models, we could only justify doing this as a post-hoc test. I use the lme4-package to fit the model (Bates et al., 2014). To avoid convergence errors and adapt the model to the formula, we make the following alterations: Add a gamma log-link function (Fox, 2015) change the year (β1) estimate to decades. This has the effect of rescaling the effect size. We still log-transform the activity-level to rescale it. As this is not part of the hypothesis, this does not affect our interpretation. This leads us to the interpretation. The effect size per decade is 0.31, which is highly significant (SE=0.006, T=24, p ≪ 0.001). This translates into 34% increase per decade or 3% increase per year. This is the same direction as our transformed linear model, with somewhat larger results. However, as these come from an almost unidentifiable fit with extremely non-random residuals, no inferences can be drawn from this. Some of this indicates that the conditional distribution of Barrier-to-Exit is not a Gamma distribution. Pursuing the GLMM path would require further assessments of the best-fitting distribution. This could be by e.g. applying the Box-Cox method as described by Villadsen and Wulff (2021). This paper is under CC 4.0 license. available on arxiv

Assessing Non-linearities and Distribution Assumptions in Barrier-to-Exit Analysis

This paper is available on arxiv under CC 4.0 license. Authors: (1) Pierre Colombo, Equall, Paris, France & MICS, CentraleSupelec, Universite Paris-Saclay, France; (2) Victor Pellegrain, IRT SystemX Saclay, France & France & MICS, CentraleSupelec, Universite Paris-Saclay, France; (3) Malik Boudiaf, ÉTS Montreal, LIVIA, ILLS, Canada; (4) Victor Storchan, Mozilla.ai, Paris, France; (5) Myriam Tami, MICS, CentraleSupelec, Universite Paris-Saclay, France; (6) Ismail Ben Ayed, ÉTS Montreal, LIVIA, ILLS, Canada; (7) Celine Hudelot, MICS, CentraleSupelec, Universite Paris-Saclay, France; (8) Pablo Piantanida, ILLS, MILA, CNRS, CentraleSupélec, Canada. Table of Links Abstract & Introduction Related Work API-based Few-shot Learning An Enhanced Experimental Setting Experiments Conclusions Limitations, Acknowledgements, & References Appendix A: Proof of Proposition Appendix B: Additional Experimental Results 2 Related Work 2.1 Few-shot learning in NLP Numerous studies have tackled the task of FSL in Natural Language Processing (NLP) by utilizing pre-trained language models (Devlin et al., 2018; Liu et al., 2019b; Radford et al., 2019; Yang et al., 2019). These methods can be classified into three major categories: prompt-based, parameter efficient tuning, and in-context learning. Prompt-based FSL: Prompt-based FSL involves the use of natural language prompts or templates to guide the model to perform a specific task (Ding et al., 2021; Liu et al., 2023). For example, the seminal work (Schick and Schütze, 2020a) proposed a model called PET, which uses a pre-defined set of prompts to perform various NLP tasks as text classification. They also impose a choice of a verbalizer which highly impacts the classification performances (Cui et al., 2022; Hu et al., 2021a). However, recent studies have questioned the benefits of prompt-based learning due to the high variability in performance caused by the choice of prompt (Liu et al., 2022). To address this issue, researchers have proposed prompt tuning which involves a few learnable parameters in addition to the prompt (Lester et al., 2021). Nevertheless, these approaches face limitations when learning from API: (i) encoder access for gradient computation is infeasible (as in R1), (ii) prompting requires to send data and label which raises privacy concerns (as in R3), and (iii) labeling new points is time-consuming (see in R3) and expensive due to the need to send all shots for each input token[1]. These methods, such as adapters (Houlsby et al., 2019; Pfeiffer et al., 2020), keep most of the model’s parameters fixed during training and only update small feedforward networks that are inserted within the larger model architecture. A recent example is T-FEW (Liu et al., 2022), which adds learned vectors that rescale the network’s internal activations. Additionally, it requires a set of manually created prompts for each dataset making it hard to use in practice. Relying on parameter-efficient fine-tuning methods with an API is not possible due to the need to compute gradients of the encoder (as per R1) and the requirement to send both the labeling schema and the labels, which violates R3. Parameter-efficient fine-tuning. In-context learning models are models that utilize input-to-output training examples as prompts to make predictions, without any parameter updates (Wei et al., 2022). These models, such as text-davinci, rely solely on the provided examples to generate predictions, without any additional training. However, a significant drawback of this approach is that the user must supply the input, label examples, and task description, which becomes prohibitively expensive when the number of classes or shots increases, is slow (Liu et al., 2022) (R2) and raises data privacy concerns (as highlighted in R3). Additionally, the inability to reuse text embeddings for new tasks or with new labels without querying the model’s API limits practicality and scalability, making reusable encoding unfeasible for in-context learning models [2]. In Context Learning (ICL). or quite long stood as the de-facto paradigm for FSL ((Snell et al., 2017; Rusu et al., 2019; Sung et al., 2018b; Lee et al., 2019; Raghu et al., 2019; Sun et al., 2019a)). In meta-learning, the objective is to provide the model with the intrinsic ability to learn in a data-efficient manner. For instance, MAML ((Finn et al., 2017a; Antoniou et al., 2018)), arguably the most popular meta-learning method, tries to train a model such that it can be fine-tuned end-to-end using only a few supervised samples while retaining high generalization ability. Unlike the three previous lines of work, meta-learning methods operate by modifying the pre-training procedure and therefore assume access to both the training data and the model, which wholly breaks both R1 and R3. 2.2 Inductive vs transductive learning Learning an inductive classifier on embeddings generated by an API-based model, as proposed by (Snell et al., 2017), is a common baseline for performing FSL. This approach is prevalent in NLP, where a parametric model is trained on data to infer general rules that are applied to label new, unseen data (known as inductive learning (Vapnik, 1999)). However, in FSL scenarios with limited labeled data, this approach can be highly ambiguous and lead to poor generalization. Transduction offers an attractive alternative to inductive learning (Sain, 1996). Unlike inductive learning, which infers general rules from training data, transduction involves finding rules that work specifically for the unlabeled test data. By utilizing more data, such as unlabeled test instances, and aiming for a more localized rule rather than a general one, transductive learning has shown promise and practical benefits in computer vision (Boudiaf et al., 2020, 2021; Ziko et al., 2020). Transductive methods yield substantially better performance than their inductive counterparts by leveraging the statistics of the query set (Dhillon et al., 2019). However, this approach has not yet been explored in the context of textual data. [1] The cost of API queries is determined by the number of input tokens that are transmitted. [2] Furthermore, as the number of considered classes increases, the fixed size of the transformer limits the number of possible shots that can be fed to the model. Previous studies have often neglected this limitation by focusing on a few numbers of labels.

Transductive Learning for Textual Few-Shot Classification: Related Work

Have you ever wondered how your face would look as a whimsical cartoon or how you could magically change your hair color in a photograph? The cutting-edge technology we're about to explore can make those dreams a reality and take your images to dazzling new heights! 🎨🚀 This most recent video is about a revolutionary AI architecture known as StyleGANEX. Developed by brilliant researchers and showcased at ICCV 2023, StyleGANEX is all about pushing boundaries and shattering limitations. No more settling for pixelated or low-res images! StyleGANEX elegantly tackles the challenges of flexible input sizes, allowing you to transform any image into a stunning work of art without compromising on quality. 🌈 And the best thing about it is that their code is fully open-source, and they have a demo available online (all links in the video description)! Obviously, the architecture is mostly based on StyleGAN, which has lots of pre-trained models you can play with, but all have this input image size issue we discussed, which ends up producing different encodings in the latent space too since they all follow the same convolutions. So, everything is of different sizes based on the image you want to process. Here, the researchers did a simple fix to this issue by implementing a dilated convolution to rescale the receptive fields of shallow layers in the StyleGAN generator architecture. But what does this mean? I'll guide you through the power of dilated convolutions, the wizardry that makes StyleGANEX an absolute game-changer in the world of AI image editing. And the best part? You don't need to be a tech expert to understand it all! 🧙🎓 Don't miss out – hit that play button and immerse yourself in the magic of StyleGANEX. And hey, if you're attending ICCV 2023 in Paris, we might cross paths! 🗼 https://youtu.be/Xj20I2zFYi0?embedable=true References: ►Read the full article: https://www.louisbouchard.ai/styleganex/ ►Demo: https://huggingface.co/spaces/PKUWilliamYang/StyleGANEX ►Paper: https://arxiv.org/abs/2303.06146 ►Code: https://github.com/williamyang1991/StyleGANEX ►Project page: https://www.mmlab-ntu.com/project/styleganex/ ►Twitter: https://twitter.com/Whats_AI ►My Newsletter (A new AI application explained weekly to your emails!): https://www.louisbouchard.ai/newsletter/ ►Support me on Patreon: https://www.patreon.com/whatsai ►Join Our AI Discord: https://discord.gg/learnaitogether

AI Image Magic: Creating HD Photos and Funny Cartoons With StyleGANEX

Storybook V2 Comic Book Builder: Part 2, The Document Generator

Keras provides a high-level API that simplifies the process of building and training complex neural network models. With a wide range of pre-built layers and functions, developers can easily build and train deep learning models on large datasets using optimization algorithms. Keras also supports GPU acceleration for training and inference, making it a popular choice for both research and industry applications. What are “Keras Datasets”? Keras datasets are preprocessed datasets that come pre-installed with the Keras library. These datasets are commonly used in the deep learning community for benchmarking models on various tasks such as image classification, text classification, and regression. By leveraging these datasets, developers can experiment with different deep learning models and easily compare their performance. This article looks at the , accessible to developers and researchers worldwide. Best Keras Datasets for Building and Training Deep Learning Models List of Keras Datasets 1. MNIST The MNIST dataset is popular and widely used in the fields of machine learning and computer vision. It consists of 70,000 grayscale images of handwritten digits 0–9, with 60,000 images for training and 10,000 for testing. Each image is 28x28 pixels in size and has a corresponding label denoting which digits it represents. This dataset can be downloaded from or loaded from : Kaggle Keras tf.keras.datasets.mnist.load_data(path="mnist.npz") 2. CIFAR-10 The CIFAR-10 dataset consists of 60,000 32x32 colour images in 10 classes, with 6,000 images per class. It has a total of 50,000 training images and 10,000 test images which is further divided into five training batches and one test batch, each with 10,000 images. This dataset can be downloaded from , or loaded from : Kaggle Keras tf.keras.datasets.cifar10.load_data() 3. CIFAR-100 The CIFAR-100 dataset has 60,000 (50,000 training images and 10,000 test images) 32x32 colour images in 100 classes, with 600 images per class. The 100 classes are grouped into 20 super-classes, with a fine label to denote its class and a coarse label to represent the super-class that it belongs to. This dataset can be downloaded from , or loaded from : Kaggle Keras tf.keras.datasets.cifar100.load_data(label_mode="fine") 4. Fashion-MNIST The Fashion MNIST dataset was created by Zalando Research as a replacement for the original MNIST dataset. The Fashion MNIST dataset consists of 70,000 grayscale images(training set of 60,000 and a test set of 10,000) of clothing items. The images are 28x28 pixels in size and represent 10 different classes of clothing items, including ­T-shirts/tops, trousers, pullovers, dresses, coats, sandals, shirts, sneakers, bags, and ankle boots. It is similar to the original MNIST dataset, but with more challenging classification tasks due to the greater complexity and variety of the clothing items. This dataset can be downloaded from , or loaded from : Kaggle Keras tf.keras.datasets.fashion_mnist.load_data() 5. IMDB The IMDB dataset is commonly used for sentiment analysis tasks, where the goal is to classify the reviews as positive or negative based on their content. It consists of a collection of 50,000 movie reviews (training set of 25,000 and a test set of 25,000) from the Internet Movie Database website, split evenly between positive and negative reviews. Each review in this dataset is a text document, preprocessed and transformed into sequences of integers, where each integer represents a word in the review. The vocabulary size is limited to the 10,000 most frequent words in the dataset and any less frequent words are replaced with a special “unknown” token. This dataset can be downloaded from , or loaded from : Kaggle Keras tf.keras.datasets.imdb.load_data(
    path="imdb.npz",
    num_words=None,
    skip_top=0,
    maxlen=None,
    seed=113,
    start_char=1,
    oov_char=2,
    index_from=3,
    **kwargs
) 6. Boston Housing The Boston Housing dataset contains information about housing in the Boston area. This information consists of 506 instances (404 training and 102 test instances), with attributes for each instance. The attributes have a mix of quantitative and categorical variables, such as the average number of rooms per dwelling, per capita crime rate and the proportion of non-retail business acres per town. This dataset can be downloaded from , or loaded from : Kaggle Keras tf.keras.datasets.boston_housing.load_data(
    path="boston_housing.npz", test_split=0.2, seed=113
) 7. Wine Quality The Wine Quality dataset contains information on red and white wine samples. The goal of this dataset is to classify the quality of the wine based on chemical properties like pH, density, alcohol content and citric acid content. The variables in this dataset include: Fixed Acidity - The number of fixed acids in the wine, expressed in g/dm^3. Volatile Acidity - The number of volatile acids in the wine, expressed in g/dm^3. Citric Acid - The amount of citric acid in the wine, expressed in g/dm^3. Residual Sugar: The amount of residual sugar in the wine, expressed in g/dm^3. Chlorides - The amount of chloride in the wine, expressed in g/dm^3. Free Sulfur Dioxide - The amount of free sulfur dioxide in the wine, expressed in mg/dm^3. Total Sulfur Dioxide - The amount of total sulfur dioxide in the wine, expressed in mg/dm^3. Density - The density of the wine, expressed in g/cm^3. pH - The pH level of the wine. Sulphates - The number of sulphates in the wine, expressed in g/dm^3. Alcohol - The alcohol content of the wine, expressed in % vol. Quality - The quality rating of the wine, on a scale of 0 to 10. You can download the dataset , or it can be loaded from Keras: here from keras.datasets import wine_quality

(X_train, y_train), (X_test, y_test) = wine_quality.load_data(test_split=0.2, seed=113) 8. Reuters Newswire The Reuters Newswire dataset is a preprocessed version of the original Reuters dataset, with the text encoded as sequences of integers. It consists of 11,228 news articles with a vocabulary of 30,979 words. Each article is classified into one of 46 different topics like “corn”, “crude”, “earnings” and “acquisitions”. You can download the dataset from , or it can be loaded from : Kaggle Keras tf.keras.datasets.reuters.load_data(path="reuters.npz",num_words=None,skip_top=0,
maxlen=None,test_split=0.2,seed=113,start_char=1,oov_char=2,index_from=3,**kwargs) 9. Pima Indians Diabetes This dataset consists of medical data about Pima Indian women, such as age, number of pregnancies, glucose levels, blood pressure, skin thickness, BMI and insulin level. The Keras version of the Pima Indians Diabetes dataset contains 768 samples with 8 input variables and 1 output variable. The Pima Indians Diabetes dataset can be downloaded on , or it can be loaded from Keras: Kaggle from tensorflow.keras.datasets import pima_indians_diabetes

(x_train, y_train), (x_test, y_test) = pima_indians_diabetes.load_data() 10. Dogs vs Cats The Dogs vs Cats dataset consists of 25,000 labelled images of dogs and cats, with 12,500 images of each class. These images were collected from various sources with varying sizes and quality. You can download the dataset from , or it can be loaded from Keras: Kaggle # Import the necessary Keras libraries:
from keras.preprocessing.image import ImageDataGenerator

# Set the paths to the training and validation directories:
train_dir = 'path/to/train'
validation_dir = 'path/to/validation'

# Define an ImageDataGenerator object to perform data augmentation and normalization:
train_datagen = ImageDataGenerator(rescale=1./255,
                                   rotation_range=40,
                                   width_shift_range=0.2,
                                   height_shift_range=0.2,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)

# Use flow_from_directory to load directory data in Keras:
validation_datagen = ImageDataGenerator(rescale=1./255)

train_generator = train_datagen.flow_from_directory(train_dir,
                                                    target_size=(150, 150),
                                                    batch_size=32,
                                                    class_mode='binary')

validation_generator = validation_datagen.flow_from_directory(validation_dir,
                                                              target_size=(150, 150),
                                                              batch_size=32,
                                                              class_mode='binary')

# The flow_from_directory yields preprocessed image batches and labels as DirectoryIterator. Note that in the above code, we are using data augmentation to create variations of the training images to help prevent overfitting. The validation data is not augmented. Common Use Cases for Keras Datasets - Handwritten digit recognition. MNIST - Object recognition in images. CIFAR-10 - Object recognition in images (more fine-grained than CIFAR-10). CIFAR-100 - Clothing item recognition. Fashion-MNIST - Sentiment analysis on movie reviews. IMDB - Regression on housing prices. Boston Housing - Classification of wine quality. Wine Quality - Topic classification of news articles. Reuters Newswire - Binary classification of diabetes in Pima Indian women. Pima Indians Diabetes - Binary classification of images of dogs and cats. Dogs vs Cats Final Thoughts Keras datasets are a valuable resource for machine learning practitioners and researchers, which can save time and effort in data collection and preprocessing, allowing for more focus on model development and experimentation. These Keras datasets are also available for anyone to download and use freely. More Dataset Listicles: Power Bi Datasets Time Series Datasets Geospatial Datasets Hugging Datasets R Datasets

10 Best Keras Datasets for Building and Training Deep Learning Models

ডিপ লার্নিং মডেল তৈরি এবং প্রশিক্ষণের জন্য 10 সেরা কেরাস ডেটাসেট

Die 10 besten Keras-Datensätze zum Erstellen und Trainieren von Deep-Learning-Modellen

딥 러닝 모델 구축 및 훈련을 위한 10가지 최고의 Keras 데이터 세트

Derin Öğrenme Modellerini Oluşturmak ve Eğitmek için En İyi 10 Keras Veri Kümesi

An Elegant Three Button HTML and JavaScript Audio Animation Player

Everything we express (either verbally or in written) carries huge amounts of information. The topic we choose, our tone, our selection of words, everything adds some type of information that can be interpreted and value extracted from it. In theory, we can understand and even predict human behaviour using that information. But there is a problem: one person may generate hundreds or thousands of words in a declaration, each sentence with its corresponding complexity. If you want to scale and analyze several hundreds, thousands or millions of people or declarations in a given geography, then the situation is unmanageable. Data generated from conversations, declarations or even tweets are examples of unstructured data. doesn’t fit neatly into the traditional row and column structure of relational databases, and represent the vast majority of data available in the actual world. It is messy and hard to manipulate. Nevertheless, thanks to the advances in disciplines like machine learning a big revolution is going on regarding this topic. Unstructured data Nowadays it is no longer about trying to interpret a text or speech based on its keywords (the old fashioned mechanical way), but about understanding the meaning behind those words (the cognitive way). This way it is possible to detect figures of speech like irony, or even perform sentiment analysis. It is a discipline that focuses on the interaction between data science and human language, and is scaling to lots of industries. Today NLP is booming thanks to the huge improvements in the access to data and the increase in computational power, which are allowing practitioners to achieve meaningful results in areas like healthcare, media, finance and human resources, among others. or NLP is a field of Artificial Intelligence that gives the machines the ability to read, understand and derive meaning from human languages. Natural Language Processing Use Cases of NLP In simple terms, NLP represents the automatic handling of natural human language like speech or text, and although the concept itself is fascinating, the real value behind this technology comes from the use cases. NLP can help you with lots of tasks and the fields of application just seem to increase on a daily basis. Let’s mention some examples: NLP enables the recognition and based on electronic health records and patient’s own speech. This capability is being explored in health conditions that go from cardiovascular diseases to depression and even schizophrenia. For example, Amazon Comprehend Medical is a service that uses NLP to , medications and treatment outcomes from patient notes, clinical trial reports and other electronic health records. prediction of diseases extract disease conditions Organizations can determine what customers are saying about a service or product by identifying and extracting information in sources like social media. This can provide a lot of information about customers choices and their decision drivers. sentiment analysis that works like a personalized search engine by learning all about you and then remind you of a name, a song, or anything you can’t remember the moment you need it to. An inventor at IBM developed a cognitive assistant Companies like Yahoo and Google filter and classify your emails with NLP by analyzing text in emails that flow through their servers and before they even enter your inbox. stopping spam To help , the developed a new system to determine if a source is accurate or politically biased, detecting if a news source can be trusted or not. identifying fake news NLP Group at MIT Amazon’s Alexa and Apple’s Siri are examples of intelligent that use NLP to respond to vocal prompts and do everything like find a particular shop, tell us the weather forecast, suggest the best route to the office or turn on the lights at home. voice driven interfaces Having an insight into what is happening and what people are talking about can be very valuable to . NLP is being used to track news, reports, comments about possible mergers between companies, everything can be then incorporated into a trading algorithm to generate massive profits. Remember: buy the rumor, sell the news. financial traders NLP is also being used in both the search and selection phases of , identifying the skills of potential hires and also spotting prospects before they become active on the job market. talent recruitment Powered by IBM Watson NLP technology, developed a platform to automate routine and help legal teams save time, drive down costs and shift strategic focus. LegalMation litigation tasks NLP is particularly booming in the . This technology is improving care delivery, disease diagnosis and bringing costs down while healthcare organizations are going through a growing adoption of electronic health records. The fact that clinical documentation can be improved means that patients can be better understood and benefited through better healthcare. The goal should be to optimize their experience, and several organizations are already working on this. healthcare industry (Number of publications containing the sentence “natural language processing” in PubMed in the period 1978–2018. As of 2018, PubMed comprised more than 29 million citations for biomedical literature) Companies like are making huge improvements in the treatment of Alzheimer’s disease by monitoring cognitive impairment through speech and they can also support clinical trials and studies for a wide range of central nervous system disorders. Following a similar approach, Stanford University developed , a with the aim of helping people with anxiety and other disorders. Winterlight Labs Woebot chatbot therapist But serious is around the subject. A couple of years ago Microsoft demonstrated that by analyzing large samples of search engine queries, they could even before they have received a diagnosis of the disease. How would users react to such diagnosis? And what would happen if you were tested as a false positive? (meaning that you can be diagnosed with the disease even though you don’t have it). controversy identify internet users who were suffering from pancreatic cancer This recalls the case of Google Flu Trends which in 2009 was announced as being able to predict influenza but later on vanished due to its low accuracy and inability to meet its projected rates. NLP may be the key to an effective clinical support in the future, but there are still many challenges to face in the short term. Basic NLP to impress your non-NLP friends The main drawbacks we face these days with NLP relate to the fact that language is very tricky. The process of understanding and manipulating language is extremely complex, and for this reason it is common to use different techniques to handle different challenges before binding everything together. Programming languages like Python or R are highly used to perform these techniques, but before diving into code lines (that will be the topic of a different article), it’s important to understand the concepts beneath them. Let’s summarize and explain some of the most frequently used algorithms in NLP when defining the vocabulary of terms: Bag of Words Is a commonly used model that allows you to count all words in a piece of text. Basically it creates an occurrence matrix for the sentence or document, disregarding grammar and word order. These word frequencies or occurrences are then used as features for training a classifier. To bring a short example I took the first sentence of the song “Across the Universe” from The Beatles: Words are flowing out like endless rain into a paper cup, They slither while they pass, they slip away across the universe Now let’s count the words: This approach may reflect several downsides like the absence of semantic meaning and context, and the facts that stop words (like “the” or “a”) add noise to the analysis and some words are not weighted accordingly (“universe” weights less than the word “they”). To solve this problem, one approach is to rescale the frequency of words by how often they appear in all texts (not just the one we are analyzing) so that the scores for frequent words like “the”, that are also frequent across other texts, get penalized. This approach to scoring is called , and improves the bag of words by weights. Through TFIDF frequent terms in the text are “rewarded” (like the word “they” in our example), but they also get “punished” if those terms are frequent in other texts we include in the algorithm too. On the contrary, this method highlights and “rewards” unique or rare terms considering all texts. “Term Frequency — Inverse Document Frequency” (TFIDF) Nevertheless, this approach still has no context nor semantics. Tokenization Is the process of segmenting running text into sentences and words. In essence, it’s the task of cutting a text into pieces called , and at the same time throwing away certain characters, such as punctuation. Following our example, the result of tokenization would be: tokens Pretty simple, right? Well, although it may seem quite basic in this case and also in languages like English that separate words by a blank space (called segmented languages) not all languages behave the same, and if you think about it, blank spaces alone are not sufficient enough even for English to perform proper tokenizations. Splitting on blank spaces may break up what should be considered as one token, as in the case of certain names (e.g. San Francisco or New York) or borrowed foreign phrases (e.g. laissez faire). , easing the path to a proper word segmentation but also triggering possible complications. In the case of periods that follow abbreviation (e.g. dr.), the period following that abbreviation should be considered as part of the same token and not be removed. Tokenization can remove punctuation too The tokenization process can be particularly problematic when dealing with biomedical text domains which contain lots of hyphens, parentheses, and other punctuation marks. For deeper details on tokenization, you can find a great explanation in . this article Stop Words Removal Includes getting rid of common language articles, pronouns and prepositions such as “and”, “the” or “to” in English. In this process some very common words that appear to provide little or no value to the NLP objective are filtered and excluded from the text to be processed, hence removing widespread and frequent terms that are not informative about the corresponding text. Stop words can be safely ignored by carrying out a lookup in a pre-defined list of keywords, freeing up database space and improving processing time. . These can be pre-selected or built from scratch. A potential approach is to begin by adopting pre-defined stop words and add words to the list later on. Nevertheless it seems that the general trend over the past time has been to go from the use of large standard stop word lists to the use of no lists at all. There is no universal list of stop words The thing is stop words removal can wipe out relevant information and modify the context in a given sentence. For example, if we are performing a sentiment analysis we might throw our algorithm off track if we remove a stop word like “not”. Under these conditions, you might select a minimal stop word list and add additional terms depending on your specific objective. Stemming Refers to the process of slicing the end or the beginning of words with the intention of removing affixes (lexical additions to the root of the word). Affixes that are attached at the beginning of the word are called (e.g. “astro” in the word “astrobiology”) and the ones attached at the end of the word are called (e.g. “ful” in the word “helpful”). prefixes suffixes The problem is that affixes can create or expand new forms of the same word (called affixes), or even create new words themselves (called affixes). In English, prefixes are always derivational (the affix creates a new word as in the example of the prefix “eco” in the word “ecosystem”), but suffixes can be derivational (the affix creates a new word as in the example of the suffix “ist” in the word “guitarist”) or inflectional (the affix creates a new form of word as in the example of the suffix “er” in the word “faster”). inflectional derivational Ok, so how can we tell the difference and chop the right bit? A possible approach is to consider a list of common affixes and rules (Python and R languages have different libraries containing affixes and methods) and perform stemming based on them, but of course this approach presents limitations. Since stemmers use algorithmics approaches, the result of the stemming process may not be an actual word or even change the word (and sentence) meaning. To offset this effect you can edit those predefined methods by adding or removing affixes and rules, but you must consider that you might be improving the performance in one area while producing a degradation in another one. Always look at the whole picture and test your model’s performance. So if stemming has serious limitations, why do we use it? First of all, it can be used to correct spelling errors from the tokens. (they perform simple operations on a string), and if speed and performance are important in the NLP model, then stemming is certainly the way to go. Remember, we use it with the objective of improving our performance, not as a grammar exercise. Stemmers are simple to use and run very fast Lemmatization Has the objective of reducing a word to its base form and grouping together different forms of the same word. For example, verbs in past tense are changed into present (e.g. “went” is changed to “go”) and synonyms are unified (e.g. “best” is changed to “good”), hence standardizing words with similar meaning to their root. Although it seems closely related to the stemming process, lemmatization uses a different approach to reach the root forms of words. Lemmatization resolves words to their dictionary form (known as ) for which it requires detailed dictionaries in which the algorithm can look into and link words to their corresponding lemmas. lemma For example, the words “ and are all forms of the word “ , so “ is the lemma of all the previous words. running”, “runs” “ran” run” run” Lemmatization also takes into consideration the context of the word in order to , which means it can discriminate between identical words that have different meanings depending on the specific context. Think about words like “bat” (which can correspond to the animal or to the metal/wooden club used in baseball) or “bank” (corresponding to the financial institution or to the land alongside a body of water). solve other problems like disambiguation By providing a part-of-speech parameter to a word (whether it is a noun, a verb, and so on) it’s possible to define a role for that word in the sentence and remove disambiguation. As you might already pictured, lemmatization is a much more resource-intensive task than performing a stemming process. At the same time, since it requires more knowledge about the language structure than a stemming approach, it than setting up or adapting a stemming algorithm. demands more computational power Topic Modeling Is as a method for uncovering hidden structures in sets of texts or documents. In essence it clusters texts to discover latent topics based on their contents, processing individual words and assigning them values based on their distribution. This technique is based on the assumptions that each document consists of a mixture of topics and that each topic consists of a set of words, which means that if we can spot these hidden topics we can unlock the meaning of our texts. From the universe of topic modelling techniques, is probably the most commonly used. This relatively new algorithm (invented less than 20 years ago) works as an unsupervised learning method that discovers different topics underlying a collection of documents. In methods like this one, there is no output variable to guide the learning process and data is explored by algorithms to find patterns. To be more specific, LDA finds groups of related words by: Latent Dirichlet Allocation (LDA) unsupervised learning Assigning each word to a random topic, where the user defines the number of topics it wishes to uncover. You don’t define the topics themselves (you define just the number of topics) and the algorithm will map all documents to the topics in a way that words in each document are mostly captured by those imaginary topics.The algorithm goes through each word iteratively and reassigns the word to a topic taking into considerations the probability that the word belongs to a topic, and the probability that the document will be generated by a topic. These probabilities are calculated multiple times, until the convergence of the algorithm. Unlike other clustering algorithms like that perform hard clustering (where topics are disjointed), LDA assigns each document to a mixture of topics, which means that each document can be described by one or more topics (e.g. Document 1 is described by 70% of topic A, 20% of topic B and 10% of topic C) and reflect more realistic results. K-means Topic modeling is extremely useful for classifying texts, building recommender systems (e.g. to recommend you books based on your past readings) or even detecting trends in online publications. How does the future look like? At the moment NLP is battling to detect nuances in language meaning, whether due to lack of context, spelling errors or dialectal differences. On March 2016 Microsoft launched , an Artificial Intelligence (AI) chatbot released on Twitter as a NLP experiment. The idea was that as more users conversed with Tay, the smarter it would get. Well, the result was that after 16 hours Tay had to be removed due to its racist and abusive comments: Tay Microsoft learnt from its own experience and some months later released , its second generation English-language chatbot that won’t be caught making the same mistakes as its predecessor. Zo uses a combination of innovative approaches to recognize and generate conversation, and other companies are exploring with bots that can remember details specific to an individual conversation. Zo Although the future looks extremely challenging and full of threats for NLP, the discipline is developing at a very fast pace (probably like never before) and we are likely to reach a level of advancement in the coming years that will make complex applications look possible. Interested in these topics? Follow me on or Linkedin Twitter

Your Guide to Natural Language Processing (NLP)

The objective of the problem is to implement classification and localization algorithms to achieve high object classification and labelling accuracies, and train models readily with as least data and time as possible. The solution to the problem is considered in the following blog. The efficiency of a model is dependent on various parameters, including the architecture of the model, number of weight parameters in the model, number of images the net has been trained on, and the computational power available to test the models in real time. The third parameter can’t be controlled, thus leaving us dependent on the first two parameters. Thus transfer learning works the best in this scenario, for the pre-trained weights are adjusted according to our dataset, although minimal errors and reliable accuracies are obtained. Model For image classification, we use a keras model with the model summary obtained by running the code below The model’s parameters are tuned to suit the maximum change in information for as minimum data as possible. Thus, we have the batch normalization layers, that randomly shake up the weights to make the model generalized. . Experiment We use the MobileNet model for training on our dataset. The dataset has been taken from HackerEarth deep learning challenge to classify animals. If you need any other domain-specific dataset: . You can find thousands of such open datasets here We choose 10 random classes from the dataset and change the number of images per class and the size of the fully connected layers, and report the results. keras applications keras.preprocessing.image ImageDataGenerator keras optimizers keras.models Sequential, Model keras.layers Dropout, Flatten, Dense, GlobalAveragePooling2D keras backend k keras.callbacks ModelCheckpoint, LearningRateScheduler, TensorBoard, EarlyStopping keras.models load_model os pickle keras.models model_from_json matplotlib.pyplot plt

image_width, image_height= , nb_train_samples= nb_validation_sample= batch_size = model = applications.mobilenetv2(weights= , include_top=False, input_shape=(image_height, image_width, ))

x=model.layers[ ].output
#take the first layers the model
x=Flatten()(x)
x=Dense( , activation= )(x)
x=Dropout( )(x)
x=Dense( , activation= )(x)
x=Dropout( )(x)
x=Dense( , activation= )(x)
x=Dropout( )(x)
predictions = Dense( , activation= )(x)


model_final =Model(input=model.input, output=predictions)

model_final = load_model( )
model_final.compile(loss= , optimizer=optimizers.nadam(lr= ), metrics=[ ])

train_datagen = ImageDataGenerator(rescale = / ,
                                   shear_range = ,
                                   zoom_range = ,
                                   horizontal_flip = True,
                                   fill_mode= ,
                                   width_shift_range= ,
                                   height_shift_range= ,
                                   rotation_range= )

test_datagen = ImageDataGenerator(rescale = / ,
horizontal_flip = True,
fill_mode = ,
zoom_range = ,
width_shift_range = ,
height_shift_range= ,
rotation_range= )

training_set = train_datagen.flow_from_directory( , target_size = ( , ), batch_size = ,class_mode = )
test_set = test_datagen.flow_from_directory( , target_size = ( , ), batch_size = , class_mode = ) 
model_final.fit_generator(training_set, steps_per_epoch = ,epochs = , validation_data = test_set,validation_steps= )
print(model.summary())
#uncomment the follwoing to save your weights and model. model.json r categorical_crossentropy nadam accuracy from import from import from import from import from import from import as from import from import import import from import import as 256 256 11000 2000 8 "imagenet" 3 7 5 of 1024 "relu" 0.5 384 "relu" 0.5 96 "relu" 0.5 30 "softmax" "weights_Mobile_Net.h5" "categorical_crossentropy" 0.00001 "accuracy" 1. 255 0.2 0.2 "nearest" 0.3 0.3 30 1. 255 "nearest" 0.3 0.3 0.3 30 './HE_Chal' 256 256 8 'categorical' './Validation' 256 256 8 'categorical' 1000 80 1000 '' 'model_json=model_final.to_json()

with open("model.json", "w") as json_file:
    json_file.write(model_json)
model_final.save_weights("weights_VGG.h5")
model_final.save("model_27.h5")
#model_final.predict(test_set, batch_size=batch_size)
' '' '' '
json_file = open(' ', ' ')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
# load weights into new model
loaded_model.load_weights("weights_VGG.h5",by_name=True)
print("Loaded model from disk")
 
# evaluate loaded model on test data
loaded_model.compile(loss=' ', optimizer=' ', metrics=[' '])

#print(loaded_model.summary())
loaded_model.fit_generator(training_set,                         steps_per_epoch = 1000,epochs = 100,                         validation_data = test_set,validation_steps=1000)
#score = loaded_model.evaluate(training_set,test_set , verbose=0)
' '' Results The models were run for 15 epochs on an Intel i7 Processor. Model 1: Mobilenet : 1000 steps/epoch: Larger FC Layers: Training Time: 18 mins/epoch : dataset: 50 images/average: accuracy : 82.2% Model 2: Mobilenet: 500 steps/epoch: Smaller FC layers: Training time : 12 mins/epoch: dataset: 50 images/average : 82.47% Model 3: Mobilnet 500 steps/epoch: Smaller FC layers: Training time: 11 mins/epoch: dataset: 30 images per class: accuracy: 76% Image Detection There are a few methods that pose detection as a regression problem. Two of the most popular ones are YOLO and SSD. These detectors are also called single shot detectors. Let’s have a look at them: You Only Look Once. YOLO divides each image into a grid of S x S and each grid predicts N bounding boxes and confidence. The confidence reflects the accuracy of the bounding box and whether the bounding box actually contains an object(regardless of class). YOLO also predicts the classification score for each box for every class in training. You can combine both the classes to calculate the probability of each class being present in a predicted box. So, total SxSxN boxes are predicted. However, most of these boxes have low confidence scores and if we set a threshold say 30% confidence, we can remove most of them as shown in the example below. (YOLO predicts one type of class in one grid! Hence small objects are not identified…) Single Shot Detectors SSD runs a convolutional network on input image only once and calculates a feature map. Now, we run a small 3×3 sized convolutional kernel on this feature map to predict the bounding boxes and classification probability. SSD also uses anchor boxes at various aspect ratio similar to Faster-RCNN and learns the off-set rather than learning the box. In order to handle the scale, SSD predicts bounding boxes after multiple convolutional layers. Since each convolutional layer operates at a different scale, it is able to detect objects of various scales. We compared two models, initially YOLO(darknet) and later SSDs and compared their accuracies and speeds. Since our inputs are images, the FPS parameter is not used to differentiate the models. Moreover, the SSDs are a balance between the Faster — RCNN model and the YOLO model. Let’s see what the experiment tells us? The SSD model is implemented using the dnn module, with the help of Adrian Rosebrock, in openCV’s library. # the necessary packages numpy np argparse cv2

# construct the argument parse and parse the ap = argparse.ArgumentParser()
ap.add_argument( , , required=True,
	help= )
ap.add_argument( , , required=True,
	help= )
ap.add_argument( , , required=True,
	help= )
ap.add_argument( , , type=float, = ,
	help= )
args = vars(ap.parse_args())
# load our serialized model disk
print( )
net = cv2.dnn.readNetFromCaffe(args[ ], args[ ])

# load the input image and construct an input blob the image
# by resizing to a fixed x300 pixels and then normalizing it
# (note: normalization is done via the authors the MobileNet SSD
# implementation)
image = cv2.imread(args[ ])
(h, w) = image.shape[: ]
blob = cv2.dnn.blobFromImage(cv2.resize(image, ( , )), ,
	( , ), )
  
# pass the blob through the network and obtain the detections and
# predictions
print( )
net.setInput(blob)
detections = net.forward()

# loop over the detections i np.arange( , detections.shape[ ]):
	# extract the confidence (i.e., probability) associated the
	# prediction
	confidence = detections[ , , i, ]

	# filter out weak detections by ensuring the is
	# greater than the minimum confidence confidence > args[ ]:
		# extract the index the = int(detections[ , , i, ])
		box = detections[ , , i, : ] * np.array([w, h, w, h])
		(startX, startY, endX, endY) = box.astype( )

		# display the prediction
		label = .format(CLASSES[idx], confidence * )
		print( .format(label))
		cv2.rectangle(image, (startX, startY), (endX, endY),
			COLORS[idx], )
		y = startY - startY - > startY + cv2.putText(image, label, (startX, y),
			cv2.FONT_HERSHEY_SIMPLEX, , COLORS[idx], )
      
     # show the output image
cv2.imshow( , image)
cv2.waitKey( ) import import as import import arguments "-i" "--image" "path to input image" "-p" "--prototxt" "path to Caffe 'deploy' prototxt file" "-m" "--model" "path to Caffe pre-trained model" "-c" "--confidence" default 0.2 "minimum probability to filter weak detections" from "[INFO] loading model..." "prototxt" "model" for 300 of "image" 2 300 300 0.007843 300 300 127.5 "[INFO] computing object detections..." for in 0 2 with 0 0 2 `confidence` if "confidence" of ` `,
		# ( , )- # class label from the detections then compute the x y coordinates of the bounding box for the object idx 0 0 1 0 0 3 7 "int" "{}: {:.2f}%" 100 "[INFO] {}" 2 15 if 15 15 else 15 0.5 2 "Output" 0 The YOLO pre-trained weights were downloaded from the author’s website where we choose the YOLOv3 model. Since it is the darknet model, the anchor boxes are different from the one we have in our dataset. Hence we initially convert the bounding boxes from VOC form to the darknet form using code from . Then we train the network by changing the config file. here Results: SSDs: IOU= 0.74, mAP: 0.83 Time /epoch: 12 minutes YOLOs: IOU= 0.69, mAP: 0.85 Time/epoch: 11 minutes Output Images (SSDs used for Vehicle Detection) (Output with YOLOv3 Pretrained Weights) Conclusion The overall problem is stated as one where we need to trade off the speed and accuracy. The overall solution is proposed as two different models for various types of images. The trade-off between speed and accuracy is accompanied with computational power available. The YOLO model is suitable for high-speed outputs, where accuracy is not that high… whereas SSDs provide higher accuracies with high-speed outputs with a higher computation time. Hence choose SSDs on good microprocessors, else YOLO is the goto for microprocessor-based computations. Shameless plugin: We are an online tool to make it super easy for you to build ML datasets like doing image bounding boxes, NER tagging etc. Check us out: the best image labeling tool !

Efficient Implementation of MobileNet and YOLO Object Detection Algorithms for Image Annotation

In this short article, I follow the main steps of video transcoding and optimization for the web. I share basic tips and examples to consistently automate these processes inhouse using ffmpeg, a powerful and open source package. When it comes to deploy a pipeline for a small to medium web business intensive in media like an ecommerce, the first decision is whether to do it inhouse or use an external service (and which service). Aspects to consider: the need of customising and branding the video experience, the amount of videos and their duration, the regional coverage sought, the cost, or the complexity of the associated workflows, among other factors. video processing and delivering While making a living from deploying and building video processing and delivery services, here I’ll be the devil’s advocate. In the case you are done with progressive video and the following steps cover your expectations, you likely don’t need anything else. The following tips are intended to deliver progressive videos in HTML5 without the need of any javascript viewer. I also comment on HLS and per title encoding, a powerful alternative to address a number of issues with progressive videos. The pristine I assume you start from a first version of a finished video provided by a photographer or media agency. This is the pristine video. The first thing to be aware is that the pristine sets the maximum resolution and the maximum quality. A good pratice for a web is to set a format, resolution, and quality for pristines and stick to it. For instance H264 in mp4, 4k resolution, and maximum visual quality ( =17). Requiring providers to stick to this definition will avoid last minute (bad) surprises. You might need to define more than one resolution with different aspect ratios, depending on the web layout. crf The variants or derivatives From the pristine video you’ll need to derive the variants with the formats, the resolutions, and the quality that you intend to deliver. As for images, progressive videos should be delivered under a responsive approach. It doesn’t make sense to deliver a heavy FullHD version only to be rendered in a small viewport. Breakpoints should be defined to ensure a proper coverage of your audience. Regarding , you should serve at least a version based on H264. This is the universally supported coding standard. You may also consider to serve a H265 version for iOS and Safari users and a VP9 version for Android and Chrome users as they will show better than H264 with even less weight. Still, you should always keep H264 as fallback. For instance, formats < = > video width "100%" controls < = = > source src "Sintel_Trailer.1080p.DivX_Plus_HD.mp4" type "video/mp4; codecs=hevc" < = = > source src "Sintel_Trailer.1080p.DivX_Plus_HD.webm" type "video/webm; codecs=vp9" < = = > source src "Sintel_Trailer.1080p.DivX_Plus_HD.m4v" type "video/mp4" </ > video may help in the decision regarding format selection. This short article Video transcoding If you decide to serve several formats, then you need transcoding. Assuming a pristine in H264, you may use ffmpeg to convert to H265 (HVEC) and to VP9. For instance ffmpeg -i input.mp4 -c:v libx265 -crf 23 -tag:v hvc1 -pix_fmt yuv420p -color_primaries 1 -color_trc 1 -colorspace 1 -movflags +faststart -an output.mp4 ffmpeg -i input.mp4 -c:v libvpx-vp9 -crf 30 -speed 3 -pix_fmt yuv420p -color_primaries 1 -color_trc 1 -colorspace 1 -movflags +faststart -an output.webm # H265 # VP9 Video resize As pointed, to be responsive you’d serve several resolutions. To define your breakpoints you’ll look to the page layout and the traffic analytics (devices and screens). Once defined, Ffmpeg allows you to easily rescale a video. for instance: ffmpeg -y -i input.mp4 -vf scale=1920:-2 -c:v libx264 -crf 23 -profile:v high -pix_fmt yuv420p -color_primaries 1 -color_trc 1 -colorspace 1 -movflags +faststart -an output.mp4 # Rescale to full HD Remind to always downscale from the pristine. Avoid upscaling. You would be inventing pixels that add to the weight and use the bandwidth, while the browser can do the same without such cost. Moreover, upscaling produces artifacts, specially blur. Just define the pristine and the breakpoints with resolution enough. Video compression Video compression for web is lossy. And lossy means discarding information to reduce weight. Depending on the amount of information discarded, the content of the video and which coding standard you’re using, at a given point you’ll notice increasing visual artifacts (blur, blocking, mosquito). When choosing compression settings, there are two main approaches: setting a visual quality or setting a bitrate. Assure visual quality In this case you should set the parameter, which is a proxy for visual quality. This is the default configuration in ffmpeg. crf The underlying metric behind the is different for each coding standard. You’ll need to guess the value that meets your expectations for each video format. A good starting point is the default value in ffmpeg, crf ffmpeg -y -i input.mp4 -vf -c:v libx264 -crf 23 -profile:v high -pix_fmt yuv420p -color_primaries 1 -color_trc 1 -colorspace 1 -movflags +faststart -an output.mp4 # Example of quality definition based on crf While the benefit of a policy based on crf is the assurance of visual quality, the main risk are peak values of bitrate in videos with rich textures and fast movements. Assure bandwidth usage If you want to assure the bandwidth used by the video, then you need to set the bitrate. ffmpeg -y -i input.mp4 -vf -c:v libx264 -b:v 2500k -profile:v high -pix_fmt yuv420p -color_primaries 1 -color_trc 1 -colorspace 1 -movflags +faststart -an output.mp4 # Example of compression with constant bitrate The downside is that to avoid a good number of videos with very poor visual quality, you’ll have to set a fairly high bitrate value. This means delivering a lot of other videos much heavier than needed. I’d rather use a compression based on and not on bitrate. crf For pros: HLS and per-title encoding While the approach described should fairly cover your basic needs with short videos of few seconds, I’d like to comment on HLS. It is an adaptive bitrate (ABR) protocol created by Apple with killing properties, and widespread support thanks to open source viewers. It adapts the resolution and quality of the video delivered not only to the viewport size but also to the network bandwidth, even if they change after the video started. For mobile users, HLS combined with -optimization of the bitrate ladder based on the content of the specific video-, provides the best possible experience, even for quite short clips. per title encoding Although transcoding can be certainly done using ffmpeg, it involves more complex aspects (quality selection, renditions, viewer), out of the scope of this basic tips article. Summary Here I have gone through some basic tips that cover a simple pipeline for transcoding progressive videos for web delivery. I have just used Ffmpeg, a very powerful package that allows to deploy almost any possible pipeline you can imagine to manipulate and process videos for web. For some more tips on basic video editing, you may also want to check . For a bird's eye view of what a custom deployment for video publishing entails you may check . this this other post

Video Transcoding And Optimization For Web With ffmpeg Made Easy

Maximizing access to the best methods & tools benefits us all In 1977, the NASA report published a grand vision of the future where among many accomplishments there would be space stations orbiting earth devoted to beaming down plentiful concentrated solar energy. The report stated: “power stations are placed in orbit around the Earth to which they deliver copious and valuable electrical energy. The economic value of these power stations will go far to justify the existence of the colony and the construction of more colonies.” Thirty Five years ago, the famous writer and futurist Isaac Asimov wrote . One of them echoed the 1977 NASA report, saying a “major part of Earth’s energy will come from the sun…energy will be so necessary to all and so clearly deliverable only if the nations remain at peace and work together, that war would become simply unthinkable.” These authors were joined by many others over the years in predicting a bright future. While there have been many advances since the seventies and eighties, and solar power has become a practical and important source of energy for the world, we are nowhere near having achieved these goals. Instead, today we are still using the fossil fuels that so many predicted should have become obsolete by now. In fact, we’re , and by . So, were these authors three and four decades ago delusional? What went wrong? Space Settlements — A Design Study predictions for 2019 in the Toronto Star still subsidizing fossil fuels 2050, the United States will have underwritten the drilling of an extra 17 billion barrels of oil, enough to emit over 6 billion tons of carbon dioxide The United States is a world leader in supercomputing or High Performance Computing and yet almost nobody uses it. We stopped using pay phones and video stores because the alternatives were so much better, and the same will happen to fossil fuel energy. The only question is how quickly can we get there. Engineers design everything from bridges, to airplanes, to the , and every one of those advances they achieve makes our lives better and grow the economy. No matter whether you are most concerned about breathing clean air, the future of the , or if you are primarily , having plentiful renewable energy would benefit us all. We all collectively stand to gain if engineers increase the pace at which they can achieve new technological feats. internet climate and sea level rise concerned about economic growth The Multidisciplinary Inventor Among the vast accomplishments of Leonardo da Vinci, were the following inventions credited with passing into general practical use: the strut bridge, the automated winder, the , the machine for testing the of wire and the -grinding machine. Nikola Tesla, famous for developing alternating current, in wireless communication, lasers, x-rays, radar, lighting, and robotics. These are two of the most prolific multidisciplinary inventors and while many think of them as aberrations, consider the question: what would it take to enable a large percentage of engineers to dramatically increase their abilities to invent? bobbin rolling mill tensile strength lens also achieved advances Left: Supercomputer — 600 GFLOPS, Right: — 600GFLOPS Hitachi SR2201 iPhone X Supercomputers are Available to Us Now are computers that demonstrate a high level of performance compared to general purpose computers — and that performance (ranked by ) has been increasing for decades. A common performance measure is operations per second ( ), which in very basic terms means the number of mathematical operations useful in science and engineering that can be performed in a second. Two decades ago the worlds top supercomputers like the Hitachi SR2201 were performing at hundreds of billions of FLOPS (hundreds of GigaFLOPS) and today iPhones are reporting this kind of performance. While the rare researcher who had access to this computing power twenty years ago would’ve told you they have no need for a supercomputer of their own, today demonstrate they have all sorts of use cases. Modern supercomputers offer performance in the PetaFLOPS range — two factors of a thousand increase in computing power from GFLOPS to PFLOPS. The Oak Ridge Leadership Computing Facility ( ) is famous for being a world leader in advancing supercomputing, and it’s a breeding ground for key scientific research and technological advancement. In 2012 OLCF’s came online, and has a peak performance of 27 PFLOPS. While OLCF continues charting a course toward Exascale computing with their new system, Petascale High Performance Computing ( ) is now available to consumers, who can rent time on cloud systems offered by companies like , , , and . Newer providers like even offer solutions to give engineers access to simulation software on these cloud platforms. Supercomputers TOP500 floating-point FLOPS hundreds of millions of worldwide users OLCF Titan supercomputer Summit HPC Google Cloud Amazon Web Services IBM Cloud Microsoft Azure Rescale Left: Computer Aided Engineering (CAE) with a desktop, Right: CAE with High Performance Computing (HPC) Advantage of Using HPC for Engineering A small team of engineers will work a concept and system development, but there are many specialty areas that must be covered to successfully complete a project and bring a new invention to market. Examples include structural design and analysis; thermal; fluid; vibration; electrical; and many others. Humankind has developed the knowledge to do all these things, but small teams can’t afford to take years to go and get training on a hundred or a thousand skills. Companies with large budgets can afford the best tools and to hire the experts. This is already a 10X advantage. And those companies will also deploy them on HPC for another 10X advantage — so there can be 100X differences in engineering productivity between large and small companies. The United States is a world leader in supercomputing or High Performance Computing and yet almost nobody uses it. , and the reason is it’s too complicated! Only 8% of the Small- and Medium-sized Enterprise businesses (SME’s) that are designing and manufacturing new products have been using HPC Hurdles remain for wider adoption especially for small and medium sized manufacturing and engineering firms Expertise-Barrier Holding Us Back There are and when an engineer can leverage these tools it gives them new design, analysis, manufacturing, and efficiency options that can radically improve the company’s competitiveness. When we’ve interviewed many vendors of such Computer Aided Engineering (CAE) tools, they tell us they might have customers in the range of 200 or maybe 1000 worldwide. There are hundreds of thousands of companies that should be using the tools, and when asked why they don’t have 100 times more customers, the consistent answer is 1) the tools are too hard to use, and 2) they’re too expensive. We can’t afford to lose time because the best tools are too complicated to use. The expertise-barrier in engineering has been identified by many organizations lately. The Department of Energy raised the concern with CAE, saying NASA set goals for the year 2030 and said the solution to this problem must more than a thousand different tools that engineering software companies have designed for specialist engineers “Computational Science has become the third pillar of science… Despite the great potential …HPC has been underutilized …hurdles remain for wider adoption especially for small and medium sized manufacturing and engineering firms.” “minimize user intervention…single engineer/scientist must be able to conceive, create, analyze, and interpret a large ensemble of related simulations in a time-critical period (e.g., 24 hours)…full automation is essential.” Left: OLCF’s , Right: OLCF’s Program Director with Titan Cray XK7 Buddy Bland Summit IBM AC922 And it’s not just CAE that needs to be made much more accessible: The in the United States, and yet they’ve done about the least to implement energy efficiency measures. . We are far from achieving 100% renewable energy, and demand continues to increase so maximizing efficiency is a must. Performing energy audits of a manufacturing plant is done today by hiring outside contractors. No one employed at the plant is tasked with energy efficiency work — they don’t have the time or the expertise to do it, and their main focus is getting the products made on time, on budget, and at a high quality. The Department of Energy recently identified the importance of solving the expertise-barrier to Energy Efficiency, The California Energy Commission recently . There are dramatic levels of Green House Gas emissions that could be avoided if this expertise-barrier was solved, and the Energy Efficiency business is projected to be a . industrial sector consumes a third of the energy The latest IPCC report makes an obvious call for energy conservation finding that three quarters of employers reported difficulty hiring qualified Energy Efficiency workers. confirmed the concerns trillion dollar endeavor MSBAI is currently raising capital. Learn more about our offering and invest here . Solution: The Engineering AI Assistant Today, cloud High Performance Computing (HPC) has become powerful and affordable enough, and Artificial Intelligence (AI) has become mature enough, that we can solve this gulf that exists in many companies’ ability to use the best engineering tools and run them on cloud HPC. and companies adopting AI will gain in productivity. There is about to be an explosion in AI assistants across multiple disciplines massive advantages GURU prototype autonomously running CAE on HPC That’s why MSBAI started developing GURU — The Ultimate Engineering AI Assistant. It’s like J.A.R.V.I.S. in the Iron Man movies. GURU is solving widespread expertise-barrier problems in engineering, by delivering specialized capabilities as a service. We leverage modern High Performance Computing (HPC) & Artificial Intelligence (AI) to do it. GURU runs a client-server connection from the user’s device to services, HPC, and the ‘Agent Society’ containing libraries of agents that perform individual tasks. An end-to-end engineering workflow is accomplished by running a series of agents collaborating together. GURU — The Ultimate Engineering AI Assistant Each individual agent represents a hybrid of a ‘symbolic’ rules-based system (where known best-practices, physics, and mathematics are baked-in) AND a ‘geometric’ Machine-Learning-based system which is invoked when problem-specific choices are made. The GURU platform enables custom agents to be built in practical timeframes with sparse datasets, through methods we’ve developed to automate rules-ingestion, and selecting/building/refining Machine Learning models. GURU works as a portal between you, the engineer, your account, and the computer systems it will use to run your engineering task. The GURU app runs locally on your devices and you can use the GURU web portal if you prefer. We have integrated voice control capability as well as point-and-click control. Some people prefer one of these two different options, some people find the voice feature most convenient while on the go and would use point-and-click for more detailed work. The application or portal running on your device is light and used primarily for communication with GURU services and the cloud HPC systems that will run your jobs. To achieve this, MSBAI is gaining access to capital in the most democratic way — from fans, future customers and the general public. MSBAI is currently raising capital. Learn more about our offering and invest here .

GIVE ENGINEERS AN ASSISTANT

Under the hood of crypto price aggregators

Deep Dream with TensorFlow: A Practical guide to build your first Deep Dream Experience

Brave’s Brendan Eich on Fixing Online Advertising

One of my favorite things about being a data scientist is creating new tools that make it easier to interpret data and models. I especially like to think about new ways to visualize data that could help solve a tough problem and be useful to my team. Visualizations and interactive interfaces tend to elevate how we work, and short-term investment in new tooling accelerate our analyses and enhance our understanding of the data. A while back, I shared screenshots on Twitter of some tools I was building and the feedback was really positive (on Twitter — imagine that!). Recently, I stumbled upon my old tweet and decided to polish up my code and share them with the community. This is the first post in a three-part series about creating visualizations for dissecting data and models. Code for Part 1 is , which includes a Jupyter Notebook that walks through each visualization and tool as well as accompanying command-line-executable code. Keep an eye on that repository or for Parts 2 and 3. now on GitHub Twitter body[data-twttr-rendered="true"] {background-color: transparent;}.twitter-tweet {margin: auto !important;} Finally picked up , wished I had sooner. Polishing up some test graphs -- next up, exploring actual RNA Seq data. #dataviz @BokehPlots — @gaurav_bio function notifyResize(height) {height = height ? height : document.documentElement.offsetHeight; var resized = false; if (window.donkey && donkey.resize) {donkey.resize(height); resized = true;}if (parent && parent._resizeIframe) {var obj = {iframe: window.frameElement, height: height}; parent._resizeIframe(obj); resized = true;}if (window.location && window.location.hash === "#amp=1" && window.parent && window.parent.postMessage) {window.parent.postMessage({sentinel: "amp", type: "embed-size", height: height}, "*");}if (window.webkit && window.webkit.messageHandlers && window.webkit.messageHandlers.resize) {window.webkit.messageHandlers.resize.postMessage(height); resized = true;}return resized;}twttr.events.bind('rendered', function (event) {notifyResize();}); twttr.events.bind('resize', function (event) {notifyResize();});if (parent && parent._resizeIframe) {var maxWidth = parseInt(window.frameElement.getAttribute("width")); if ( 500 < maxWidth) {window.frameElement.setAttribute("width", "500");}} Principal Component Analysis A stalwart of the data scientist toolkit is the (PCA), which transforms data into linearly, uncorrelated features or (PCs). Importantly, these new features are meaningful — they indicate axes in the data where variance the variance is greatest. We can reason that variance is where much of the ‘signal’ or information in the data is kept, because it can explain why different groups in the data are different or why an outcome that can be predicted from the data can vary. Variance is vital. Principal Component Analysis principal components The first principal component, or PC1, ‘explains the most variance’ in the original dataset — this also means that contribute to a large amount of variance in the data. features that correlate with PC1 As you go from PC1 to the final PC, the amount of variance explained decreases while cumulative explained variance approaches 100%. If you wish to reduce the number of dimensions for analysis, you can choose a specific number of PCs based on how much variance is explained (e.g. 95%). You can also understand how much variance is explained in just two or three easy-to-visualize dimensions. When analyzing data with a lot of variables, I like to understand how many and which features are useful. I work in genomics, where you can easily have thousands of features per instance and understanding how many features I need makes it easier to train and interpret models on that data. In genomics, features are cheap and instances are precious. For this reason, I often use PCA as a guide to selecting which features to focus on. Obligatory figure showing (left) random data in two dimensions and (right) PC1 and PC2 of the data. Black lines indicate the axes of along which the most variance exists. Note that these axes are orthogonal. In PCA space (right), the axes are vectors along PC1 and PC2. Interactive PCA The first visualization I want to walk through helps me quickly unpack a PCA analysis and share with others. Specifically, it plots the explained variance per PC as well as the cumulative explained variance as you go from PC1 to the final PC. Here’s an example output, generated with the classic dataset: iris <a href="https://medium.com/media/ba9d114b2185ef5da3f4c282cf465cde/href">https://medium.com/media/ba9d114b2185ef5da3f4c282cf465cde/href</a> If the embed above doesn’t work for you, here’s a screenshot: Screenshot of an interactive visualization for PCA. Seagreen bars indicate explained variance for that PC. The orange line shows the cumulative variance over N PCs. The bold dashed line indicates the number of PCs at which explained variance exceeds 95% (or 0.95). The tool also includes dashed lines for N=2 and N=3, to quickly understand how much variance is explained within easy-to-visualize dimensions. To create this tool, I used for the PCA analysis and for interactive visualization. scikit-learn bokeh Performing a PCA analysis with is a snap: scikit-learn from sklearn.decomposition import PCA

# create 2D PCA space from original data (X)
pca = PCA(2)
X_pca = pca.fit_transform(X) From pca, we can unpack the explained variance per PC as a ratio from 0 to 1 and calculate the cumulative explained variance from PC1 to the final PC: # Explained variance per PC
pca.explained_variance_ratio_

# Cumulative explained variance
np.cumsum(pca_evr) Finally, we can find the first PC at which >95% of the variance in the data is explained, and the explained variance ratio for the first 2 and 3 components: # PC where >95% variance explained
np.argmax(cumsum_ >= 0.95) + 1

# Variance explained with first 2 PCs
cumsum_[1]

# Variance explained with first 3 PCs
cumsum_[2] With these variables, we have the necessary information to generate the above plot in bokeh. For this post, I won’t get too deep into how works (I’ll save that for a future post) — instead, I’ll highlight the most critical components of the bokeh code provided on GitHub . The crux of using is understanding the . This object allows you to package up data and labels together for use in various bokeh plots. For a 2D lineplot, for example, you can create a ColumnDataSource with simple dictionary: bokeh ColumnDataSource {
    'x': x_values,
    'y': y_values,
    'labels': labels
} In this dictionary, the values are all lists or arrays of the same length. The dictionary can also be passed directly to ColumnDataSource: ColumnDataSource(data=dict(x=x_values, y=y_values, labels=labels)) The ColumnDataSource is a useful intermediate step because it can then be reused for multiple plots. In the case of a line plot where we want to create a circle at each point, we can create one ColumnDataSource and reuse it for both plots: from bokeh.plotting import figure, ColumnDataSource, show

# create ColumnDataSource
cds = ColumnDataSource(data=dict(x=x_values, y=y_values, labels=labels))

# instantiate plot
p = figure(title='PCA Analysis')

# line plot - 'x' and 'y' refer to keys in the source (cds)
p.line('x', 'y', line_width=1, color='#F79737', source=cds)

# circle plot
p.circle('x', 'y', size=10, color='#FF4C00', source=cds)

# show plot
p.show() The goes into greater detail, including customizing the bokeh toolbar, adding labels when hovering over data points, and more. code repository Understanding How Features Contribute to PCs One benefit to transforming data to ‘PCA-space’ is that it allows you to identify features that are the most informative. The previous tool allows you to better understand the overall structure of the data, but doesn’t reveal which features contribute to the PCs with the most information. One method for understanding which features are ‘important’ is to examine how each feature contributes to each principal component. To do this, . we can take the dot product of our original data and our principal components The dot product of two vectors is the product of their magnitudes and the cosine of the angle between them. When two vectors are orthogonal, the dot product is zero, since _cos(_90°)=0. When two vectors lie along the same axis, the dot product is the product of their magnitudes. Assuming our data is rescaled, the relative magnitudes of its dot product with the principal components will indicate the co-linearity or correlation of individual features and PCs. In other words, if a feature is nearly co-linear with a PC, the magnitude of the dot product will be relatively large. The dot product we take is with the transpose of our original dataset and its PCA, which reveals an matrix (where N is the number of features/PCs). NxN The dot product of the transpose of the original dataset (X_T) and its PCA (X_pca) generates a new square matrix that informs how each feature correlates to each principal component. For the dataset, this results in the following heatmap (for easier visualization, I also Z-normalize each column in the resulting matrix): iris Z-normalized correlation matrix between the original iris dataset and PC-space. Above, we can see that and correlate strongly with PC1. petal length sepal width The feedback I received on this heatmap was that it took a while to interpret. Co-workers suggested a visualization that would make it easier to immediately understand which features helped explain the most variance in the dataset. For , you could interrogate each cell one-by-one, but at scale we’ll need a better visualization. iris To address this, I decided to re-normalize the heatmap with the explained variance of each PC. I essentially took the dot product of our new matrix and the explained variance as a vector. This would immediately reveal not only how each feature correlates with each PC, but how they contribute to the variance in the dataset. For we get the following heatmap, which I think is much easier to grok: iris, Z-normalized correlation matrix between the original iris dataset and PC-space, normalized by explained variance. The significance of petal length and sepal width are easily seen. For datasets where feature selection is critical, this visualization (and the stack-rank of features that contribute to the PCA) immediately reveal which features to focus on. Boston Housing To me, it’s important that tools are reusable and scale properly with different datasets. To demonstrate how the feature importance visualizations scale with (modestly) larger datasets, let’s take a look at the Boston Housing dataset. Here’s how each feature in Boston Housing correlates with each principal component: Z-normalized correlation matrix between the original Boston housing dataset and PC-space. Once again, we see which features contribute to each PC, but beyond the first few PCs the plot is harder to interpret. Now let’s look at the version that’s normalized by explained variance: Z-normalized correlation matrix between the original Boston housing dataset and PC-space, normalized by explained variance. With this version, the picture becomes much clear: and contribute the most amount of variance, following by and perhaps . TAX B ZN AGE The Cancer Genome Atlas Breast Cancer Dataset The Cancer Genome Atlas (TCGA) breast cancer RNA-Seq dataset (I’m using an old freeze from 2015) has 20,532 features (genes for which expression is measured) but only 204 samples of either a primary tumor or normal tissue. This makes for a very fun machine learning problem — can we build a reliable model that uses gene expression to distinguish normal tissue from cancer tissue? If we try and train a model on all 20,532 features, we’re going to run into many issues. Instead, let’s take a look at whether we can generate some interpretable principal components for visualization and model building. First, let’s look at the interactive PCA plot with these data: PCA on the TCGA-BRCA RNA-Seq dataset. It takes only 3 dimensions to explain ~1/3 of the variance in the data. From this, we see that it takes ‘only’ 129 features to explain 95% of the variance. Importantly, 33.0% of the variance is explained from just three principal components. Let’s dive deeper. We can also use the heatmaps from before to inspect the data— but have you ever tried to create a 20,532 x 20,532 dimensional heatmap? This kills the kernel. Instead, we can modify the code to cap the number of features/PCs for visualization to a reasonable number (a future, more elegant solution might only generate a heatmap for features/PCs that explain up to a certain amount of variance, say 95%.) Below is a heatmap showing correlation between the ‘top 20’ features and principal components: Z-normalized correlation matrix between the original TCGA-BRCA RNA-seq dataset and PC-space, normalized by explained variance. PC1 and PC2 look to be the most meaningful. In addition, the code also gives us a printout the ‘top’ features, for easier inspection: Stack rank of 20 features that contribute to PCs that explain the most variance in the TCGA-BRCA RNA-Seq dataset. You see a number of extracellular matrix and basement membrane proteins, which makes sense because ECM remodeling is often observed in breast cancer. From these, we see that PC1 has strong contributions from four extracellular matrix proteins and PC2 has contributions from the gene EEF1A1. From a molecular biology standpoint, this makes sense — extracellular matrix remodeling is frequently seen in breast cancer [ , ], and EEF1A1 expression is associated with poor outcomes in certain breast cancer patients [ ]. 1 2 3 Now let’s step back — we seem to see strong signal in PC1 and PC2. And from the first plot, we see that they explain ~25% of the variance in the data. So what does it look like when we plot PC1 vs. PC2? 2D PCA plot of the TCGA-BRCA RNA-Seq PCA, shown by Primary Tumor samples (red) and Solid Tissue Normal samples (blue). In 2D PCA-space, you can almost draw a line with the naked eye between both groups — strongly suggesting that we can train a classifier with just two principal components. The above plot shows all Primary Tumor (red) and Solid Tissue Normal samples (blue) along PC1 and PC2. You can almost draw a line with the naked eye between both groups — which strongly suggests that we can successfully train a classifier with just two principal components using a simple linear model. That’s pretty incredible when you think about it. From over 20,000 genes, we can define two linear, uncorrelated features that explain enough variance in the data to allow us to differentiate between two groups of interest. Further, we already have some indication of genes that help discriminate normal tissue from breast cancer tissue, and could have value for prognosis, diagnosis, or as therapeutic targets. I hope this first post has been helpful! In Part 2, I’ll shift to interpreting machine learning models and decision boundaries. Keep an eye on Twitter or GitHub for when it drops! Additional Resources If you’d like to learn more about principal component analysis and related topics, I suggest the following articles and videos. — the series on is excellent, as is the one on . 3Blue1Brown is a fantastic YouTube channel linear algebra deep neural networks I really like from , which goes more in-depth into PCA and discusses eigenvalues and eigenvectors. this post Matt Brems Want to dive deeper into singular value decomposition with the dataset? ! iris Have I got the post for you Here’s the . Check out the example plots and tutorials. scikit-learn documentation on PCA . Here’s where to go next if you’re not afraid of mathematical notation

Creating visualizations to better understand your data and models (Part 1)

This is a response to ’ . Karl L. Hughes The Bulk of Software Engineering in 2018 is Just Plumbing So we’re here, living in a world where most “software engineering” is essentially plumbing. What should we do about it? What does it mean for our careers? Will the money keep flowing forever? It just so happens that I’ve been thinking about these questions for quite a while and I think I have some answers now. Do the other part of software engineering. You would have to become better or obsolete. It depends on the 2. Let me describe my week to show what I mean by “the other part”. The last week I was finishing a texture generating feature for 3D-printing related desktop application. was a refactoring day. I did some recomposition, removed an unused structure, got rid of some unnecessary type conversions. Suddenly, performance tests failed. Fascinating! Apparently, when I changes bitmap dimensions from back to , the rescaling algorithm lost some 30% in performance. Suddenly, Monday became disassembly day. Monday unsigned int size_t It turns out, the conversion from 64-bit to 32-bit helps the compiler exploit the register space optimally. When everything fits the registers, the rescale runs super-fast, but when not, it has to upload a constant bitmap dimension every time in the tightest spot, which ruins the perfection. If not the performance coverage and disassembly, I would have never figured this out. size_t int morning I had a meeting with our application engineer. We discussed an interpolating function for the generator. I proposed a cubic polynomial and, so see and show how would it behave in our case, made one of the ’ pages into a small HTML+Javascript demo, and sent it to him immediately. Tuesday wordsandbuttons He replied just an hour later. The cubic works for the most scenarios we want, but it would be good to have options. This made my the day. Wednesday SymPy I could have taken any NURBS library to make a spline instead of a cubic, but since it was meant to work in the tight spot, and NURBS is an overkill anyway, I decided to hand-craft a special non-uniform non-rational 2–3–2 polynomial spline. That’s what I needed SymPy for. When you have your constraints clarified, all you have to do to make a spline — is to solve a few Vandermonde systems symbolically — and this will be basically your code. It takes some effort, but it doesn’t bring a third-party dependency and, since you’re not bound to any predetermined data-structures, the compiler works wonders with the optimizer. was the finalization day. Full testing, final code review, gated check-in. Gated check-in failed. Turns out, I forgot a standard mismatch between VS compiler and an XCode’s Clang. One man’s habit is another man’s syntax error. Thursday afternoon I taught in the . I told about this to thing. Shown how to read a disassembly. Explained floating point error and why do we want stability in our algorithms. Friday Academy size_t int A student shown me an interesting thing in return. When an initializer list uses the static class member, the latter may not be initialized yet. I would expect it to be stored in the and thus fully initialized by the time of object construction in the runtime. Apparently, I was wrong. .data Well, I would never do teaching if not for the opportunity to learn. 90% of our users would have been happy with the initial performance. 90% would have settled for linear interpolation. 90% don’t care about macOS port. None of the users care about our students. So was it all worth the effort? Yes. It is a dangerous misconception that business is about achieving goals at the lowest possible cost. Business is about competition, and “good enough” doesn’t win market share. Everyone can do 90%, you have to do better than that. You have to be better than your rivals and you have to be better than your former self as well. Investors are willing to invest. If you are willing to walk an extra mile, the stakeholders will walk it with you. As long as you are explicit about the cost and benefits, of course. Business doesn’t want our job to became boring and miserable. Quite the contrary. Business is as challenging as ever. Robustness, performance, and scalability are all in high demand right now. Probably higher than a decade ago when you could have covered your butt with the Moor’s law. And I totally agree with Karl in his last advice: Job market of software plumbers is way overheated indeed. And it takes a whole lot of extra miles to come to the world of software engineering. don’t get comfortable .

The Job Market of Software Plumbers is Overheated

Machine learning is part art and part science. When you look at machine learning algorithms, there is no one solution or one approach that fits all. There are several factors that can affect your decision to choose a machine learning algorithm. Some problems are very specific and require a unique approach. E.g. if you look at a recommender system, it’s a very common type of machine learning algorithm and it solves a very specific kind of problem. While some other problems are very open and need a trial & error approach. Supervised learning, classification and regression etc. are very open. They could be used in anomaly detection, or they could be used to build more general sorts of predictive models. Besides some of the decisions that we make when choosing a machine learning algorithm have less to do with the optimization or the technical aspects of the algorithm but more to do with business decisions. Below we look at some of the factors that can help you narrow down the search for your machine learning algorithm. Data Science Process Before you start looking at different ML algorithms, you need to have a clear picture of your data, your problem and your constraints. Understand Your Data The type and kind of data we have plays a key role in deciding which algorithm to use. Some algorithms can work with smaller sample sets while others require tons and tons of samples. Certain algorithms work with certain types of data. E.g. Naïve Bayes works well with categorical input but is not at all sensitive to missing data. Hence it is important that you: Know your data Look at Summary statistics and visualizations Percentiles can help identify the range for most of the data Averages and medians can describe central tendency Correlations can indicate strong relationships 2. Visualize the data Box plots can identify outliers Density plots and histograms show the spread of data Scatter plots can describe bivariate relationships Clean your data Deal with missing value. Missing data affects some models more than others. Even for models that handle missing data, they can be sensitive to it (missing data for certain variables can result in poor predictions) Choose what to do with outliers Outliers can be very common in multidimensional data. Some models are less sensitive to outliers than others. Usually tree models are less sensitive to the presence of outliers. However regression models, or any model that tries to use equations, could definitely be effected by outliers. Outliers can be the result of bad data collection, or they can be legitimate extreme values. 3. Does the data needs to be aggregated Augment your data Feature engineering is the process of going from raw data to data that is ready for modeling. It can serve multiple purposes: Make the models easier to interpret (e.g. binning) Capture more complex relationships (e.g. NNs) Reduce data redundancy and dimensionality (e.g. PCA) Rescale variables (e.g. standardizing or normalizing) 2. Different models may have different feature engineering requirements. Some have built in feature engineering. Categorize the problem The next step is to categorize the problem. This is a two-step process. Categorize by input: If you have labelled data, it’s a supervised learning problem. If you have unlabelled data and want to find structure, it’s an unsupervised learning problem. If you want to optimize an objective function by interacting with an environment, it’s a reinforcement learning problem. 2. Categorize by output. If the output of your model is a number, it’s a regression problem. If the output of your model is a class, it’s a classification problem. If the output of your model is a set of input groups, it’s a clustering problem. Do you want to detect an anomaly ? That’s anomaly detection Understand your constraints What is your data storage capacity? Depending on the storage capacity of your system, you might not be able to store gigabytes of classification/regression models or gigabytes of data to clusterize. This is the case, for instance, for embedded systems. Does the prediction have to be fast? In real time applications, it is obviously very important to have a prediction as fast as possible. For instance, in autonomous driving, it’s important that the classification of road signs be as fast as possible to avoid accidents. Does the learning have to be fast? In some circumstances, training models quickly is necessary: sometimes, you need to rapidly update, on the fly, your model with a different dataset. Find the available algorithms Now that you a clear understanding of where you stand, you can identify the algorithms that are applicable and practical to implement using the tools at your disposal. Some of the factors affecting the choice of a model are: Whether the model meets the business goals How much pre processing the model needs How accurate the model is How explainable the model is How fast the model is: How long does it take to build a model, and how long does the model take to make predictions. How scalable the model is An important criteria affecting choice of algorithm is model complexity. Generally speaking, a model is more complex is: It relies on more features to learn and predict (e.g. using two features vs ten features to predict a target) It relies on more complex feature engineering (e.g. using polynomial terms, interactions, or principal components) It has more computational overhead (e.g. a single decision tree vs. a random forest of 100 trees). Besides this, the same machine learning algorithm can be made more complex based on the number of parameters or the choice of some hyperparameters. For example, A regression model can have more features, or polynomial terms and interaction terms. A decision tree can have more or less depth. Making the same algorithm more complex increases the chance of overfitting. ( ) Overcoming the Barriers to Production-Ready Machine Learning Workflows Commonly used Machine Learning algorithms Linear Regression These are probably the simplest algorithms in machine learning. Regression algorithms can be used for example, when you want to compute some continuous value as compared to Classification where the output is categoric. So whenever you are told to predict some future value of a process which is currently running, you can go with regression algorithm. Linear Regressions are however unstable in case features are redundant, i.e. if there is multicollinearity Some examples where linear regression can used are: Time to go one location to another Predicting sales of particular product next month Impact of blood alcohol content on coordination Predict monthly gift card sales and improve yearly revenue projections Logistic Regression Logistic regression performs binary classification, so the label outputs are binary. It takes linear combination of features and applies non-linear function (sigmoid) to it, so it’s a very small instance of neural network. Logistic regression provides lots of ways to regularize your model, and you don’t have to worry as much about your features being correlated, like you do in Naive Bayes. You also have a nice probabilistic interpretation, and you can easily update your model to take in new data, unlike decision trees or SVMs. Use it if you want a probabilistic framework or if you expect to receive more training data in the future that you want to be able to quickly incorporate into your model. Logistic regression can also help you understand the contributing factors behind the prediction, and is not just a black box method. Logistic regression can be used in cases such as: Predicting the Customer Churn Credit Scoring & Fraud Detection Measuring the effectiveness of marketing campaigns Decision trees Single trees are used very rarely, but in composition with many others they build very efficient algorithms such as Random Forest or Gradient Tree Boosting. Decision trees easily handle feature interactions and they’re non-parametric, so you don’t have to worry about outliers or whether the data is linearly separable. One disadvantage is that they don’t support online learning, so you have to rebuild your tree when new examples come on. Another disadvantage is that they easily overfit, but that’s where ensemble methods like random forests (or boosted trees) come in. Decision Trees can also take a lot of memory (the more features you have, the deeper and larger your decision tree is likely to be) Trees are excellent tools for helping you to choose between several courses of action. Investment decisions Customer churn Banks loan defaulters Build vs Buy decisions Sales lead qualifications K-means Sometimes you don’t know any labels and your goal is to assign labels according to the features of objects. This is called clusterization task. Clustering algorithms can be used for example, when there is a large group of users and you want to divide them into particular groups based on some common attributes. If there are questions like how is this organized or grouping something or concentrating on particular groups etc. in your problem statement then you should go with Clustering. The biggest disadvantage is that K-Means needs to know in advance how many clusters there will be in your data, so this may require a lot of trials to “guess” the best K number of clusters to define. Principal component analysis (PCA) Principal component analysis provides dimensionality reduction. Sometimes you have a wide range of features, probably highly correlated between each other, and models can easily overfit on a huge amount of data. Then, you can apply PCA. One of the keys behind the success of PCA is that in addition to the low-dimensional sample representation, it provides a synchronized low-dimensional representation of the variables. The synchronized sample and variable representations provide a way to visually find variables that are characteristic of a group of samples. Support Vector Machines Support Vector Machine (SVM) is a supervised machine learning technique that is widely used in pattern recognition and classification problems — when your data has exactly two classes. High accuracy, nice theoretical guarantees regarding overfitting, and with an appropriate kernel they can work well even if you’re data isn’t linearly separable in the base feature space. Especially popular in text classification problems where very high-dimensional spaces are the norm. SVMs are however memory-intensive, hard to interpret, and difficult to tune. SVM can be used in real-world applications such as: detecting persons with common diseases such as diabetes hand-written character recognition text categorization — news articles by topics stock market price prediction Naive Bayes It is a classification technique based on Bayes’ theorem and very easy to build and particularly useful for very large data sets. Along with simplicity, Naive Bayes is known to outperform even highly sophisticated classification methods. Naive Bayes is also a good choice when CPU and memory resources are a limiting factor. Naive Bayes is super simple, you’re just doing a bunch of counts. If the NB conditional independence assumption actually holds, a Naive Bayes classifier will converge quicker than discriminative models like logistic regression, so you need less training data. And even if the NB assumption doesn’t hold, a NB classifier still often does a great job in practice. A good bet if want something fast and easy that performs pretty well. Its main disadvantage is that it can’t learn interactions between features. Naive Bayes can be used in real-world applications such as: Sentiment analysis and text classification Recommendation systems like Netflix, Amazon To mark an email as spam or not spam Face recognition Random Forest Random Forest is an ensemble of decision trees. It can solve both regression and classification problems with large data sets. It also helps identify most significant variables from thousands of input variables. Random Forest is highly scalable to any number of dimensions and has generally quite acceptable performances. Then finally, there are genetic algorithms, which scale admirably well to any dimension and any data with minimal knowledge of the data itself, with the most minimal and simplest implementation being the microbial genetic algorithm. With Random Forest however, learning may be slow (depending on the parameterization) and it is not possible to iteratively improve the generated models Random Forest can be used in real-world applications such as: Predict patients for high risks Predict parts failures in manufacturing Predict loan defaulters Neural networks Neural Networks take in the weights of connections between neurons . The weights are balanced, learning data point in the wake of learning data point . When all weights are trained, the neural network can be utilized to predict the class or a quantity, if there should arise an occurrence of regression of a new input data point. With Neural networks, extremely complex models can be trained and they can be utilized as a kind of black box, without playing out an unpredictable complex feature engineering before training the model. Joined with the “deep approach” even more unpredictable models can be picked up to realize new possibilities. E.g. object recognition has been as of late enormously enhanced utilizing Deep Neural Networks. Applied to unsupervised learning tasks, such as feature extraction, deep learning also extracts features from raw images or speech with much less human intervention. On the other hand, neural networks are very hard to just clarify and parameterization is extremely mind boggling. They are also very resource and memory intensive. Scikit Cheat Sheet Scikit learning has put a very indepth and well explained flow chart to help you choose the right algorithm that I find very handy. ( ) http://scikit-learn.org/stable/tutorial/machine_learning_map/index.html Conclusion Generally speaking you can use the points above to shortlist a few algorithms but it is hard to know right at the start which algorithm will work best. It is usually best to work iteratively. Amongst the ML algorithms you identified as potential good approaches, throw your data into them, run them all in either parallel or serial, and at the end evaluate the performance of the algorithms to select the best one(s). And finally, developing the right solution to a real life problem is rarely just an applied mathematics problem. It requires awareness of business demands, rules and regulations, and stakeholders’ concerns as well as considerable expertise. In solving a machine problem, being able to combine and balance these is crucial; those who can do this can create the most value.

Stories, News & Mentions about REGSCALE

Regscale’s Stories on HackerNoon