# data[].attributes.body
10 python open source projects on Github

# data[].attributes.wish_content.attachment_props.text
10 Python Open Source Projects On GitHub.

If you ask the best programming language for job & future, Python undoubtedly tops the list.

This 🧵 will help you to become a pro. in Python 💕

# data[].attributes.wish_content.attachment_props.original_text
10 Python Open Source Projects On GitHub.

If you ask the best programming language for job & future, Python undoubtedly tops the list.

This 🧵 will help you to become a pro. in Python 💕

# data[].attributes.attachment_link.embed_code
10 Python Open Source Projects On GitHub.

If you ask the best programming language for job & future, Python undoubtedly tops the list.

This 🧵 will help you to become a pro. in Python 💕
— Trilochan Parida ☁️🚀 (@TechParida) August 12, 2020

# data[].attributes.attachment_link.metadata.attachment_props_source.data.text
10 Python Open Source Projects On GitHub.

If you ask the best programming language for job & future, Python undoubtedly tops the list.

This 🧵 will help you to become a pro. in Python 💕

# data[].attributes.attachment_link.metadata.attachment_props.original_text
10 Python Open Source Projects On GitHub.

If you ask the best programming language for job & future, Python undoubtedly tops the list.

This 🧵 will help you to become a pro. in Python 💕

# data[].attributes.attachment_link.metadata.attachment_props.text
10 Python Open Source Projects On GitHub.

If you ask the best programming language for job & future, Python undoubtedly tops the list.

This 🧵 will help you to become a pro. in Python 💕

# data[].attributes.attachment_link.readable_text
Bueno, les hago el hilo ahora porque me copé y lo terminé.
Mini introducción a Data Science, by me.

Data se considera a la información alamacenada en algún formato digital que luego se puede utilizar como base para análisis y tomar decisiones.
Hay dos tipos de data: traditional data & big data.
Enfrentarse a la data es el primer paso para resolver un problema de cualquier tipo.

Traditional data: datos estructurados en tablas y que pueden ser manejados desde una sola computadora.
Big Data: volúmenes de datos extremadamente grandes y que poseen varios formatos a la vez (estructurado, semi-estructurado o desestructurado). 3Vs: volumen, variedad, velocidad.

Una vez que tenemos los datos. pasamos a la parte de Data Science, que es un campo interdisciplinario que combina herramientas de estadística, matemática, programación y gestión de datos.
Segmentos: Business Intelligence, Traditional Methods, Machine Learning.

Business Intelligence: incluye las tecnologías involucradas en el proceso de analizar, entender y reportar (dashboards) data disponible del pasado, para guiar el camino estratégico hacia la toma de decisiones empresariales, extrayendo ideas y encontrando patrones.

Ponósticos a futuro (analytics): una vez que en BI se presentan los dashboards y/o reports, se puede seguir procesando dicha info a través de dos métodos → Traditional Methods o Machine Learning.

Traditional Methods TD (ciencia de datos tradicional): conjunto de métodos que derivan de la estadística y se adaptan a los negocios. Son imprescindibles para pronosticar el rendimiento en el corto y mediano plazo con gran precisión → regresión, clustering, factores.

Machine Learning ML (aprendizaje automático): matemática + AI combinados para predecir resultados sin la necesidad de haber sido programado para eso. Emplea algoritmos que reciben datos, se procesan con AI y a través de la aplicación de estad y mate se obtienen predicciones

Entonces, lo más importante es la data y la aplicación de la misma a través de la data science.

DATA: TD & BD
Si bien son distintas, cumplen el mismo rol en la empresa. → materia prima del análisis

DATA SCIENCE
Una vez que tenemos la data, dependiendo para qué la necesitemos, vamos a trabajar en algún campo de la DS → analysis (BI) o analytics (TM & ML)

TD:
1) Recolección de la data y Procesamiento: se crea el dataset.

primary data: aquella sin limpiar, cruda, virgen → una vez procesada ya se la puede llamar data procesada → y una vez que represanta algo como información útil ya es DATA

1.1 etiquetar (labeling): numérica o categórica
1.2 Se limpia (cleansing, cleaning o scrubbing)
1.3 Se investiga sobre valores faltantes
1.4 Data shuffling (mezcla de datos): mezclo de manera random la data, obtengo una muestra más aleatoria y posiblemente representativa.

BG

1) Recolección de la data y Procesamiento: se crea el dataset

primary data: aquella sin limpiar, cruda, virgen → una vez procesada ya se la puede llamar data procesada → y una vez que represanta algo como información útil ya es DATA

1.1 etiquetar: numérica, texto, imagen, video, audio, etc
1.2 Se limpia
1.3 Se investiga sobre valores faltantes: pueden ser MUCHOS, acá es donde entra en juego la minería de datos (data mining)
1.4 Data masking: codificar para analizar la información sin comprometer datos.

Busines Intelligence Analysis: ya tenemos la data procesada y organizada.
Data skills + business + intuición → explicar performance pasadas (qué pasó, cuándo, cuánto tiempo, en qué período, etc)

