1677908307

InferPy is a high-level API for probabilistic modeling written in Python and capable of running on top of Edward and Tensorflow. InferPy's API is strongly inspired by Keras and it has a focus on enabling flexible data processing, easy-to-code probablistic modeling, scalable inference and robust model validation.

Use InferPy is you need a probabilistic programming language that:

- Allows easy and fast prototyping of hierarchical probabilistic models with a simple and user friendly API inspired by Keras.
- Defines probabilistic models with complex probabilistic constructs containing deep neural networks.
- Automatically creates computational efficient batched models without the need to deal with complex tensor operations.
- Run seamlessly on CPU and GPU by relying on Tensorflow.

InferPy's aim is to be to Edward what Keras is to Tensorflow. Edward is a general purpose probabilistic programing language, like Tensorflow is a general computational engine. But this generality comes a at price. Edward's API is verbose and is based on distributions over Tensor objects, which are n-dimensional arrays with complex semantics operations. Probability distributions over Tensors are powerful abstractions but it is not easy to operate with them. InferPy's API is no so general like Edward's API but still covers a wide range of powerful and widely used probabilistic models, which can contain complex probability constructs containing deep neural networks.

Install InferPy from PyPI:

`$ python -m pip install inferpy`

The core data structures of InferPy is a **probabilistic model**, defined as a set of **random variables** with a conditional dependency structure. A **random varible** is an object parameterized by a set of tensors.

Let's look at a simple non-linear **probabilistic component analysis** model (NLPCA). Graphically the model can be defined as follows,

Non-linear PCA

We start by importing the required packages and defining the constant parameters in the model.

```
import inferpy as inf
import tensorflow as tf
# number of components
k = 1
# size of the hidden layer in the NN
d0 = 100
# dimensionality of the data
dx = 2
# number of observations (dataset size)
N = 1000
```

A model can be defined by decorating any function with `@inf.probmodel`

. The model is fully specified by the variables defined inside this function:

```
@inf.probmodel
def nlpca(k, d0, dx, decoder):
with inf.datamodel():
z = inf.Normal(tf.ones([k])*0.5, 1, name="z") # shape = [N,k]
output = decoder(z,d0,dx)
x_loc = output[:,:dx]
x_scale = tf.nn.softmax(output[:,dx:])
x = inf.Normal(x_loc, x_scale, name="x") # shape = [N,d]
```

The construct `with inf.datamodel()`

, which resembles to the **plateau notation**, will replicate N times the variables enclosed, where N is the size of our data.

In the previous model, the input argument `decoder`

must be a function implementing a neural network. This might be defined outside the model as follows.

```
def decoder(z,d0,dx):
h0 = tf.layers.dense(z, d0, tf.nn.relu)
return tf.layers.dense(h0, 2 * dx)
```

Now, we can instantiate our model and obtain samples (from the prior distributions).

```
# create an instance of the model
m = nlpca(k,d0,dx, decoder)
# Sample from priors
samples = m.prior().sample()
```

In variational inference, we must defined a Q-model as follows.

```
@inf.probmodel
def qmodel(k):
with inf.datamodel():
qz_loc = inf.Parameter(tf.ones([k])*0.5, name="qz_loc")
qz_scale = tf.math.softplus(inf.Parameter(tf.ones([k]),name="qz_scale"))
qz = inf.Normal(qz_loc, qz_scale, name="z")
```

Afterwards, we define the parameters of our inference algorithm and fit the data to the model.

```
# set the inference algorithm
VI = inf.inference.VI(qmodel(k), epochs=5000)
# learn the parameters
m.fit({"x": x_train}, VI)
```

The inference method can be further configured. But, as in Keras, a core principle is to try make things reasonably simple, while allowing the user the full control if needed.

Finally, we might extract the posterior of `z`

, which is basically the hidden representation of our data.

```
#extract the hidden representation
hidden_encoding = m.posterior("z", data={"x":x_train})
print(hidden_encoding.sample())
```

Author: PGM-Lab

Source Code: https://github.com/PGM-Lab/InferPy

License: Apache-2.0 license

#machinelearning #python #tensorflow

1677908307

InferPy is a high-level API for probabilistic modeling written in Python and capable of running on top of Edward and Tensorflow. InferPy's API is strongly inspired by Keras and it has a focus on enabling flexible data processing, easy-to-code probablistic modeling, scalable inference and robust model validation.

Use InferPy is you need a probabilistic programming language that:

- Allows easy and fast prototyping of hierarchical probabilistic models with a simple and user friendly API inspired by Keras.
- Defines probabilistic models with complex probabilistic constructs containing deep neural networks.
- Automatically creates computational efficient batched models without the need to deal with complex tensor operations.
- Run seamlessly on CPU and GPU by relying on Tensorflow.

InferPy's aim is to be to Edward what Keras is to Tensorflow. Edward is a general purpose probabilistic programing language, like Tensorflow is a general computational engine. But this generality comes a at price. Edward's API is verbose and is based on distributions over Tensor objects, which are n-dimensional arrays with complex semantics operations. Probability distributions over Tensors are powerful abstractions but it is not easy to operate with them. InferPy's API is no so general like Edward's API but still covers a wide range of powerful and widely used probabilistic models, which can contain complex probability constructs containing deep neural networks.

Install InferPy from PyPI:

`$ python -m pip install inferpy`

The core data structures of InferPy is a **probabilistic model**, defined as a set of **random variables** with a conditional dependency structure. A **random varible** is an object parameterized by a set of tensors.

Let's look at a simple non-linear **probabilistic component analysis** model (NLPCA). Graphically the model can be defined as follows,

Non-linear PCA

We start by importing the required packages and defining the constant parameters in the model.

