Month: July 2021

Exploring BERT Language Framework for NLP Tasks

As artificial intelligence apes the human speech, vision, and mind patterns, the domain of NLP is buzzing with some key developments in place.

NLP is one of the most crucial components for structuring a language-focused AI program, for example, the chatbots which readily assist visitors on the websites and AI-based voice assistants or VAs. NLP as the subset of AI enables machines to understand the language text and interpret the intent behind it by various means. A hoard of other tasks is being added via NLP like sentiment analysis, text classification, text extraction, text summarization, speech recognition, and auto-correction, etc.

However, NLP is being explored for many more tasks. There have been many advancements lately in the field of NLP and also NLU (natural language understanding) which are being applied on many analytics and modern BI platforms. Advanced applications are using ML algorithms with NLP to perform complex tasks by analyzing and interpreting a variety of content.

About NLP and NLP tasks

Apart from leveraging the data produced on social media in the form of text, image, video, and user profiles, NLP is working as a key enabler with the AI programs. It is heightening the application of Artificial Intelligence programs for innovative usages like speech recognition, chatbots, machine translation, and OCR or optical character recognition. Often the capabilities of NLP are turning the unstructured content into useful insights to predict the trends and empower the next level of customer-focused product solutions or platforms.

Among many, NLP is being utilized for programs that require to apply techniques like:

  • Machine translation: Using different methods for processing like statistical, or rule-based, with this technique, one natural language is converted into another without impacting its fluency and meaning to produce text as result.
  • Parts of speech tagging: NLP technique of NER or named entity recognition is key to establish the relation between words. But before that, the NLP model needs to tag parts of speech or POS for evaluating the context. There are multiple methods of POS tagging like probabilistic or lexical.
  • Information grouping: An NLP model which requires to classify documents on the basis of language, subject, type of document, time or author would require labeled data for text classification.
  • Named entity recognition: NER is primarily used for identifying and categorizing text on the basis of name, time, location, company, and more for content classification in programs for academic research, lab reports analysis, or for customer support practices. This often involves text summarization, classification, and extraction.
  • Virtual assistance: Specifically for Chatbots and virtual assistants, NLG or natural language generation is a crucial technique that enables the program to respond to queries using appropriate words and sentence structures.

All about the BERT framework

An open-source machine learning framework, BERT, or bidirectional encoder representation from a transformer is used for training the baseline model of NLP for streamlining the NLP tasks further. This framework is used for language modeling tasks and is pre-trained on unlabelled data. BERT is particularly useful for neural network-based NLP models, which make use of left and right layers to form relations to move to the next step.

BERT is based on Transformer, a path-breaking model developed and adopted in 2017 to identify important words to predict the next word in a sentence of a language. Toppling the earlier NLP frameworks which were limited to smaller data sets, the Transformer could establish larger contexts and handle issues related to the ambiguity of the text. Following this, the BERT framework performs exceptionally on deep learning-based NLP tasks. BERT enables the NLP model to understand the semantic meaning of a sentence – The market valuation of XX firm stands at XX%, by reading bi-directionally (right to left and left to right) and helps in predicting the next sentence.

In tasks like sentence pair, single sentence classification, single sentence tagging, and question answering, the BERT framework is highly usable and works with impressive accuracy. BERT involves two-stage applications – unsupervised pre-training and supervised fine-tuning. It is pre-trained on MLM (masked language model) and NSP (next sentence prediction). While the MLM task helps the framework to learn using the context in right and left layers through unmasking the masked tokens; the NSP task helps in capturing the relation between two sentences. In terms of the technical specifications required for the framework, the pre-trained models are available as Base (12 layers, 786 hidden layers, 12 self attention head, and 110 m parameters) and Large (24 layers, 1024 hidden layer, 16 self attention head, and 340 m parameters).

BERT creates multiple embeddings around a word to find and relate with the context. The input embeddings of BERT include token, segment, and position components.