Se comienza con OBSERVACIONES y las CUANTIFICAMOS, luego pasamos a las MEDIDAS (acumulación de observaciones para mostrar cierta data) para luego derivar las MÉTRICAS (mediciones de rendimiento y esto es lo que se compara, sería MEDIDA + RAZÓN DE IMPORTANCIA)

Es decir: OBSERVATIONS → QUANTIFICATIONS → MEASURES → METRICS

KPIs (key performance indicators) → ¿Podemos hacer un seguimiento de todas las métricas que obtenemos de un dataset? Sí, pero no tendría sentido, y gastaríamos tiempo y recursos.
Lo que hay que hacer es elegir las métricas que están estrechamente relacionadas con nuestros obj

→ KPIs = métricas + objetivos
Key: relacionadas con los principales objetivos
performance: muestran el éxito (o no) en un período de tiempo determinado
indicators: los valores indican algo relacionado al rendimiento

Por último, todo lo que genere contenido importante cuantitativo o cualitativo debe ser reportado (reports & dashboards). Reporte: prosa. Dashboard: gráficos.

Una vez que preparamos los reportes y dashboards, estamos listos para utilizar la información y predecir situaciones a futuro. En este punto, dejamos de lidiar con el análisis y pasamos a todo lo analítico, más precisamente, predicciones analíticas.

TM (ciencia de datos tradicional)
Tipos
→ linear regression: modelo utilizado para cuantificar de manera lineal las relaciones entre las diferentes variables de análisis, se traza una línea que represente la acumulación de estos datos y = bx (función lineal),

→ logistic regression: modelo utilizado para cuantificar de manera no lineal las relaciones entre las diferentes variables de análisis, a través de valores booleanos (1 o 0, True o False), se utilizan para la toma de decisiones.

→ clusters: se agrupan ciertas variables que comparten características y se las analiza en conjunto. Y = a + b1x1 + b2x2 + ... + bnxn → x: variable exploratoria → el clustering, entonces, consiste en agrupar dichas variables exploratorias

→ time series: muy usadas en economía y finanzas, es la evolución de valores es función del tiempo

ML (aprendizaje automático): crear un algoritmo que una computadora use para encontrar un modelo que encaje lo mejor posible y hacer predicciones en base al mismo. El algoritmo le da instrucciones a la computadora para aprender por sí misma.

Entonces... el algoritmo de ML se puede definir de manera criolla como un ensayo constante de prueba y error, donde cada nuevo intento es al menos tan bueno como el anterior.

DATA (datasets) → MODEL(ecuación matemática) → OBJECTIVE FUNCTION (obejtivos)→ OPTIMIZATION ALGORITHM

Tipos de ML:
3.1) Aprendizaje supervisado: entrenar un algoritmo que se parece a un maestro que supervisa el aprendizaje de sus estudiantes (labelled data), permite medir la ineficiencia de la objective function y mejorar el algoritmo de optimización.

Lo que se supervisa es la capacitación misma. Ejemplo: redes neuronales, deep learning, modelos aleatorios, Bayes
3.2) Aprendizaje no supervisado: unlabelled data, el modelo se ajusta a las observaciones y se tratan los datos de entrada. Ejemplos: k-means y deep learning

3.3) Aprendizaje de refuerzo: similar al aprendizaje supervisado, pero en vez de minimizar las pérdidas o errores, maximiza el beneficio

Lenguajes de programación más comunes: R, Python y SQL.
SW más comunes: excel, SPSS, HADOOP, POWER BI, QLIK, TABLEAU. STATA, AZURE

Puestos de laburo:
Data architect: crea bases de datos desde cero y diseñan la forma en que los datos serán recuperados, procesados y consumidos

Data engineer: inerviene el trabajo del data architect, procesando los datos para dejarlos listos para el análisis dando como resultando un dataset limpio y ordenado

Database administrator: maneja el control de datos, administra la bdd y trabaja con data tradicional porque la administración de big data está usualmente automatizada

BI Analyst: hará un análisis y reporte de sucesos pasados
BI Consultant: BI Analyst freelance
BI Developer: BI a través de Python y SQL para crear y manipular análisis especialmente de la empresa

Data Scientist: utiliza métodos estadísticos y/o de ML para hacer predicciones analíticas
Data Analyst: se encargan de tipos de análisis más complejos y hacen las partes básicas de las predicciones analíticas.

Machine Learning Engineer: aquellos que crean y aplican métodos y modelos computacionales de última generación desarrollados en el campo del aprendizaje automático para resolver tareas complejos de la ciencia de datos.

Cosas que hay que saber antes de arrancar:
*diferencia entre cualitativo y cuantitativo
*diferencia entre analysis (pasado) y analytics (predicciones futuras)
*storytelling: crucial, no siempre el otro sabrá lenguaje técnico

Esto es todo amigues, se los dejo pinneado en mi perfil.

Si tienen alguna duda me dicen, sepan que lo hice rápido y triste así que puede tener algún que otro pifie. Estoy abierta a debates y críticas constructivas.

You can follow @printmaga.

____ Since you're here...
Tip: mention@threader_app on a Twitter thread with the keyword "compile" to get a link to it.

Enjoy Threader? Sign up.

