Hello all, I’ve some experience in building DL models using Tensorflow in Unix environments leveraging on platforms such as AWS and GCP. My work/company also provides me with Unix servers to build my models.

Now that I want to build my own DL rig, on Windows no less, I am interested to know about performance degradation on Tensorflow of a GPU that is shared with the host OS. Anyone has any experience in this?

PS. I have no choice but to use Windows, much as I would prefer a Linux system.

TLDR; Want to do deep learning on GPUs on Windows, worried whether the host OS sharing the GPU will affect performance much, using Tensorflow.

DyNetSharp – C# wrapper for DyNet: The Dynamic Neural Network Toolkit

​

DyNet is a neural network library developed by Carnegie Mellon University and many others. It is written in C++ (with bindings in Python, and for the first time now also in C#) and is designed to work well with networks that have dynamic structures that change for every training instance. For example, these kinds of networks are particularly important in natural language processing tasks, and DyNet has been used to build state-of-the-art systems for syntactic parsing (https://github.com/clab/lstm-parser), machine translation (https://github.com/neubig/lamtram), morphological inflection (https://github.com/mfaruqui/morph-trans), and many other application areas.

​

C# installation is currently available through NuGet (https://www.nuget.org/packages/DynetSharp), and will be available for compiling from the source over the next couple of days.

For documentation on how to use, and for some examples: https://github.com/shaltielshmid/dynet/tree/master/contrib/csharp

​

[The link above is the fork, the code is currently being merged into the main branch: http://github.com/clab/dynet]

​

It will be continually developed, any contributions are welcome.

Any idea how to deploy big data models like ALSModel using databricks?Any and all ideas would be appreciated

Checkout the release notes here: https://github.com/pytorch/pytorch/releases/tag/v1.1.0

Hello AI technology users!

I am writing on behalf of my institution’s Technology, Relationship, and Language lab. We are a small group of Psychologists aiming to understand the relationship quality and formation characteristics of chatbot and human connections. Once we can better understand the positive aspects of these technological relationships, we can initiate further studies that can aid in the advancement of more meaningful and fulfilling relationships with humans and their technological counterparts.

You are invited to participate in a survey assessing your experiences interacting with artificial intelligence (AI) chatbots. Specifically, our study focuses on the AI chatbot Replika. Your participation is voluntary, but nonetheless greatly appreciated. Our goal is simple: analyzing the effectiveness, quality, and relationships of human participants with their personal chatbots. With your help in taking this quick (7 min max) survey, we can create an informative understanding of the areas in which AI technology is improving the lives and relationships with humans. Please feel free to reach out to me or our principal investigator (whose contact information is included in the first page of the survey) with any questions. The survey is linked below:

https://forms.gle/ZYbhc5BnFbcGm5ib6

Hello All! First, thanks in advance 🙂 I’m stumped on this one.

​

I have a deep convolutional autoencoder, and in the final layer of the encoder, I’m not sure if I should use a 1×1 convolution (I’ve already brought it down to 1 spatial dimension), batch normalization, or an activation function, such as ReLu. If I use ReLu on the thinnest layer, I feel like I’m limiting the capacity of that layer more than I need to, since I’m eliminating all negative potential values. Using batch normalization and/or a convolution seems fine, but then what do I lead with in the decoder? If I create a convolution.batch norm.relu set, then I’m doing two linear transformations in a row, which doesn’t seem right.

​

Thank you for your insights!!

Does anybody has numbers on how many percentage of non-deep learning (non-neural nets related) papers are accepted at main ML conferences? (NeurIPS, ICML, CVPR, etc…) and what are the papers being accepted for?

I am working on a POC in which I want to perform some surrogate modeling, but conceptually I have some confusion on this.

​

A little background: in this POC, I have a Deep Learning network that is performing quite well. In terms of interpretability, I have implemented DeepExplainer to display the SHAP values for local predictions. At a local level, I do feel that this does a good job explaining how exactly the model arrived at the conclusion it did, and how the individual features values contributed to this.

​

Wanting to take this further, an idea of Surrogate Models was proposed.

​

From my understanding for Global Surrogate Models are computed as follows: Given a trained black box model, we create an interpretable model using the input into the black box model as the data, and the output of the black box model as the target variable. We now interpret this model

​

With Local Surrogate Models, my understanding is that at a local level (for individual predictions). This is computed as: taking a local instance of data, perturbing the data, using this perturbed data to train an interpretable model, and interpret this model.

​

The question I am having a hard time understanding is say I was to create a Global Surrogate Model (say a linear regression). This use this surrogate model to make a specific prediction. Why couldn’t I explain locally how I arrived at this prediction (say I look at the equation of the linear regression for this)?

​

Any help would be much appreciated!

The purpose of this project is to devise a vision system that will return the safest area for an autonomous rocket powered lander to land given a terrain image.

I started working on this project a while ago, gave up, and am hoping to restart it soon. However, I think that the approach I’ve taken previously is suboptimal.

Current Work: https://github.com/GerardMaggiolino/SEDS-Aquarius-Vision

Some promising (not garbage) results on test data.

​

Previous Approach:

I felt that semantic segmentation was overly expressive; pixel-wise labelling is not necessary, since I only need to find a large, contiguous region that is safe. Additionally, I am creating my own data set, and wanted to find a way to solve this problem without requiring an extensive amount of time labelling, or creating labels that would need to be very, very precise. I settled on something like sliding-window, with ordinal classification over each region. The paper used for ordinal classification reference is in the repo.

I’m classifying individual patches of an image as safe or not safe – this would ideally be a regression problem, but I don’t have the ability to be that precise in my labelling. Binary classification would be poor, as there’s many images right on the boundary. A comprise is ordinal classification, where penalization for a “5” of safeness when the true label is “1” is much greater than a penalization for a “2” on the same image. I’m manually labelling terrain images between 1 and 5. I wrote a short script that allows me to label about six images per minute.

With a small network using strided depth-wise convolutions and only 411 greyscaled images without using augmentation, I achieved some promising results. Random classification would achieve a 52% accuracy of within at least 1 category correct (E.G. an output of 2 for a label of 1 is correct), and I achieved 96% with a few minutes of training. I’m hoping this would improve as I increase data set size, and I could perform augmentation to * 8 that with rotations and horizontal flips.

The problem: Classifying over a 1500 x 1500 image (about 2 megapixels) takes around 0.2 seconds on my 6 core MacBook Pro. The lander will likely have less computational power, and it needs to be near real time. This is with NO sliding-window overlap, meaning potential good regions could be excluded if they’re on boundaries.

​

Solution:

I’m not sure. I’m unaware of what architectures are common for problems like this. At the end of the day, I want to return a single, precise location for where to land.

I’m thinking of two approaches: First, a YOLO-eqsue model, where safe regions are labelled in bounding boxes. Problem – safe regions are hardly ever in perfect rectangles. Second, a semantic segmentation model with limited / no upsampling, from which the center of the largest inscribed circle in the polygons corresponding to safe regions could be returned. Problem – speed might still be a concern, and labelling would be more challenging.

In both of the above, labelling would be more time consuming and difficult, potentially resulting in lower quality models. Additionally, I’m under the impression that the amount of data necessary to train a good patch detector (1 – 5 ordinal regression) is far less than that to train SSDs or FCNs.

Any advice would be greatly appreciated! Sorry for the long post, and thank you so much if you’ve made it this far.