Since 2018, reportedly the BERT framework is in extensive usage for various NLP models and in deep language learning algorithms. As Bert is open source, there are several variants that have also been in usage, often delivering better results than the base framework such as ALBERT, HUBERT, XLNet, VisualBERT, RoBERTA, MT-DNN, etc.

What makes BERT so useful for NLP?

When Google introduced and open-sourced the BERT framework, it produced highly accurate results in 11 languages simplifying tasks such as sentiment analysis, words with multiple meanings, and sentence classification. Again in 2019, Google utilized the framework for understanding the intent of search queries on its search engine. Following this, it is being widely applied for tasks like answering questions on SquAD (Stanford question answering dataset), GLUE (Generational language understanding evaluation), and NQ datasets, for product recommendation based on product review, deeper sentiment analysis based on user intent.

By the end of 2019, the framework was adopted for almost 70 languages used across different AI programs. BERT helped solve various complexities of NLP models built with a focus on natural languages spoken by humans. Where previous NLP techniques were required to train on repositories of large unlabeled data, BERT is pre-trained and works bi-directionally to establish contexts and predict. This mechanism increases the capability of NLP models further which are able to execute data without requiring it to be sequenced and organized in order. In addition to this, the BERT framework performs exceptionally for NLP tasks surrounding sequence-to-sequence language development and natural language understanding (NLU) tasks.


Endnote:

BERT has helped in saving a lot of time, cost, energy, and infrastructural resources by emerging as the sole enabler in place of building a distinguished language processing model from scratch. By being open-source, it has proved to be far more efficient and scalable than previous language models Word2Vec and Glove. BERT has outperformed human accuracy levels by 2% and has scored 80% on GLUE score and almost 93.2% accuracy on SquAD 1.1. BERT can be fine-tuned as per user specification while it is adaptable for any volume of content.

The framework has been a valuable addition to NLP tasks by introducing pre-trained language models while proving as a reliable source to execute NLU and NLG tasks through the availability of its multiple variants. The BERT framework definitely provides the opportunity to watch out for some exciting New Development in NLP in the near future. Originally published Click 

“Beijing One Pass” Employee Benefits Software Exhibits Spyware Characteristics

Insikt Group

Editor’s Note: The following post is an excerpt of a full report. To read the entire analysis, click here to download the report as a PDF.

Executive Summary

A Recorded Future client provided information to Insikt Group relating to a potential security incident triggered by a software application called “Beijing One Pass”. This Chinese government-backed application enables access to state benefits information and was downloaded by employees of the Recorded Future client after they were informed that paper copies of the information would no longer be available.

Insikt Group independently verified that the installed application exhibits characteristics consistent with potentially unwanted applications (PUA) and spyware. The software is associated with the Beijing Certificate Authority (北京数字认证股份有限公司), which is a Chinese state-owned enterprise (BJCA, www.bjca[.]cn). 

Some notable suspicious behaviors relate to several dropped files and subsequent processes initiated from the primary application. These behaviors include a persistence mechanism, the collection of user data such as screenshots and keystrokes, a backdoor functionality, and other behaviors commonly associated with malicious tools, such as disabling security and backup-related services.

We cannot confirm the intent behind Beijing One Pass’s containing spyware-like capabilities; however, the presence of software with similar spyware-like functionality, developed by at least one other Chinese region, the Shaanxi CA, is notable. These capabilities could be evidence of a deliberate attempt to gain access to devices (such as in support of China’s Cybersecurity Law that allows security organizations to inspect corporate networks remotely), the result of lax security practices by the certificate authorities (CA) and developers, or features designed to comply with Chinese laws and regulations.

Whatever the motive, installing such software on devices that have access to sensitive data is not advised. Recorded Future recommends that companies with China-based employees who need access to state benefit information using “One Pass” software not use it on devices with access to sensitive corporate data.

Analysis