... we're asking visitors like you to make a contribution to support this independent project. In these uncertain times, access to information is vital. Threader gets 1,000,000+ visits a month and our iOS Twitter client was featured as an App of the Day by Apple. Your financial support will help two developers to keep working on this app. Everyone's contribution, big or small, is so valuable. Support Threader by becoming premium or by donating on PayPal. Thank you.

# data[].attributes.attachment_link.description
Bueno, les hago el hilo ahora porque me copé y lo terminé.Mini introducción a Data Science, by me. Data se considera a la información alamacenada en algún formato digital que luego se puede utilizar como base para análisis y tomar decisiones.Hay dos tipos de data: traditional data & big data.Enfrentarse a la data es el primer paso para resolver un problema de cualquier tipo.

# data[].attributes.body
Apuntes increibles de Python

# data[].attributes.attachment_link.description
hi human! soy Majo👋🏻, realizo apuntes a mano sobre las tecnologías más utilizadas.¡Espero te sean de ayuda!

# data[].attributes.attachment_link.readable_text
En esta segunda parte sobre sistemas de numeración nos toca hablar del sistema binario, ese que se representa con ceros y unos, y que habremos visto más de una vez.

En el sistema binario los dígitos solo pueden tener dos valores ("bi" = dos) y estos se representan con los caracteres 0 o 1. Esta característica convierte al sistema binario en el sistema de numeración natural para las máquinas (ordenadores), ya que éstas, al nivel más primario solo entienden dos estados, encendido o apagado (1 o 0).

Cada dígito binario se denomina "bit" y al número de dígitos que tiene un número binario se le llama "longitud", por ejemplo 1101 tiene 4 bits de longitud.

Decimal / Binario

Al igual que hicimos en el artículo dedicado al sistema hexadecimal, vamos a comparar el sistema decimal con el binario.

El sistema decimal es un sistema en que utiliza 10 caractere s para su representación: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.

El sistema binario es un sistema en que utiliza 2 caracteres para su representación: 0, 1.

Como vemos arriba, si en el sistema decimal un dígito puede tener 10 valores diferentes, en el binario solo 2.

Hagamos ahora el desglose de una cifra en sistema decimal, y su correspondiente en binario, .

Si nos fijamos en la cifra del sistema decimal del ejemplo , el primer dígito a la izquierda de la coma de los decimales puede representar 10 valores diferentes en este caso el 2, el siguiente dígito a su izquierda representa el 1 multiplicado por 10 (10 ¹), y así continuaría en el caso de que hubiese más dígitos (10 ², 10 ³, 10 ⁴, . . ).

Si nos fijamos en la cifra binaria la lógica es la misma, lo que cambia es que son dígitos que solo pueden tomar 2 valores diferentes. El primer y segundo dígito en este caso toman el valor 0, el tercer dígito desde la izquierda toma el 1 que se multiplica por 4 (2 ²). Y el cuarto dígito desde toma el 1 que se multiplica por 8 (2 ³). En el caso de que la cifra tuviese más dígitos continuaría 2 ⁴, 2 ⁵, 2 ⁶, . .

Hagamos lo mismo ahora con otra cifra binaria, , que en decimal es 215.

Y para terminar vamos a hacer la conversión al revés, de decimal a binario . Para ello tomaremos el número decimal y lo dividiremos entre dos, recuerda que el sistema binario trabaja en base 2, el cociente que obtengamos volveremos a dividirlo entre dos, y así sucesivamente hasta que el cociente nos de cero. Una vez que obtengamos el cociente cero tomaremos todos los restos desde el último al primero consiguiendo así el número binario.

# data[].attributes.attachment_link.title
¿Qué son los números binarios? | El visualista

# data[].attributes.attachment_link.description
En esta segunda parte sobre sistemas de numeración nos toca hablar del sistema binario, ese que se representa con ceros y unos, y que habremos visto más de una vez. En el sistema binario los dígitos solo pueden tener dos ... Continuar

# data[].attributes.attachment_link.description
En este tutorial vamos a aprender que son las secuencias de escape en Python y como usarlas en nuestros programas. Publicado el Las secuencias de escape nos dejan incrustar caracteres en cadenas que ni pueden ser fácilmente tipeadas desde un teclado.