```
import inferpy as inf
import tensorflow as tf
# number of components
k = 1
# size of the hidden layer in the NN
d0 = 100
# dimensionality of the data
dx = 2
# number of observations (dataset size)
N = 1000
```

A model can be defined by decorating any function with `@inf.probmodel`

. The model is fully specified by the variables defined inside this function:

```
@inf.probmodel
def nlpca(k, d0, dx, decoder):
with inf.datamodel():
z = inf.Normal(tf.ones([k])*0.5, 1, name="z") # shape = [N,k]
output = decoder(z,d0,dx)
x_loc = output[:,:dx]
x_scale = tf.nn.softmax(output[:,dx:])
x = inf.Normal(x_loc, x_scale, name="x") # shape = [N,d]
```

The construct `with inf.datamodel()`

, which resembles to the **plateau notation**, will replicate N times the variables enclosed, where N is the size of our data.

In the previous model, the input argument `decoder`

must be a function implementing a neural network. This might be defined outside the model as follows.

```
def decoder(z,d0,dx):
h0 = tf.layers.dense(z, d0, tf.nn.relu)
return tf.layers.dense(h0, 2 * dx)
```

Now, we can instantiate our model and obtain samples (from the prior distributions).

```
# create an instance of the model
m = nlpca(k,d0,dx, decoder)
# Sample from priors
samples = m.prior().sample()
```

In variational inference, we must defined a Q-model as follows.

```
@inf.probmodel
def qmodel(k):
with inf.datamodel():
qz_loc = inf.Parameter(tf.ones([k])*0.5, name="qz_loc")
qz_scale = tf.math.softplus(inf.Parameter(tf.ones([k]),name="qz_scale"))
qz = inf.Normal(qz_loc, qz_scale, name="z")
```

Afterwards, we define the parameters of our inference algorithm and fit the data to the model.

```
# set the inference algorithm
VI = inf.inference.VI(qmodel(k), epochs=5000)
# learn the parameters
m.fit({"x": x_train}, VI)
```

The inference method can be further configured. But, as in Keras, a core principle is to try make things reasonably simple, while allowing the user the full control if needed.

Finally, we might extract the posterior of `z`

, which is basically the hidden representation of our data.

```
#extract the hidden representation
hidden_encoding = m.posterior("z", data={"x":x_train})
print(hidden_encoding.sample())
```

Author: PGM-Lab

Source Code: https://github.com/PGM-Lab/InferPy

License: Apache-2.0 license

1617331277

The Association of Data Scientists (AdaSci), the premier global professional body of data science and ML practitioners, has announced a hands-on workshop on deep learning model deployment on February 6, Saturday.

Over the last few years, the applications of deep learning models have increased exponentially, with use cases ranging from automated driving, fraud detection, healthcare, voice assistants, machine translation and text generation.

Typically, when data scientists start machine learning model development, they mostly focus on the algorithms to use, feature engineering process, and hyperparameters to make the model more accurate. However, model deployment is the most critical step in the machine learning pipeline. As a matter of fact, models can only be beneficial to a business if deployed and managed correctly. Model deployment or management is probably the most under discussed topic.

In this workshop, the attendees get to learn about ML lifecycle, from gathering data to the deployment of models. Researchers and data scientists can build a pipeline to log and deploy machine learning models. Alongside, they will be able to learn about the challenges associated with machine learning models in production and handling different toolkits to track and monitor these models once deployed.

#hands on deep learning #machine learning model deployment #machine learning models #model deployment #model deployment workshop

1623906637

*If you are new to working with a deep learning framework, such as TensorFlow, there are a variety of typical errors beginners face when building and training models. Here, we explore and solve some of the most common errors to help you develop a better intuition for debugging in TensorFlow.*

TensorFlow is one of the most famous deep learning models, and it is easy to learn. This article will discuss the most common errors a beginner can face while learning TensorFlow, the reasons, and how to solve these errors. We will discuss the solutions and also what experts from StackOverflow say about them.

…

#2021 jun tutorials #overviews #beginners #deep learning #tensorflow #beginners guide to debugging tensorflow models

1618317562

View more: https://www.inexture.com/services/deep-learning-development/

We at Inexture, strategically work on every project we are associated with. We propose a robust set of AI, ML, and DL consulting services. Our virtuoso team of data scientists and developers meticulously work on every project and add a personalized touch to it. Because we keep our clientele aware of everything being done associated with their project so there’s a sense of transparency being maintained. Leverage our services for your next AI project for end-to-end optimum services.

#deep learning development #deep learning framework #deep learning expert #deep learning ai #deep learning services

1614043320

TensorFlow Serving is a flexible, high-performance serving system for machine learning models, designed for production environments. TensorFlow Serving makes it easy to deploy new algorithms and experiments, while keeping the same server architecture and APIs. TensorFlow Serving provides out-of-the-box integration with TensorFlow models, but can be easily extended to serve other types of models and data.

Currently there are a lot of different solutions to serve ML models in production with the growth that **MLOps **is having nowadays as the standard procedure to work with ML models during all their lifecycle. Maybe the most popular one is TensorFlow Serving developed by TensorFlow so as to server their models in production environments.

This post is a guide on how to train, save, serve and use TensorFlow ML models in production environments. Along the GitHub repository linked to this post we will prepare and train a custom CNN model for image classification of The Simpsons Characters Data dataset, that will be later deployed using TensorFlow Serving.

So as to get a better understanding on all the process that is presented in this post, as a personal recommendation, you should read it while you check the resources available in the repository, as well as trying to reproduce it with the same or with a different TensorFlow model, as “practice makes the master”.

alvarobartt/serving-tensorflow-models

#deep-learning #tensorflow-serving #tensorflow