During preliminary analysis, Insikt Group found that the “Beijing One Pass” PC client exhibits behaviors similar to spyware applications. The software contains built-in functionality that, taken in aggregation, raise considerable suspicions about the implication of its data collection capabilities:

  • Ability to autorun at Windows startup to ensure persistence
  • Checking periodically for human interaction with the operating system as the file is run
  • Attempting to read, create, or modify system registry ROOT certificates
  • Disabling security and backup services on the host device
  • Allowlisting domains for ActiveX use, which potentially allows it to connect to additional internet resources
  • Reading data from the clipboard
  • Recording screenshots
  • Capturing and retrieving keystrokes

There is also some indication that the file contains backdoor functionality to open a port and listen for incoming connections. This functionality is present in a driver that accompanies the CertAppEnv installation called “wmControl.exe”. We also observed anti-analysis capability within the application, which is typically associated with malware.

Based on data provided by the Recorded Future client, the “Beijing One Pass” application requires the installation of the “Certificate Application Environment” software. This software appears to be developed by the Chinese state-owned enterprise Beijing Certificate Authority (北京数字认证股份有限公司). Upon installation of the One Pass PC client, the subsequent process tree that is spawned is detailed in Figure 1 and was investigated further by Insikt Group analysts.

Editor’s Note: This post was an excerpt of a full report. To read the entire analysis, click here to download the report as a PDF.

The post “Beijing One Pass” Employee Benefits Software Exhibits Spyware Characteristics appeared first on Recorded Future.

A Simple Regression Problem

This article is part of a new series featuring problems with solution, to help you hone your machine learning and pattern recognition skills. Try to solve this problem by yourself first, before looking at the solution. Today’s problem also has an intriguing mathematical appeal and solution: this allows you to check if your solution found using machine learning techniques, is correct or not. The level is for beginners. 

The problem is as follows. Let X1, X2, X3 and so on be a sequence recursively defined by Xn+1 = Stdev(X1, …, Xn). Here X1, the initial condition, is a positive real number or random variable. Thus,

It is clear that Xn = An X1, where An is a number that does not depend on X1. So we can assume, without loss of generality, that X1 = 1. For instance, A1 = 1 and A2 = 0. The purpose here is to study the behavior of An (for large n) using simple model fitting techniques. I plotted the first few values of An, below. In the figure below, the X-axis represents n, and the Y-axis represents An. The question is: how to approximate An as a simple function of n? Of course, a linear regression won’t work. What about a polynomial regression?

The first 600 values of An are available here, as a text file.

Solution

A tool as basic as Excel is good enough to find the solution. However, if you use Excel, the built-in function Stdev has a correcting factor that needs to be taken care of. But you can just use the values of An available in my text file mentioned above, to avoid this problem.

If you use Excel, you can try various types of trend lines to approximate the blue curve, and even compute the regression coefficients and the R-squared for each tested model. You will find very quickly that the power trend line is the best model by far, that is, An is very well approximated (for large values of n) by An = b n^c. Here n^c stands for n at power c; also, b and c are the regression coefficients. In other words, log An = log b + c log n (approximately). 

What is very interesting, is that using some mathematics, you can actually compute the exact value of c. Indeed, c is solution of the equation c^2 = (2c + 1) (c + 1)^2, see here. This is a polynomial equation of degree 3, so the exact value of c can be computed. The approximation is c = -0.3522011. It is however very hard to get the exact value of b

It would interesting to plot the residual error for each estimated value of An, and see if it shows some pattern. This could lead to a better approximation: An = b n^c (1 + n), with three parameters: b, c (unchanged) and d.

To receive a weekly digest of our new articles, subscribe to our newsletter, here.

About the author:  Vincent Granville is a data science pioneer, mathematician, book author (Wiley), patent owner, former post-doc at Cambridge University, former VC-funded executive, with 20+ years of corporate experience including CNET, NBC, Visa, Wells Fargo, Microsoft, eBay. Vincent is also self-publisher at DataShaping.com, and founded and co-founded a few start-ups, including one with a successful exit (Data Science Central acquired by Tech Target). He recently opened Paris Restaurant, in Anacortes. You can access Vincent’s articles and books, here.

The Tao of Tau