# data[].attributes.attachment_link.readable_text
I consider this book a mini-encyclopedia of modern data engineering. Like a specialized encyclopedia, it covers a broad field and in considerable detail. But it is not a practice or a cookbook for a particular Big Data, NoSQL or newSQL product. What the author does is to lay down the principles of current distributed big data systems, and he does a very fine job of it. If you are after the obscure details of a particular product, or some tutorials and "how-to"s, go elsewhere. But if you want to understand the main principles, issues, as well as the challenges of data intensive and distributed system, you've come to the right place. Martin Klepman starts out by solidly giving the reader the conceptual framework in the first chapter: what does reliability mean? How is it defined? What is the difference between a "fault" and a "failure"? How do you describe load on a data intensive system? How do you talk about performance and scalability in a meaningful way? What does it mean to have a "maintainable" system?Second chapter gives a brief overview of different data models and shows the suitability of of them to different use cases, using modern challenges that companies such as Twitter faced. This chapter is a solid foundation for understanding the difference between the relational data model, document data model, graph data model, as well as the languages used for processing data stored using these methods.The third chapter goes into a lot of detail regarding the building blocks of different types of database systems: the data structures and algorithms used for the different systems shown in the previous chapter are described; you get to know what hash indexes, SSTables (Sorted String Tables), Log-Structured Merge trees (LSM-trees), B-trees and other data structures. Following this chapter, you are introduced to Column Databases and the underlying principles and structures behind them.Following these, the books describes the methods of data encoding, starting from the venerable XML and JSON, and going into the details of formats such as Avro, Thrift and Protocol Buffers, showing the trade-offs between these choices.Following the building blocks and foundations above is the Part II of the book and this is where things start to get really interesting because now the reader starts to learn about challenging topic of distributed systems: how to use the basic building blocks in a setting where anything can go wrong in the most unexpected ways. This Part II is the most complex of part the book: you learn about how to replicate your data, what happens when replication lags behind, how you provide a consistent picture to the end-user or the end-programmer, what algorithms are used for leader election in consensus systems, and how leaderless replication works. One of the primary purpose of using a distributed system is to have an advantage over a single, central system, and that advantage is to provide better service, meaning a more resilient service with an acceptable level of responsiveness. This means you need to distribute the load and your data, and there a lot of schemes for partitioning your data. Chapter 6 of Part II provides a lot of details on partitioning, keys, indexes, secondary indexes and how to handle data queries when your data is partitioned using various methods.No data systems book can be complete without touching the topic of transactions, and this book is not an exception to the rule. You learn about the fuzziness surrounding the definition of ACID, isolation levels, and serializability. The remaining two chapters of Part II, Chapter 8 and 9 is probably the most interesting part of the book. You are now ready to learn the gory details of how to deal with all kinds of network and other types of faults to keep your data system in usable and consistent state, the problems with the CAP theorem, version vectors and that they are not vector clocks, Byzantine faults, how to have a sense of causality and ordering in a distributed system, why algorithms such as Paxos, Raft, and ZAB (used in ZooKeeper) exist, distributed transactions, and many more topics. The rest of the book, that is Part III, is dedicated to batch and stream processing. The author describes the famous Map Reduce batch processing model in detail, and briefly touches upon the modern frameworks for processing distributed data processing such as Apache Spark. The final chapter discusses event streams and messaging systems and challenges that arise when trying to process this "data in motion". You might not be in the business of building the next generation streaming system, but you'll definitely need to have a handle on these topics because you'll encounter the described issues in the practical stream processing systems that you deal with daily as a data engineer.As I said in the opening of this review, consider this a mini-encyclopedia for the modern data engineer, and also don't be surprised if you see more than 100 references at the end of some chapters; if the author tried to include most of them in the text itself, the book would well go beyond 2000 pages! At the time of my writing, the book is 90% complete, according to its official site there's only 1 more chapter to be added (Chapter 12: Materialized Views and Caching), so it is safe to say that I recommend this book to anyone working with distributed big data systems, dealing with NoSQL and newSQL databases, document stores, column oriented data stores, streaming and messaging systems. As for me, it'll definitely be my go-to reference for the upcoming years for these topics.

# data[].attributes.attachment_link.title
Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems

# data[].attributes.attachment_link.description
Data is at the center of many challenges in system design today. Difficult issues need to be figured out, such as scalability, consistency, reliability, efficiency, and maintainability. In addition, we have an overwhelming variety of tools, including relational databases, NoSQL datastores, stream or batch processors, and message brokers.

# data[].attributes.body
Bastante dinamico para aprender codeando.

# data[].attributes.attachment_link.readable_text
How do I start my trial period?

You need to register to start your 7-day trial period, for which you won't need to enter any payment information. Note that you can prolong your trial period: complete the first stage of your first project during your trial period and extend the trial by +1 month. Then, complete the first project during the trial period and get +1 month more of free access. You can find all the instructions under your profile settings on the platform.

How to proceed with a paid subscription after the trial is over?

Once your trial is over, your monthly fee will be $49.90 (or $24.90 monthly fee for the next 12 months if you register before October 1, 2020).

If you've registered before July 1, 2020, you get free access until January 1, 2021. Thanks for being with us in the early stages of development! Once your free access period is over, your monthly fee will be $24.90 for the next 12 months.

You will need to create a JetBrains Account or sign in to an existing one, to manage your subscription. You can find all the instructions under your profile settings on the platform.

Will there be an annual subscription?

We're planning to offer an annual subscription that will cost less than 12 months of the monthly subscription. We will share more details about the annual subscription before the end of the year.

How can I cancel my subscription?

You can stop your subscription payments at any time. Please use your JetBrains Account and follow the instructions under your profile settings on the platform.

How long does it take to complete your learning program?

On average, the Java track takes 128 hours and the Python track takes 70 hours to complete. This means you will need about 7 months for Java and about 4 months for Python if you study 4 hours per week. But please note that our estimates are now based on an average completion rate, and there are some professional developers who go through our basic programming tracks with ease. This means that you may need more time if you are new to programming and just getting started. We're working on making these estimates more accurate and personalized.