I missed Tau day, which was the 28th of June. However, I’ve been thinking about the intersection of Tau, complex numbers, code libraries and Javascript in analytics for a while now, and this seemed like a good chance to explore one of my favorite topics: Tauism. — Kurt Cagle

One of the things that most young mathematicians (think eight years old or so) learn is that pie are square, a fact which is immediately refuted with the confused observation “No they’re not! Pies are round!” Later, of course, they discover algebra and geometry, where in fact it is proven demonstrably that, well, the circumference of a circle and the area of the same circle are related by two simple equations:

C=2πr

and

A=πr^2

The first law was at least known at the time of Euclid, though it would be a few centuries later that Archimedes actually calculated the ratio of the diameter (twice the radius) to the circumference to be roughly 3 1/7 (though in fact, he was able to get it right to within eight digits eventually, in Greek numeric notation). However, it would be early in the eighteen century AD that Welsh mathematician William Jones would use the Greek letter π (pi) for this particular ratio.

The great mathematician Leonhard Euler would eventually pull together the use of π, the base of the natural logarithms (e, approximately 2.71828) and the square root of negative one (called i) into one of the more fundamental equations of mathematics:

e^(πi) = -1

For the next three hundred years, π would reign supreme in mathematics as perhaps the single most well known constant ever. However, for several years, Euler debated whether to use π to indicate the circumference of a circle divided by the diameter (a ratio of about 3.1415927…) or to indicate the circumference divided by the ratio (a ratio of 6.2831854…). His decision, ultimately, to go with the former may have complicated mathematics far more than he’d planned.

In 2010, mathematician Michael Hartl wrote a paper that would eventually become known as the Tau Manifesto, in which he proposed using the letter tau (τ) for the ratio of the circumference divided by radius, the aforementioned 6.28 value. His arguments were actually quite compelling:

  • One τ is precisely one turn around a circle, or one revolution (360°). τ/2 is half a circle or 180°, τ/4 is one fourth of a circle, or 90° and so forth. Compare this with 2ππ, and π/2 respectively. In general, this becomes the same as C= τr, as opposed to C= xn
  • Euler’s equation (which laid the foundation for complex numbers), can be expressed with τ as:

e^(τi) = 1

  • Similarly, the area of a circle takes on the same characteristics as other power laws in mathematics and physics:

A = dfrac{1}{2} tau r^2; E= dfrac{1}{2} m v^2;

A=(1/2)τr^2 ; E = (1/2) mv^2

Where it really shines, however, is in areas such as trigonometry and complex matrix algebra. For instance, if you had trigonometric functions built around τ, you can state that

e^(iθ) = cos(θ) + i sin(θ), where 0 < θ < τ

This equation makes it clear that a quarter of the way through a revolution, the equation has the value +i, at halfway it’s -1, at 3/4 of the revolution, the equation is –i, and at one full revolution you’re right back to where you started. It also highlights the close association between exponential functions and rotations.

No alt text provided for this image

This becomes especially useful in gaming and 3D applications, in which the square root of -1 (the i part) is treated as an axis of rotation. In three dimensions, you end up with three such axes: ijand k. These are known as quaternions. If each of these are used to describe a complex number (such as 0.5 + 0.866i) on the unit sphere (a great circle), then by performing a rotation on that circle (from 0 to 1 τ ), you can position that object precisely along that rotation. Camera operators (and pilots) understand these three dimensions as pitch, yaw and roll.

No alt text provided for this image

These quaternions become especially important when dealing with rigging in three-dimensional work, involving vectors connecting end to end. These are also known as gimbals, again from the camera mounts that allow for orienting in any dimension. While in data science this can be done using matrix transformations, quaternion calculations are often faster and less time consuming to set up.

No alt text provided for this image

The skeleton of a 3D figure is made up of vectors, with quaternions acting as gimbals at the joints to help move the figure around.

No alt text provided for this image

A Library For Tau Based Complex Number Operations