Will studying on your platform lead to some chances of getting a job?

We believe that learning at JetBrains Academy will definitely help you become more prepared for your first job interview. The more complex projects are inspired by test assignments for junior developer positions. We do not have any special agreements with IT companies and therefore can't give any guarantees.

Will I get a certificate after completing a program?

We don't have any certification program at the moment. Please comment and vote for the corresponding feature request in our tracker.

After my subscription ends, will I be able to revise the topics and solutions that I worked on while my subscription was active?

All the code that you write in your IDE while solving code challenges or working on projects is stored locally on your machine, and you can keep it without any restrictions. We're also looking at the possibility of providing read-only access to your learning history for a period of time after your subscription ends.

# data[].attributes.attachment_link.title
JetBrains Academy: A hands-on platform for learning to program

# data[].attributes.attachment_link.description
How do I start my trial period? You need to register to start your 7-day trial period, for which you won't need to enter any payment information. Note that you can prolong your trial period: complete the first stage of your first project during your trial period and extend the trial by +1 month.

# data[].attributes.attachment_link.readable_text
Machine Learning Practitioners have different personalities. While some of them are "I am an expert in X and X can train on any type of data", where X = some algorithm, some others are "Right tool for the right job people". A lot of them also subscribe to "Jack of all trades. Master of one" strategy, where they have one area of deep expertise and know slightly about different fields of Machine Learning. That said, no one can deny the fact that as practicing Data Scientists, we will have to know basics of some common machine learning algorithms, which would help us engage with a new-domain problem we come across. This is a whirlwind tour of common machine learning algorithms and quick resources about them which can help you get started on them.

PCA is an unsupervised method to understand global properties of a dataset consisting of vectors. Covariance Matrix of data points is analyzed here to understand what dimensions(mostly)/ data points (sometimes) are more important (ie have high variance amongst themselves, but low covariance with others). One way to think of top PCs of a matrix is to think of its eigenvectors with highest eigenvalues. SVD is essentially a way to calculate ordered components too, but you don't need to get the covariance matrix of points to get it.

This Algorithm helps one fight curse of dimensionality by getting datapoints with reduced dimensions.
https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.svd.html http://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html https://arxiv.org/pdf/1404.1100.pdf
Remember your Numerical Analysis code in college, where you used to fit lines and curves to points to get an equation. You can use them to fit curves in Machine Learning for very small datasets with low dimensions. (For large data or datasets with many dimensions, you might just end up terribly overfitting, so don't bother). OLS has a closed form solution, so you don't need to use complex optimization techniques.

As is obvious, use this algorithm to fit simple curves / regression
https://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.lstsq.html https://lagunita.stanford.edu/c4x/HumanitiesScience/StatLearning/asset/linear_regression.pdf https://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.polyfit.html
Least Squares can get confused with outliers, spurious fields and noise in data. We thus need constraints to decrease the variance of the line we fit on a dataset. The right method to do it is to fit a linear regression model which will ensure that the weights do not misbehave. Models can have L1 norm (LASSO) or L2 (Ridge Regression) or both (elastic regression). Mean Squared Loss is optimized.
http://scikit-learn.org/stable/modules/linear_model.html https://www.youtube.com/watch?v=5asL5Eq2x0A https://www.youtube.com/watch?v=jbwSCwoT51M
Use these algorithms to fit regression lines with constraints, avoiding overfitting and masking noise dimensions from model.

Everyone's favorite unsupervised clustering algorithm. Given a set of data points in form of vectors, we can make clusters of points based on distances between them. It's an Expectation Maximization algorithm that iteratively moves the centers of clusters and then clubs points with each cluster centers. The input the algorithm has taken is the number of clusters which are to be generated and the number of iterations in which it will try to converge clusters.
http://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html https://www.youtube.com/watch?v=hDmNF9JG3lo https://www.datascience.com/blog/k-means-clustering
As is obvious from the name, you can use this algorithm to create K clusters in dataset

Logistic Regression is constrained Linear Regression with a nonlinearity (sigmoid function is used mostly or you can use tanh too) application after weights are applied, hence restricting the outputs close to +/- classes (which is 1 and 0 in case of sigmoid). Cross-Entropy Loss functions are optimized using Gradient Descent. A note to beginners: Logistic Regression is used for classification, not regression. You can also think of Logistic regression as a one layered Neural Network. Logistic Regression is trained using optimization methods like Gradient Descent or L-BFGS. NLP people will often use it with the name of Maximum Entropy Classifier.

This is what a Sigmoid looks like:
http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html https://www.youtube.com/watch?v=-la3q9d7AKQ
Use LR to train simple, but very robust classifiers.

SVMs are linear models like Linear/ Logistic Regression, the difference is that they have different margin-based loss function (The derivation of Support Vectors is one of the most beautiful mathematical results I have seen along with eigenvalue calculation). You can optimize the loss function using optimization methods like L-BFGS or even SGD.

Another innovation in SVMs is the usage of kernels on data to feature engineer. If you have good domain insight, you can replace the good-old RBF kernel with smarter ones and profit.

One unique thing that SVMs can do is learn one class classifiers.
http://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html https://www.youtube.com/watch?v=eHsErlPJWUU
SVMs can used to Train a classifier (even regressors)

Note: SGD based training of both Logistic Regression and SVMs are found in SKLearn's http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.SGDClassifier.html , which I often use as it lets me check both LR and SVM with a common interface. You can also train it on >RAM sized datasets using mini batches.

These are basically multilayered Logistic Regression classifiers. Many layers of weights separated by non-linearities (sigmoid, tanh, relu + softmax and the cool new selu). Another popular name for them is Multi-Layered Perceptrons. FFNNs can be used for classification and unsupervised feature learning as autoencoders.
http://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPClassifier.html#sklearn.neural_network.MLPClassifier http://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPRegressor.html https://github.com/keras-team/keras/blob/master/examples/reuters_mlp_relu_vs_selu.py http://www.deeplearningbook.org/contents/mlp.html http://www.deeplearningbook.org/contents/autoencoders.html http://www.deeplearningbook.org/contents/representation.html
FFNNs can be used to train a classifier or extract features as autoencoders

Almost any state of the art Vision based Machine Learning result in the world today has been achieved using Convolutional Neural Networks. They can be used for Image classification, Object Detection or even segmentation of images. Invented by Yann Lecun in late 80s-early 90s, Convnets feature convolutional layers which act as hierarchical feature extractors. You can use them in text too (and even graphs).
https://developer.nvidia.com/digits https://github.com/kuangliu/torchcv https://github.com/chainer/chainercv https://keras.io/applications/ http://cs231n.github.io/ https://adeshpande3.github.io/A-Beginner%27s-Guide-To-Understanding-Convolutional-Neural-Networks/
Use convnets for state of the art image and text classification, object detection, image segmentation.

RNNs model sequences by applying the same set of weights recursively on the aggregator state at a time t and input at a time t (Given a sequence has inputs at times 0..t..T, and have a hidden state at each time t which is output from t-1 step of RNN). Pure RNNs are rarely used now but its counterparts like LSTMs and GRUs are state of the art in most sequence modeling tasks.

RNN (If here is a densely connected unit and a nonlinearity, nowadays f is generally LSTMs or GRUs ). LSTM unit which is used instead of a plain dense layer in a pure RNN.

Use RNNs for any sequence modelling task specially text classification, machine translation, language modelling
https://github.com/wabyking/TextClassificationBenchmark http://opennmt.net/ http://cs224d.stanford.edu/ http://www.wildml.com/category/neural-networks/recurrent-neural-networks/ http://colah.github.io/posts/2015-08-Understanding-LSTMs/
https://github.com/tensorflow/models (Many cool NLP research papers from Google are here)

CRFs are probably the most frequently used models from the family of Probabilitic Graphical Models (PGMs). They are used for sequence modeling like RNNs and can be used in combination with RNNs too. Before Neural Machine Translation systems came in CRFs were the state of the art and in many sequence tagging tasks with small datasets, they will still learn better than RNNs which require a larger amount of data to generalize. They can also be used in other structured prediction tasks like Image Segmentation etc. CRF models each element of the sequence (say a sentence) such that neighbors affect a label of a component in a sequence instead of all labels being independent of each other.
https://sklearn-crfsuite.readthedocs.io/en/latest/ http://blog.echen.me/2012/01/03/introduction-to-conditional-random-fields/
Use CRFs to tag sequences (in Text, Image, Time Series, DNA etc.)

7 part lecture series by Hugo Larochelle on Youtube: https://www.youtube.com/watch?v=GF3iSJkgPbA

Let's say I am given an Excel sheet with data about various fruits and I have to tell which look like Apples. What I will do is ask a question "Which fruits are red and round ?" and divide all fruits which answer yes and no to the question. Now, All Red and Round fruits might not be apples and all apples won't be red and round. So I will ask a question "Which fruits have red or yellow color hints on them? " on red and round fruits and will ask "Which fruits are green and round ?" on not red and round fruits. Based on these questions I can tell with considerable accuracy which are apples. This cascade of questions is what a decision tree is. However, this is a decision tree based on my intuition. Intuition cannot work on high dimensional and complex data. We have to come up with the cascade of questions automatically by looking at tagged data. That is what Machine Learning based decision trees do. Earlier versions like CART trees were once used for simple data, but with bigger and larger dataset, the bias-variance tradeoff needs to solved with better algorithms. The two common decision trees algorithms used nowadays are Random Forests (which build different classifiers on a random subset of attributes and combine them for output) and Boosting Trees (which train a cascade of trees one on top of others, correcting the mistakes of ones below them).
http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingClassifier.html http://xgboost.readthedocs.io/en/latest/ https://catboost.yandex/ http://xgboost.readthedocs.io/en/latest/model.html https://arxiv.org/abs/1511.05741 https://arxiv.org/abs/1407.7502 http://education.parrotprediction.teachable.com/p/practical-xgboost-in-python
Decision Trees can be used to classify datapoints (and even regression)

If you are still wondering how can any of the above methods solve tasks like defeating Go world champion like DeepMind did, they cannot. All the 10 type of algorithms we talked about before this was Pattern Recognition, not strategy learners. To learn strategy to solve a multi-step problem like winning a game of chess or playing Atari console, we need to let an agent-free in the world and learn from the rewards/penalties it faces. This type of Machine Learning is called Reinforcement Learning. A lot (not all) of recent successes in the field is a result of combining perception abilities of a convnet or a LSTM to a set of algorithms called Temporal Difference Learning. These include Q-Learning, SARSA and some other variants. These algorithms are a smart play on Bellman's equations to get a loss function that can be trained with rewards an agent gets from the environment.
https://github.com/keras-rl/keras-rl https://github.com/tensorflow/minigo
These algorithms are used to automatically play games mostly :D, also other applications in language generation and object detection.

Grab the free Sutton and Barto book: https://web2.qatar.cmu.edu/~gdicaro/15381/additional/SuttonBarto-RL-5Nov17.pdf

Watch David Silver course: https://www.youtube.com/watch?v=2pWv7GOvuf0

These are the 10 machine learning algorithms which you can learn to become a data scientist.

You can also read about machine learning libraries here.

We hope you liked the article. Please Sign Up for a free ParallelDots account to start your AI journey. You can also check demo's of our APIs here.

Read the original article here.

# data[].attributes.attachment_link.title
Ten Machine Learning Algorithms You Should Know to Become a Data Scientist

# data[].attributes.attachment_link.description
Machine Learning Practitioners have different personalities. While some of them are "I am an expert in X and X can train on any type of data", where X = some algorithm, some others are "Right tool for the right job people". A lot of them also subscribe to "Jack of all trades.

# data[].attributes.attachment_link.readable_text
Though it might seem rather basic, reversing a string with char looping can be rather tedious and annoying. Fortunately, Python includes an easy built-in operation to perform exactly this task. To do this, we simply access the indice ::-1 on our string.

a = "!dlrow olleH"
backward = a[::-1]

In most languages, in order to get an array into a set of variables we would need to either loop through the values iteratively or access the dims by position like so:

firstdim = array[1]

In Python, however, there is a way cooler and quicker way to do so. In order to change a list of values into variables we can simply set variable names equal to the array with the same length of the array:

array = [5, 10, 15, 20]
five, ten, fift, twent = array

If you're going to spend any time whatsoever in Python, you will definitely want to get familiar with itertools. Itertools is a module within the standard library that will allow you to get around iteration constantly. Not only does it make it far easier to code complex loops, it also makes your code both faster and more concise. Here is just one example of a use for Itertools, but there are hundreds:

c = [[1, 2], [3, 4], [5, 6]]
# Let's convert this matrix to a 1 dimensional list.
import itertools as it
newlist = list(it.chain.from_iterable(c))

Unpacking values iteratively can be rather intensive and time consuming. Fortunately, Python has several cool ways in which we can unpack lists! One example of this is the *, which will fill in unassigned values and add them to a new list under our variable name.

If you're not aware of enumerate, you probably should get familiar with it. Enumerate will allow you to get indexes of certain values in a list. This is especially useful in data science when working with arrays rather than data-frames.

for i,w in enumerate(array):
 print(i,w)

Slicing apart lists in Python is incredibly easy! There are all sorts of great tools that can be used for this, but one that certainly is valuable is the ability to name slices of your list. This is especially useful for linear algebra in Python.

a = [0, 1, 2, 3, 4, 5]
LASTTHREE = slice(-3, None)
slice(-3, None, None)
print(a[LASTTHREE])

Grouping adjacent loops could certainly be done rather easily in a for loop, especially by using zip(), but this is certainly not the best way of doing things. To make things a bit easier and faster, we can write a lambda expression with zip that will group our adjacent lists like so:

a = [1, 2, 3, 4, 5, 6]
group_adjacent = lambda a, k: zip(*([iter(a)] * k))
group_adjacent(a, 3) [(1, 2, 3), (4, 5, 6)]
group_adjacent(a, 2) [(1, 2), (3, 4), (5, 6)]
group_adjacent(a, 1)

In most normal scenarios in programming, we can access an indice and get our position number by using a counter, which will just be a value that is added to:

array1 = [5, 10, 15, 20]# This code wouldn't work because 'i' is not in array2.
array2 = (x ** 2 for x in range(10))
counter = 0 for i in array1:
 # i = array2[i]
 i = array2[counter]
# ^^^ This code would because we are accessing the position of i

Instead of this, however, we can use next(). Next takes an iterator that will store our current position in memory and will iterate across our list in the background.

g = (x ** 2 for x in range(10))
print(next(g))
print(next(g))

Another great module from the standard library is collections, and what I would like to introduce to you today is Counter from collections. Using Counter, we can easily get counts of a list. This is useful for getting the total number of values in our data, getting a null count of our data, and seeing the unique values of our data. I know what you're thinking,

" Why not just use Pandas?"

And this is certainly a valid point. However, using Pandas for this is certainly going to be a lot harder to automate, and is just another dependency you are going to need to add to your virtual environment whenever you deploy your algorithm. Additionally, a counter type in Python has a lot of features that Pandas Series don't have, which can make it far more useful for certain situations.

A = collections.Counter([1, 1, 2, 2, 3, 3, 3, 3, 4, 5, 6, 7])
A Counter({3: 4, 1: 2, 2: 2, 4: 1, 5: 1, 6: 1, 7: 1})
A.most_common(1) [(3, 4)]
A.most_common(3) [(3, 4), (1, 2), (2, 2)]

Another great thing coming out of the collections module is dequeue. Check out all the neat things we can do with this type!

import collections
Q = collections.deque()
Q.append(1)
Q.appendleft(2)
Q.extend([3, 4])
Q.extendleft([5, 6])
Q.pop()
Q.popleft()
Q.rotate(3)
Q.rotate(-3)
print(Q)

# data[].attributes.attachment_link.description
Though it might seem rather basic, reversing a string with char looping can be rather tedious and annoying. Fortunately, Python includes an easy built-in operation to perform exactly this task. To do this, we simply access the indice ::-1 on our string.

# data[].attributes.body
https://www.kdnuggets.com/2020/08/start-learning-data-science-again.html

# data[].attributes.attachment_link.readable_text
Eventos Aleatorios

Todo a nuestro alrededor es aleatorio. La teoría de la probabilidad es la herramienta matemática que nos permite analizar los eventos aleatorios de manera estructurada. La probabilidad de un evento es un número que indica que tan factible es la ocurrencia de este. Este número siempre está entre 0 y 1, donde 0 significa imposibilidad, mientras 1 significa certidumbre.

Un típico experimento probabilístico es el lanzamiento de una moneda, en el cual sólo hay dos posibles resultados: cara o sello. Si la moneda no está cargada, la probabilidad de obtener cara o sello es 1/2. En la realidad, al observar la secuencia de las monedas no necesariamente exactamente la mitad de ellas son cara. Sin embargo, a medida que el número de lanzamientos incrementa, la frecuencia de caras se aproxima cada vez a 50%.

Si la moneda está cargada, los 2 posibles resultados no son igualmente probables. Tu puedes cambiar la distribución de las monedas arrastrando las barras de la probabilidad real (a la derecha en azul) hacia arriba o hacia abajo. Si asignamos un número a cada resultado - digamos, 1 para cara, 0 para sello - entonces hemos creado un objeto matemático conocido como variable aleatoria.

# data[].attributes.attachment_link.description
Todo a nuestro alrededor es aleatorio. La teoría de la probabilidad es la herramienta matemática que nos permite analizar los eventos aleatorios de manera estructurada. La probabilidad de un evento es un número que indica que tan factible es la ocurrencia de este.

# data[].attributes.attachment_link.readable_text
"

Nunca voy a olvidarme como aprendi Arduino y que fue gracias a CódigoFacilito, no entendia nada de nada y tenía un kit de arduino, me recomendaron a CF y quede fascinado, fue el primer curso que hice aquí y no me arrepiento de nada. Contenido de una calidad increible desde hace muchisimo tiempo!

# data[].attributes.attachment_link.description
" Nunca voy a olvidarme como aprendi Arduino y que fue gracias a CódigoFacilito, no entendia nada de nada y tenía un kit de arduino, me recomendaron a CF y quede fascinado, fue el primer curso que hice aquí y no me arrepiento de nada. Contenido de una calidad increible desde hace muchisimo tiempo!

# data[].attributes.attachment_link.title
Learn To Code For IoT With Python Essentials Course | Networking Academy

# data[].attributes.attachment_link.description
The Programming Essentials in Python course takes a deep dive into the language surrounding IoT devices. Start learning today.

# data[].attributes.attachment_link.readable_text
Python is an easy to learn, powerful programming language. It has efficient high-level data structures and a simple but effective approach to object-oriented programming. Python's elegant syntax and dynamic typing, together with its interpreted nature, make it an ideal language for scripting and rapid application development in many areas on most platforms.

The Python interpreter and the extensive standard library are freely available in source or binary form for all major platforms from the Python Web site, https://www.python.org/, and may be freely distributed. The same site also contains distributions of and pointers to many free third party Python modules, programs and tools, and additional documentation.

The Python interpreter is easily extended with new functions and data types implemented in C or C++ (or other languages callable from C). Python is also suitable as an extension language for customizable applications.

This tutorial introduces the reader informally to the basic concepts and features of the Python language and system. It helps to have a Python interpreter handy for hands-on experience, but all examples are self-contained, so the tutorial can be read off-line as well.

For a description of standard objects and modules, see The Python Standard Library . The Python Language Reference gives a more formal definition of the language. To write extensions in C or C++, read Extending and Embedding the Python Interpreter and Python/C API Reference Manual . There are also several books covering Python in depth.

This tutorial does not attempt to be comprehensive and cover every single feature, or even every commonly used feature. Instead, it introduces many of Python's most noteworthy features, and will give you a good idea of the language's flavor and style. After reading it, you will be able to read and write Python modules and programs, and you will be ready to learn more about the various Python library modules described in The Python Standard Library .

The is also worth going through.

# data[].attributes.attachment_link.title
The Python Tutorial - Python 3.9.0 documentation

# data[].attributes.attachment_link.description
Python is an easy to learn, powerful programming language. It has efficient high-level data structures and a simple but effective approach to object-oriented programming.