The value of Tau (and the relationship between Tau revolutions and complex numbers, inspired me to write a small Javascript library that both defined some Tau helper functions (the Tau class, made up exclusively of static) and an immutable TauComplex class that was built specifically with Tau revolutions in mind. These scripts are available at https://github.com/kurtcagle/tau.

class Tau {     
        static TAU = 2 * Math.PI
        static TAU_2 = this.TAU/2
        static TAU_4 = this.TAU/4
        static TAU_6 = this.TAU/6
        static TAU_8 = this.TAU/8
        static TAU_12 = this.TAU/12
        constructor(){
            // This consists solely of static methods and constants
        }
        // converts a revolution to degrees
        static toDegrees(rev){return rev * 360}
        // converts a revolution to radians
        static toRadians(rev){return rev * this.TAU}
        // converts from degrees to revolutions
        static fromDegrees(deg){return deg / 360}
        // converts from radians to revolutions
        static fromRadians(rad){return rad / this.TAU}
        // returns the sine value of the given revolution
        static sin(rev){
            return Math.sin(rev * this.TAU)
        }
        // returns the cosine value of the given revolution
        static cos(rev){
            return Math.cos(rev * this.TAU)
        }
        // returns the tangent value of the given revolution
        static tan(rev){
            return Math.tan(rev * this.TAU)
        }
        // returns the arcsine value of the given revolution
        static asin(rev){
            return this.fromRadians(Math.asin(rev))
        }
        // returns the arccosine value of the given revolution
        static acos(rev){
            return this.fromRadians(Math.acos(rev))
        }
        // For a given x,y value, returns the corresponding revolution from -0.5 to 0.5.
        static atan(x,y){
            return this.fromRadians(Math.atan2(y,x))    }
    
    }
    
    class TauComplex{
        // Indicates the number of significant digits complex numbers are displayed using.
        static SIGDIGITS = 5;
        constructor(x,y){
            this.x = x
            this.y = y
            return this
        }
        // toString() generates a complex number of the form “a+bi” for string output
        toString(){
            let minX = Math.abs(this.x)<1e-5?0:TauComplex.trim(this.x);
            let minY = Math.abs(this.y)<1e-5?0:TauComplex.trim(this.y);
            return `${minX} ${Math.sign(this.y)>=0?‘+’:‘-‘} ${Math.abs(minY)}i`
        }
        // generates the length of the complex number vector
        get modulus(){
            return Math.sqrt(this.x*this.x + this.y*this.y);
        }
        // generates the square of the length of the complex number vector. This avoids the need to take the square root
        get modsquare(){
            return this.x*this.x + this.y*this.y;
        }
        // retrieves the angle relative to the positive x axis of the complex number, in revolutions
        get theta(){
            let angle = Tau.atan(this.x,this.y);
            let ySgn = Math.sign(this.y);
            let adjAngle = ySgn<0?1+angle:angle;
            return adjAngle;
        }
        // retrieves the complex conjugate (a-bi) of the complex number (a+bi)
        get conjugate(){
            return new TauComplex(this.x,-this.y)
        }
        // retrieves the complex inverse of the number (a+bi).
        get inverse(){
            return (this.conjugate).scale(1/this.modsquare)
        }
        // rotates the complex number through the angle, expressed in revolutions.
        rotate(angle){
            let newX = this.x * Tau.cos(angle) – this.y * Tau.sin(angle);
            let newY = this.x * Tau.sin(angle) + this.y * Tau.cos(angle)
            return new TauComplex(newX,newY)
        }
        // Multiplies the complex number by a scalar value (or values if two arguments are supplied)
        scale(x,y=x){
            let newX = this.x * x;
            let newY = this.y * y;
            return new TauComplex(newX,newY)
        }
        // translates the complex number by the given amount. Equivalent to adding two complex numbers
        translate(x,y=x){
            let newX = this.x + x;
            let newY = this.y + y;
            return new TauComplex(newX,newY)
        }
        // Adds two or more complex numbers together.
        static sum(…c){
            let reducer = (acccur=> new TauComplex(acc.x+cur.x,acc.y+cur.y)
            return c.reduce(reducer)
        }
        // Multiples two or more complex numbers together.
        static mult(…c){
            let reducer = (acccur=> new TauComplex(acc.x*cur.xacc.y*cur.y,acc.x*cur.y+acc.y*cur.x)
            return c.reduce(reducer)
        }
        // Divides the first complex number by the second
        static div(c1,c2){
            return TauComplex.mult(c1,c2.inverse)
        }
        // Takes the complex number to the given power. Power MUST be a non-negative integer.
        pow(power){
            let arr = [];
            for (var index=0;index!=power;index++){
                arr.push(this);
            }
            if (arr.length>0) {
                return TauComplex.mult(…arr)
            }
            else {
                return new TauComplex(1,0);
            }
        }
        // Returns the real portion of a complex number
        get re(){
            return this.x
        }
        // Returns the imaginary portion of a complex number
        get im(){
            return this.y
        }
        // Returns the complex number associated with a unit vector rotated by the revolution amount
        static tau(rev){
            return new TauComplex(Tau.cos(rev),Tau.sin(rev));
        }
        // Returns the complex exponent of the given complex number
        get exp(){
            return TauComplex.tau(this.y).scale(Math.exp(this.x))
        }
        // Creates a string representation of a number to the given significant digits, default being 5.
        static trim(value,sigDigits=this.SIGDIGITS){
            return value.toLocaleString(“en-us”,{maximumSignificantDigits:sigDigits})
        }
        static array(…arr){
            return arr.map((subArr,index)=>new TauComplex(…subArr))
        }
    }
    const _TauComplex = TauComplex;
    exports.TauComplex = _TauComplex;
    const _Tau = Tau;
    exports.Tau = _Tau;

The complex class is reasonably complete for complex number manipulation, including handling addition and multiplication of complex numbers, creating complex conjugates, moduli, and equations for rotating, scaling and translating such numbers in the complex plane. A test script (TauTest.js) illustrates how these functions are invoked:

const { TauTauComplex } = require(‘./tau’);
TauComplex.SIGDIGITS = 3
const c1 = new TauComplex(1,2);
const c2 =  c1.rotate(0.25);
const c3 = TauComplex.sum(c1,c2);
const c4 = new TauComplex(0,-1);
const c5 = new TauComplex(1,3/8);
const cArr = TauComplex.array([1,0],[0,1],[-1,0],[0,-1])

console.log(`c1: ${c1}`);
console.log(`c2: ${c2}`);
console.log(`c3: ${c3}`);
console.log(`c4: ${c4}`);
console.log(`modulus of c3: ${c3.modulus}`)
console.log(`modulus squared of c3: ${c3.modsquare}`)
console.log(`theta of c3: ${c3.theta}`)
console.log(`conjugate of c3: ${c3.conjugate}`)
console.log(‘c1 + c2: ‘+TauComplex.sum(c1,c2))
console.log(‘c1 * c2: ‘+TauComplex.mult(c1,c2))
console.log(‘c1 ^ 2: ‘+c1.pow(2))
console.log(‘c1 ^ 3: ‘+c1.pow(3))
console.log(‘1 / c1: ‘+c1.inverse)
console.log(`c1 / c3: ${TauComplex.div(c1,c3)}`)
console.log(`exp(c5): ${c5.exp}`)
console.log(‘c1 scale 2: ‘+c1.scale(2));
console.log(‘c1 translate 2,3: ‘+c1.translate(2,3));
for (index=0;index<=12;index++){
    console.log(`c4 rotate ${index}/12 or ${Tau.toDegrees(index/12)}${c4.rotate(index/12)}`)
}
console.log(`Complex Array: ${cArr}`);

with this test script generating the following output :

c1: 1 + 2i
c2: -2 + 1i
c3: -1 + 3i
c4: 0 - 1i
modulus of c3: 3.1622776601683795
modulus squared of c3: 10
theta of c3: 0.30120819117478337
conjugate of c3: -1 - 3i
c1 + c2: -1 + 3i
c1 * c2: -4 - 3i
c1 ^ 2: -3 + 4i
c1 ^ 3: -11 - 2i
1 / c1: 0.2 - 0.4i
c1 / c3: 0.5 - 0.5i
exp(c5): -1.92 + 1.92i
c1 scale 2: 2 + 4i
c1 translate 2,3: 3 + 5i
c4 rotate 0/12 or 0: 0 - 1i
c4 rotate 1/12 or 30: 0.5 - 0.866i
c4 rotate 2/12 or 60: 0.866 - 0.5i
c4 rotate 3/12 or 90: 1 - 0i
c4 rotate 4/12 or 120: 0.866 + 0.5i
c4 rotate 5/12 or 150: 0.5 + 0.866i
c4 rotate 6/12 or 180: 0 + 1i
c4 rotate 7/12 or 210: -0.5 + 0.866i
c4 rotate 8/12 or 240: -0.866 + 0.5i
c4 rotate 9/12 or 270: -1 + 0i
c4 rotate 10/12 or 300: -0.866 - 0.5i
c4 rotate 11/12 or 330: -0.5 - 0.866i
c4 rotate 12/12 or 360: 0 - 1i
Complex Array: 1 + 0i,0 + 1i,-1 + 0i,0 - 1i

One of the critical points about this library is that the complex numbers are meant to be treated as immutable, with any operation on a complex number generating a new complex number. For instance, if you wanted to add three complex numbers, you’d create an expression such as:

const c6 = TauComplex.sum(c1,c2,c3)  => c6 = Sum of (c1,c2,c3): -2 + 6i 

Complex numbers factor heavily in both pure and applied mathematics, and can be proved to be the largest complete set of numbers – you cannot construct another space of numbers that cannot be decomposed into complex numbers. Additionally, the equations used to create approximations of surfaces, known as the Taylor Series, makes extensive use of complex numbers.

There is one final point to be made in this particular article. There is a tendency to look at either Python or R when dealing with mathematics, but it’s worth noting that it is perfectly possible to create mathematics libraries and classes in JavaScript as well. Indeed, Javascript contains its own equivalents of both Pandas (Danfo.js) and NumPy (nympy.js), two of the foundational classes, and Google’s TensorFlow library has been ported over to Javascript as well (primarily around the node.js version). In some cases, Javascript is even faster than Python in the analytics space, especially given recent optimizations for handling binary data types.

Foolproof strategy to carve a niche in big data engineering

The big data and data engineering services market is growing worldwide. Learn the principles, tools, and technologies to build the data architecture, handle data storage, streamline data processing, and maintain security infrastructure in big data management for your business. Carve your niche in big data with big data engineering certification!

Boost your data science career by earning the most in-demand Senior Big Data Engineer (SBDE) certification from DASCA.

https://preview.redd.it/6v7f1lqhk9e71.jpg?width=874&format=pjpg&auto=webp&s=55068f6b45e7b2574cb85769ea4b6792600766aa

submitted by /u/sharmaniti437
[link] [comments]

IC-82977-G9N8

The complainant requested information on 12 November 2019 relating to the Pay Consistency Panel at the ICO. The ICO provided information in response to the request to the complainant’s satisfaction on 6 July 2021. The ICO therefore failed to respond to this request fully within the statutory time for compliance. The Commissioner considers that the ICO has breached section 10(1) FOIA in the handling of this request. The Commissioner requires no steps to be taken.

IC-62225-K7N5

The complainant has requested information relating to a potential Trading Standards investigation. In relation to parts 1-6 of the request Kent County Council refused to confirm or deny whether the information was held, relying on section 44(2) of the FOIA (the exemption from disclosure for any information whose disclosure would be otherwise prohibited by another piece of legislation). In relation to part 7 of the request, it directed the complainant to information on its website. The Commissioner’s decision is that Kent County Council correctly applied section 44(2) to parts 1-6 of the request and that its response to part 7 of the request complied with section 1(1). The Commissioner does not require the public authority to take any steps.
Scroll to top